让你快速理解工厂模式

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

`
工厂模式分为简单工厂（不包含在23个设计模式之中）、工厂方法、抽象方法；这里我将以最简单的方式来总结讲解这三者的区别，如果你想快速的了解这三者模式的具体用法、优缺点请继续往下阅读！

一、简单工厂

定义

三个角色：工厂类、抽象产品类、具体产品类
简单工厂实现原理：
1）定义一个工厂，客户端只需要传相应参数，即可从该工厂获取对象，不用关心对象具体产品时怎么创建的；
2）工厂类负责去根据参数创建对象

代码示例

如下所示简单工厂类：

publicclass PhoneFactory {
    public static Phone createPhone(String type) {
        Phone phone = null;
        if ("huawei".equals(type)) {
            phone = new Huawei();
        } elseif ("xiaomi".equals(type)) {
            phone = new Xiaomi();
        } elseif ("apple".equals(type)) {
            phone = new IPhone();
        } else {
            System.out.println("暂不支持");
        }
        return phone;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

优缺点

优点：
1）松耦合，用户不需要知道具体实现的类，只需要传入具体的参数就能获取想要的对象。
缺点：
1）不符合开闭原则，当新增加产品时需要修改工厂类。
2）当具体实现产品较多时，if…else会比较多导致代码不美观

工厂方法可以解决这两个问题

二、工厂方法

定义

角色：工厂基类、具体产品工厂、抽象产品、具体产品
跟简单工厂一类似，只不过将工厂形式改为了工厂基类+具体产品工厂的组合；工厂里不再负责创建对象了。而是利用依赖倒置原则来获取要调用的具体对象。

代码示例

工厂基类

publicinterface PhoneFactory {
   Phone createPhone();
}
1
2
3

具体工厂

publicclass HuaweiFactory implements PhoneFactory {
   @Override
   public Phone createPhone() {
      returnnew Huawei();
   }
}
1
2
3
4
5
6

客户端

 public static void main(String[] args) {
        PhoneFactory phoneFactory = new XiaomiFactory();
        Phone phone = phoneFactory.createPhone();
        phone.play()
    }
1
2
3
4
5

优缺点

优点：
1）不需要通过参数去判断获取相应的产品
2）减少了简单工厂中的if…else多问题
3）符合开闭原则，做到了产品类和工厂类代码的完全解耦；当新增产品时，不需要修改工厂类方法，只需要新增产品工厂即可

缺点：新增产品时，需要同时新增产品和产品工厂类，成对增加了，导致了系统的复杂度。

三、抽象工厂

定义

在工厂模式的基础上进行了向上的扩展，它将具有一定共性的产品放到一起，由工厂类为这些产品提供共性的调用方法，再由调用者根据自己的需求调用对应的工厂类去实现获取产品实例。

类图：

为了更好的理解抽象工厂模式，这里我放了一张有关颜色和形状的类图：

以下解释是帮助理解这张类图的：
    1）形状和颜色看似不通的业务，由一个工厂生产出来
    2）形状：方形、圆形除都是形状外，都有自己各自的实现方法
    3）颜色：红色、蓝色、绿色除了都是颜色外，还有各自自己的实现方法

具体实现思路（代理示例）

1，定义形状和颜色两个接口，具体的形状和颜色各自实现其接口。

形状

public interface Shape {
   void draw();
}
1
2
3

//方形

public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}
1
2
3
4
5
6
7

//圆形

public class Circle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}
1
2
3
4
5
6
7

颜色

public interface Color {
   void fill();
}
1
2
3

//红色

public class Red implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Red::fill() method.");
   }
}
1
2
3
4
5
6
7

//蓝色

public class Blue implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Blue::fill() method.");
   }
}
1
2
3
4
5
6
7

2，定义抽象工厂，里面有抽象形状和抽象颜色方法。

public abstract class AbstractFactory {
   public abstract Color getColor(String color);
   public abstract Shape getShape(String shape);
}
1
2
3
4

3，形状工厂类和颜色工厂类实现抽象工厂类，实现自己的业务逻辑。

形状抽象类

public class ShapeFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      }
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      return null;
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

颜色抽象类

public class ColorFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      if(color == null){
         return null;
      }        
      if(color.equalsIgnoreCase("RED")){
         return new Red();
      } else if(color.equalsIgnoreCase("BLUE")){
         return new Blue();
      }
      return null;
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4，创建工厂构造器（通过参数来决定获取其产品实例）

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("SHAPE")){
         return new ShapeFactory();
      } else if(choice.equalsIgnoreCase("COLOR")){
         return new ColorFactory();
      }
      return null;
   }
}
1
2
3
4
5
6
7
8
9
10

5）客户端

 public static void main(String[] args) {
 
      //1,获取形状工厂
      AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
      //获取形状为 Circle 的对象
      Shape shape1 = shapeFactory.getShape("CIRCLE");
      //调用 Circle 的 draw 方法
      shape1.draw();

     //2,获取颜色工厂
      AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
      //获取颜色为 Red 的对象
      Color color1 = colorFactory.getColor("RED");
      //调用 Red 的 fill 方法
      color1.fill();
     

 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

优缺点

优点：将一定共性的产品集中在一起，能保证始终使用的都是一个产品族中的对象。
缺点：降低了系统的扩展性，当新增产品时需要在抽象类中增加，也要在实现类中增加，较为复杂。

如果本篇博客对您有一定的帮助，大家记得留言+点赞哦。