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

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();
		
	}
}

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

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

---

工厂方法：

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();
		
	}
}

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

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

---

抽象工厂：

 

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

	简单工厂	工厂方法	抽象工厂
创建包含角色	抽象产品类	抽象产品类	抽象产品分类1
	具体产品类	具体产品类	抽象产品分类2
	具体工厂类	抽象工厂类	具体产品1类
	客户端测试	具体工厂类	具体产品2 类
		客户端测试	抽象工厂类
			具体工厂类
			客户端测试
工厂方法：在简单工厂基础上多了一个抽象工厂类 抽象工厂：在工厂方法上多了抽象产品分类

 

 

 4.三者对比优缺点

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

---

使用场景：

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