工厂模式及抽象工厂模式-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_47803327/article/details/147393959

工厂模式和抽象工厂模式都是创建型设计模式，用于对象的创建，但它们在抽象层次和应用场景上有所不同。

工厂模式 (Factory Pattern)

概念

工厂模式定义了一个创建对象的接口，但让子类决定实例化哪个类。工厂方法让类的实例化推迟到子类。

特点

通过工厂方法创建对象，而不是直接使用new操作符
客户端代码只需知道抽象接口，无需关心具体实现
便于扩展新的产品类型

实现方式

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

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

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

// 工厂接口
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 Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactoryA();
        Product product = factory.createProduct();
        product.use(); // 输出: Using Product A
    }
}

抽象工厂模式 (Abstract Factory Pattern)

概念

抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

特点

创建的是产品族（多个相关产品）
比工厂模式更高层次的抽象
易于交换产品系列
难以支持新增产品种类

实现方式

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

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

// 具体产品A1
class ProductA1 implements AbstractProductA {
    @Override
    public void useA() {
        System.out.println("Using Product A1");
    }
}

// 具体产品A2
class ProductA2 implements AbstractProductA {
    @Override
    public void useA() {
        System.out.println("Using Product A2");
    }
}

// 具体产品B1
class ProductB1 implements AbstractProductB {
    @Override
    public void useB() {
        System.out.println("Using Product B1");
    }
}

// 具体产品B2
class ProductB2 implements AbstractProductB {
    @Override
    public void useB() {
        System.out.println("Using Product B2");
    }
}

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

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

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

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

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory1();
        AbstractProductA productA = factory.createProductA();
        AbstractProductB productB = factory.createProductB();
        
        productA.useA(); // 输出: Using Product A1
        productB.useB(); // 输出: Using Product B1
    }
}