1. 简介

  抽象工厂是一种创建型模式，它提代一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂允许调用者使用抽象的接口创建一组相关的产口，而不需要关心它们具体的产品，这样就从具体的产口中解耦出来，依赖抽象而不是依赖具体类。

2. UML类图

  AbstractFactory是声明了创建抽象产品的抽象工厂，ConcreteFactory是具体的工厂，实现了创建具体产品。AbstractProduct是一类产品的抽象接口，Product是具体的产品。

3. 实例

抽象产品A

public interface AbstractProductA {
    void showProductA();
}

具体产品A

public class ProductA1 implements AbstractProductA {
    public void showProductA() {
        System.out.println("ProductA1");
    }
}

public class ProductA2 implements AbstractProductB {
    public void showProductA() {
        System.out.println("ProductA2");
    }
}

抽象产品B

public interface AbstractProductB {
    void showProductB();
}

具体产品B

public class ProductB1 implements AbstractProductB {
    public void showProductB() {
        System.out.println("ProductB1");
    }
}

public class ProductB2 implements AbstractProductB {
    public void showProductB() {
        System.out.println("ProductB2");
    }
}

抽象工厂

public interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

具体工厂

public class Factory1 implements AbstractFactory {
    public AbstractProductA createProductA() {
        return new ProductA1();
    }
    
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

public class Factory2 implements AbstractFactory {
    public AbstractProductA createProductA() {
        return new ProductA2();
    }
    
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

测试

public class Test {
    public static void main(String[] args) {
        AbstractFactory factory = new Factory1();
        AbstractProductA productA = factory.createProductA();
        productA.showProductA();
        
        AbstractProductB productB = factory.createProductB();
        productB.showProductB();
    }
}