JAVA设计模式之工厂模式—Factory Pattern

1.工厂模式简介

工厂模式用于对象的创建，使得客户从具体的产品对象中被解耦。

2.工厂模式分类

这里以制造coffee的例子开始工厂模式设计之旅。

我们知道coffee只是一种泛举，在点购咖啡时需要指定具体的咖啡种类：美式咖啡、卡布奇诺、拿铁等等。

/**

*/
public abstract class Coffee {

/**
 * 获取coffee名称
 * @return
 */
public abstract String getName();

}

/**

*/
public class Americano extends Coffee {

@Override
public String getName() {
    return "美式咖啡";
}

}

/**

*/
public class Cappuccino extends Coffee {

@Override
public String getName() {
    return "卡布奇诺";
}

}

/**

*/
public class Latte extends Coffee {

@Override
public String getName() {
    return "拿铁";
}

}

2.1 简单工厂

简单工厂实际不能算作一种设计模式，它引入了创建者的概念，将实例化的代码从应用代码中抽离，在创建者类的静态方法中只处理创建对象的细节，后续创建的实例如需改变，只需改造创建者类即可，

但由于使用静态方法来获取对象，使其不能在运行期间通过不同方式去动态改变创建行为，因此存在一定局限性。

/**

*/
public class SimpleFactory {

/**
 * 通过类型获取Coffee实例对象
 * @param type 咖啡类型
 * @return
 */
public static Coffee createInstance(String type){
    if("americano".equals(type)){
        return new Americano();
    }else if("cappuccino".equals(type)){
        return new Cappuccino();
    }else if("latte".equals(type)){
        return new Latte();
    }else{
        throw new RuntimeException("type["+type+"]类型不可识别，没有匹配到可实例化的对象！");
    }
}

public static void main(String[] args) {
    Coffee latte = SimpleFactory.createInstance("latte");
    System.out.println("创建的咖啡实例为:" + latte.getName());
    Coffee cappuccino = SimpleFactory.createInstance("cappuccino");
    System.out.println("创建的咖啡实例为:" + cappuccino.getName());
}

}

2.2 工厂方法模式

定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，工厂方法让类把实例化推迟到了子类。

场景延伸：不同地区咖啡工厂受制于环境、原料等因素的影响，制造出的咖啡种类有限。中国咖啡工厂仅能制造卡布奇诺、拿铁，而美国咖啡工厂仅能制造美式咖啡、拿铁。

/**

public abstract class CoffeeFactory {

/**
 * 生产可制造的咖啡
 * @return
 */
public abstract Coffee[] createCoffee();

}

/**

*/
public class ChinaCoffeeFactory extends CoffeeFactory {

@Override
public Coffee[] createCoffee() {
    // TODO Auto-generated method stub
    return new Coffee[]{new Cappuccino(), new Latte()};
}

}

/**

*/
public class AmericaCoffeeFactory extends CoffeeFactory {

@Override
public Coffee[] createCoffee() {
    // TODO Auto-generated method stub
    return new Coffee[]{new Americano(), new Latte()};
}

}

/**

*/
public class FactoryMethodTest {

static void print(Coffee[] c){
    for (Coffee coffee : c) {
        System.out.println(coffee.getName());
    }
}

public static void main(String[] args) {
    CoffeeFactory chinaCoffeeFactory = new ChinaCoffeeFactory();
    Coffee[] chinaCoffees = chinaCoffeeFactory.createCoffee();
    System.out.println("中国咖啡工厂可以生产的咖啡有：");
    print(chinaCoffees);
    CoffeeFactory americaCoffeeFactory = new AmericaCoffeeFactory();
    Coffee[] americaCoffees = americaCoffeeFactory.createCoffee();
    System.out.println("美国咖啡工厂可以生产的咖啡有：");
    print(americaCoffees);
}

}

2.3 抽象工厂

提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

在上述的场景上继续延伸：咖啡工厂做大做强，引入了新的饮品种类：茶、 碳酸饮料。中国工厂只能制造咖啡和茶，美国工厂只能制造咖啡和碳酸饮料。

如果用上述工厂方法方式，除去对应的产品实体类还需要新增2个抽象工厂（茶制造工厂、碳酸饮料制造工厂），4个具体工厂实现。随着产品的增多，会导致类爆炸。

所以这里引出一个概念产品家族，在此例子中，不同的饮品就组成我们的饮品家族， 饮品家族开始承担创建者的责任，负责制造不同的产品。

/**

*/
public interface AbstractDrinksFactory {

/**
 * 制造咖啡
 * @return
 */
Coffee createCoffee();

/**
 * 制造茶
 * @return
 */
Tea createTea();

/**
 * 制造碳酸饮料
 * @return
 */
Sodas createSodas();

}

/**

*/
public class ChinaDrinksFactory implements AbstractDrinksFactory {

@Override
public Coffee createCoffee() {
    // TODO Auto-generated method stub
    return new Latte();
}

@Override
public Tea createTea() {
    // TODO Auto-generated method stub
    return new MilkTea();
}

@Override
public Sodas createSodas() {
    // TODO Auto-generated method stub
    return null;
}

}

/**

*/
public class AmericaDrinksFactory implements AbstractDrinksFactory {

@Override
public Coffee createCoffee() {
    // TODO Auto-generated method stub
    return new Latte();
}

@Override
public Tea createTea() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public Sodas createSodas() {
    // TODO Auto-generated method stub
    return new CocaCola();
}

}

/**

*/
public class AbstractFactoryTest {

static void print(Drink drink){
    if(drink == null){
        System.out.println("产品：--" );
    }else{
        System.out.println("产品：" + drink.getName());
    }
}

public static void main(String[] args) {
    AbstractDrinksFactory chinaDrinksFactory = new ChinaDrinksFactory();
    Coffee coffee = chinaDrinksFactory.createCoffee();
    Tea tea = chinaDrinksFactory.createTea();
    Sodas sodas = chinaDrinksFactory.createSodas();
    System.out.println("中国饮品工厂有如下产品：");
    print(coffee);
    print(tea);
    print(sodas);
    
    AbstractDrinksFactory americaDrinksFactory = new AmericaDrinksFactory();
    coffee = americaDrinksFactory.createCoffee();
    tea = americaDrinksFactory.createTea();
    sodas = americaDrinksFactory.createSodas();
    System.out.println("美国饮品工厂有如下产品：");
    print(coffee);
    print(tea);
    print(sodas);
}

}

3.总结

简单工厂：不能算是真正意义上的设计模式，但可以将客户程序从具体类解耦。

工厂方法：使用继承，把对象的创建委托给子类，由子类来实现创建方法，可以看作是抽象工厂模式中只有单一产品的情况。

抽象工厂：使对象的创建被实现在工厂接口所暴露出来的方法中。

工厂模式可以帮助我们针对抽象/接口编程，而不是针对具体类编程，在不同的场景下按具体情况来使用。

参考书籍：

《HeadFirst 设计模式》