思维导图学常用设计模式- 工厂模式 - 简单工厂、工厂方法、抽象工厂

参考 《HeadFirst 设计模式》

2.工厂模式

工厂模式是一种创造型的模式，提供了创建对象的最佳方式，在工厂模式中，创建对象的时候不会暴露具体的创建逻辑，而是通过一个共同的接口来指向新的创建的对象

例如，一个Coffer的例子

public abstract class Coffee {
    /**
     * 获取coffer名称
     * @return
     */
    public abstract String getName();

}

/**
 * 美式咖啡
 */
class Americano extends Coffee{

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

/**
 * 卡布奇诺
 */
class Cappuccino extends Coffee{

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

/**
 * 拿铁
 */
class Latte extends Coffee{

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

简单工厂方法

优点：简单工厂引入了创建者模式的概念，将实例化的代码从应用代码中分离，后续创建的实例如果需要改变，只需要改变创建者的代码

缺点：使用静态方式来创建，不能在运行期间改变创建的行为，所以存在局限性

package FactoryPattern;



/**
 * 简单工厂模式 用于创建不同类型的Coffer实例
 */
public class SimpleFactory {
    public static Coffee createInstance(String type){
        if("americano".equalsIgnoreCase(type)){
            return new Americano();
        }else if("cappuccino".equalsIgnoreCase(type)){
            return new Cappuccino();
        }else if("latte".equalsIgnoreCase(type)){
            return new Latte();
        }else {
            throw new RuntimeException("类型不可用");
        }
    }

    public static void main(String[] args) {
        Coffee latte = SimpleFactory.createInstance("latte");
        System.out.println(latte.getName());
    }
}

工厂方法模式

定义一个创建对象的接口，但是由子类来决定要实例化哪一个，也就是说将实例化推迟到了子类

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

public abstract class CoffeeFactory {
    public abstract Coffee[] createCoffee();
}

class ChinaCoffeeFactory extends CoffeeFactory {

    @Override
    public Coffee[] createCoffee() {
        return new Coffee[]{new Cappuccino(), new Latte()};
    }
}

class AmericaCoffeeFactory extends CoffeeFactory {

    @Override
    public Coffee[] createCoffee() {
        return new Coffee[]{new Americano(), new Latte()};
    }
}

测试

public class FactoryMethodTest {
    public static void main(String[] args) {
        ChinaCoffeeFactory chinaCoffeeFactory = new ChinaCoffeeFactory();
        //中国可以制造的Coffee
        Coffee[] coffee = chinaCoffeeFactory.createCoffee();
        for (Coffee temp : coffee){
            System.out.println(temp.getName());
        }

    }
}

抽象工厂

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

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

package FactoryPattern;

public interface AbstractDrinksFactory {
    /**
     * 制造咖啡
     * @return
     */
    Coffee createCoffee();

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

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

}
/**
 * 中国饮品工厂
 * 制造咖啡与茶
 * @author Lsj
 *
 */
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 Tea();
    }

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

}