构造型模式之Abstract Factory（抽象工厂）模式

1.如果你期望构造一系列具有某个公共特性的对象，可使用Abstract Factory（抽象工厂）模式
2.举例（在工厂方法模式基础上添加和修改）

//工厂抽象类
public abstract class Factory {
    abstract <T> T createProduct(T t);
    abstract String getFactoryName();
}

//添加另外产品接口
public interface IProductOther {
    void twe();
    void setFactoryName(String string);
}

//另外产品A
public class ProductOtherA implements IProductOther{

    @Override
    public void twe() {
        // TODO Auto-generated method stub
        System.out.println("twe ProductOtherA");
    }

    @Override
    public void setFactoryName(String string) {
        // TODO Auto-generated method stub
        System.out.println(string + "->" + "ProductOtherA");
    }

}

//另外产品B
public class ProductOtherB implements IProductOther{

    @Override
    public void twe() {
        // TODO Auto-generated method stub
        System.out.println("twe ProductOtherB");
    }

    @Override
    public void setFactoryName(String string) {
        // TODO Auto-generated method stub
        System.out.println(string + "->" + "ProductOtherB");
    }

}

//第一个工厂：只能生产IProduct相关产品
public class FirstFactory extends Factory{

    @Override
    <T> T createProduct(T t) {
        // TODO Auto-generated method stub
        T product = null;
        try {
            product = (T)Class.forName(t.getClass().getName()).newInstance();   
            if(product instanceof IProduct){                
                ((IProduct) product).setFactoryName(getFactoryName());
                return product;
            }
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    @Override
    String getFactoryName() {
        // TODO Auto-generated method stub
        return "FirstFactory";
    }

}

//第二个工厂：可以生产所有产品的全能工厂
public class SecondFactory extends Factory{

    @Override
    <T> T createProduct(T t) {
        // TODO Auto-generated method stub
        T product = null;
        try {
            product = (T)Class.forName(t.getClass().getName()).newInstance();
            if(product instanceof IProduct){
                ((IProduct) product).setFactoryName(getFactoryName());
            } else if (product instanceof IProductOther) {
                ((IProductOther) product).setFactoryName(getFactoryName());
            }
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        };
        return product;
    }

    @Override
    String getFactoryName() {
        // TODO Auto-generated method stub
        return "SecondFactory";
    }

}

//测试类
public class Test {
    public static void main(String[] args){
        Factory ff = new FirstFactory();
        IProduct a1 = ff.createProduct(new ProductA());
        IProduct b1 = ff.createProduct(new ProductB());
        IProductOther aO1 = ff.createProduct(new ProductOtherA());

        Factory sf = new SecondFactory();
        IProduct a2 = sf.createProduct(new ProductA());
        IProductOther bO2 = sf.createProduct(new ProductOtherB());

        if(a1 != null){
            a1.one();
        } else {
            System.out.println("a1 == null");
        }
        if(b1 != null){
            b1.one();
        } else {
            System.out.println("b1 == null");
        }
        if(aO1 != null){
            aO1.twe();
        } else {
            System.out.println("aO1 == null");
        }
        if(a2 != null){
            a2.one();
        } else {
            System.out.println("a2 == null");
        }
        if(bO2 != null){
            bO2.twe();
        } else {
            System.out.println("bO2 == null");
        }
    }
}

//结果
FirstFactory->ProductA
FirstFactory->ProductB
SecondFactory->ProductA
SecondFactory->ProductOtherB
one productA
one ProductB
aO1 == null
one productA
twe ProductOtherB

3.总结：Abstract Factory（抽象工厂）模式的意图在于创建一系列相关联或互相依赖的对象。借助该模式，可以为客户提供工厂类，每个工厂类都可用于创建一系列与某一公共主题相关的对象。
4.工厂方法模式与抽象工厂的区别
4.1工厂方法模式是对一个系列的对象进行创建，而抽象工厂模式是对工厂方法模式的扩展，使得可以对多个系列的对象进行创建
4.2在我看来，工厂模式始终是一对多关系，抽象工厂模式可以针对需求定义成可以生产所有产品的全能工厂，或者定义多个成只能生产特别产品的工厂（即多个工厂方法模式）。
参考：http://www.cnblogs.com/devinzhang/archive/2011/12/19/2293160.html这里写链接内容