抽象工厂模式举例

旧城等待， 2024-03-23 12:44 10阅读 0赞

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

使用抽象工厂方法的好处:

1.  简单易用：客户端不需要知道具体产品类的名称，只需要知道所需产品的抽象类即可。
2.  具有良好的扩展性：当需要增加新的产品族时，只需要增加一个新的具体工厂类，不需要修改原来的代码。
3.  可以保证产品的一致性：一个工厂只负责生产同一产品族中的产品，保证所有产品都具有相同的风格和特点。

下面是一个简单的抽象工厂方法的示例：

// 抽象工厂接口
    public interface AbstractFactory {
        
        AbstractProductA createProductA();
        AbstractProductB createProductB();
    }
    
    // 具体工厂1，生产产品A1和B1
    public class ConcreteFactory1 implements AbstractFactory {
        
        @Override
        public AbstractProductA createProductA() {
        
            return new ProductA1();
        }
    
        @Override
        public AbstractProductB createProductB() {
        
            return new ProductB1();
        }
    }
    
    // 具体工厂2，生产产品A2和B2
    public class ConcreteFactory2 implements AbstractFactory {
        
        @Override
        public AbstractProductA createProductA() {
        
            return new ProductA2();
        }
    
        @Override
        public AbstractProductB createProductB() {
        
            return new ProductB2();
        }
    }
    
    // 抽象产品A
    public interface AbstractProductA {
        
        void show();
    }
    
    // 具体产品A1
    public class ProductA1 implements AbstractProductA {
        
        @Override
        public void show() {
        
            System.out.println("Product A1");
        }
    }
    
    // 具体产品A2
    public class ProductA2 implements AbstractProductA {
        
        @Override
        public void show() {
        
            System.out.println("Product A2");
        }
    }
    
    // 抽象产品B
    public interface AbstractProductB {
        
        void display();
    }
    
    // 具体产品B1
    public class ProductB1 implements AbstractProductB {
        
        @Override
        public void display() {
        
            System.out.println("Product B1");
        }
    }
    
    // 具体产品B2
    public class ProductB2 implements AbstractProductB {
        
        @Override
        public void display() {
        
            System.out.println("Product B2");
        }
    }
    
    // 客户端使用
    public class Client {
        
        public static void main(String[] args) {
        
            AbstractFactory factory1 = new ConcreteFactory1();
            AbstractProductA productA1 = factory1.createProductA();
            AbstractProductB productB1 = factory1.createProductB();
    
            AbstractFactory factory2 = new ConcreteFactory2();
            AbstractProductA productA2 = factory2.createProductA();
            AbstractProductB productB2 = factory2.createProductB();
    
            productA1.show(); // Product A1
            productB1.display(); // Product B1
    
            productA2.show(); // Product A2
            productB2.display(); // Product B2
        }
    }

在上面的代码中，抽象工厂接口 `AbstractFactory` 定义了两个创建产品的方法，分别对应两个产品族中的产品。具体工厂类 `ConcreteFactory1` 和 `ConcreteFactory2` 分别实现了抽象工厂接口，生产不同的产品族中的产品。

抽象产品类 `AbstractProductA` 和 `AbstractProductB` 定义了产品的基本行为，具体产品类 `ProductA1`、 `ProductA2`、`ProductB1` 和 `ProductB2` 实现了具体的产品行为。

在客户端中，通过创建具体工厂对象并调用其创建产品的方法，可以获取到具体的产品对象。由于客户端只依赖产品的抽象类而不依赖具体的产品类，因此可以很方便地进行扩展和修改。