设计模式之-3种常见的工厂模式简单工厂模式、工厂方法模式和抽象工厂模式，每一种模式的概念、使用场景和优缺点。

---

前言

当谈到工厂模式时，通常指的是三种常见的工厂模式：简单工厂模式、工厂方法模式和抽象工厂模式。下面我将详细讲解每一种模式的概念、使用场景和优缺点。

一、3种模式的概念、使用场景和优缺点

简单工厂模式（Simple Factory Pattern）：

概念：简单工厂模式通过一个工厂类来创建不同类型的对象，客户端只需要知道所需对象的类型即可。
使用场景：当对象的创建逻辑相对简单且不需要频繁修改时，可以使用简单工厂模式。
优点：客户端代码与具体产品解耦，易于扩展和维护。
缺点：违反了开闭原则，新增产品需要修改工厂类的代码，不符合开放封闭原则。

工厂方法模式（Factory Method Pattern）：

概念：工厂方法模式将对象的创建延迟到子类中，由子类决定具体创建哪个对象。
使用场景：当需要创建一组相关或相互依赖的对象时，可以使用工厂方法模式。
优点：符合开闭原则，新增产品只需要添加相应的工厂类，不需要修改现有代码。
缺点：增加了系统的复杂度，每个产品都需要一个对应的工厂类。

抽象工厂模式（Abstract Factory Pattern）：

概念：抽象工厂模式提供一个接口，用于创建一系列相关或相互依赖的对象，而不需要指定具体的类。
使用场景：当需要创建一组相关对象的产品族时，可以使用抽象工厂模式。
优点：符合开闭原则，新增产品族只需要添加相应的具体工厂类，不需要修改现有代码。
缺点：增加了系统的复杂度，每个产品族都需要一个对应的具体工厂类。

二、3种工厂模式的代码示例

简单工厂模式：

// 产品接口
interface Product {
    void operation();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductA operation");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB operation");
    }
}

// 简单工厂类
class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.operation();

        Product productB = SimpleFactory.createProduct("B");
        productB.operation();
    }
}

工厂方法模式：

// 产品接口
interface Product {
    void operation();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductA operation");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB operation");
    }
}

// 工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂A
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.operation();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.operation();
    }
}

抽象工厂模式：

// 产品接口A
interface ProductA {
    void operation();
}

// 具体产品A1
class ConcreteProductA1 implements ProductA {
    @Override
    public void operation() {
        System.out.println("ConcreteProductA1 operation");
    }
}

// 具体产品A2
class ConcreteProductA2 implements ProductA {
    @Override
    public void operation() {
        System.out.println("ConcreteProductA2 operation");
    }
}

// 产品接口B
interface ProductB {
    void operation();
}

// 具体产品B1
class ConcreteProductB1 implements ProductB {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB1 operation");
    }
}

// 具体产品B2
class ConcreteProductB2 implements ProductB {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB2 operation");
    }
}

// 抽象工厂接口
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.operation();
        productB1.operation();

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.operation();
        productB2.operation();
    }
}