1.什么是工厂模式
工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的接口，而不是直接实例化类的方式。工厂模式通过定义一个用于创建对象的接口，让子类决定实例化哪一个类。这样，客户端代码与具体类的实例化过程解耦，提高了代码的灵活性和可维护性。
2.优缺点
优点：
-
解耦创建和使用：
- 工厂模式将对象的创建与其使用分离，使得代码更加符合单一职责原则。这种分离简化了对象创建的过程，增强了代码的可维护性和可读性。
-
增强代码的可扩展性：
- 新的产品类可以很容易地添加到系统中，而不需要修改现有的代码。通过引入新的工厂子类，可以在不影响客户端代码的情况下扩展产品家族。
-
隐藏对象创建的复杂性：
- 工厂模式隐藏了对象创建的复杂性，客户端不需要了解创建对象的具体细节，只需调用工厂方法即可。
-
统一对象创建的管理：
- 集中管理对象创建的逻辑，可以在工厂类中进行修改和优化，而不影响使用这些对象的代码部分。
-
支持抽象工厂和工厂方法模式的多态性：
- 通过使用多态性，工厂模式可以使客户端代码更加灵活，能够处理不同类型的对象而无需修改代码。
缺点：
-
增加系统的复杂性：
- 工厂模式引入了额外的工厂类和接口，增加了系统的复杂性和代码量。在简单应用中，这种复杂性可能是多余的。
-
可能导致类数量增加：
- 每一个具体产品都需要一个相应的工厂类，可能导致类的数量急剧增加，进而增加了系统的复杂度和维护成本。
-
难以调试：
- 由于工厂模式隐藏了对象的创建过程，调试时可能难以追踪对象的创建路径和原因。
-
不适用于所有场景：
- 工厂模式主要适用于需要灵活和可扩展的对象创建过程。如果对象的创建过程非常简单，使用工厂模式可能会显得过于繁琐。
3.工厂模式分类
主要有三种工厂模式：
- 简单工厂模式（Simple Factory）：不属于GOF 23种设计模式之一。通过一个工厂类来决定创建哪种产品类的实例。通常是用一个静态方法，根据参数的不同返回不同类的实例。
- 工厂方法模式（Factory Method）：定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法把实例化的工作推迟到子类。
- 抽象工厂模式（Abstract Factory）：提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。这个模式常用于系统的产品系列中。
4.代码示例
4.1 简单工厂模式
//定义一个产品接口
public interface Product {
void use();
}
//具体的产品类
public class ProductA implements Product {
@Override
public void use() {
System.out.println("Using Product A");
}
}
public class ProductB implements Product {
@Override
public void use() {
System.out.println("Using Product B");
}
}
public class ProductC implements Product {
@Override
public void use() {
System.out.println("Using Product C");
}
}
//创建一个工厂类
public class ProductFactory {
public static Product createProduct(String type) {
switch (type) {
case "A":
return new ProductA();
case "B":
return new ProductB();
case "C":
return new ProductC();
default:
throw new IllegalArgumentException("Unknown product type: " + type);
}
}
}
//测试
public class FactoryDemo {
public static void main(String[] args) {
Product productA = ProductFactory.createProduct("A");
productA.use();
Product productB = ProductFactory.createProduct("B");
productB.use();
Product productC = ProductFactory.createProduct("C");
productC.use();
}
}
4.2 工厂方法模式
//定义一个产品接口
public interface Product {
void use();
}
//具体的产品类
public class ProductA implements Product {
@Override
public void use() {
System.out.println("Using Product A");
}
}
public class ProductB implements Product {
@Override
public void use() {
System.out.println("Using Product B");
}
}
//定义工厂接口和具体工厂类：
public interface ProductFactory {
Product createProduct();
}
public class ProductAFactory implements ProductFactory {
@Override
public Product createProduct() {
return new ProductA();
}
}
public class ProductBFactory implements ProductFactory {
@Override
public Product createProduct() {
return new ProductB();
}
}
//测试
public class FactoryMethodDemo {
public static void main(String[] args) {
ProductFactory factoryA = new ProductAFactory();
Product productA = factoryA.createProduct();
productA.use();
ProductFactory factoryB = new ProductBFactory();
Product productB = factoryB.createProduct();
productB.use();
}
}
}
4.3 抽象工厂模式
// 产品接口1
public interface AbstractProductA {
void use();
}
// 产品A1的具体实现
public class ProductA1 implements AbstractProductA {
@Override
public void use() {
System.out.println("Using Product A1");
}
}
// 产品A2的具体实现
public class ProductA2 implements AbstractProductA {
@Override
public void use() {
System.out.println("Using Product A2");
}
}
// 产品接口2
public interface AbstractProductB {
void eat();
}
// 产品B1的具体实现
public class ProductB1 implements AbstractProductB {
@Override
public void eat() {
System.out.println("Eating Product B1");
}
}
// 产品B2的具体实现
public class ProductB2 implements AbstractProductB {
@Override
public void eat() {
System.out.println("Eating Product B2");
}
}
// 抽象工厂
public interface AbstractFactory {
AbstractProductA createProductA();
AbstractProductB createProductB();
}
// 具体工厂1，创建A1和B1产品
public class ConcreteFactory1 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ProductA1();
}
@Override
public AbstractProductB createProductB() {
return new ProductB1();
}
}
// 具体工厂2，创建A2和B2产品
public class ConcreteFactory2 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ProductA2();
}
@Override
public AbstractProductB createProductB() {
return new ProductB2();
}
}
//测试
public class AbstractFactoryDemo {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
AbstractProductA productA1 = factory1.createProductA();
AbstractProductB productB1 = factory1.createProductB();
productA1.use();
productB1.eat();
AbstractFactory factory2 = new ConcreteFactory2();
AbstractProductA productA2 = factory2.createProductA();
AbstractProductB productB2 = factory2.createProductB();
productA2.use();
productB2.eat();
}
}
