java设计模式--工厂模式

1. 工厂方法模式

结合代码来看

• 普通工厂模式 对接口的方法进行实现的不同的类

interface Sender{
    void send();
        }

class ASender implements Sender{   //实现同一个接口的一个类
    public void send(){//实现接口中的抽象方法
        System.out.print("A Sender……");
    }
}

class BSender implements Sender{//实现同一个接口的另一个类
    public void send(){
        System.out.print("B Sender……");
    }
}
public class Factory {
    public static void main(String[] args) {
        Sender sender=produce("A");
        sender.send();
    }

   public static Sender produce(String str){  //构造一个方法，判断属于哪一个类，再进行实例化
        if("A".equals(str)){
            return new ASender();
        }else   if("B".equals(str)){
            return new BSender();
        }else{
            System.out.print("error……");
            return null;
        }
   }
}

• 多个工厂方法模式

//多个工厂方法模式   工厂中有多个方法

interface Sender{
    void send();
}

class ASender implements Sender{   //实现同一个接口的一个类
    public void send(){//实现接口中的抽象方法
        System.out.print("A Sender……");
    }
}

class BSender implements Sender{//实现同一个接口的另一个类
    public void send(){
        System.out.print("B Sender……");
    }
}

class factory {  //工厂当中的多个方法
    public Sender produceA(){
        return new ASender();
    }
    public Sender produceB(){
        return new BSender();
    }
}
public class Factory {
    public static void main(String[] args) {
      factory fac=new factory();
      Sender sender=fac.produceA();
      sender.send();
    }
}

• 静态工厂模式 --工厂中的方法设置为静态，不必实例化就可以直接调用

//静态工厂模式
interface Sender{
    void send();
}

class ASender implements Sender{   //实现同一个接口的一个类
    public void send(){//实现接口中的抽象方法
        System.out.print("A Sender……");
    }
}

class BSender implements Sender{//实现同一个接口的另一个类
    public void send(){
        System.out.print("B Sender……");
    }
}

class factory {  //工厂当中的多个方法设置为静态，可以直接调用不需要创建工厂实例
    public static Sender produceA(){
        return new ASender();
    }
    public static  Sender produceB(){
        return new BSender();
    }
}
public class Factory {
    public static void main(String[] args) {
        Sender sender=factory.produceA();
        sender.send();
    }
}

2. 抽象工厂模式

类的创建依赖工厂类，也就是说，如果想要扩展程序，必须对工厂类进行修改，这违背了闭包原则

• 闭包原则 软件实体对扩展是开放的，但对修改是关闭的，在不去修改一个软件实体去扩展其他功能

interface Sender{
    void send();
}

interface Provider{  //方法中需要实现的接口
   Sender produce(); //抽象的方法
        }
class ASender implements Sender{   //实现同一个接口的一个类
    public void send(){//实现接口中的抽象方法
        System.out.print("A Sender……");
    }
}

class BSender implements Sender{//实现同一个接口的另一个类
    public void send(){
        System.out.print("B Sender……");
    }
}

class AFactory implements Provider{  //创建多个工厂类
    public Sender produce(){
  return new ASender();
    }
}
class BFactory implements Provider{
    public Sender produce(){
  return new BSender();
    }
}


public class Factory {
    public static void main(String[] args) {
        Provider provider=new AFactory();//使用哪个方法就实例化哪个
        Sender sender=provider.produce();
        sender.send();
    }
}

将方法封装到各个类中，当我们需要扩展工厂的功能时候，只需要再去添加一个工厂类，在这个工厂类当中添加相应的方法实现功能

参考了这位前辈的代码进行学习理解

敲一遍代码之后感觉理解的好多了，捋顺了