工厂方法模式与抽象工厂模式的区别

工厂方法模式和抽象工厂模式都是创建型设计模式，它们的目的是通过引入工厂方法，隐藏对象的创建逻辑，减少代码的耦合性。尽管它们都解决了如何创建对象的问题，但它们的设计结构和应用场景有所不同。

1. 工厂方法模式（Factory Method Pattern）

工厂方法模式定义了一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法模式允许类的实例化推迟到子类，这样可以将对象的创建和使用分离。

工厂方法模式的结构

• 产品接口（Product）：定义了对象的基本接口。
• 具体产品（ConcreteProduct）：实现了 Product 接口的具体类。
• 工厂接口（Creator）：声明了一个工厂方法，用于创建产品。
• 具体工厂（ConcreteCreator）：实现了 Creator 接口，重写工厂方法来创建具体的产品。

工厂方法模式的优缺点

优点：

• 封装对象创建过程：客户端无需知道如何创建产品，只需要调用工厂方法。
• 扩展性好：可以通过增加新的具体工厂类和具体产品类来扩展程序，而不需要修改现有代码。

缺点：

• 增加类的数量：每增加一个产品类，就需要增加一个对应的工厂类，可能导致类的数量增多。

2. 抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而不指定具体的类。抽象工厂模式适用于需要创建多个系列的产品时，每个系列的产品可能包含多个类，并且这些类之间有一定的关系。

抽象工厂模式的结构

• 抽象产品（AbstractProduct）：定义了一组产品的接口。
• 具体产品（ConcreteProduct）：实现了 AbstractProduct 接口的具体类，通常会有多个产品类。
• 抽象工厂（AbstractFactory）：声明了创建一组产品的方法。
• 具体工厂（ConcreteFactory）：实现了 AbstractFactory 接口，具体创建某一组产品的实例。

抽象工厂模式的优缺点

优点：

• 解耦产品的创建与使用：客户端不需要知道具体的产品类，只需要知道如何通过工厂来创建产品。
• 适用于产品族的创建：当需要创建多个相关产品时，抽象工厂模式特别有效。

缺点：

• 扩展性较差：如果需要增加新的产品系列（即增加新的工厂类），可能需要修改现有的工厂类，违反了开闭原则。

3. 工厂方法模式与抽象工厂模式的区别

4. 代码实现

工厂方法模式的代码实现

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

// 具体产品A
class ConcreteProductA implements Product {
    public void display() {
        System.out.println("This is ConcreteProductA");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    public void display() {
        System.out.println("This is ConcreteProductB");
    }
}

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

// 具体工厂A
class ConcreteCreatorA implements Creator {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteCreatorB implements Creator {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

public class FactoryMethodPattern {
    public static void main(String[] args) {
        Creator creatorA = new ConcreteCreatorA();
        Product productA = creatorA.createProduct();
        productA.display();
        
        Creator creatorB = new ConcreteCreatorB();
        Product productB = creatorB.createProduct();
        productB.display();
    }
}

抽象工厂模式的代码实现

// 抽象产品接口
interface ProductA {
    void displayA();
}

interface ProductB {
    void displayB();
}

// 具体产品A1
class ConcreteProductA1 implements ProductA {
    public void displayA() {
        System.out.println("This is ConcreteProductA1");
    }
}

// 具体产品A2
class ConcreteProductA2 implements ProductA {
    public void displayA() {
        System.out.println("This is ConcreteProductA2");
    }
}

// 具体产品B1
class ConcreteProductB1 implements ProductB {
    public void displayB() {
        System.out.println("This is ConcreteProductB1");
    }
}

// 具体产品B2
class ConcreteProductB2 implements ProductB {
    public void displayB() {
        System.out.println("This is ConcreteProductB2");
    }
}

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

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

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

public class AbstractFactoryPattern {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.displayA();
        productB1.displayB();
        
        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.displayA();
        productB2.displayB();
    }
}

总结

• 工厂方法模式：适用于单一产品的创建，每个具体工厂负责创建一个具体产品。
• 抽象工厂模式：适用于多个相关产品的创建，每个具体工厂负责创建一系列相关产品，适合产品族的管理。

两者的主要区别在于工厂的复杂度，工厂方法模式关注单一产品的创建，而抽象工厂模式关注多个相关产品的创建。