工厂设计模式（Factory）

观察如下例子：
食物接口：所有食物都应该能够食用，但食用方式不同，因此包含抽象方法 eat()
面包子类：实现食物接口，实现接口中的 eat() 方法 —— “吃面包”
牛奶子类：实现食物接口，实现接口中的 eat() 方法 —— “喝牛奶”
主类中，实例化的子类向上转型为 食物接口对象，再调用 eat() 方法。

interface IFood { // 定义应该食物标准
    public void eat();  // 吃
}

class Bread implements IFood { // 定义一种食物
    public void eat(){
        System.out.println("吃面包。。。");
    }
}

class Milk implements IFood {
    public void eat(){
        System.out.println("喝牛奶。。。");
    }
}
public class JavaDemo{
    public static void main(String args[]){
        IFood food = new Bread(); // 在主类中，必须明确子类的类型
        food.eat();
    }
}

在如上的例子中，在主类中如果我们要将面包换成牛奶的话，必须在主类中修改IFood food = new Bread();的实例化语句，此时主类和子类就发生了 “耦合”。

而我们以 JVM 的设计为例，java的实现可移植性的关键在于：JVM，而JVM的核心原理：利用应该虚拟机来运行java程序，所有的程序并不与具体的操作系统有任何的关联，而是由JVM来进行匹配。因此，良好的设计应该避免耦合。

因此，对于以上的例子，我们使用工厂模式来设计：
我们观察到，导致耦合的主要原因是在选择不同子类的时候，new 所进行的实例化需要变更，那我们可以将不同子类的实例化选择放入一个工厂类中，在主类中只调用工厂类，并且使用命令行的初始化参数来进行工厂类中不同子类的选择。

interface IFood { // 定义应该食物标准
    public void eat();  // 吃
}

class Bread implements IFood { // 定义一种食物
    public void eat(){
        System.out.println("吃面包。。。");
    }
}

class Milk implements IFood {
    public void eat(){
        System.out.println("喝牛奶。。。");
    }
}
class Factory {
    public static IFood getInstance(String className) {
        if ("bread".equals(className)){
            return new Bread();
        } else if ("milk".equals(className)) {
            return new Milk();
        } else {
            return null;
        }
    }
}
public class JavaDemo{
    public static void main(String args[]){
        IFood food = Factory.getInstance(args[0]); // 在主类中，必须明确子类的类型
        food.eat();
    }
}

在使用了工厂设计模式后，客户端程序类与IFood接口的子类没有任何关联，所有的关联都是通过 Factory类完成的，而在程序运行的时候可以通过初始化参数进行要使用的子类定义：

• java JavaDemo bread
• java JavaDemo milk

在日后进行子类扩充的时候只需要修改 Factory 程序类即可。