一头扎进设计模式-抽象工厂模式

定义：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据里氏替换原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。

通俗的讲：就是通过接口定义好“工厂”的类型与“产品的类型”，把产品的产生制作流程封装在工厂里面，调用时直接使用接口声明，实现一个可拔插的效果。

代码实现：

抽象工厂类（这里我不使用接口，而运用了类似于模版的方法，把一些特殊的实现交给子类）

/**
 * 
 */
package com.jjt.factory;

/**
 * @author jiangjintai
 *
 */
public abstract class IFactory {
    private String name;
    public IFactory(String name){
        this.name=name;
    }
    public  void name(){
        System.out.println(name);
    }
    public abstract IProduct creat(FactoryEnum fenum);//创建商品主方法
}

抽象产品类

/**
 * 
 */
package com.jjt.factory;

/**
 * @author jiangjintai
 *
 */
public abstract class IProduct {
    private String name;
    public IProduct(String name){
        this.name=name;
    }
    public abstract void xuxu();
    public void name(){
        System.out.println(name);
    }
}

具体的工厂1实现类

/**
 * 
 */
package com.jjt.factory;

/**
 * @author jiangjintai
 *
 */
public class BoyFactory extends IFactory {

    /**
     * @param name
     */
    public BoyFactory(String name) {
        super(name);
        // TODO 自动生成的构造函数存根
    }

    /* （非 Javadoc）
     * @see com.jjt.factory.IFactory#creat()
     */
    @Override
    public IProduct creat() {
        // TODO 自动生成的方法存根
        this.name();
        System.out.println("正在制作一个男孩");
        return new Boy("江锦泰");  
    }

}

具体工厂实现类2

/**
 * 
 */
package com.jjt.factory;

/**
 * @author jiangjintai
 *
 */
public class GirlFactory extends IFactory {

    /**
     * @param name
     */
    public GirlFactory(String name) {
        super(name);
        // TODO 自动生成的构造函数存根
    }

    /* （非 Javadoc）
     * @see com.jjt.factory.IFactory#creat()
     */
    @Override
    public IProduct creat() {
        // TODO 自动生成的方法存根
        this.name();
        System.out.println("正在制作一个女孩");
        return new Girl("黄瑜琪"); 
    }

}

具体产品实现类1

/**
 * 
 */
package com.jjt.factory;

/**
 * @author jiangjintai
 *
 */
public class Boy extends IProduct {

    /**
     * @param name
     */
    public Boy(String name) {
        super(name);
        // TODO 自动生成的构造函数存根
    }

    /* （非 Javadoc）
     * @see com.jjt.factory.IProduct#xuxu()
     */
    @Override
    public void xuxu() {
        // TODO 自动生成的方法存根
        System.out.println("站着嘘嘘");
    }

}

具体产品实现类2

/**
 * 
 */
package com.jjt.factory;

/**
 * @author jiangjintai
 *
 */
public class Girl extends IProduct {

    /**
     * @param name
     */
    public Girl(String name) {
        super(name);
        // TODO 自动生成的构造函数存根
    }

    /* （非 Javadoc）
     * @see com.jjt.factory.IProduct#xuxu()
     */
    @Override
    public void xuxu() {
        // TODO 自动生成的方法存根
        System.out.println("蹲在嘘嘘");
    }
}

测试

public static void  main(String[] args){
        IFactory f  = new BoyFactory("男孩制作工场");
        IProduct i = f.creat(FactoryEnum.boy);
        i.name();
        i.xuxu();

        f=new GirlFactory("女孩制作工厂");
        IProduct i3 = f.creat();
        i3.name();
        i3.xuxu();
    }

结果如下：

男孩制作工场
正在制作一个男孩
江锦泰
站着嘘嘘
女孩制作工厂
正在制作一个女孩
黄瑜琪
蹲在嘘嘘

总结简单工厂模式-工厂模式-抽象工厂模式的区别
首先简单工厂模式：创建什么产品都由一个方法决定，比如：

    public Product getProduct(String status){
        if(status==1)
            return new Product1();
        if(status==2)
            return new Product2();
    }

工厂模式：把创建不同的产品分开到不同的工厂类中，比如对上面代码进行改进：

    public interface Factory(){
        Product getProduct();
    }

    public class Product1Factory(){
        public Product getProduct(){
            return new Product1();
        }
    }

    public class Product2Factory(){
        public Product getProduct(){
            return new Product2();
        }
    }

抽象工厂模式：对一个生成不同产品族，其实就是说此时的工厂接口，不仅可以生产产品，也可以生产其他的产品，再次升级：

public interface Factory(){
        Product getProduct();
        OrderProduct getOrderProduct();
    }