抽象工厂示例(二)

例子来源：《设计模式之禅》——第9章 抽象工厂方法模式

AbstractProduct

public abstract class AbstractProductA {
    public abstract void doSomething();
}
public abstract class AbstractProductB {
    public abstract void doSomething();
}

ConcreteProduct

public class ConcreteProductA1 extends AbstractProductA {
    @Override
    public void doSomething() {
        System.out.println("产品A1的实现方法");
    }
}
public class ConcreteProductA2 extends AbstractProductA {
    @Override
    public void doSomething() {
        System.out.println("产品A2的实现方法");
    }
}
public class ConcreteProductB1 extends AbstractProductB {
    @Override
    public void doSomething() {
        System.out.println("产品B1的实现方法");
    }
}
public class ConcreteProductB2 extends AbstractProductB {
    @Override
    public void doSomething() {
        System.out.println("产品B2的实现方法");
    }
}

AbstractFactory

public abstract class AbstractFactory {
    /**
     * 创建A产品家族
     * @return
     */
    public abstract AbstractProductA createProductA();

    /**
     * 创建B产品家族
     * @return
     */
    public abstract AbstractProductB createProductB();
}

ConcreteFactory

public class Creator1 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}
public class Creator2 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

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

Client

public class Client {
    public static void main(String[] args) {
        // 定义两个工厂
        AbstractFactory f1 = new Creator1();
        AbstractFactory f2 = new Creator2();

        // 产生A1对象
        AbstractProductA a1 = f1.createProductA();

        // 产生A2对象
        AbstractProductA a2 = f2.createProductA();

        // 产生B1对象
        AbstractProductB b1 = f1.createProductB();

        // 产生B2对象
        AbstractProductB b2 = f2.createProductB();
    }
}

抽象工厂优点

• 封装性，每个产品的实现类不是高层模块要关心的
• 产品族内的约束为非公开状态

抽象工厂缺点

产品族的扩展非常困难