Java设计模式——工厂设计模式，详解

心已赠人 2024-03-24 19:55 64阅读 0赞

1.  **什么是工厂模式**
2.  **为什么需要工厂模式、工厂模式是干什么的**
3.  **工厂模式有哪些，怎么创建，怎么使用**
    
    1.  简单工厂模式
    2.  工厂方法模式
    3.  抽象工厂模式
4.  **其中每一个区别，以及使用场景**

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

###  ###

### 1.什么是工厂模式： ###

工厂模式是一种创建对象的设计模式，它提供了一种方式来封装对象的创建逻辑，并根据不同的需求，返回相应的对象实例。工厂模式使得客户端代码与具体对象的创建过程解耦（将代码中的关联性和依赖性降低，使得各个模块之间的耦合度减少），提高了代码灵活性和可维护性。

总结：工厂模式是 通过封装对象创建的过程，提供了一种 统一的接口来创建对象。它隐藏了对象的具体实现细节，提供了灵活性、可扩展性，并提高了代码的可读性和可维护性。

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

###  ###

### **2.为什么需要工厂模式、工厂模式是干什么的：** ###

工厂模式的主要目的是解决以下问题：

1.  将对象的创建逻辑与使用代码分离，使得使用代码不需要关心对象具体如何创建。（解耦）
2.  提供一种简单的扩展机制，使得新增一种产品时不需要修改现有的代码，只需扩展工厂类即可。

工厂模式的**核心思想**是引入一个抽象的工厂接口或抽象类，该接口或抽象类定义了创建对象的方法，具体的对象创建由实现该接口或抽象类的具体工厂类来完成。

**优点：**

1.  **封装**对象的**创建过程**：工厂模式将对象的创建过程封装在工厂类中，使得客户端无需关注对象的具体创建细节，只需通过工厂类获取所需对象。
2.  **解耦**客户端与具体产品：客户端只需要通过工厂接口来创建对象，而无需直接实例化具体产品类，从而降低了客户端与具体产品的耦合度。
3.  提供**灵活性**和可**扩展性**：通过新增具体工厂类和产品类，可以方便地扩展工厂模式，增加新的产品类型，而不需要修改已有代码。
4.  代码**可读性**和**可维护性**：工厂模式提供了清晰的代码结构，使得代码更易于理解、维护和测试。

**缺点：**

1.  **增加了系统的复杂性**：引入工厂类和抽象产品类会增加系统的类和对象数量，增加了系统的复杂性。
2.  **增加**了开发的初期**成本**：工厂模式需要定义抽象工厂类和具体工厂类，以及相应的产品类，这在开发的初期会增加一定的开发成本。
3.  难以支持新种类的产品：如果需要添加新种类的产品，除了新增具体产品类外，还需要修改抽象工厂接口和所有具体工厂类的实现，可能会导致较大的修改范围。

综上所述，工厂模式在提**供灵活性、可扩展性和代码可读性**方面具有优点，但也会**增加系统的复杂性和开发成本**。在设计时需要权衡使用工厂模式的利弊，并根据具体情况选择是否使用该模式。

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

### **3.工厂模式有哪些：** ###

**工厂模式包含很多，常见的三种分别是：**

1.  1.简单工厂模式（Simple Factory Pattern）：简单工厂模式通过一个工厂类来封装对象的创建逻辑，根据客户端传入的参数返回相应的产品对象。
2.   2.工厂方法模式（Factory Method Pattern）：工厂方法模式将对象的创建延迟到子类中，每个具体子类都负责创建一个特定的产品对象，客户端通过调用工厂方法来获取所需的产品对象。
3.  3.抽象工厂模式（Abstract Factory Pattern）：抽象工厂模式提供一个接口或抽象类，用于创建一系列相关或相互依赖的产品对象。具体的工厂类实现了该接口或继承了该抽象类，并负责创建对应的产品系列。

实例：

#### 简单工厂： ####

package 设计模式.工厂模式.简单工厂;
    
    //定义产品接口   抽象产品类
    public interface Shape {
    	void draw();
    
    }

package 设计模式.工厂模式.简单工厂;
    
    //实现产品接口  具体类 三角形
    public class Triangle implements Shape {
    
    	@Override
    	public void draw() {
    		System.out.println("三角形实现类");
    		
    	}
    
    }

package 设计模式.工厂模式.简单工厂;
    
    //实现产品接口  具体类 圆
    public class Cricle implements Shape {
    
    	@Override
    	public void draw() {
    		System.out.println("圆实现类");
    
    	}
    
    }

package 设计模式.工厂模式.简单工厂;
    
    //实现产品接口  具体类 正方形
    public class Square implements Shape {
    
    	@Override
    	public void draw() {
    		System.out.println("正方形实现类");
    
    	}
    
    }

package 设计模式.工厂模式.简单工厂;
    
    //简单工厂
    public class ShapeFactory {
    
    	public static Shape CreateShap( String type) {
    
    //		equalsIgnoreCase比较不区分大小写
    		if(type.equalsIgnoreCase("circle")) {
    			return new Cricle();
    		}else if (type.equalsIgnoreCase("square")) {
    			return new Square();
    		}else if (type.equalsIgnoreCase("triangle")) {
    			return new Triangle();
    		}else {
    			return null;
    		}
    	}
    }

package 设计模式.工厂模式.简单工厂;
    
    public class text {
    
    	public static void main(String[] args) {
    		
    		Shape circle=ShapeFactory.CreateShap("circle");
    		circle.draw();
    		
    		Shape square=ShapeFactory.CreateShap("square");
    		square.draw();
    		
    		Shape triangle=ShapeFactory.CreateShap("triangle");
    		triangle.draw();
    		
    	}
    }

![d08d084c601e4055b8479d4dffe96c09.png][]

**简单工厂包含****三部分**抽象产品类  具体产品类  具体工厂类  客户端测试

这里的抽象类（可以理解就是共有部分，比如水果类。这就是抽象类，他抽象了所有水果的一个合集。）

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

#### 工厂方法： ####

package 设计模式.工厂模式.工厂方法模式;
    
    
    //抽象产品类
    public interface Product {
    	public void operation();
    
    }

package 设计模式.工厂模式.工厂方法模式;
    
    //具体产品A
    public class ProduceA implements Product {
    
    	@Override
    	public void operation() {
    		System.out.println("具体产品A生产!");
    	}
    
    }

package 设计模式.工厂模式.工厂方法模式;
    
    //具体产品B
    public class ProduceB implements Product  {
    
    	@Override
    	public void operation() {
    		System.out.println("具体产品B生产!");
    	}
    
    }

package 设计模式.工厂模式.工厂方法模式;
    
    //抽象工厂类
    public interface Factory {
    	Product createProdct();
    }

package 设计模式.工厂模式.工厂方法模式;
    
    //具体工厂类A，负责创建产品A
    public class FactoryA implements Factory {
    
    	@Override
    	public Product createProdct() {
    		// TODO Auto-generated method stub
    		return new ProduceA();
    	}
    
    }

package 设计模式.工厂模式.工厂方法模式;
    
    //具体工厂类B，负责创建产品B
    public class FactoryB implements Factory {
    
    	@Override
    	public Product createProdct() {
    		// TODO Auto-generated method stub
    		return new ProduceB();
    	}
    
    }

package 设计模式.工厂模式.工厂方法模式;
    
    public class text {
    
    	public static void main(String[] args) {
    		
    		// 使用具体工厂A创建产品对象
    		Factory factoryA=new FactoryA();
    		Product productA=factoryA.createProdct();
    		productA.operation();
    		
    		Factory factoryB=new FactoryB();
    		Product productB=factoryB.createProdct();
    		productB.operation();
    		
    	}
    }

![692b53593ce44fb199cae45f225b29d5.png][]

**简单工厂包含****四部分** 抽象产品类 具体产品类  抽象工厂类 具体工厂类  客户端测试

**在简单工厂基础上多了一个抽象工厂类**

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

####  ####

#### 抽象工厂： ####

![78b3aec52ab8478c81d92ee263dca2c3.png][]

#### 从实例来看，前期最直观的就是创建上的区别： ####

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td style="width:111px;"></td> 
 <td style="width:135px;">简单工厂</td> 
 <td style="width:128px;">工厂方法</td> 
 <td>抽象工厂</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="width:111px;">创建包含角色</td> 
 <td style="width:135px;">抽象产品类</td> 
 <td style="width:128px;">抽象产品类&nbsp;</td> 
 <td>抽象产品分类1</td> 
 </tr> 
 <tr> 
 <td style="width:135px;">具体产品类</td> 
 <td style="width:128px;">具体产品类</td> 
 <td>抽象产品分类2</td> 
 </tr> 
 <tr> 
 <td style="width:135px;">具体工厂类</td> 
 <td style="width:128px;">抽象工厂类</td> 
 <td>具体产品1类&nbsp;</td> 
 </tr> 
 <tr> 
 <td style="width:135px;">客户端测试</td> 
 <td style="width:128px;">具体工厂类&nbsp;</td> 
 <td>具体产品2 类</td> 
 </tr> 
 <tr> 
 <td style="width:135px;"></td> 
 <td style="width:128px;">客户端测试</td> 
 <td>抽象工厂类</td> 
 </tr> 
 <tr> 
 <td style="width:135px;"></td> 
 <td style="width:128px;"></td> 
 <td>具体工厂类&nbsp;</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="width:111px;"></td> 
 <td style="width:135px;"></td> 
 <td style="width:128px;"></td> 
 <td>客户端测试</td> 
 </tr> 
 <tr> 
 <td colspan="4" style="width:111px;"> 工厂方法：在简单工厂基础上多了一个抽象工厂类 抽象工厂：在工厂方法上多了抽象产品分类 </td> 
 </tr> 
 </tbody> 
</table>

### 4.三者对比优缺点 ###

<table> 
 <tbody> 
 <tr> 
 <td style="width:84px;">名称：</td> 
 <td style="width:334px;">优点：</td> 
 <td>缺点：</td> 
 </tr> 
 <tr> 
 <td style="width:84px;">简单工厂</td> 
 <td style="width:334px;"> 
 <ul> 
 <li>实现简单，适合创建单一类型的对象。</li> 
 <li>将对象的实例化过程集中在工厂类中，客户端只需要与工厂进行交互，降低了客户端的复杂度。</li> 
 <li>隐藏了对象的创建细节，提供了一种简单的方式来获取所需对象。</li> 
 </ul></td> 
 <td> 
 <ul> 
 <li>扩展性较差，对于新增产品类型需要修改工厂类的逻辑。</li> 
 <li>违背了开闭原则，对于每个新增的产品类型都需要修改工厂类的代码，增加了耦合性。</li> 
 </ul></td> 
 </tr> 
 <tr> 
 <td style="width:84px;">工厂方法</td> 
 <td style="width:334px;"> 
 <ul> 
 <li>通过定义抽象工厂和具体工厂，每个具体工厂负责创建特定的产品，可以灵活地扩展工厂和产品。</li> 
 <li>符合开闭原则，新增产品类型只需添加相应的具体工厂即可，无需修改已有代码。</li> 
 </ul></td> 
 <td> 
 <ul> 
 <li>客户端需要与具体工厂进行交互，增加了客户端的复杂性。</li> 
 </ul></td> 
 </tr> 
 <tr> 
 <td style="width:84px;">抽象工厂</td> 
 <td style="width:334px;"> 
 <ul> 
 <li>提供一种将相关产品组合成系列或簇的方式。</li> 
 <li>可以在不修改已有代码的情况下引入新的产品系列。</li> 
 <li>可以确保创建的产品是相互配套的。</li> 
 </ul></td> 
 <td> 
 <ul> 
 <li>扩展新的产品族比较困难，需要修改抽象工厂接口和所有具体工厂的实现。</li> 
 </ul> </td> 
 </tr> 
 <tr> 
 <td colspan="3" style="width:84px;"> 简单工厂模式适合简单场景，但扩展性较差。 工厂方法模式更灵活，符合开闭原则。 抽象工厂模式适用于创建产品族。使用时，需要根据需求和设计目标综合考虑选择合适的工厂模式。 </td> 
 </tr> 
 </tbody> 
</table>

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

### 使用场景： ###

<table> 
 <tbody> 
 <tr> 
 <td style="width:128px;">名称：</td> 
 <td style="width:546px;">使用场景：</td> 
 </tr> 
 <tr> 
 <td style="width:128px;">简单工厂</td> 
 <td style="width:546px;"> 当需要根据不同的条件创建单一类型的对象时，可以使用简单工厂模式。例如，根据用户的角色类型创建相应的权限对象。 </td> 
 </tr> 
 <tr> 
 <td style="width:128px;">工厂方法</td> 
 <td style="width:546px;"> 当需要根据不同的产品类型创建不同的工厂，并且客户端需要与具体工厂进行交互时，可以使用工厂方法模式。例如，创建不同类型的日志记录器，每种类型的日志记录器由对应的日志记录器工厂来创建。 </td> 
 </tr> 
 <tr> 
 <td style="width:128px;">抽象工厂</td> 
 <td style="width:546px;"> 当需要创建一系列相关或相互依赖的产品对象时，可以使用抽象工厂模式。例如，创建不同操作系统下的图形界面组件，每个操作系统对应一个图形界面组件工厂，而每个工厂分别负责创建各种类型的组件。 </td> 
 </tr> 
 <tr> 
 <td colspan="2" style="width:128px;"> 总结： 
 <ul> 
 <li>简单工厂模式适用于创建单一类型的对象。</li> 
 <li>工厂方法模式适合在客户端与具体工厂进行交互、根据不同的产品类型创建不同的工厂的情况。</li> 
 <li>抽象工厂模式适用于创建一系列相关或相互依赖的产品对象的情况。</li> 
 </ul></td> 
 </tr> 
 </tbody> 
</table>

[d08d084c601e4055b8479d4dffe96c09.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/c5fe9bac90304411a01f774a7993b9b1.png
[692b53593ce44fb199cae45f225b29d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/381d0f9f6250466fb958f1a8ac25bb11.png
[78b3aec52ab8478c81d92ee263dca2c3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/b95481e60a9f48418873e5de38cc948a.png