简单工厂模式、工厂方法模式、抽象工厂模式

示例：需要生产特仑苏（TeLunSu），蒙牛（MenNIu），伊利牛奶（YilI）

1、简单模式：

就是简单的创建指定的牛奶，如需要特仑苏（new TeLunSu（））

2、简单工厂模式

定义一个工厂，工厂有每个牛奶的生产，客户端只要给描述（如伊利），工厂就返回伊利给客户端

优点：我们可以对创建的对象进行一些 “加工” ，而且客户端并不知道，因为工厂隐藏了这些细节。如果，没有工厂的话，那我们是不是就得自己在客户端上写这些代码，这就好比本来可以在工厂里生产的东西，拿来自己手工制作，不仅麻烦以后还不好维护

缺点：每需要添加新的牛奶类型，就需要在工厂里增加代码，使代码耦合度过高，也违反了开闭原则

---

/**
 * 简单工厂模式
 *
 * date： 2019/8/8
 * @version 1.0
 */
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();
        }
        return null;
    }
}

/**
 * 简单工厂模式
 *
 * date： 2019/8/8
 * @version 1.0
 */
public class SimpleFactoryTest {
    public static void main(String[] args) {
        // 简单工厂模式
        SimpleFactory factory = new SimpleFactory();
        System.out.println(factory.getMilk("特仑苏"));
    }

}

3、工厂方法模式

定义一个接口，写上公共的生产牛奶的方法。创建每个牛奶的工厂（蒙牛工厂MenNiuFactory，伊利工厂YiLiFactory，特仑苏工厂TeLunSuFactory）

优点：解耦，代码没有写在同一个类中，也符合了开闭原则

缺点：每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发量。

/**
 * 工厂方法模式
 *
 * date： 2019/8/8
 * @version 1.0
 */
public interface Factory {
    Milk getMilk();
}

/**
 * 工厂方法模式：指定工厂只生产指定牛奶，这个工厂只生产蒙牛
 *
 * date： 2019/8/8
 * @version 1.0
 */
public class MenNiuFactory implements Factory {

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

/**
 * 工厂方法模式：指定工厂只生产指定牛奶，这个工厂只生产特仑苏
 *
 * date： 2019/8/8
 * @version 1.0
 */
public class TelunsuFactory implements Factory {

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

/**
 * 工厂方法模式，一个工厂只生产一个牛奶，如TelunsuFactory只生产特仑苏
 * 这种工厂模式，需要对指定的牛奶建立指定的一个工厂，浪费
 * 这种模式如果需要新的牛奶，就需要建立一个新的工厂
 *
 * date： 2019/8/8
 * @version 1.0
 */
public class FactoryTest {
    public static void main(String[] args) {
        // 伊利牛奶
        System.out.println(new YiliFactory().getMilk());
    }
}

4、抽象工厂模式

定义一个抽象类，定义生产品牌的牛奶方法，然后派生一个子类，实现抽象类需要生产的品牌牛奶。

优点：对类进行约束

/**
 * 抽象工厂是用户的主入口，
 * 拿到这个工厂，就可以工厂可以提供什么产品
 *
 * date： 2019/8/8
 * @version 1.0
 */
public abstract class AbstractFactory {

    public abstract Milk getMenNiu();

    public abstract Milk getTeLunSu();

    public abstract Milk getYiLi();

    public abstract Milk getSanLu();
}

/**
 * 抽象工厂是用户的主入口，
 * 到这个工厂，就可以工厂可以提供什么产品
 *
 * date： 2019/8/8
 * @version 1.0
 */
public class MilkFactory extends AbstractFactory {

    @Override
    public Milk getMenNiu() {
        return new MengNiu();
    }

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

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

    @Override
    public Milk getSanLu() {
        return new SanLu();
    }
}

/**
 * 这种模式应用的是最多的
 * 抽象工厂模式，一个工厂可以生产多个品牌的牛奶，不浪费
 * 这种工厂模式，只需要建立一个工厂，但是工厂可以生产多种牛奶
 * 这种情况用户只有选择权不会乱要牛奶种类，保证了程序的健壮性
 *
 * date： 2019/8/8
 * @version 1.0
 */
public class AbstractFactoryTest {
    public static void main(String[] args) {
        System.out.println(new MilkFactory().getMenNiu());
    }
}