headfirst设计模式(4)—工厂模式。headfirst设计模式(4)—工厂模式。

开篇

开篇

天天逛博客园,就是狠毒不下中心来写首博客,忙是单向,但是说没空能有多繁忙呢,都起日闲逛博客园,写首博客的时间都没有?(这还当真不好说)

整日逛博客园,就是为富不仁不产中心来描写篇博客,忙是一面,但是说没空能来多繁忙吗,都出时间闲逛博客园,写首博客的日都并未?(这尚真的不好说)

老是想到写一首新的设计模式,我总会咨询自己:

每次想到写一首新的设计模式,我总会咨询自己:

1,自己理解了吧?

1,自己明白了邪?

2,我能坐平等栽简易且发出逻辑的艺术将它们说下呢?

2,我能够以同等种简单且有逻辑的办法把它说出呢?

隐瞒好万无一失,但是同样论正经的胡扯还是如发吧,起码要忽悠得头头是道嘛(手动斜眼笑)

隐秘好万无一失,但是同样依照正经的胡扯还是如有吧,起码要忽悠得头头是道嘛(手动斜眼笑)

有关工厂模式的几乎个问题

有关工厂模式的几乎只问题

1,这个是将来波及啊的?

1,这个是用来波及啊的?

2,怎么用?

2,怎么用?

3,不用行大?

3,不用行不行?

第一独及老三个问题,我现在尽管足以告诉您答案:早点收工,可以

先是个及老三单问题,我本即使足以告知您答案:早点下班,可以

备的设计模式对自我来说还是以减少工作量。关于减少工作量我的掌握是:每个需求,都应有当其相当的时节起适当的代码!这个极其重大了

富有的设计模式对己的话都是为削减工作量。关于减少工作量我的亮是:每个需求,都该在它适用的时光起适当的代码!这个极端重大了

代码偷懒,后期返工多

代码偷懒,后期返工多

过分设计,后期返工多

过火设计,后期返工多

设计模式+经验好化解这题目,其他的自己还非知底。没有经历怎么惩罚?两独要点:

设计模式+经验可以解决这题目,其他的我还无懂得。没有经历怎么惩罚?两单要点:

1,能用

1,能用

2,简洁

2,简洁

第一要达成能就此,然后便尽量精简,这样代码就非会见太差。首先你一旦自己看得掌握,然后是给队友看得懂得。

先是要达标能因此,然后便尽可能精简,这样代码就无会见无限差。首先你如果和谐看得懂得,然后是给队友看得知道。

你懂您队友看到同一堆积烂的禁闭还看无亮堂,也同句注释都未曾底代码的时段的思维阴影面积也?

公知你队友看到同一堆放烂的拘留都看无明白,也同句注释都无底代码的下的思维阴影面积也?

马上实则呢从没什么,谁没有填了别人的坑呢?关键是外知你家在何,而且还亮乃常倒夜路,就问你害怕就是?(卧槽,又飞题了。。)

就实质上也尚未什么,谁没填过别人的坑呢?关键是他懂你家在哪,而且还明白您时走夜路,就咨询您毛骨悚然就是?(卧槽,又跑题了。。)

 

 

要求:你生一个披萨店,只售同种披萨,代码如下:

需要:你来一个披萨店,只售同种披萨,代码如下:

披萨:

披萨:

import java.util.ArrayList;
import java.util.List;

/**
 * 披萨类
 * @author skysea
 */
public class Pizza {

    private String name;//披萨名称

    private String dough;//面团

    private String sauce;//酱料

    private List<String> toppings = new ArrayList<>();//佐料

    public Pizza() {
            this.name = "原味披萨";
            this.dough = "原味面团";
            this.sauce = "原味酱料";
    }

    void prepare() {
        System.out.println("开始准备披萨:" + name);

        System.out.println("开始处理面团:" + dough);

        System.out.println("添加酱料:" + sauce);

        System.out.println("添加佐料:");
        if(toppings.size() > 0) {
            for(String t : toppings) {
                System.out.println(" " + t);
            }
        }
    }

    void bake() {
        System.out.println("烘焙25分钟..");
    }

    void cut() {
        System.out.println("披萨切片..");
    }

    void box() {
        System.out.println("披萨打包..");
    }

    public String getName() {
        return name;
    }
}
import java.util.ArrayList;
import java.util.List;

/**
 * 披萨类
 * @author skysea
 */
public class Pizza {

    private String name;//披萨名称

    private String dough;//面团

    private String sauce;//酱料

    private List<String> toppings = new ArrayList<>();//佐料

    public Pizza() {
            this.name = "原味披萨";
            this.dough = "原味面团";
            this.sauce = "原味酱料";
    }

    void prepare() {
        System.out.println("开始准备披萨:" + name);

        System.out.println("开始处理面团:" + dough);

        System.out.println("添加酱料:" + sauce);

        System.out.println("添加佐料:");
        if(toppings.size() > 0) {
            for(String t : toppings) {
                System.out.println(" " + t);
            }
        }
    }

    void bake() {
        System.out.println("烘焙25分钟..");
    }

    void cut() {
        System.out.println("披萨切片..");
    }

    void box() {
        System.out.println("披萨打包..");
    }

    public String getName() {
        return name;
    }
}

 

 

披萨店:

披萨店:

/**
 * 只卖一种披萨的披萨店
 * @author skysea
 */
public class PizzaStore {

    public Pizza orderPizza() {
        Pizza pizza = new Pizza();
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}
/**
 * 只卖一种披萨的披萨店
 * @author skysea
 */
public class PizzaStore {

    public Pizza orderPizza() {
        Pizza pizza = new Pizza();
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

 测试类:

 测试类:

/**
 * pizza测试类
 * @author skysea
 */
public class PizzaTest {
    public static void main(String[] args) {
        PizzaStore pizzaStore = new PizzaStore();
        Pizza pizza = pizzaStore.orderPizza();
        System.out.println("当前预定的披萨:" + pizza.getName());
    }
}
/**
 * pizza测试类
 * @author skysea
 */
public class PizzaTest {
    public static void main(String[] args) {
        PizzaStore pizzaStore = new PizzaStore();
        Pizza pizza = pizzaStore.orderPizza();
        System.out.println("当前预定的披萨:" + pizza.getName());
    }
}

图片 1 

图片 2 

现在披萨店要开展工作了,因为卖同种植披萨顾客就吃腻了,现在要是从头上加新的披萨类型

兹披萨店要开展业务了,因为卖同种植披萨顾客既吃腻了,现在使开始上加新的披萨类型

简而言之工厂模式

简言之工厂模式

Pizza类的精益求精

Pizza类的改进

import java.util.ArrayList;
import java.util.List;

/**
 * 披萨抽象类
 * 1,修改private -> protected(保证子类拥有这些属性)
 * 2,将Pizza定义为abstract类,防止被new,也是为后面的改造做准备
 * @author skysea
 */
public abstract class Pizza {

    protected String name;//披萨名称

    protected String dough;//面团

    protected String sauce;//酱料

    protected List<String> toppings = new ArrayList<>();//佐料

    void prepare() {
        System.out.println("开始准备披萨:" + name);

        System.out.print("开始处理面团:" + dough);

        System.out.println("添加酱料:" + sauce);

        System.out.println("添加佐料:");
        for(String t : toppings) {
            System.out.println(" " + t);
        }
    }

    void bake() {
        System.out.println("烘焙25分钟..");
    }

    void cut() {
        System.out.println("披萨切片..");
    }

    void box() {
        System.out.println("披萨打包..");
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Pizza [name=" + name + ", dough=" + dough + ", sauce=" + sauce + ", toppings=" + toppings + "]";
    }
}
import java.util.ArrayList;
import java.util.List;

/**
 * 披萨抽象类
 * 1,修改private -> protected(保证子类拥有这些属性)
 * 2,将Pizza定义为abstract类,防止被new,也是为后面的改造做准备
 * @author skysea
 */
public abstract class Pizza {

    protected String name;//披萨名称

    protected String dough;//面团

    protected String sauce;//酱料

    protected List<String> toppings = new ArrayList<>();//佐料

    void prepare() {
        System.out.println("开始准备披萨:" + name);

        System.out.print("开始处理面团:" + dough);

        System.out.println("添加酱料:" + sauce);

        System.out.println("添加佐料:");
        for(String t : toppings) {
            System.out.println(" " + t);
        }
    }

    void bake() {
        System.out.println("烘焙25分钟..");
    }

    void cut() {
        System.out.println("披萨切片..");
    }

    void box() {
        System.out.println("披萨打包..");
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Pizza [name=" + name + ", dough=" + dough + ", sauce=" + sauce + ", toppings=" + toppings + "]";
    }
}

先被起新增的披萨

先期让有新增的披萨

芝士披萨:

芝士披萨:

图片 3图片 4

图片 5图片 6

/**
 * 芝士披萨
 * @author skysea
 */
public class CheesePizza extends Pizza{
    public CheesePizza() {
        this.name = "芝士披萨";
        this.dough = "芝士披萨的面团";
        this.sauce = "芝士披萨的酱料";
        this.toppings.add("很多芝士....");
    }
}
/**
 * 芝士披萨
 * @author skysea
 */
public class CheesePizza extends Pizza{
    public CheesePizza() {
        this.name = "芝士披萨";
        this.dough = "芝士披萨的面团";
        this.sauce = "芝士披萨的酱料";
        this.toppings.add("很多芝士....");
    }
}

View Code

View Code

蛤蜊披萨:

蛤蜊披萨:

图片 7图片 8

图片 9图片 10

/**
 * 蛤蜊披萨
 * @author skysea
 */
public class ClamPizza extends Pizza {
    public ClamPizza() {
        this.name = "蛤蜊披萨";
        this.dough = "蛤蜊披萨的面团";
        this.sauce = "蛤蜊披萨的酱料";
        this.toppings.add("蛤蜊");
    }
}
/**
 * 蛤蜊披萨
 * @author skysea
 */
public class ClamPizza extends Pizza {
    public ClamPizza() {
        this.name = "蛤蜊披萨";
        this.dough = "蛤蜊披萨的面团";
        this.sauce = "蛤蜊披萨的酱料";
        this.toppings.add("蛤蜊");
    }
}

View Code

View Code

意大利烤肠披萨:

意大利烤肠披萨:

图片 11图片 12

图片 13图片 14

/**
 * 意大利烤肠披萨
 * @author skysea
 */
public class PepperoniPizza extends Pizza{

    public PepperoniPizza() {
        this.name = "意大利烤肠披萨";
        this.dough = "意大利烤肠披萨的面团";
        this.sauce = "意大利烤肠披萨的酱料";
        this.toppings.add("一大波意大利烤肠...");
    }
}
/**
 * 意大利烤肠披萨
 * @author skysea
 */
public class PepperoniPizza extends Pizza{

    public PepperoniPizza() {
        this.name = "意大利烤肠披萨";
        this.dough = "意大利烤肠披萨的面团";
        this.sauce = "意大利烤肠披萨的酱料";
        this.toppings.add("一大波意大利烤肠...");
    }
}

View Code

View Code

 素食比萨:

 素食比萨:

图片 15图片 16

图片 17图片 18

/**
 * 素食比萨
 * @author skysea
 */
public class VeggiePizza extends Pizza {
    public VeggiePizza() {
        name = "素食比萨";
        dough = "素食比萨的面团";
        sauce = "素食比萨的酱料";
        toppings.add("素食比萨");
        toppings.add("素食比萨佐料1");
        toppings.add("素食比萨佐料2");
    }
}
/**
 * 素食比萨
 * @author skysea
 */
public class VeggiePizza extends Pizza {
    public VeggiePizza() {
        name = "素食比萨";
        dough = "素食比萨的面团";
        sauce = "素食比萨的酱料";
        toppings.add("素食比萨");
        toppings.add("素食比萨佐料1");
        toppings.add("素食比萨佐料2");
    }
}

View Code

View Code

贴了这么多代码,先被起一致波简单的实现:

贴了如此多代码,先给出同波简单的实现:

/**
 * pizza店
 * @author skysea
 */
public class PizzaStore {

    public Pizza orderPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (type.equals("pepperoni")) {
            pizza = new PepperoniPizza();
        } else if (type.equals("clam")) {
            pizza = new ClamPizza();
        } else if (type.equals("veggie")) {
            pizza = new VeggiePizza();
        }

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }

}
/**
 * pizza店
 * @author skysea
 */
public class PizzaStore {

    public Pizza orderPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (type.equals("pepperoni")) {
            pizza = new PepperoniPizza();
        } else if (type.equals("clam")) {
            pizza = new ClamPizza();
        } else if (type.equals("veggie")) {
            pizza = new VeggiePizza();
        }

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }

}

当匪考虑继续扩张披萨型的当儿,这样的兑现有没发出题目,一般的话,达到了好就此底正统,但是不好用,问题如下:

于非考虑继续扩大披萨型的早晚,这样的兑现有没起题目,一般的话,达到了足以用底正规,但是不好用,问题如下:

1,没有兼容原来的一样栽披萨方法 public Pizza
orderPizza(),相信自己,每一个public方法都是格外重要的,因为你无明了有些许地方因此到过。当然也非是绝非道知道,只是你掌握也未肯定就是能够改变,就算你能改,也非自然改对。

1,没有兼容原来的一致种植披萨方法 public Pizza
orderPizza(),相信自己,每一个public方法都是大要紧的,因为您莫晓出略地方因此到过。当然为非是从未道知道,只是你了解啊未必然就能够改变,就算你能改,也非肯定改对。

2,String类型的type太爱失误了,个人感觉对先后支付不谐和,当然者也要是分情况,灵活和严谨本来就杀为难形成少通通

2,String类型的type太爱错了,个人感觉对程序支付不友善,当然者吧只要分开情况,灵活和严谨本来就是老大麻烦就少咸

3,推荐获得不交相当的type时抛大,而无是回到空,便于排查问题(此处的if里面只是直new返回的目标,实际状况颇为较今的错综复杂)

3,推荐获得不至适当的type时抛大,而无是回来空,便于排查问题(此处的if里面只是一直new返回的靶子,实际情况远较今天之繁杂)

叫来第二版本:

为出第二本子:

/**
 * pizza店
 * @author skysea
 */
public class PizzaStore {

    public Pizza orderPizza() {
        return orderPizza(PizzaTypeEnum.CHEESE);
    }

    public Pizza orderPizza(PizzaTypeEnum type) {
        Pizza pizza;

        pizza = SimplePizzaFactory.getPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }
}
/**
 * pizza店
 * @author skysea
 */
public class PizzaStore {

    public Pizza orderPizza() {
        return orderPizza(PizzaTypeEnum.CHEESE);
    }

    public Pizza orderPizza(PizzaTypeEnum type) {
        Pizza pizza;

        pizza = SimplePizzaFactory.getPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }
}

SimplePizzaFactory:

SimplePizzaFactory:

/**
 * 简单工厂类
 * @author skysea
 */
public class SimplePizzaFactory {

    /**
     * 根据类型获取pizza
     * @param type
     * @return
     */
    public static final Pizza getPizza(PizzaTypeEnum type){
        switch (type) {
            case CHEESE: return new CheesePizza();
            case CLAM: return new ClamPizza();
            case PEPPERONI: return new PepperoniPizza();
            case VEGGIE: return new VeggiePizza();
            default: throw new NoSuchPizzaException(type.getCode());
        }
    }
}
/**
 * 简单工厂类
 * @author skysea
 */
public class SimplePizzaFactory {

    /**
     * 根据类型获取pizza
     * @param type
     * @return
     */
    public static final Pizza getPizza(PizzaTypeEnum type){
        switch (type) {
            case CHEESE: return new CheesePizza();
            case CLAM: return new ClamPizza();
            case PEPPERONI: return new PepperoniPizza();
            case VEGGIE: return new VeggiePizza();
            default: throw new NoSuchPizzaException(type.getCode());
        }
    }
}

辅助类(枚举,异常):

辅助类(枚举,异常):

图片 19图片 20

图片 21图片 22

/**
 * 定义pizza类型枚举
 * @author skysea
 *
 */
public enum PizzaTypeEnum{
    /**
     * 芝士披萨
     */
    CHEESE("cheese"),
    /**
     * 意大利烤肠披萨
     */
    PEPPERONI("pepperoni"),
    /**
     * 蛤蜊披萨
     */
    CLAM("clam"),
    /**
     * 素食比萨
     */
    VEGGIE("veggie");
    private final String code;
    PizzaTypeEnum(String code) {
        this.code = code;
    }
    public String getCode() {
        return code;
    }
}
/**
 * 定义pizza类型枚举
 * @author skysea
 *
 */
public enum PizzaTypeEnum{
    /**
     * 芝士披萨
     */
    CHEESE("cheese"),
    /**
     * 意大利烤肠披萨
     */
    PEPPERONI("pepperoni"),
    /**
     * 蛤蜊披萨
     */
    CLAM("clam"),
    /**
     * 素食比萨
     */
    VEGGIE("veggie");
    private final String code;
    PizzaTypeEnum(String code) {
        this.code = code;
    }
    public String getCode() {
        return code;
    }
}

View Code

View Code

图片 23图片 24

图片 25图片 26

/**
 * 没有匹配的pizza异常
 * @author skysea
 */
public class NoSuchPizzaException extends RuntimeException{
    private static final long serialVersionUID = 6831396172306375611L;
    public NoSuchPizzaException(String message) {
        super(message);
    }
}
/**
 * 没有匹配的pizza异常
 * @author skysea
 */
public class NoSuchPizzaException extends RuntimeException{
    private static final long serialVersionUID = 6831396172306375611L;
    public NoSuchPizzaException(String message) {
        super(message);
    }
}

View Code

View Code

测试类:

测试类:

/**
 * pizza测试类
 * @author skysea
 */
public class PizzaTest {

    public static void main(String[] args) {
        PizzaStore store = new PizzaStore();

        Pizza pizza = store.orderPizza(PizzaTypeEnum.CHEESE);
        System.out.println(pizza);

        pizza = store.orderPizza(PizzaTypeEnum.VEGGIE);
        System.out.println(pizza);
    }
}
/**
 * pizza测试类
 * @author skysea
 */
public class PizzaTest {

    public static void main(String[] args) {
        PizzaStore store = new PizzaStore();

        Pizza pizza = store.orderPizza(PizzaTypeEnum.CHEESE);
        System.out.println(pizza);

        pizza = store.orderPizza(PizzaTypeEnum.VEGGIE);
        System.out.println(pizza);
    }
}

图片 27

图片 28

好了,代码写及这里,其实对:新增披萨类型的是需求的兑现其实都充分好了。至少来说现阶段之需求实现了,其次就是是本着调用方友好,至少队友不见面跑过来咨询您种传啥,不见面告诉你他string字符串传错了,不见面当公转移个类型的下,还要通知他(当然这也可通过常量来拍卖)。

哼了,代码写及此地,其实对于:新增披萨类型的斯需要的落实其实就生好了。至少来说现阶段底需要实现了,其次就是是对准调用方友好,至少队友不见面走过来咨询您种传啥,不见面报告您他string字符串传错了,不见面在您转移个类别的时候,还要通知他(当然者邪得经常量来拍卖)。

流产了一半龙,来说说这段代码的问题,正常情形下,需求会是如此变:

流产了一半上,来说说马上段代码的问题,正常状态下,需求会是这样变:

1,PepperoniPizza暂时不要了,一般的话,你问问他只要无设,他会见说,这个要扣后边的运营状态(我:…)

1,PepperoniPizza暂时不用了,一般的话,你问问他一旦无若,他会见说,这个要扣后的运营状况(我:…)

2,你叫自家新加一个xx披萨

2,你让自身新加一个xx披萨

当今急需改之凡少单地方,一个是厂类,一个凡是枚举,但是主要的流程是毫无转了,如果你道还是怪烦在未考虑性能的景象下,你还足以用反射来玩,改造一下厂类(实现通过class来创建对象)和枚举(添加一个字段来存放type对应之class)就足以了,不赘述..

现得转移的是零星个地方,一个凡是工厂类,一个凡枚举,但是要的流水线是决不转了,如果您看还是好辛苦在无考虑性能的情况下,你还可以就此反射来打,改造一下工厂类(实现通过class来创建对象)和枚举(添加一个字段来存放在type对应的class)就足以了,不赘述..

首先波需求就多得如此收手了,随着工作的向上,披萨店那让一个富饶啊,虽然中为本着代码做了许多新的披萨,但是由PizzaStore相当稳定,也从来不来什么好题材。

先是波需求就是差不多可以这么收手了,随着事情的进步,披萨店那吃一个有余啊,虽然中也本着代码做了过多初的披萨,但是由PizzaStore相当稳定,也从未发出什么大问题。

新的题目(开分店):

初的题材(开分店):

1,旗舰店在芝加哥,现在设当纽约开班平寒新的旅店

1,旗舰店在芝加哥,现在一旦当纽约开平贱新的客栈

2,分店的披萨口味要基于地方的脾胃来拓展调整,保证能不失去品牌特色之而,也会满足当地非常之气韵

2,分店的披萨口味要依据地方的口味来开展调整,保证会不失去品牌特色之还要,也能满足当地特有的气韵

3,分店披萨的类与小与胡舰店保持一致

3,分店披萨的档次与少与洋舰店保持一致

厂子方法模式

厂子方法模式

事先拿具有的披萨列出来

预先把富有的披萨列出来

芝加哥底披萨:

芝加哥底披萨:

图片 29图片 30

图片 31图片 32

/**
 * 芝加哥芝士披萨
 * @author skysea
 */
public class ChicagoStyleCheesePizza extends Pizza {

    public ChicagoStyleCheesePizza() { 
        name = "芝加哥芝士披萨";
        dough = "芝加哥芝士披萨面团";
        sauce = "芝加哥芝士披萨酱料";

        toppings.add("芝加哥芝士披萨调料1");
        toppings.add("芝加哥芝士披萨调料2");
    }

    @Override
    void cut() {
        System.out.println("芝加哥芝士披萨版切片...");
    }
}
/**
 * 芝加哥蛤蜊披萨
 * @author skysea
 */
public class ChicagoStyleClamPizza extends Pizza {
    public ChicagoStyleClamPizza() {
        name = "芝加哥蛤蜊披萨";
        dough = "芝加哥蛤蜊披萨面团";
        sauce = "芝加哥蛤蜊披萨酱料";

        toppings.add("芝加哥蛤蜊披萨佐料1");
        toppings.add("芝加哥蛤蜊披萨佐料2");
    }

    @Override
    void cut() {
        System.out.println("芝加哥蛤蜊披萨版切片...");
    }
}
/**
 * 芝加哥意大利烤肠披萨
 * @author skysea
 */
public class ChicagoStylePepperoniPizza extends Pizza {
    public ChicagoStylePepperoniPizza() {
        name = "芝加哥意大利烤肠披萨";
        dough = "芝加哥意大利烤肠披萨面团";
        sauce = "芝加哥意大利烤肠披萨酱料";

        toppings.add("芝加哥意大利烤肠披萨调料1");
        toppings.add("芝加哥意大利烤肠披萨调料2");
        toppings.add("芝加哥意大利烤肠披萨调料3");
        toppings.add("芝加哥意大利烤肠披萨调料4");
    }

    @Override
    void cut() {
        System.out.println("芝加哥意大利烤肠披萨版切片...");
    }
}
/**
 * 芝加哥素食比萨
 * @author skysea
 */
public class ChicagoStyleVeggiePizza extends Pizza {
    public ChicagoStyleVeggiePizza() {
        name = "芝加哥素食比萨";
        dough = "芝加哥素食比萨的面团";
        sauce = "芝加哥素食比萨的酱料";

        toppings.add("芝加哥素食比萨调料1");
        toppings.add("芝加哥素食比萨调料2");
        toppings.add("芝加哥素食比萨调料3");
    }

    void cut() {
        System.out.println("芝加哥素食比萨版切片...");
    }
}
/**
 * 芝加哥芝士披萨
 * @author skysea
 */
public class ChicagoStyleCheesePizza extends Pizza {

    public ChicagoStyleCheesePizza() { 
        name = "芝加哥芝士披萨";
        dough = "芝加哥芝士披萨面团";
        sauce = "芝加哥芝士披萨酱料";

        toppings.add("芝加哥芝士披萨调料1");
        toppings.add("芝加哥芝士披萨调料2");
    }

    @Override
    void cut() {
        System.out.println("芝加哥芝士披萨版切片...");
    }
}
/**
 * 芝加哥蛤蜊披萨
 * @author skysea
 */
public class ChicagoStyleClamPizza extends Pizza {
    public ChicagoStyleClamPizza() {
        name = "芝加哥蛤蜊披萨";
        dough = "芝加哥蛤蜊披萨面团";
        sauce = "芝加哥蛤蜊披萨酱料";

        toppings.add("芝加哥蛤蜊披萨佐料1");
        toppings.add("芝加哥蛤蜊披萨佐料2");
    }

    @Override
    void cut() {
        System.out.println("芝加哥蛤蜊披萨版切片...");
    }
}
/**
 * 芝加哥意大利烤肠披萨
 * @author skysea
 */
public class ChicagoStylePepperoniPizza extends Pizza {
    public ChicagoStylePepperoniPizza() {
        name = "芝加哥意大利烤肠披萨";
        dough = "芝加哥意大利烤肠披萨面团";
        sauce = "芝加哥意大利烤肠披萨酱料";

        toppings.add("芝加哥意大利烤肠披萨调料1");
        toppings.add("芝加哥意大利烤肠披萨调料2");
        toppings.add("芝加哥意大利烤肠披萨调料3");
        toppings.add("芝加哥意大利烤肠披萨调料4");
    }

    @Override
    void cut() {
        System.out.println("芝加哥意大利烤肠披萨版切片...");
    }
}
/**
 * 芝加哥素食比萨
 * @author skysea
 */
public class ChicagoStyleVeggiePizza extends Pizza {
    public ChicagoStyleVeggiePizza() {
        name = "芝加哥素食比萨";
        dough = "芝加哥素食比萨的面团";
        sauce = "芝加哥素食比萨的酱料";

        toppings.add("芝加哥素食比萨调料1");
        toppings.add("芝加哥素食比萨调料2");
        toppings.add("芝加哥素食比萨调料3");
    }

    void cut() {
        System.out.println("芝加哥素食比萨版切片...");
    }
}

View Code

View Code

纽约的披萨:

纽约之披萨:

图片 33图片 34

图片 35图片 36

/**
 * 纽约芝士披萨
 * @author skysea
 */
public class NYStyleCheesePizza extends Pizza {

    public NYStyleCheesePizza() { 
        name = "纽约芝士披萨";
        dough = "纽约芝士披萨面团";
        sauce = "纽约芝士披萨酱料";

        toppings.add("纽约芝士披萨调料1");
        toppings.add("纽约芝士披萨调料2");
    }

    @Override
    void cut() {
        System.out.println("纽约芝士披萨版切片...");
    }
}
/**
 * 纽约蛤蜊披萨
 * @author skysea
 */
public class NYStyleClamPizza extends Pizza {
    public NYStyleClamPizza() {
        name = "纽约蛤蜊披萨";
        dough = "纽约蛤蜊披萨面团";
        sauce = "纽约蛤蜊披萨酱料";

        toppings.add("纽约蛤蜊披萨佐料1");
        toppings.add("纽约蛤蜊披萨佐料2");
    }

    @Override
    void cut() {
        System.out.println("纽约蛤蜊披萨版切片...");
    }
}
/**
 * 纽约意大利烤肠披萨
 * @author skysea
 */
public class NYStylePepperoniPizza extends Pizza {
    public NYStylePepperoniPizza() {
        name = "纽约意大利烤肠披萨";
        dough = "纽约意大利烤肠披萨面团";
        sauce = "纽约意大利烤肠披萨酱料";

        toppings.add("纽约意大利烤肠披萨调料1");
        toppings.add("纽约意大利烤肠披萨调料2");
        toppings.add("纽约意大利烤肠披萨调料3");
        toppings.add("纽约意大利烤肠披萨调料4");
    }

    @Override
    void cut() {
        System.out.println("纽约意大利烤肠披萨版切片...");
    }
}
/**
 * 纽约素食比萨
 * @author skysea
 */
public class NYStyleVeggiePizza extends Pizza {
    public NYStyleVeggiePizza() {
        name = "纽约素食比萨";
        dough = "纽约素食比萨的面团";
        sauce = "纽约素食比萨的酱料";

        toppings.add("纽约素食比萨调料1");
        toppings.add("纽约素食比萨调料2");
        toppings.add("纽约素食比萨调料3");
    }

    void cut() {
        System.out.println("纽约素食比萨版切片...");
    }
}
/**
 * 纽约芝士披萨
 * @author skysea
 */
public class NYStyleCheesePizza extends Pizza {

    public NYStyleCheesePizza() { 
        name = "纽约芝士披萨";
        dough = "纽约芝士披萨面团";
        sauce = "纽约芝士披萨酱料";

        toppings.add("纽约芝士披萨调料1");
        toppings.add("纽约芝士披萨调料2");
    }

    @Override
    void cut() {
        System.out.println("纽约芝士披萨版切片...");
    }
}
/**
 * 纽约蛤蜊披萨
 * @author skysea
 */
public class NYStyleClamPizza extends Pizza {
    public NYStyleClamPizza() {
        name = "纽约蛤蜊披萨";
        dough = "纽约蛤蜊披萨面团";
        sauce = "纽约蛤蜊披萨酱料";

        toppings.add("纽约蛤蜊披萨佐料1");
        toppings.add("纽约蛤蜊披萨佐料2");
    }

    @Override
    void cut() {
        System.out.println("纽约蛤蜊披萨版切片...");
    }
}
/**
 * 纽约意大利烤肠披萨
 * @author skysea
 */
public class NYStylePepperoniPizza extends Pizza {
    public NYStylePepperoniPizza() {
        name = "纽约意大利烤肠披萨";
        dough = "纽约意大利烤肠披萨面团";
        sauce = "纽约意大利烤肠披萨酱料";

        toppings.add("纽约意大利烤肠披萨调料1");
        toppings.add("纽约意大利烤肠披萨调料2");
        toppings.add("纽约意大利烤肠披萨调料3");
        toppings.add("纽约意大利烤肠披萨调料4");
    }

    @Override
    void cut() {
        System.out.println("纽约意大利烤肠披萨版切片...");
    }
}
/**
 * 纽约素食比萨
 * @author skysea
 */
public class NYStyleVeggiePizza extends Pizza {
    public NYStyleVeggiePizza() {
        name = "纽约素食比萨";
        dough = "纽约素食比萨的面团";
        sauce = "纽约素食比萨的酱料";

        toppings.add("纽约素食比萨调料1");
        toppings.add("纽约素食比萨调料2");
        toppings.add("纽约素食比萨调料3");
    }

    void cut() {
        System.out.println("纽约素食比萨版切片...");
    }
}

View Code

View Code

披萨倒是排了了,但是以实际上的开支过程被,业务逻辑这么简单那是不可能的,想只要改变那什么旗舰店披萨的类名是深不便的

披萨倒是排了了,但是于事实上的出过程被,业务逻辑这么简单那是未容许的,想要转那什么旗舰店披萨的类名是异常窘迫的

相似如果考虑:

貌似要考虑:

1,是未是单机,有没有来另外部系统以调用

1,是免是单机,有没有发生另外外部系统以调用

2,改动原来的代码来啊好处,更易于了解啊?迭代了几独版之后垃圾代码太多矣呢?

2,改动原来的代码有什么补,更便于掌握为?迭代了几乎单版后垃圾代码太多了呢?

3,影响挺莫怪

3,影响好未杀

当然,我此是按照便造,你们吗,我哪怕未知情了,嘿嘿嘿,所以遇到这种情景,一般的话要悠着点,看时光,也使扣影响,开发就是这般,同一个意义,2天发生2龙之做法,5天来5天的做法,10上发10龙的做法

自然,我此是比照便造,你们啊,我不怕无知情了,嘿嘿嘿,所以遇到这种状态,一般的话要悠着点,看时光,也使扣押影响,开发就是如此,同一个功能,2天来2龙的做法,5天有5天的做法,10上来10龙之做法

披萨店改造:

披萨店改造:

/**
 * 披萨店抽象类
 * @author skysea
 */
public abstract class PizzaStore {

    abstract Pizza createPizza(String item);

    public Pizza orderPizza(String type) {
        Pizza pizza = createPizza(type);
        System.out.println("--- 制作 " + pizza.getName() + " ---");
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

/**
 * 芝加哥披萨店
 * @author skysea
 */
public class ChicagoPizzaStore extends PizzaStore {
    public static final String CHEESE = "cheese";
    public static final String VEGGIE = "veggie";
    public static final String CLAM = "clam";
    public static final String PEPPERONI = "pepperoni";
    Pizza createPizza(String item) {
        if (CHEESE.equals(item)) {
            return new ChicagoStyleCheesePizza();
        } else if (VEGGIE.equals(item)) {
            return new ChicagoStyleVeggiePizza();
        } else if (CLAM.equals(item)) {
            return new ChicagoStyleClamPizza();
        } else if (PEPPERONI.equals(item)) {
            return new ChicagoStylePepperoniPizza();
        } else {
            throw new NoSuchPizzaException(item);
        }
    }
}
/**
 * 披萨店抽象类
 * @author skysea
 */
public abstract class PizzaStore {

    abstract Pizza createPizza(String item);

    public Pizza orderPizza(String type) {
        Pizza pizza = createPizza(type);
        System.out.println("--- 制作 " + pizza.getName() + " ---");
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

/**
 * 芝加哥披萨店
 * @author skysea
 */
public class ChicagoPizzaStore extends PizzaStore {
    public static final String CHEESE = "cheese";
    public static final String VEGGIE = "veggie";
    public static final String CLAM = "clam";
    public static final String PEPPERONI = "pepperoni";
    Pizza createPizza(String item) {
        if (CHEESE.equals(item)) {
            return new ChicagoStyleCheesePizza();
        } else if (VEGGIE.equals(item)) {
            return new ChicagoStyleVeggiePizza();
        } else if (CLAM.equals(item)) {
            return new ChicagoStyleClamPizza();
        } else if (PEPPERONI.equals(item)) {
            return new ChicagoStylePepperoniPizza();
        } else {
            throw new NoSuchPizzaException(item);
        }
    }
}

纽约披萨店(和芝加哥披萨店几乎一毛一样,这里虽未开展了):

纽约披萨店(和芝加哥披萨店几乎一毛一样,这里虽无进行了):

图片 37图片 38

图片 39图片 40

/**
 * 纽约披萨店
 * @author skysea
 */
public class NYPizzaStore extends PizzaStore {

    public static final String CHEESE = "cheese";
    public static final String VEGGIE = "veggie";
    public static final String CLAM = "clam";
    public static final String PEPPERONI = "pepperoni";
    Pizza createPizza(String item) {
        if (CHEESE.equals(item)) {
            return new NYStyleCheesePizza();
        } else if (VEGGIE.equals(item)) {
            return new NYStyleVeggiePizza();
        } else if (CLAM.equals(item)) {
            return new NYStyleClamPizza();
        } else if (PEPPERONI.equals(item)) {
            return new NYStylePepperoniPizza();
        } else {
            throw new NoSuchPizzaException(item);
        }
    }
}
/**
 * 纽约披萨店
 * @author skysea
 */
public class NYPizzaStore extends PizzaStore {

    public static final String CHEESE = "cheese";
    public static final String VEGGIE = "veggie";
    public static final String CLAM = "clam";
    public static final String PEPPERONI = "pepperoni";
    Pizza createPizza(String item) {
        if (CHEESE.equals(item)) {
            return new NYStyleCheesePizza();
        } else if (VEGGIE.equals(item)) {
            return new NYStyleVeggiePizza();
        } else if (CLAM.equals(item)) {
            return new NYStyleClamPizza();
        } else if (PEPPERONI.equals(item)) {
            return new NYStylePepperoniPizza();
        } else {
            throw new NoSuchPizzaException(item);
        }
    }
}

View Code

View Code

即时段代码有三只问题使明了掌握:

随即段代码来三单问题要懂掌握:

1,这个地方为甚要弄个泛类出来?

1,这个地方吧甚要来个抽象类出来?

夫将要结合实际来了解了,分店以及分店里,需不需要统一规范化管理?需不需要保证自己之风味?答案肯定,都是要的

斯即将结合实际来理解了,分店和分店里,需不需要统一规范化管理?需不需要保证自己的风味?答案自然,都是内需之

斯地方制造披萨之历程,毫无疑问是必然使一如既往的。就比如外卖一样,下单,炒菜,配送。整套流程都是如此,不能够说若出就是从头炒菜了啊,这不正确。不一样的地方便是,你做菜的哟菜,好不可口。配送得快不快,稳不稳当,服务好不好。

是地方制造披萨底经过,毫无疑问是早晚要平等的。就如外卖一样,下单,炒菜,配送。整套流程都是这么,不克说而出去就开炒菜了什么,这不得法。不同等的地方就是,你做菜之呀菜,好不好吃。配送得抢不快,稳不妥当,服务好不好。

所以,抽象类的意义就是是:规范、特色

因此,抽象类的含义就是:规范、特色

2,factory咋个不见了?

2,factory咋个不见了?

因为把它们跟现实的store合并在联名了,这样以引申出另外一个题目:为甚要联合?因为store现在担任的角色就是是facotry,刚才说罢的造作过程都坐父类中实现了,现在只需要以切实可行的store中去解决披萨的创造问题

坐把其与现实性的store合并在共同了,这样以引申出另外一个问题:为甚要合并?因为store现在任的角色就是是facotry,刚才说罢之制造过程已经坐父类中贯彻了,现在一味需要在切实的store中失化解披萨之创立问题

3,为底还要毫不枚举了,弄个String来创造pizza?

3,为底还要不用枚举了,弄个String来创造pizza?

倘还是单机,用枚举当然会于直丢弃个string来得稳。

若果还是单机,用枚举当然会于直接丢弃个string来得稳当。

开了子公司,要是每个子公司还是一律效仿完整的劳务在打,丢个string,要比较枚举来得好。原因出2:传输过程遭到的序列化和反序列化、更加灵敏(客户端不用每次都盖此原因只要失去提升对应的管,特别是大半只版在跑得时,升级了而会造成其他东西不能够玩)

千帆竞发了分公司,要是每个子公司还是千篇一律效仿完整的服务在戏耍,丢个string,要比较枚举来得好。原因出2:传输过程中之序列化和反序列化、更加灵敏(客户端不用每次都坐此由只要错过提升对应的保管,特别是大半只本子在走得时,升级了并且会造成其他东西不可知打)

测试类:

测试类:

/**
 * 披萨测试类
 * @author skysea
 */
public class PizzaTest {

    public static void main(String[] args) {
        PizzaStore nyStore = new NYPizzaStore();
        PizzaStore chicagoStore = new ChicagoPizzaStore();

        Pizza pizza = nyStore.orderPizza(NYPizzaStore.CHEESE);
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza(ChicagoPizzaStore.CHEESE);
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

        pizza = nyStore.orderPizza(NYPizzaStore.CLAM);
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza(ChicagoPizzaStore.CLAM);
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

        pizza = nyStore.orderPizza(NYPizzaStore.PEPPERONI);
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza(ChicagoPizzaStore.PEPPERONI);
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

        pizza = nyStore.orderPizza(NYPizzaStore.VEGGIE);
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza(ChicagoPizzaStore.VEGGIE);
        System.out.println("Joel ordered a " + pizza.getName() + "\n");
    }
}
/**
 * 披萨测试类
 * @author skysea
 */
public class PizzaTest {

    public static void main(String[] args) {
        PizzaStore nyStore = new NYPizzaStore();
        PizzaStore chicagoStore = new ChicagoPizzaStore();

        Pizza pizza = nyStore.orderPizza(NYPizzaStore.CHEESE);
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza(ChicagoPizzaStore.CHEESE);
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

        pizza = nyStore.orderPizza(NYPizzaStore.CLAM);
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza(ChicagoPizzaStore.CLAM);
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

        pizza = nyStore.orderPizza(NYPizzaStore.PEPPERONI);
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza(ChicagoPizzaStore.PEPPERONI);
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

        pizza = nyStore.orderPizza(NYPizzaStore.VEGGIE);
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza(ChicagoPizzaStore.VEGGIE);
        System.out.println("Joel ordered a " + pizza.getName() + "\n");
    }
}

结果(结果绝多矣,就未浑截图出来了):

结果(结果绝多了,就未整截图出来了):

图片 41

图片 42

 

 

 

 

相关文章