什么是工厂模式？

我们在创建对象时不会对客户端直接暴露创建逻辑，而是 **通过使用一个共同的接口根据不同的条件来指向具体想要创建的对象。**简单来说，我需要某个类的对象，我只需要告诉工厂我需要这个类，工厂就给我返回这个类对象，而创建对象的具体实现由工厂来实现，调用者直接用结果就可以。

工厂模式的优点？

• 使用工厂模式的优点在于一个调用者想创建一个对象，只要知道其名称（创建该对象的条件）就可以在工厂获取具体的对象

• 扩展性强，如果想增加一个产品（也就是具体的对象），只要扩展工厂类就可以（也就是增加不同的标签，增加不同标签所对应的对象）。

• 屏蔽产品的具体实现，调用者只关心能否获得想要的结果，无需关心内部实现

三种工厂模式详解

• 简单工厂模式

  用工厂模式实现加减法运算器

  //运算器
  public class Operation {
        
     
      public String getName(){
        
          return "";
      }
  }
  
  

  //加法运算器
  public class Add extends Operation {
        
      @Override
      public String getName(){
        
          return "加法";
      }
  }
  
  

  //减法运算器
  public class Sub extends Operation{
        
      @Override
      public String getName(){
        
          return "减法";
      }
  }
  
  

  public class Factory {
        
  
      public static Operation createOperation(String operate){
        
  
  		//运算器
          Operation oper = null;
  
          switch(operate){
        
              case "+":
                  oper = new Add();
                  break;
              case "-":
                  oper = new Sub();
                  break;
          }
          return oper;
      }
  }
  

  //测试
  public class Test {
        
      public static void main(String[] args) {
        
          //创建运算器
          Operation operation;
          //通过入参条件告诉工厂我应该创建的是减法运算器
          operation = Factory.createOperation("-");
          System.out.println(operation.getName());
      }
  }
  
  

  特点

  • 只有一个工厂factory

  • factory类是一个具体的类，非接口/抽象类。有一个重要的create()方法，利用if或者 switch创建产品并返回。

• create()方法通常是静态的，所以也称之为静态工厂。

缺点

• 扩展性差（我想增加乘法，除了新增一个乘法类，还需要修改工厂类方法，在switch添加乘法条件）

  • 不同的类需要不同额外参数的时候 不支持。

• 工厂方法模式

  还是上面那个例子，如果我需要添加乘法和除法功能，势必要添加新的运算类，并且还有修改factory类的create方法。这样是违法开闭原则的。

  我们先定义加减运算为简单运算，乘除运算为复杂运算。

  //定义抽象工厂，所有工厂必须实现该接口
  public interface Factory {
        
      public Operation createOperation(String operate);
  }
  
  
  //复杂运算工厂
  public class ComplexFactory implements Factory {
        
  
      public Operation createOperation(String operate){
        
          Operation oper = null;
          switch(operate){
        
              case "*":
                  oper = new Mul();
                  break;
              case "/":
                  oper = new Div();
                  break;
          }
          return oper;
      }
  }
  
  //简单运算工厂
  public class EasyFactory implements Factory {
        
      public  Operation createOperation(String operate){
        
          Operation oper = null;
          switch(operate){
        
              case "+":
                  oper = new Add();
                  break;
              case "-":
                  oper = new Sub();
                  break;
          }
          return oper;
      }
  }
  

  //定义抽象运算器，所有运算器必须实现该接口
  public interface Operation {
        
      public String getName();
  }
  
  //复杂运算器
  public class ComplexOperation implements Operation {
        
  
      public String getName(){
        
          return "";
      }
  }
  
  //简单运算器
  public class EasyOperation implements Operation {
        
      @Override
      public String getName() {
        
          return "";
      }
  }
  

  //加法运算器
  public class Add extends EasyOperation {
        
      @Override
      public String getName() {
        
          return "加法";
      }
  }
  
  //减法运算器
  public class Sub extends EasyOperation{
        
      @Override
      public String getName() {
        
          return "减法";
      }
  }
  
  //乘法运算器
  public class Mul extends ComplexOperation {
        
  
      @Override
      public String getName() {
        
          return "乘法";
      }
  }
  
  //除法运算器
  public class Div extends ComplexOperation {
        
      @Override
      public String getName() {
        
          return "除法";
      }
  }
  
  

  //测试
  public class Test {
        
      public static void main(String[] args) {
        
  
          //运算器
          Operation operation = null;
  
          //复杂运算工厂
          Factory complexfactory = new ComplexFactory();
  		//简单运算工厂
          Factory easyfactory = new EasyFactory();
  		//通过不同工厂可创建不同的对象实例
          operation = complexfactory.createOperation("*");
          System.out.println(operation.getName());
          
          operation = easyfactory.createOperation("+");
          System.out.println(operation.getName());
  
      }
  }
  

  特点

  • 有多个工厂factory（实现同一工厂接口），有多种产品operation（实现同一产品接口），产品与工厂相对应
  • 扩展性强，添加新的产品需要添加对应的工厂，无需改动原来代码，直接实现产品接口和工厂接口即可

• 抽象工厂模式

  在工厂方法模式中，产品种类是单一的，比如上面的例子，运算只是基本的四则运算，如果涉及到对象与对象之间的运算呢？这就不是简单的四则运算了，抽象方法模式就针对多种产品。