1. 工厂模式（简单工厂模式）

概念

工厂模式是一种创建对象的设计模式，它将对象的创建和使用分离。通过一个工厂类来负责创建对象，客户端只需要向工厂类请求对象，而不需要知道对象的具体创建过程。

使用场景

• 当创建对象的逻辑比较复杂，且创建过程可能会经常变化时。
• 当需要根据不同的条件创建不同类型的对象时。

使用方法

• 定义一个产品接口或抽象类。
• 实现具体的产品类，这些类都实现产品接口或继承抽象类。
• 创建一个工厂类，在工厂类中提供一个创建产品的方法，根据不同的条件返回不同的产品对象。

Java 实现

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

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

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

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

// 客户端代码
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        if (productA != null) {
            productA.use();
        }

        Product productB = SimpleFactory.createProduct("B");
        if (productB != null) {
            productB.use();
        }
    }
}

2. 工厂方法模式

概念

工厂方法模式是在简单工厂模式的基础上进行了改进，它将对象的创建延迟到子类中实现。定义一个创建对象的抽象方法，由子类决定具体创建哪个对象。

使用场景

• 当一个类不知道它所需要的对象的类时。
• 当一个类希望由它的子类来指定它所创建的对象时。
• 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化时。

使用方法

• 定义一个抽象产品接口或抽象类。
• 实现具体的产品类，这些类都实现产品接口或继承抽象类。
• 定义一个抽象工厂类，其中包含一个抽象的创建产品的方法。
• 实现具体的工厂类，继承抽象工厂类，实现创建产品的方法。

Java 实现

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

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

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

// 抽象工厂类
abstract class Factory {
    public abstract Product createProduct();
}

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

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

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

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

3. 抽象工厂方法模式

概念

抽象工厂模式是工厂方法模式的进一步扩展，它提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。客户端通过抽象工厂来创建一组相关的产品，而不需要关心具体的产品类。

使用场景

• 当需要创建一组相关的产品对象，并且希望这些对象之间保持一定的一致性时。
• 当系统需要独立于它的产品的创建、组合和表示时。

使用方法

• 定义多个抽象产品接口或抽象类，每个接口或抽象类代表一个产品族。
• 实现具体的产品类，这些类分别实现不同的产品接口或继承不同的抽象类。
• 定义一个抽象工厂接口，其中包含多个创建不同产品的抽象方法。
• 实现具体的工厂类，实现抽象工厂接口，创建具体的产品对象。

Java 实现

// 抽象产品A
interface AbstractProductA {
    void use();
}

// 具体产品A1
class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void use() {
        System.out.println("使用产品A1");
    }
}

// 具体产品A2
class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void use() {
        System.out.println("使用产品A2");
    }
}

// 抽象产品B
interface AbstractProductB {
    void operate();
}

// 具体产品B1
class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void operate() {
        System.out.println("操作产品B1");
    }
}

// 具体产品B2
class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void operate() {
        System.out.println("操作产品B2");
    }
}

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

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

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

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

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

// 客户端代码
public class AbstractFactoryDemo {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();
        productA1.use();
        productB1.operate();

        AbstractFactory factory2 = new ConcreteFactory2();
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();
        productA2.use();
        productB2.operate();
    }
}

总结

• 简单工厂模式：通过一个工厂类创建不同类型的对象，适用于创建对象逻辑简单且变化不大的场景。
• 工厂方法模式：将对象的创建延迟到子类中实现，增加了代码的可扩展性，适用于需要根据不同情况创建不同对象的场景。
• 抽象工厂模式：用于创建一组相关的产品对象，保证了产品之间的一致性，适用于创建多个相关产品族的场景。