GOF23设计模式（创建型模式）工厂模式

电玩女神 2023-02-17 05:29 62阅读 0赞

# 目录： #

## 一：工厂模式的核心本质 ##

## 二：关于面向对象的六大基本原则 ##

## 三：工厂模式的三大类详解（代码示例，详细分析） ##

--------------------

### 首先，上咱本GOF23所有工厂模式的分类表格！！！ ###

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:1.3854in;"> 创建型模式 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:1.3854in;"> 结构型横式 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:1.3854in;"> 行为型模式 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式 </td> 
 </tr> 
 </tbody> 
</table>

###  **其中我们讲的工厂模式为创建型模式！！！！** ###

--------------------

## **一：工厂模式的核心本质** ##

1.  实现了创建者和调用者的分离，实例化对象，用工厂方法代替new操作。
2.  将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

我们要明确的一点，我们设计模式的基础是**面向对象编程(Object Oriented Programming,OOP)**,只要是提及设计模式,肯定*都是*基于面向对象编程的，所以我们的设计模式要以面向对象的基本原则为基础！！！接下来，我给大家列出关于面向对象的六大基本原则！

--------------------

## 二：面向对象的六大基本原则（其中OCP为总原则） ##

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:404px;"> 总原则：OCP（开闭原则， Open-Closed Principle） </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:497px;"> 对扩展开放，对修改关闭。设计功能模块的时候，应当使这个模块在不被修改的前提下可以被扩展（功能） </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:404px;"> DIP（依赖倒转原则， Dependence Inversion Principle） </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:497px;"> 依赖抽象不依赖具体，高层模块不应该依赖底层模块，两者应该依赖抽象，抽象不应该依赖细节（具体实现），细节依赖抽象（依赖接口） 提高可维护性 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:404px;"> LOD（迪米特法则， Law of demeter） </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:497px;"> 对象之间联系越少越好，对于对象的使用，方法调用，具体内部细节知道的越少越好（高内聚，低耦合） 可维护性强。（尽量少与其他类有关系，利于解耦） </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:404px;"> SRP（单一职责原则，Single responsibility principle） </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:497px;"> 一个类或模块应该只做一件事(一个类或者模块对应一个功能类),高内聚，低耦合，专注于单一功能（高内聚） </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:404px;"> ISP（接口隔离原则，Interface Segregation Principle） </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:497px;"> 一个接口最好只有一个方法（功能），让实现一个接口的类重写一种方法（功能）。针对不同功能应该有不同接口，使接口的功能有选择性，不强迫必须实现不需要的功能。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:404px;"> CRP（组合/聚合原则，Composite Reuse Principle） </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:497px;"> 尽量使用对象组合，而不是继承对象达到功能复用的目的，一个新对象A能使用已有对象B达到功能复用(B对象的功能)，就不要通过继承(B)对象来达到功能复用 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:404px;"> LSP（里氏替换原则，Liskov Substitution Principle） </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:497px;"> 对于父类出现的地方，都可以用子类代替（多态，继承） </td> 
 </tr> 
 </tbody> 
</table>

--------------------

## 三： 三大工厂模式剖析 ##

### **详细分类：** ###

<table style="margin-left:.3333in;"> 
 <tbody> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:1.3881in;"> 简单工厂模式 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码） </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:1.3881in;"> 工厂方法模式 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 用来生产同一等级结构中的固定产品。（支持增加任意产品） </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:1.3881in;"> 抽象工厂模式 </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;"> 用来生产不同产品族的全部产品。（对于增加新的产品，无能为力，支持增加产品族） </td> 
 </tr> 
 </tbody> 
</table>

###  让我们一起来看看简单工厂模式！！ ###

首先我，定义了一个**Instrument** 接口（乐器）

package 二_工厂模式;
    
    public interface Instrument {
        void sing();
    }

然后定义了两个类**Guitar** 和**Piano** 继承**Instrument** 接口

package 二_工厂模式;
    
    public class Guitar implements Instrument {
        @Override
        public void sing() {
            System.out.println("吉他~");
        }
    }

package 二_工厂模式;
    
    public class Piano implements Instrument {
        @Override
        public void sing() {
            System.out.println("钢琴~");
        }
    }

### 在没有工厂的情况下： ###

package 二_工厂模式;
    
    public class noFactory {
        public static void main(String[] args) {
            Instrument i1 = new Guitar();
            Instrument i2 = new Piano();
            i1.sing();
            i2.sing();
        }
    }

发现实例化出Guitar和Piano的两个对象要和Instrument接口以及这两个实现类**都要**打交道，有些臃肿，于是我们引入了工厂模式

## 1 . 简单工厂模式 ##

在前面代码的基础上定义一个工厂类**InstrumentFactory**，其中的方法都定义为静态方法，直接通过类调用，其中创建对象有两种实现方式，在一下代码中给出！！

package 二_工厂模式;
    
    public class InstrumentFactory {
        public static Guitar creatGuitar() {
            return new Guitar();
        }
    
        public static Piano creatPiano() {
            return new Piano();
        }
    
        //或者这样实现
        public static Instrument creatInstrument(String type) {
            Instrument i = null;
            if ("吉他".equals(type))
                i = new Guitar();
            else if ("钢琴".equals(type))
                i = new Piano();
            return i;
        }
    }

然后我们进行实例化只用和工厂打交道

package 二_工厂模式;
    
    public class simpleFactory {
        public static void main(String[] args) {
            InstrumentFactory.creatGuitar().sing();
            InstrumentFactory.creatPiano().sing();
            //或者这样实现
            InstrumentFactory.creatInstrument("吉他").sing();
            InstrumentFactory.creatInstrument("钢琴").sing();
        }
    }

相比没有工厂的情况下，我们减少了在主函数里创建一个对象需要接触的类或者接口，实现了创建者和调用者的分离，实例化对象，用工厂方法代替new操作！！！

**但是**要增加新的类，比如"贝斯"类，必须修改工厂里已有的代码！！这是简单工厂模式的**一个弊端！！**

### 总结： ###

*  简单工厂模式也叫静态工厂模式、就是工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例
 *  对于增加新产品必须修改已有的代码！违反了OCP原则！不修改代码的话，是无法扩展的。

--------------------

## 2. **工厂方法模式** ##

同样在最前面的代码基础上增加一个工厂接口**creatFactory**

package 二_工厂模式;
    
    public interface creatFactory {
        Instrument creat();
    }

然后再增加两个具体的工厂实现类**GuitarCreat**和**PianoCreat**继承**creatFactory**接口

package 二_工厂模式;
    
    public class GuitarCreat implements creatFactory {
        @Override
        public Instrument creat() {
            return new Guitar();
        }
    }

package 二_工厂模式;
    
    public class PianoCreat implements creatFactory {
        @Override
        public Instrument creat() {
            return new Piano();
        }
    }

### 然后我们进行实例化只用分别和这两个工厂打交道 ###

package 二_工厂模式;
    
    public class FunctionFactory {
        public static void main(String[] args) {
            new GuitarCreat().creat().sing();
            new PianoCreat().creat().sing();
        }
    }

相比简单工厂法，如果要增加新的类，比如"贝斯"类，**不用修改工厂里已有的代码**，直接多加一个新的贝斯工厂实现工厂接口即可！！这是工厂方法模式的**一个好处！！！**

###  总结： ###

*  为了避免简单工厂模式的缺点，此方法满足了**总原则：OCP原则**
 *  工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

--------------------

## 3.**抽象工厂模式** ##

### **简介：** ###

*  用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
 *  抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业努分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式

--------------------

首先我们明白什么是**产品族**，接下来我会以实现一个**汽车工厂**为例

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0_size_16_color_FFFFFF_t_70][]

我们把汽车拆分为Engine（发动机）、Seat（座位）、Tyre（轮胎）三部分

分别创建这三个接口~~

汽车就是一种**产品**，我们将汽车这个产品分为两个**产品族：**

1.  **昂贵的汽车**，包括LuxuryEngine、LuxurySeat、LuxuryTyre三个部分，分别实现了以上三个对应的接口
2.  **低端的汽车**，包括LowEngine、LowSeat、LowTyre三个部分，分别实现了以上三个对应的接口

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:288px;"> package 二_工厂模式_抽象工厂模式; &nbsp; //发动机 public interface Engine { &nbsp;&nbsp;&nbsp; void noice();//噪音 &nbsp;&nbsp;&nbsp; void price();//价格 } &nbsp; class LowEngine implements Engine { &nbsp;&nbsp;&nbsp; @Override &nbsp;&nbsp;&nbsp; public void noice() { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("噪音很大"); &nbsp;&nbsp;&nbsp; } &nbsp; &nbsp;&nbsp;&nbsp; @Override &nbsp;&nbsp;&nbsp; public void price() { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("价格便宜"); &nbsp;&nbsp;&nbsp; } } &nbsp; class LuxuryEngine implements Engine { &nbsp;&nbsp;&nbsp; @Override &nbsp;&nbsp;&nbsp; public void noice() { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("噪音很小"); &nbsp;&nbsp;&nbsp; } &nbsp; &nbsp;&nbsp;&nbsp; @Override &nbsp;&nbsp;&nbsp; public void price() { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("价格昂贵"); &nbsp;&nbsp;&nbsp; } } </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:14px;"> &nbsp; </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:299px;"> package 二_工厂模式_抽象工厂模式; &nbsp; //座位 public interface Seat { &nbsp;&nbsp;&nbsp; void comfortable();//舒适程度 &nbsp;&nbsp;&nbsp; void functionality();//功能性 } &nbsp; class LowSeat implements Seat { &nbsp;&nbsp;&nbsp; @Override &nbsp;&nbsp;&nbsp; public void comfortable() { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("不舒服"); &nbsp;&nbsp;&nbsp; } &nbsp; &nbsp;&nbsp;&nbsp; @Override &nbsp;&nbsp;&nbsp; public void functionality() { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("功能性很差"); &nbsp;&nbsp;&nbsp; } } &nbsp; class LuxurySeat implements Seat { &nbsp;&nbsp;&nbsp; @Override &nbsp;&nbsp;&nbsp; public void comfortable() { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("很舒适"); &nbsp;&nbsp;&nbsp; } &nbsp; &nbsp;&nbsp;&nbsp; @Override &nbsp;&nbsp;&nbsp; public void functionality() { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("功能性很强大"); &nbsp;&nbsp;&nbsp; } } </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:17px;"> &nbsp; </td> 
 <td style="border-color:#a3a3a3;vertical-align:top;width:296px;"> package 二_工厂模式_抽象工厂模式; &nbsp; //轮胎 public interface Tyre { &nbsp;&nbsp;&nbsp; void durability();//耐用性 &nbsp;&nbsp;&nbsp; void security();//安全性 } &nbsp; class LowTyre implements Tyre { &nbsp;&nbsp;&nbsp; @Override &nbsp;&nbsp;&nbsp; public void durability() { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("耐用性很差"); &nbsp;&nbsp;&nbsp; } &nbsp; &nbsp;&nbsp;&nbsp; @Override &nbsp;&nbsp;&nbsp; public void security() { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("安全性很差"); &nbsp;&nbsp;&nbsp; } } &nbsp; class LuxuryTyre implements Tyre { &nbsp;&nbsp;&nbsp; public void durability() { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("耐用性很好"); &nbsp;&nbsp;&nbsp; } &nbsp; &nbsp;&nbsp;&nbsp; @Override &nbsp;&nbsp;&nbsp; public void security() { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("安全性很好"); &nbsp;&nbsp;&nbsp; } } </td> 
 </tr> 
 </tbody> 
</table>

接下来，我们创建一个汽车工厂的接口**CarFactory**，并且为旗下的两个产品族分别创建工厂LowFactory、LuxuryFactory、实现以上接口，用来创建Engine（发动机）、Seat（座位）、Tyre（轮胎）

package 二_工厂模式_抽象工厂模式;
    
    public interface CarFactory {
        Engine createEngine();
        Seat createSeat();
        Tyre createTyre();
    }
    
    class LowFactory implements CarFactory {
    
        @Override
        public Engine createEngine() {
            return new LowEngine();
        }
    
        @Override
        public Seat createSeat() {
            return new LowSeat();
        }
    
        @Override
        public Tyre createTyre() {
            return new LowTyre();
        }
    }
    
    class LuxuryFactory implements CarFactory {
    
        @Override
        public Engine createEngine() {
            return new LuxuryEngine();
        }
    
        @Override
        public Seat createSeat() {
            return new LuxurySeat();
        }
    
        @Override
        public Tyre createTyre() {
            return new LuxuryTyre();
        }
    }

最后，我们在一个主方法里测试，通过两个产品族的工厂直接分别创建两个产品族汽车的轮子，座椅和发动机

package 二_工厂模式_抽象工厂模式;
    
    public class client {
        public static void main(String[] args) {
            //高端汽车产品族
            CarFactory factory1 = new LuxuryFactory();
            factory1.createEngine().noice();
            factory1.createEngine().price();
            factory1.createSeat().comfortable();
            factory1.createSeat().functionality();
            factory1.createTyre().durability();
            factory1.createTyre().security();
            //低端汽车产品族
            CarFactory factory2 = new LowFactory();
            factory2.createEngine().noice();
            factory2.createEngine().price();
            factory2.createSeat().comfortable();
            factory2.createSeat().functionality();
            factory2.createTyre().durability();
            factory2.createTyre().security();
        }
    }

根据结果，我们已经创建成功，这就是关于抽象工厂模式的一个实例！！！

--------------------

### THE END------------------------------------------------------------------------------------------------------- ###

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200612203541338.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0,size_16,color_FFFFFF,t_70