抽象工厂

定义：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类**

package net;
interface ProductA {
    void methodA();
}
interface ProductB {
    void methodB();
}
class ProductA1 implements ProductA{
    public void methodA() {
        System.out.println("产品A系列中1型号产品的方法");
    }
}
class ProductA2 implements ProductA{
    public void methodA() {
        System.out.println("产品A系列中2型号产品的方法");
    }
}
class ProductB1 implements ProductB{
    public void methodB() {
        System.out.println("产品B系列中1型号产品的方法");
    }
}
class ProductB2 implements ProductB{
    public void methodB() {
        System.out.println("产品B系列中2型号产品的方法");
    }
}

工厂接口

package net;
public interface Creator {
    ProductA createProductA();
    ProductB createProductB();
}

工厂实现

package net;
public class ConcreteCreator1 implements Creator{
    public ProductA createProductA() {
        return new ProductA1();
    }
    public ProductB createProductB() {
        return new ProductB1();
    }
}
package net;
public class ConcreteCreator2 implements Creator{
    public ProductA createProductA() {
        return new ProductA2();
    }
    public ProductB createProductB() {
        return new ProductB2();
    }
}

测试

package net;


public class Client {

    public static void main(String[] args) throws Exception {
        Creator creator = new ConcreteCreator1();
        ProductA productA = creator.createProductA();
        ProductB productB = creator.createProductB();
        productA.methodA();
        productB.methodB();

        creator = new ConcreteCreator2();
        productA = creator.createProductA();
        productB = creator.createProductB();
        productA.methodA();
        productB.methodB();
    }
}

基于抽象工厂一旦定义，抽象产品的个数就已经固定，所以最好在抽象产品的个数不太会变化的情况下使用抽象工厂模式，当然，我们可以使用继承去弥补抽象工厂模式的这一不足，创造另外一个继承体系去扩展现有的框架。