设计模式-抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是工厂方法模式的进一步抽象，也是一种创建型设计模式。与工厂方法模式最大的不同点是：工厂方法模式是一个抽象产品对应一个具体产品，而抽象工厂模式是多个抽象产品对应多个具体产品。

定义： 为创建一组相关或者是相互依赖的对象提供一个接口，而不需要指定他们的具体类。

使用场景： 一个对象族有相同的约束时可以使用此模式。比如说鸟和狗都有吃东西、拉屎、睡觉的行为。但是它们不是相同种类，这种情况下就可以用抽象工厂模式来生成它们的相同行为。

抽象产品类A:

public abstract class AbsProductA {
    public abstract void method();
}

抽象产品类B:

public abstract class AbsProductB {
    public abstract void method();
}

具体产品类A1：

public class ConcreteProductA1 extends AbsProductA{

    @Override
    public void method() {
        // TODO Auto-generated method stub
        System.out.println("具体产品A1");
    }

}

具体产品类A2：

public class ConcreteProductA2 extends AbsProductA{

    @Override
    public void method() {
        // TODO Auto-generated method stub
        System.out.println("具体产品A2");
    }

}

具体产品类B1：

public class ConcreteProductB1 extends AbsProductB{

    @Override
    public void method() {
        // TODO Auto-generated method stub
        System.out.println("具体产品B1");
    }

}

具体产品类B2：

public class ConcreteProductB2 extends AbsProductB{

    @Override
    public void method() {
        // TODO Auto-generated method stub
        System.out.println("具体产品B2");
    }

}

抽象工厂类：

public abstract class AbsFactory {

    public abstract AbsProductA createProductA();

    public abstract AbsProductB createProductB();
}

具体工厂类1：

public class ConcreteFactory1 extends AbsFactory{

    @Override
    public AbsProductA createProductA() {
        // TODO Auto-generated method stub
        return new ConcreteProductA1();
    }

    @Override
    public AbsProductB createProductB() {
        // TODO Auto-generated method stub
        return new ConcreteProductB1();
    }

}

具体工厂类2：

public class ConcreteFactory2 extends AbsFactory{

    @Override
    public AbsProductA createProductA() {
        // TODO Auto-generated method stub
        return new ConcreteProductA2();
    }

    @Override
    public AbsProductB createProductB() {
        // TODO Auto-generated method stub
        return new ConcreteProductB2();
    }

}

测试类：

public class Test {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        AbsFactory factory = new ConcreteFactory1();
        factory.createProductA().method();
        factory.createProductB().method();

        AbsFactory factory2 = new ConcreteFactory2();
        factory2.createProductA().method();
        factory2.createProductB().method();
    }

}

输出结果：

具体产品A1
具体产品B1
具体产品A2
具体产品B2

抽象工厂方法类比较多，主要分为4类：
AbsProduct：抽象产品角色，它为不同的产品声明接口。
ConcreteProduct：具体产品角色，实现抽象产品接口中的方法，由具体工厂生成具体产品对象。
AbsFactory: 抽象工厂角色，它声明多个创建产品的方法，一个方法对应一个产品。
ConcreteFactory: 具体工厂角色，它实现抽象工厂中创建产品的方法，生成一组具体产品，每一种产品都属于其实现的抽象产品类。

由此可以看出每增加一个工厂类相应的抽象产品类，和具体产品类都得增加，从而增加好些类。这也是它的一个弊端。

最后工厂方法模式和抽象工厂模式除了一个只有一个抽象产品类，一个有多个外。工厂方法模式的具体工厂类一次只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个两点不同处。