工厂模式

1.什么是工厂模式

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的接口，而不是直接实例化类的方式。工厂模式通过定义一个用于创建对象的接口，让子类决定实例化哪一个类。这样，客户端代码与具体类的实例化过程解耦，提高了代码的灵活性和可维护性。

2.优缺点

优点：

• 解耦创建和使用：
  • 工厂模式将对象的创建与其使用分离，使得代码更加符合单一职责原则。这种分离简化了对象创建的过程，增强了代码的可维护性和可读性。
• 增强代码的可扩展性：
  • 新的产品类可以很容易地添加到系统中，而不需要修改现有的代码。通过引入新的工厂子类，可以在不影响客户端代码的情况下扩展产品家族。
• 隐藏对象创建的复杂性：
  • 工厂模式隐藏了对象创建的复杂性，客户端不需要了解创建对象的具体细节，只需调用工厂方法即可。
• 统一对象创建的管理：
  • 集中管理对象创建的逻辑，可以在工厂类中进行修改和优化，而不影响使用这些对象的代码部分。
• 支持抽象工厂和工厂方法模式的多态性：
  • 通过使用多态性，工厂模式可以使客户端代码更加灵活，能够处理不同类型的对象而无需修改代码。

缺点：

• 增加系统的复杂性：
  • 工厂模式引入了额外的工厂类和接口，增加了系统的复杂性和代码量。在简单应用中，这种复杂性可能是多余的。
• 可能导致类数量增加：
  • 每一个具体产品都需要一个相应的工厂类，可能导致类的数量急剧增加，进而增加了系统的复杂度和维护成本。
• 难以调试：
  • 由于工厂模式隐藏了对象的创建过程，调试时可能难以追踪对象的创建路径和原因。
• 不适用于所有场景：
  • 工厂模式主要适用于需要灵活和可扩展的对象创建过程。如果对象的创建过程非常简单，使用工厂模式可能会显得过于繁琐。

3.工厂模式分类

主要有三种工厂模式：

1. 简单工厂模式（Simple Factory）：不属于GOF 23种设计模式之一。通过一个工厂类来决定创建哪种产品类的实例。通常是用一个静态方法，根据参数的不同返回不同类的实例。
2. 工厂方法模式（Factory Method）：定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法把实例化的工作推迟到子类。
3. 抽象工厂模式（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();
    }
}