第一篇、工厂模式详解（三种）

一、什么是工厂设计模式？

工厂设计模式，顾名思义，就是用来生产对象的，在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则，如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦

本篇主要介绍三种工厂设计模式的使用：
1、简单工厂
2、工厂方法
3、抽象工厂

二、简单工厂设计模式

定义：一个工厂方法，依据传入的参数，生成对应的产品对象；
角色：
1、抽象产品
2、具体产品
3、具体工厂
4、产品使用者
使用说明：先将产品类抽象出来，比如，伊利和蒙牛都属于牛奶，抽象出来一个牛奶类Milk，伊利和蒙牛就是具体的产品类，然后创建一个牛奶工厂，分别用来创建伊利和蒙牛；代码如下：

牛奶接口：

public interface Milk {

    /**
     * 获取一个标准产品
     * @return
     */
    public String getName();

}

具体类 蒙牛 

public class Mengniu implements Milk {
    @Override
    public String getName() {
        return "蒙牛";
    }
}

 具体类  三鹿

public class Sanlu implements  Milk{
    @Override
    public String getName() {
        return "三鹿";
    }
}

 具体类  特仑苏

public class Telunsu implements Milk {
    @Override
    public String getName() {
        return "特仑苏";
    }
}

  具体类  伊利

public class Yili implements  Milk {
    @Override
    public String getName() {
        return "伊利";
    }
}

具体工厂 牛奶工厂 

public class SimpleFactory {

    public Milk getMilk(String name){
        if("特仑苏".equals(name)){
            return new Telunsu();
        }else if("伊利".equals(name)){
            return new Yili();
        }else if("蒙牛".equals(name)){
            return new Mengniu();
        }else {
            System.out.println("不能生产您所需的产品");
            return null;
        }
    }

}

产品使用

public class SimpleFactoryTest {

    public static void main(String[] args) {

        //这个new的过程实际上一个比较复杂的过程
        //有人民币及不需要自己new了
       // System.out.println(new Telunsu().getName());

        //小作坊式的生产模式
        //用户本身不再关心生产的过程，而只需要关心这个结果

        //假如：特仑苏、伊利、蒙牛
        //成分配比都是不一样的
        SimpleFactory factory = new SimpleFactory();

        //把用户的需求告诉工厂
        //创建产品的过程隐藏了，对于用户而且完全不清楚是怎么产生的
        System.out.println(factory.getMilk("AAA"));

        //知其然，知其所以然，知其所必然

    }
}

就这样，一个非常简单的工厂设计模式就完成了，但是有没有发现什么问题呢？
对，那就是如果我想喝其他牛奶呢？所以，以上的这种方式，每当我想添加一种产品，就必然要修改工厂类，这显然违反了开闭原则，亦不可取；所以简单工厂只适合于产品对象较少，且产品固定的需求，对于产品变化无常的需求来说显然不合适；所以我们来看下一种方式；

三、工厂方法设计模式

定义：将工厂提取成一个接口或抽象类，具体生产什么产品由子类决定；
角色：
抽象产品类
具体产品类
抽象工厂类
具体工厂类
使用说明：和上例中一样，产品类抽象出来，这次我们把工厂类也抽象出来，生产什么样的产品由子类来决定；
代码如下：
牛奶接口 蒙牛类和伊利类 代码和上例一样

工厂接口

public interface Factory {

    //工厂必然具有生产产品技能，统一的产品出口
    Milk getMilk();

}

蒙牛工厂

public class MengniuFactory implements  Factory {


    @Override
    public Milk getMilk() {
        return new Mengniu();
    }
}

三鹿工厂

public class SanluFactory implements  Factory {
    @Override
    public Milk getMilk() {
        return new Sanlu();
    }
}

特仑苏工厂

public class TelunsuFactory implements Factory {

    @Override
    public Milk getMilk() {
        return new Telunsu();
    }
}

伊利工厂

public class YiliFactory implements Factory {

    @Override
    public Milk getMilk() {
        return new Yili();
    }
}

使用

public class FactoryTest {
    public static void main(String[] args) {
        //System.out.println(new Factory().getMilk(););


        //货比三家
        //不知道谁好谁好谁坏
        //配置，可能会配置错
        Factory factory = new SanluFactory();
        System.out.println(factory.getMilk());

    }
}

以上这种方式，虽然解耦了，也遵循了开闭原则，但是问题根本还是没有解决啊，换汤没换药，如果我需要的产品很多的话，需要创建非常多的工厂，所以这种方式的缺点也很明显；

四、抽象工厂设计模式

定义：为创建一组相关或者是相互依赖的对象提供的一个接口，而不需要指定它们的具体类。
角色：和工厂方法一样
抽象工厂和工厂方法的模式基本一样，区别在于，工厂方法是生产一个具体的产品，而抽象工厂可以用来生产一组相同，有相对关系的产品；重点在于一组，一批，一系列；

工厂接口或抽象类

public abstract class AbstractFactory {

    //公共的逻辑
    //方便于统一管理

    /**
     * 获得一个蒙牛品牌的牛奶
     * @return
     */
    public  abstract Milk getMengniu();

    /**
     * 获得一个伊利品牌的牛奶
     * @return
     */
    public abstract  Milk getYili();

    /**
     * 获得一个特仑苏品牌的牛奶
     * @return
     */
    public  abstract  Milk getTelunsu();

    public abstract Milk getSanlu();

}

 实现类

public class MilkFactory extends  AbstractFactory {


    @Override
    public Milk getMengniu() {
        return new Mengniu();
    }

    @Override
    public Milk getYili() {
        return new Yili();
    }

    @Override
    public Milk getTelunsu() {
        return new Telunsu();
    }

    @Override
    public Milk getSanlu() {
        return new Sanlu();
    }
}

 

以上例子可以看出，抽象工厂可以解决一系列的产品生产的需求，对于大批量，多系列的产品，用抽象工厂可以更好的管理和扩展；

三种工厂方式总结：
1、对于简单工厂和工厂方法来说，两者的使用方式实际上是一样的，如果对于产品的分类和名称是确定的，数量是相对固定的，推荐使用简单工厂模式；
2、抽象工厂用来解决相对复杂的问题，适用于一系列、大批量的对象生产；