王小抠活成了工厂的样子

NEW 自食其力

王小扣在早上 7 点准时床，第一件事情就是要做一顿早餐补充下能量。王小扣的早餐是一个手抓饼（此处省略做手抓饼的简单过程）自己做上自己吃，很美味。

代码实现：
早餐可以包含的食物很多，我们抽象为 Food 接口。
手抓饼是具体的产品，我们定义为 ShouZhuaBing 类。

public class OldTest {
    public static void main(String[] args) {
        Food shouZhuaBing = new ShouZhuaBing();
        shouZhuaBing.eaten();
    }
}

简单工厂 和别人要

吃完早餐的王小抠正要去上班，这个时候刚刚睡醒的女票叫住了他：
“王小扣，我饿了。。”
“拜拜，我去上班了”
“王小扣，我要吃手抓饼！！”
“哦，那我再做一个呗”
这个时候，王小抠意识到自己变成了一个失去理智温顺善良的简单工厂，女票和他要手抓饼他就立刻去做，不让女票关心手抓饼如何去做。

代码实现：
我们把王小抠抽象为一个简单工厂类 SimpleFactory
把使唤工厂的女票抽象为类 SimpleFactoryUser

// 定义简单工厂类
public class SimpleFactory {
	// 定义静态工厂方法
    public static Food createFood(String foodName) {
        Food food = null;
        if ("手抓饼".equals(foodName)) {
            food = new ShouZhuaBing();
        } else if ("其它食物。。。".equals(foodName)) {
            // food = new XXX
        }
        return food;
    }
}

public class SimpleFactoryUser {
    public static void main(String[] args) {
        Food shouZhuaBing = SimpleFactory.createFood("手抓饼");
        shouZhuaBing.eaten();
    }
}
// 手抓饼被吃了！

可以看出简单工厂的优点是，使用者可以直接从工厂中拿到想要的产品，而不用了解产品的生产过程。
由于 createFood 的修饰符为 static ，所以简单工厂又叫静态工厂。

工厂方法 创建分身

日子一天天过去，王小抠的生活越来越痛苦了，因为女票吃腻了手抓饼，开始和王小抠要烤冷面、鸡蛋灌饼。。。
可是王小抠觉得做两样早餐有点费时间呀，又得早起十分钟呢。
这个时候王小抠就幻想着能有一个会做烤冷面的分身，再来一个会做鸡蛋灌饼的分身，再来一个。。。
这样可以让每个王小抠负责每种早餐的制作，我们想吃什么只需要找相应的王小抠即可。

代码实现：
每个分身王小抠都是一个具体的工厂，他们都拥有制作早餐的方法。
这样我们就可以定义一个抽象接口 Factory 和 抽象的工厂方法 createFood。

// 定义接口
public interface Factory {
	// 定义工厂方法
    Food createFood();
}

// 定义具体工厂类
public class KaoLengMianFactory implements Factory{
    public Food createFood() {
        return new KaoLengMian();
    }
}
public class ShouZhuaBingFactory implements Factory{
    public Food createFood() {
        return new ShouZhuaBing();
    }
}

// 使用
public class FactoryMethodTest {
    public static void main(String[] args) {
        KaoLengMianFactory kaoLengMianFactory = new KaoLengMianFactory();
        Food kaoLengMian = kaoLengMianFactory.createFood();
        kaoLengMian.eaten();

        ShouZhuaBingFactory shouZhuaBingFactory = new ShouZhuaBingFactory();
        Food shouZhuaBing = shouZhuaBingFactory.createFood();
        shouZhuaBing.eaten();
    }
}
// 烤冷面被吃了！
// 手抓饼被吃了！

工厂方法可以看出是简单工厂的升级，简单工厂把不同种类产品的创建都放到一个类的一个方法中。
现在我们将创建产品的工作放到不同类中，有多少产品就创建多少工厂，让工厂的功能更加专一。
在获取产品时，使用者需要指定具体的工厂，仍然有耦合，请忽略，使用工厂的目的是对产品创建工作的解耦。

抽象工厂 不同配方

分身太多，记不住呀能不能统一管理呀。

// 创建抽象工厂
public abstract class AbstractFactory {
	
	// TODO

    abstract Food createShouZhuangbing();

    abstract Food createKaoLengMian();
}

// 具体实现
public class Factory extends AbstractFactory {
    @Override
    Food createShouZhuangbing() {
        return new ShouZhuaBing();
    }

    @Override
    Food createKaoLengMian() {
        return new KaoLengMian();
    }
}

// 使用
public class AbstractFactoryUser {
    public static void main(String[] args) {
        AbstractFactory factory = new Factory();
        Food kaoLengMian = factory.createKaoLengMian();
        Food shouZhuangbing = factory.createShouZhuangbing();

        kaoLengMian.eaten();
        shouZhuangbing.eaten();
    }
}

抽象工厂只需要获取一个工厂，通过工厂的不同方法就可以创建不同的产品。

新增产品时

1. 静态工厂需要修改代码，增加 if 语句
2. 工厂方法需要增加新的类，在使用处还需要 new 一个新的工厂
3. 抽象工厂需要在 AbstractFactory 和 Factory 中添加方法，还是用原来的 factory 去创建

以上只是说了抽象工厂可以对不同产品进行统一管理，和不同配方没有多大联系。
想要实现不同配方，需要再创建几个抽象工厂的实现类。

// 甜味的早餐
public class TianFactory extends AbstractFactory{
}
// 辣味的早餐
public class LaFactory extends AbstarctFactory{
}

如果我们要吃甜味的，只要使用甜味工厂，创建出的所有产品都是甜味的

AbstractFactory factory = New TianFactory();
factory.createXXX

---

完整代码