JAVA设计模式-工厂模式（Factory Pattern）

分手后的思念是犯贱 2024-02-23 08:01 49阅读 0赞

#### 一.概念 ####

我们在创建对象时不会对客户端直接暴露创建逻辑，而是 通过使用一个共同的接口根据不同的条件来指向具体想要创建的对象。

#### 二.工厂模式优点 ####

1.解耦 ：把对象的创建和使用的过程分开

2.降低代码重复： 如果创建某个对象的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。

3.降低维护成本 ：由于创建过程都由工厂统一管理，所以发生业务逻辑变化，不需要找到所有需要创建某个对象的地方去逐个修正，只需要在工厂里修改即可，降低维护成本。

#### 三.适用场景 ####

1.需要创建的对象较少

2.客户端不关心对象的创建过程

#### 四.工厂模式分类 ####

1.**简单工厂模式**，又称静态工厂方法模式（Static Factory Method Pattern）。

2.**工厂方法模式**，又称多态性工厂（Polymorphic Factory）模式或虚拟构造子（Virtual Constructor）模式；

3.**抽象工厂模式**，又称工具箱（Kit 或Toolkit）模式。

#### 五.简单工厂模式的实现 ####

##### 1.类图 #####

![6c28ec7d2af544dfb3172a3a11143ba1.png][]

专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。它又称为静态工厂方法模式。它的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。在这个模式中，工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。

##### 2.角色分配 #####

1.  **工厂(Factory)角色** :简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
2.  **抽象产品(Product)角色** :简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
3.  **具体产品(Concrete Product)角色**:简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

##### 3.优点 #####

工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅”消费”产品。简单工厂模式通过这种做法实现了对责任的分割。简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。通过它，外界可以从直接创建具体产品对象的尴尬局面中摆脱出来。外界与具体类隔离开来，偶合性低。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。

##### 4.缺点 #####

当产品有复杂的多层等级结构时，工厂类只有自己，以不变应万变，就是模式的缺点。因为工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，有可能造成工厂逻辑过于复杂,违背了”开放–封闭”原则(OCP).另外，简单工厂模式通常使用静态工厂方法，这使得无法由子类继承，造成工厂角色无法形成基于继承的等级结构。

##### 5.适用范围 #####

工厂类负责创建的对象比较少，客户只知道传入了工厂类的参数，对于始何创建对象（逻辑）不关心。

##### 6.实现 #####

###### 创建Shape接口 ######

public interface Shape {
        void draw();
    }

###### 创建实现该接口的具体图形类 ######

//圆形
    public class Circle implements Shape {
        public Circle() {
            System.out.println("Circle");
        }
        @Override
        public void draw() {
            System.out.println("Draw Circle");
        }
    }

//长方形
    public class Rectangle implements Shape {
        public Rectangle() {
            System.out.println("Rectangle");
        }
        @Override
        public void draw() {
            System.out.println("Draw Rectangle");
        }
    }

//正方形
    public class Square implements Shape {
        public Square() {
            System.out.println("Square");
        }
    
        @Override
        public void draw() {
            System.out.println("Draw Square");
        }
    }

###### 创建工厂类 ######

public class ShapeFactory {
    
        // 使用 getShape 方法获取形状类型的对象
        public static Shape getShape(String shapeType) {
            if (shapeType == null) {
                return null;
            }
            if (shapeType.equalsIgnoreCase("CIRCLE")) {
                return new Circle();
            } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
                return new Rectangle();
            } else if (shapeType.equalsIgnoreCase("SQUARE")) {
                return new Square();
            }
            return null;
        }
    }

这样的实现有个问题，如果我们新增产品类的话，就需要修改工厂类中的getShape（）方法，这很明显不符合 **开放-封闭原则**

#### 六.工厂方法模式实现 ####

##### 1.类图 #####

![f51659e77bd1477e897a17fbd7e4db7d.png][]

工厂方法模式应该是在工厂模式家族中是用的最多模式，一般项目中存在最多的就是这个模式。

工厂方法模式是简单工厂的仅一步深化， 在工厂方法模式中，我们不再提供一个统一的工厂类来创建所有的对象，而是针对不同的对象提供不同的工厂。也就是说 **每个对象都有一个与之对应的工厂** 。

##### 2.角色分配 #####

*  **抽象工厂(Abstract Factory)角色**：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
 *  **具体工厂(Concrete Factory)角色** ：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建某一种产品对象。
 *  **抽象产品(AbstractProduct)角色** ：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。
 *  **具体产品(Concrete Product)角色** ：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应

##### 3.适用场景 #####

*  一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类。
 *  一个类通过其子类来指定创建哪个对象：在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏
 *  将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无需关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。

##### 4.实现 #####

上面简单工厂例子中的图形接口以及相关图像实现类不变。我们只需要增加一个工厂接口以及实现这个接口的工厂类即可

###### 增加一个工厂接口 ######

public interface Factory {
        public Shape getShape();
    }

###### 增加相关工厂类 ######

//圆形工厂类
    public class CircleFactory implements Factory {
    
        @Override
        public Shape getShape() {
            // TODO Auto-generated method stub
            return new Circle();
        }
    
    }

//长方形工厂类
    public class RectangleFactory implements Factory{
    
        @Override
        public Shape getShape() {
            // TODO Auto-generated method stub
            return new Rectangle();
        }
    
    }

//正方形工厂类
    public class SquareFactory implements Factory{
    
        @Override
        public Shape getShape() {
            // TODO Auto-generated method stub
            return new Square();
        }
    
    }

这样每个工厂负责一种类型，再增加其他的类型只需要添加一个工厂类以及具体的图形类即可，符合了**开放-封闭原则**

#### 七.抽象工厂模式实现 ####

##### 1.图解 #####

![984359cd1dc845fea23cc6e3e82aa356.png][]

在工厂方法模式中，其实我们有一个潜在意识的意识。那就是我们生产的都是同一类产品。抽象工厂模式是工厂方法的仅一步深化，在这个模式中的工厂类不单单可以创建一种产品，而是可以创建一组产品。抽象工厂应该是比较最难理解的一个工厂模式了。

##### 2.角色分配 #####

*  **抽象工厂（AbstractFactory）角色** ：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
 *  **具体工厂类（ConreteFactory）角色** ：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建某一种产品对象。
 *  **抽象产品（Abstract Product）角色** ：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。
 *  **具体产品（Concrete Product）角色** ：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。在抽象工厂中创建的产品属于同一产品族，这不同于工厂模式中的工厂只创建单一产品，我后面也会详解介绍到。

##### 3.适用场景 #####

*  和工厂方法一样客户端不需要知道它所创建的对象的类。
 *  需要一组对象共同完成某种功能时，并且可能存在多组对象完成不同功能的情况。（同属于同一个产品族的产品）
 *  系统结构稳定，不会频繁的增加对象。（因为一旦增加就需要修改原有代码，不符合开闭原则）

##### 4.抽象工厂和工厂方法的区别 #####

抽象工厂是生产一整套有产品的（至少要生产两个产品)，这些产品必须相互是有关系或有依赖的，而工厂方法中的工厂是生产单一产品的工厂

##### 5.实现 #####

不知道大家玩过穿越火线或者吃鸡这类游戏了吗，游戏中存在各种枪。我们假设现在存在AK、M4A1两类枪，每一种枪对应一种子弹。我们现在这样考虑生产AK的工厂可以顺便生产AK使用的子弹，生产M4A1的工厂可以顺便生产M4A1使用的子弹。（AK工厂生产AK系列产品包括子弹啊，AK枪的类型啊这些，M4A1工厂同理）

###### 创建相关接口 ######

枪

public interface Gun {
        public void shooting();
    }

子弹

public interface Bullet {
        public void load();
    }

###### 创建接口对应实现类 ######

Ak类

public class AK implements Gun{
    
        @Override
        public void shooting() {
            System.out.println("shooting with AK");
    
        }
    
    }

M4A1类

public class M4A1 implements Gun {
    
        @Override
        public void shooting() {
            System.out.println("shooting with M4A1");
    
        }
    
    }

AK子弹类

public class AK_Bullet implements Bullet {
    
        @Override
        public void load() {
            System.out.println("Load bullets with AK");
        }
    
    }

M4A1子弹类

public class M4A1
    _Bullet implements Bullet {
    
        @Override
        public void load() {
            System.out.println("Load bullets with M4A1");
        }
    
    }

###### 创建工厂接口 ######

public interface Factory {
        public Gun produceGun();
        public Bullet produceBullet();
    }

###### 创建具体工厂 ######

生产AK和AK子弹的工厂

public class AK_Factory implements Factory{
    
        @Override
        public Gun produceGun() {
            return new AK();
        }
    
        @Override
        public Bullet produceBullet() {
            return new AK_Bullet();
        }
    
    }

生产M4A1和M4A1子弹的工厂

public class M4A1_Factory implements Factory{
    
        @Override
        public Gun produceGun() {
            return new M4A1();
        }
    
        @Override
        public Bullet produceBullet() {
            return new M4A1_Bullet();
        }
    
    }

#### 八.总结 ####

其实，无论是简单工厂模式、工厂模式还是抽象工厂模式，它们本质上都是将不变的业务部分提取出来，将可变的业务部分留作接口，以达到最大程度上的复用。究竟用哪种设计模式更适合，这要根据具体的业务需求来决定。

[6c28ec7d2af544dfb3172a3a11143ba1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/23/255266c28f0048e48b8ffb8dfdb452f2.png
[f51659e77bd1477e897a17fbd7e4db7d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/23/3627fc0a09f64ba884191b21d5c72abc.png
[984359cd1dc845fea23cc6e3e82aa356.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/23/eb033798440c4371970daaf9f178ef71.png