Java设计模式之工厂模式(Factory)

案例（没有使用设计模式之前）

package com.onlyk.design.factory.before;

/**
 * @author only老K 我为自己代言
 * @create 2020-03-20 11:20
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public interface Pizza {
    void pre();
    void bake();
    void cut();
    void box();
}
/**
 * 中式披萨
 */
class ChinesePizza implements Pizza {
    public ChinesePizza() {
        this.pre();
        this.bake();
        this.cut();
        this.box();
    }
    @Override
    public void pre() {
        System.out.println("中式披萨材料准备...");
    }
    @Override
    public void bake() {
        System.out.println("中式披萨烘培...");
    }
    @Override
    public void cut() {
        System.out.println("中式披萨的切片...");
    }
    @Override
    public void box() {
        System.out.println("中式披萨包装盒包装");
    }
}
/**
 * 美式披萨
 */
class AmericaPizza implements Pizza {
    public AmericaPizza() {
        this.pre();
        this.bake();
        this.cut();
        this.box();
    }
    @Override
    public void pre() {
        System.out.println("美式 披萨材料准备...");
    }
    @Override
    public void bake() {
        System.out.println("美式 披萨烘培...");
    }
    @Override
    public void cut() {
        System.out.println("美式 披萨的切片...");
    }
    @Override
    public void box() {
        System.out.println("美式 披萨包装盒包装");
    }
}
class JapanPizza implements Pizza {
    public JapanPizza() {
        this.pre();
        this.bake();
        this.cut();
        this.box();
    }
    @Override
    public void pre() {
        System.out.println("日式 披萨材料准备...");
    }
    @Override
    public void bake() {
        System.out.println("日式 披萨烘培...");
    }
    @Override
    public void cut() {
        System.out.println("日式 披萨的切片...");
    }
    @Override
    public void box() {
        System.out.println("日式 披萨包装盒包装");
    }
}



package com.onlyk.design.factory.before;

/**
 * @author only老K 我为自己代言
 * @create 2020-03-20 11:22
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class PizzaFactory {
    public static Pizza createPizza(int no){
        switch (no){
            case 1:
                return new ChinesePizza();
            case 2:
                return new AmericaPizza();
            case 3:
                return new JapanPizza();
        }
        return null;
    }
}

package com.onlyk.design.factory.before;

/**
 * @author only老K 我为自己代言
 * @create 2020-03-20 11:23
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class Client {
    public static void main(String[] args) {
        Pizza chinaPizza = PizzaFactory.createPizza(1);
        System.out.println("=============================");
        Pizza americaPizza = PizzaFactory.createPizza(2);
        System.out.println("=============================");
        Pizza japanPizza = PizzaFactory.createPizza(3);
    }
}

结果：

这个时候需求就是在创建一个自己的披萨，并且加入海鲜

Pizza接口写入...
class OnlyKPizza extends ChinesePizza{
//需要在制作过程中添加海鲜
    public OnlyKPizza(){
        super();
        System.out.println("加点海鲜");
        //这样设计，耦合性太高，不便于维护，整个披萨的制作都交给了构造器
    }
}

工厂写入
case 4:
                return new OnlyKPizza();
Clent写入：
System.out.println("=============================");
Pizza OnlyKPizza = PizzaFactory.createPizza(4);

结果：

会发现不好做到在制作过程中加入海鲜…(原因是因为制作过程全部交给了构造器去完成）

案例（使用了设计模式）

package com.onlyk.design.factory.after;

/**
 * @author only老K 我为自己代言
 * @create 2020-03-20 11:44
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public interface Pizza {
    void pre();
    void bake();
    void cut();
    void box();
}
/**
 * 中式披萨
 */
class ChinesePizza implements Pizza {
    @Override
    public void pre() {
        System.out.println("中式披萨材料准备...");
    }
    @Override
    public void bake() {
        System.out.println("中式披萨烘培...");
    }
    @Override
    public void cut() {
        System.out.println("中式披萨的切片...");
    }
    @Override
    public void box() {
        System.out.println("中式披萨包装盒包装");
    }
}
/**
 * 美式披萨
 */
class AmericaPizza implements Pizza {
    @Override
    public void pre() {
        System.out.println("美式 披萨材料准备...");
    }
    @Override
    public void bake() {
        System.out.println("美式 披萨烘培...");
    }
    @Override
    public void cut() {
        System.out.println("美式 披萨的切片...");
    }
    @Override
    public void box() {
        System.out.println("美式 披萨包装盒包装");
    }
}
class JapanPizza implements Pizza {
    @Override
    public void pre() {
        System.out.println("日式 披萨材料准备...");
    }
    @Override
    public void bake() {
        System.out.println("日式 披萨烘培...");
    }
    @Override
    public void cut() {
        System.out.println("日式 披萨的切片...");
    }
    @Override
    public void box() {
        System.out.println("日式 披萨包装盒包装");
    }
}


package com.onlyk.design.factory.after;

/**
 * @author only老K 我为自己代言
 * @create 2020-03-20 11:46
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class PizzaFactory {
    public static Pizza createPizza(int no){
        Pizza pizza = null;
        switch (no){
            case 1:
                pizza = new ChinesePizza();
                break;
            case 2:
                pizza = new AmericaPizza();
                break;
            case 3:
                pizza = new JapanPizza();
                break;
        }
        if (pizza == null){
            System.out.println("没有此披萨订购服务");
        }else {
            pizza.pre();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }
        return pizza;
    }
}


package com.onlyk.design.factory.after;

/**
 * @author only老K 我为自己代言
 * @create 2020-03-20 11:48
 * @blogaddress https://blog.csdn.net/weixin_44255950
 */
public class Client {
    public static void main(String[] args) {
        Pizza chinaPizza = PizzaFactory.createPizza(1);
        System.out.println("=============================");
        Pizza americaPizza = PizzaFactory.createPizza(2);
        System.out.println("=============================");
        Pizza japanPizza = PizzaFactory.createPizza(3);
        System.out.println("=============================");
        Pizza otherPizza = PizzaFactory.createPizza(4);
    }
}

和上面一样新来一个

Pizza接口
class OnlyK extends ChinesePizza{
    @Override
    public void pre() {
        System.out.println("King式披萨材料准备...");
    }
    @Override
    public void bake() {
        System.out.println("加海鲜.");
        System.out.println("King式披萨烘培...");
    }
    @Override
    public void cut() {
        System.out.println("King式披萨的切片...");
    }
    @Override
    public void box() {
        System.out.println("King式披萨包装盒包装");
    }
}

工厂：
 case 4:
                pizza = new OnlyK();
                break;

结果:

使用前后对比：
前者将对象初始化的工作交给了对象的构造函数完成；

后者将初始化的过程交给了工厂类完成；
这么做的好处在于解耦自身对象实例化和对象初始化动作，还有一个因素在于构造函数的初始化会影响到子类；