当前位置：首页 > article >正文

抽象工厂模式和工厂模式的区别

article 2024/9/30 18:51:38

1. 工厂模式（Factory Method Pattern）
工厂模式是为创建对象提供一个接口，让子类决定实例化哪一个类。工厂模式通过将实例化的过程延迟到子类，从而实现对象创建的灵活性。

核心思想：定义一个创建对象的接口，但由子类来具体决定要实例化哪一个类。
特点：关注的是“创建某一种类的对象”，它解决的是不同子类中如何实例化对象的细节问题。

结构：

抽象工厂类：声明创建产品的方法。
具体工厂类：实现创建产品的方法。
产品接口：定义产品的共同接口。
具体产品类：实现产品接口的具体类。

示例：

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

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

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

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

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

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

在工厂模式中，每个具体工厂负责生产一种具体产品。你可以通过选择不同的工厂来创建不同的产品。

2. 抽象工厂模式（Abstract Factory Pattern）
抽象工厂模式是一种更复杂的设计模式，它允许你创建一组相关的对象，而不是单个对象。抽象工厂提供一个接口，能够创建一系列相关或依赖的对象，而无需指定它们的具体类。

核心思想：提供一个创建一组相关或相互依赖对象的接口，而无需指定具体类。
特点：不仅能创建一个产品，还能创建一组产品，这组产品通常有某种关联或依赖关系。

结构：

抽象工厂接口：定义创建一组相关对象的方法。
具体工厂类：实现创建具体产品的方法。
抽象产品接口：为每个产品类提供接口。
具体产品类：实现抽象产品接口的具体类。

示例：

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

// 抽象产品B接口
interface ProductB {
    void consume();
}

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

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

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

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

// 抽象工厂接口
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();
    }
}