工厂方式

工厂方式

本文的概念性内容出自深刻浅出设计格局1书.

正文源自深刻浅出设计格局. 只可是小编是使用C#/.NET Core达成的例子.

一.落笔缘由

鉴于看了《Head First Design
Patterns》1书,查阅资料对各个情势抱有精通,把网络的认为相比易于领悟的材料摘抄下来,并依靠《Head
First Design Patterns》的从头到尾的经过张开实行和驾驭,在此做下笔记。

厂子方法格局定义:定义了多少个成立对象的接口,但由子类决定要实例化的类是哪2个。工厂方法让类把实例化推迟到子类。(注:“决定”不是指情势允许子类本身在运行时做决定,而是指在编辑创造者类时,不需求明白实际成立的出品是哪二个。选择了运用哪个子类,自然就决定了事实上创建的制品是怎么)

上一篇作品讲了简要工厂和工厂方法设计格局
, 使用的是披萨店的例子.

 

二.厂子格局概念与分类

厂子情势属于创造型格局。
厂子形式能够分成两种:

 

文将继续选用这一个事例, 这里要用到虚幻工厂.

前言

当您瞧瞧new这一个重大字的时候, 就活该想到它是有血有肉的完毕.

图片 1

那正是贰个实际的类, 为了更灵活, 我们应有选拔的是接口(interface).

神跡, 你只怕会写出如此的代码:

图片 2

此处有多少个具体的类被实例化了, 是依附分化景况在运作时被实例化的. 

当您看看那般的代码, 你就能够懂伏贴有须求须求对其举办改动只怕扩张的时候,
你就得把这些文件张开, 然后看看在此处应该加上大概去除点什么.
那类的代码常常会分散在程序的多个地点,
那维护和翻新起来就很麻烦而且轻松出错.

本着interface实行编制程序的时候,
你精晓能够把温馨独自于系统今后大概要发生的变化. 为何呢?
因为一旦你针对interface编制程序,
那么对于别的落成了该接口的具体类对你的话都能够用, 多态吗.

一)轻易工厂形式(Simple Factory)

粗略工厂其实不是1种设计形式,反而更像1种编制程序习贯。

一旦我们要开一间披萨店,提供不一致口味的披萨。

披萨店的需求变动

前些天披萨店在处处授权了无数皮之不存毛将焉附分店, 可是壹对子公司偷工减料,
使用劣质原料代替标准原料.

披萨店老总未来固然想化解那些难题.

品种本来供给

有3个前方的披萨店, 做披萨, 下边是订购披萨的类:

图片 3

new2个披萨, 然后根据工序进行加工 最终回来披萨.

但是, 2个披萨店不恐怕唯有一种披萨, 恐怕会有多数中披萨,
所以你大概会那样修改代码:

图片 4

听别人说传入的种类, 成立区别的披萨, 然后加工重返.

下一场难点来了, 随着时间的推迟,
3个披萨店会淘汰不火爆的披萨并增加新类型披萨.

运用方面包车型地铁代码就能够产出这几个主题材料, 针对须求变化,
作者只好把OrderPizza的1对代码改来改去:

图片 5

从此间, 大家也足以看来, 上半片段是会扭转的局地, 下半部分是不改变的片段,
所以它们应该分别(把转换的一部分和不改变的1对分离, 然后开始展览包装).

结构应当是这么的:

图片 6

右上角是变化的片段, 把那有个别包装到二个目标里, 它正是用来成立披萨的靶子,
大家把这么些目的叫做: 工厂.

工厂担当创立对象的细节专门的学业. 我们成立的这一个工厂叫做SimplePizzaFactory,
而orderPizza()这几个主意正是该工厂的二个客户(client).

任曾几何时候客户必要披萨的时候, 披萨工厂就能给客户创造二个披萨.

接下去, 大家就创设那些大约的披萨工厂:

图片 7

哪怕经过传播的品种参数, 组建并重返不一样门类的披萨.

如此那般我们就把披萨成立的劳作封装到了二个类里面, 产生变化的时候,
只供给修改那2个类就能够.

专注: 有时候上面那种轻便工厂能够选拔静态方法, 不过那样也有隐疾,
正是力不从心透过持续来增添那些工厂了.

回到修改PizzaStore这些类:

图片 8

工厂是从构造函数字传送入的, 并在PizzaStore里面保留二个引用.

在OrderPizza()方法里面, 大家利用工厂的创导方法代替了new关键字,
所以在此地未有切实可行的实例化.

二)工厂方法形式(Factory Method)

概念了一个创造对象的接口,但由子类决定实例化的类是哪多个,工厂方法让类把实例化推迟到子类。(Head
First Design Patterns那样定义的)

第三有1个PizzaStore的类,里面提供1个orderPizza的章程,让客户选取要购买的Pizza。

原料的一致性问题

首先如何保管原材质的质量难点? 能够创立1个工厂生产原料,
然后把原材质分发到四面八方的授权店.

然后还有多个原料的壹致性难点,
比如London的臭柿酱和阿姆斯特丹的洋茄酱只怕有点不相同, 所以它们分别须要一套原料.

也就是说内地的披萨是运用同一的原质地,
可是各样原料在到处恐怕会存在差别(分化的贯彻).

图片 9

那就是London, 伊斯坦布尔和加州个其他原材料家族.

粗略工厂的概念

简轻巧单/简易工厂并不是三个设计形式, 越来越多是2个编制程序习贯. 不过利用的至极分布.

简言之工厂类图:

图片 10

本条非常的粗略, 就不解释了. 

回顾工厂就到那, 下边要讲八个重量级的厂子格局.

3)抽象工厂情势(Abstract Factory)

提供八个接口,用于创设连锁大概注重对象的家族,而不须要鲜明钦点具体类。(Head
First Design Patterns那样定义的)

最开始想到的是如此写:

建立原料工厂

接下去正是树立原料工厂, 那个工厂将担当为各自的家族(地方)创立原料.

第一是工厂的接口:

图片 11

下一场大家要做上边这么些剧情:

  • 为每个区域创建四个工厂 (落成PizzaIngredientFactory接口及其方法)
  • 得以完毕部分原材料的类, 它们得以呗工厂使用, 当中一些原料能够跨地域共享
  • 末段我们把地点那些整合到PizzaStore里面.

London的原材质工厂:

图片 12

即使落成接口, 返回本地须要的原材质而已.

修改Pizza抽象类:

图片 13

这里大家把Prepare()方法(企图原料)改成肤浅的了, 其它的维系不变.

接下去须求为各市创建不相同风格的披萨了.
现在内地披萨店的原材质都是从工厂送来的, 就不可能使用劣质原料代替了.

后面运用工厂方法情势时, 我们为各样地方创制了差异风格的披萨, 比方NYCheesePizza, ChicagoCheesePizza. 你可以看一下那四个类,
它们中间唯有原料部分(都以均等的原材料, 但是所在风格不相同)是分歧的.

故而实际, 大家无需为每种地方创造分裂风格的披萨,
原料工厂将会替我们管理各市风格披萨原料不一那种景况.

诸如奶酪披萨只需求2个类就能够:

图片 14

为了创制奶酪披萨, 在其构造函数里面传出原料工厂为它提供原料就能够.

在prepare()方法里面打算的原料都是工厂来提供的.

使用什么地段/风格的原料由工厂决定, 披萨类自个儿并不关注,
它只需清楚怎么制作披萨就行.

那样披萨类和各省段的原材质就解耦了.

综上, 正是一句话:

图片 15

原材质由工厂提供.

能够再看看其它二个披萨的例子:

图片 16

用C#/.NET Core实现轻便工厂

Pizza父类:

图片 17图片 18

using System;
using System.Collections.Generic;

namespace SimpleFactory.Pizzas
{
    public abstract class Pizza
    {
        public string Name { get; protected set; }
        public string Dough { get; protected set; }
        public string Sauce { get; protected set; }
        protected List<string> Toppings = new List<string>();

        public void Prepare()
        {
            Console.WriteLine($"Preparing: {Name}");
            Console.WriteLine($"Tossing: {Dough}");
            Console.WriteLine($"Adding sauce: {Sauce}");
            Console.WriteLine("Adding toppings: ");
            Toppings.ForEach(x => Console.WriteLine($"  {x}"));
        }

        public void Bake()
        {
            Console.WriteLine("Bake for 25 minutes");
        }

        public void Cut()
        {
            Console.WriteLine("Cutting the pizza into diagnol slices");
        }

        public void Box()
        {
            Console.WriteLine("Placing pizza in official PizzaStore box......");
        }
    }
}

View Code

各种Pizza:

图片 19图片 20

namespace SimpleFactory.Pizzas
{
    public class CheesePizza: Pizza
    {
        public CheesePizza()
        {
            Name = "Cheese Pizza";
            Dough = "Think Dough";
            Sauce = "Salad";
            Toppings.Add("Grated Reggiano Cheese");
        }
    }
}

namespace SimpleFactory.Pizzas
{
    public class ClamPizza: Pizza
    {
        public ClamPizza()
        {
            Name = "Clam Pizza";
            Sauce = "Tomato sauce";
            Dough = "Soft dough";
            Toppings.Add("Shrimp meat");
        }
    }
}

namespace SimpleFactory.Pizzas
{
    public class PepperoniPizza: Pizza
    {
        public PepperoniPizza()
        {
            Name = "Pepperoni Pizza";
            Dough = "Thin dough";
            Sauce = "Black pepper";
            Toppings.Add("Beef Granules");
            Toppings.Add("Niblet");
        }
    }
}

View Code

轻松易行工厂:

using SimpleFactory.Pizzas;

namespace SimpleFactory
{
    public class SimplePizzaFactory
    {
        public Pizza CreatePizza(string type)
        {
            Pizza pizza = null;
            switch (type)
            {
                case "cheese":
                    pizza = new CheesePizza();
                    break;
                case "pepperoni":
                    pizza = new PepperoniPizza();
                    break;
                case "clam":
                    pizza = new ClamPizza();
                    break;
            }

            return pizza;
        }
    }
}

PizzaStore:

using SimpleFactory.Pizzas;

namespace SimpleFactory
{
    public class PizzaStore
    {
        private readonly SimplePizzaFactory _factory;

        public PizzaStore(SimplePizzaFactory factory)
        {
            _factory = factory;
        }

        public Pizza OrderPizza(string type)
        {
            var pizza = _factory.CreatePizza(type);
            pizza.Prepare();
            pizza.Bake();
            pizza.Cut();
            pizza.Box();
            return pizza;
        }
    }
}

测试运转:

using System;

namespace SimpleFactory
{
    class Program
    {
        static void Main(string[] args)
        {
            var pizzaStore = new PizzaStore(new SimplePizzaFactory());
            var cheesePizza = pizzaStore.OrderPizza("cheese");
            Console.WriteLine();
            var clamPizza = pizzaStore.OrderPizza("pepperoni");
            Console.ReadKey();
        }
    }
}

图片 21

 

3.轻易工厂方式

图片 22

简短工厂情势类图

它由三种剧中人物组成:
工厂类剧中人物:那是本格局的基本,含有一定的经济贸易逻辑和判定逻辑,依照逻辑区别,产生实际的厂子产品。
空泛产品剧中人物:它一般是现实性产品持续的父类大概落成的接口。由接口只怕抽象类来促成。
切实产品剧中人物:工厂类所开创的靶子正是此剧中人物的实例。在java中由三个具体类实现。

抽象产品剧中人物

public interface Pizza {

    public void prepare();
    public void bake();
    public void cut();
    public void box();
}

切实产品剧中人物
产品一:起司披萨

public class CheezePizza implements Pizza {

    public CheezePizza() {
        System.out.println("起司Pizza");
    }

    public void bake() {
    }

    public void box() {
    }

    public void cut() {
    }

    public void prepare() {
    }
}

产品二:蔬菜披萨

public class VaggiesPizza implements Pizza {

    public VaggiesPizza() {
        System.out.println("Vaggle Pizza");
    }
    public void bake() {
    }

    public void box() {
    }

    public void cut() {
    }

    public void prepare() {
    }
}

工厂剧中人物:

public class SimplePizzaFactory {

    public Pizza createPizza(int type)
    {
        Pizza pizza = null;
        if (type == 1) {
            pizza = new CheezePizza();
        }else if (type == 2) {
            pizza = new VagglePizza();
        }
        return pizza;
    }
}

客户端

public class Test2 {

    public static void main(String[] args) {
        SimplePizzaFactory simplePizzaFactory = new SimplePizzaFactory();
        Pizza  pizza = simplePizzaFactory.createPizza(1);
    }
}
public class PizzaStore {

    public Pizza orderPizza(String type) {
        Pizza pizza = null;

        if(type.equals("cheese")) {
            pizza = new CheesePizza();
        } else if(type.equals("greek")){
            pizza = new GreekPizza();
        } else if(type.equals("pepperoni")){
            pizza = new PepperoniPizza();
        }

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

修改各市的披萨店

图片 23

London的披萨店现在和London的原材质工厂组合在一齐,
那样它就可以出现纽约风格的披萨了.

在创制披萨的时候把原材质工厂传进去为披萨提供原料.

须要改变 – 授权连锁披萨店

 披萨店开的很好, 所以老总在全国各市开授权连锁分店了,
而每个区域的支行分局面居民的脾胃, 它们所提供的披萨类别可能会分歧.

譬如London和首尔和爱达荷的就有十分的大可能率不相同.

针对那一个要求, 大家恐怕会想到的第二种方法正是:
把SimplePizzaFactory收取出来, 分别成立多少个地点的厂子,
然后总局点把相应的工厂组合到PizzaStore

图片 24

代码是这么的:

纽约:

图片 25

芝加哥:

图片 26

因为个体验店布满在六街三陌, 总老板想做质管调控: 做披萨的为主工序应该是同等的,
然则指向某种披萨各省能够有两样的作风做法.

于是我们把createPizza()方法放回到PizzaStore, 但此次它是用空想来欺骗别人方法,
然后外省都会创立和煦的PIzzaStore:

图片 27

上边是London和洛杉矶的披萨店:

图片 28

本着每一个披萨, 纽约和熊川大概会有温馨风格具体达成的披萨.

orderPizza()方法是在父类/抽象类里面落成的, 这里的披萨照旧抽象的,
所以它并不知道是PizzaStore的哪些子类来做的披萨.

代码运转的时候, orderPizza()会调用createPizza()方法,
PizzaStore的某部子类料定会对此担负.

从而你哪些地点的PizzaStore, 就能够调控产出的是哪些地点特产的披萨.

 

上面就创办PizzaStore, 举个例子London的:

图片 29

其余地点的都大致, 就不贴图了.

四.工厂方法格局

图片 30

厂子方法情势类图

它由两种角色组成:
虚幻工厂剧中人物:这是工厂方法形式的骨干。是切实可行工厂剧中人物必须达成的接口或许必须继续的父类。在java中它由抽象类也许接口来贯彻。
实际工厂剧中人物:它含有和现实性作业逻辑有关的代码。由应用程序调用以创制对应的求实产品的目的。在java中它由具体的类来促成。
虚幻产品剧中人物:它是有血有肉产品持续的父类或然是得以实现的接口。在java中貌似有抽象类或许接口来促成。
切实产品剧中人物:具体育工作厂剧中人物所创制的靶子便是此剧中人物的实例。在java中由现实的类来促成。

空泛产品剧中人物:

public abstract class Pizza {

    String name;
    String dough;
    String sauce;
    ArrayList topping = new ArrayList();
    public  void prepare()
    {
        System.out.println("Prepareing "+name);
        System.out.println(dough+" Dough");
        System.out.println(sauce+" Sauce");
        System.out.println("Add topping:");
        for (int i = 0; i < topping.size(); i++) {
            System.out.println(topping.get(i)+" ");
        }
    }
    public  void bake()
    {
        System.out.println("Bake for 35 minutes at 350");
    }
    public  void cut()
    {
        System.out.println("Cutting the pizza into diagonal slices");
    }
    public  void box()
    {
        System.out.println("Place pizza in offical PizzaStore box");
    }
}

具体产品剧中人物:
出品一:London韵味起司披萨

public class NYStyleCheesePizza extends Pizza {

    public NYStyleCheesePizza() {
        System.out.println("纽约起司Pizza");
    }
}

产品二:布鲁塞尔起司披萨

public class ChicagoStyleCheesePizza extends Pizza {

    public ChicagoStyleCheesePizza() {
        System.out.println("芝加哥起司Pizza");
    }
}

虚幻工厂剧中人物

public abstract class PizzaStore {

    public Pizza orderPizza(int type) {
        Pizza pizza = createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    abstract Pizza createPizza(int type);
}

实际工厂剧中人物壹:London披萨工厂

public class NYPizzaStore extends PizzaStore{

    public NYPizzaStore() {
        System.out.println("欢迎光临纽约Pizza店---------");
    }
    public Pizza createPizza(int type)
    {
        Pizza pizza = null;
        if (type == 1) {
            pizza = new NYStyleCheesePizza();
        }
        return pizza;
    }
}

具体育工作厂剧中人物2:大邱披萨工厂

    public ChicagoPizzaStore() {
        System.out.println("欢迎光临芝加哥Pizza店---------");
    }
    public Pizza createPizza(int type)
    {
        Pizza pizza = null;
        if (type == 1) {
            pizza = new ChicagoStyleCheesePizza();
        }
        return pizza;
    }
}

客户端

public class Test {
    public static void main(String[] args) {
        PizzaStore nyPizzaStore = new NYPizzaStore();
        nyPizzaStore.orderPizza(1);

        PizzaStore chicagoPizzaStore = new ChicagoPizzaStore();
        chicagoPizzaStore.orderPizza(1);
    }
}

当披萨店增添比萨口味的时候,必须修改if
else部分的代码,那样做未有对修改关闭。

到当前地点, 大家做了怎么样?

咱们提供了壹种可认为披萨提供一族原料的厂子, 这一个工厂就称为抽象工厂.

虚幻工厂为创制某一家门的制品提供接口(interface), 针对这一个接口编制程序,
就能够兑现从现实生产成品的厂子解耦.

诸如此类做就允许大家为不相同的上下文使用不相同完成的厂子了.

因为大家的代码是从实际产品解耦的,
大家就足以经过轮换工厂来获得不一样风格的成品了.

图片 31

怎么样声爱他美(Beingmate)个工厂方法

依旧看那张图:

图片 32

虚幻的PizzaStore把订购披萨的永久工序orderPizza()放在了抽象类里面.

创建披萨createPizza()方法是在外地的披萨店里做实现.

用壹行代码来讲解工厂方法正是:

图片 33

工厂方法是让其子类具体来兑现目的创制的专门的工作.
这样就把父类中的客户代码和子类的创制对象部分的代码解耦了.

 

地点事业做的挺好, 然而还差1件事….披萨.

率先抽象父类:

图片 34

在那之中定义了调味料和工序

接下来实际的披萨:

伦敦的奶酪披萨

图片 35

马德里的奶酪披萨

图片 36

末段运营一下:

图片 37

图片 38

 

5.虚无工厂

图片 39

泛泛工厂类图

产品族:位于不相同产品品级结构中,功用相关联的产品组合的家门。
厂子方法格局与用空想来安慰自己工厂形式的区分:
工厂方法是提供三个虚幻接口来创制“1个出品”。
泛泛工厂是提供1个虚无接口来创立二个出品家族。

空洞工厂由二种剧中人物组成::
泛泛工厂角色:是实际工厂剧中人物必须兑现的接口只怕必须继承的父类。在java中它由抽象类只怕接口来完毕。
具体育工作厂角色:它富含和具体育赛事情逻辑有关的代码。由应用程序调用以成立对应的切实可行产品的靶子。在java中它由现实的类来兑现。
泛泛产品剧中人物:它是现实性产品继续的父类大概是兑现的接口。在java中一般有抽象类可能接口来贯彻。
切切实实产品角色:具体育工作厂剧中人物所创立的目的便是此剧中人物的实例。在java中由现实的类来贯彻。

架空产品角色
空泛产品剧中人物壹:抽象起司

public interface Cheese {
}

起司具体产品1:Mozzaralla起司

public class MozzarallaCheese implements Cheese {
    public MozzarallaCheese() {
        System.out.println("MozzarallaCheese");
    }
}

起司具体产品二:Regglano起司

public class RegglanoCheese implements Cheese {

    public RegglanoCheese() {
        System.out.println("RegglanoCheese");
    }
}

泛泛产品剧中人物二:抽象蔬菜

public interface Veggie {
}

蔬菜具体产品一:白茄

public class EggPlant implements Veggie {

    public EggPlant() {
        System.out.println("EggPlant");
    }
}

蔬菜具体产品2:飞龙菜

public class Spinach implements Veggie {
    public Spinach() {
        System.out.println("Spinach");
    }
}

蔬菜具体产品三:红杭椒

public class RedPepper implements Veggie {
    public RedPepper() {
        System.out.println("RedPepper");
    }
}

蔬菜具体产品肆:黑黄榄

public class BlackOlives implements Veggie {

    public BlackOlives() {
        System.out.println("BlackOlives");
    }
}

蔬菜具体产品5:独蒜

public class Garlic implements Veggie {

    public Garlic() {
        System.out.println("Garlic");
    }
}

虚幻工厂剧中人物
空洞工厂角色:原材料工厂

public interface IngredientFactory {

    public  Clam createClams();
    public  Sauce createSauce();
    public  Cheese createCheese();
    public  Dough createDough();
    public Veggie[] createVeggies();
    public Pepperoni createPepperoni();
}

切切实实工厂角色壹:London原材料工厂

public class NYIngredientFactory implements IngredientFactory {

    public Cheese createCheese() {
        return new RegglanoCheese();
    }

    public Clam createClams() {
        return new FreshClams();
    }

    public Dough createDough() {
        return new ThinCrustDough();
    }

    public Pepperoni createPepperoni() {
        return new SlicedPepperoni();
    }

    public Sauce createSauce() {
        return new ManinaraSauce();
    }

    public Veggie[] createVeggies() {
        Veggie[] veggies= {new Garlic(),new Onion(),new Mashroom(),new RedPepper()};
        return veggies;
    }
}

现实工厂剧中人物二:大田原质地工厂

public class ChicagoIngredientFactory implements IngredientFactory {

    public Cheese createCheese() {
        return new MozzarallaCheese();
    }

    public Clam createClams() {
        return new FrozenClams();
    }

    public Dough createDough() {
        return new ThickCrustDough();
    }

    public Pepperoni createPepperoni() {
        return new SlicedPepperoni();
    }

    public Sauce createSauce() {
        return new PlumTomatoSauce();
    }

    public Veggie[] createVeggies() {
        Veggie[] veggies = {new BlackOlives(),new EggPlant(),new Garlic()};
        return veggies;
    }
}

图片 40

事例类图

由此,将代码会扭转的有些提收取来,封装创造对象的代码到另3个类,正是SimplePizzaFactory。

梳理一下全套工艺流程

  1. 成立London的披萨店:

图片 41

  1. 下订单买披萨

图片 42

  1. orderPizza方法调用创制披萨的方法:

图片 43

到那, 代码都尚未变化.

四.开立披萨的时候, 使用原料工厂:

图片 44

  1. 披萨的预备工序里是由工厂来提供原料:

图片 45

  1. 依据其余工序加工并赶回披萨.

工厂方法格局

负有的厂子方式都会卷入对象的始建进度,
而工厂方法情势把对象创设的动作交给了子类, 并让它决定创办哪些对象.

创建者:

图片 46

 

产品:

图片 47

探访其它1种结构 — 并行的类组织:

图片 48

 

厂子方法形式的概念:

工厂方法方式定义了一个创立对象的接口,
不过让子类来支配具体创立的是哪1个对象. 工厂方法让多少个类延迟实例化,
直到子类的出现.

图片 49

左臂是成品, 全体具体的成品都应有继续于同二个父类/接口.

左边的Creator类里面富含全体办法的兑现除了抽象的工厂方法.
那些抽象的厂子方法在Creator的子类里面必须实行落到实处,
产品便是在子类具体贯彻的厂子方法里面创设出来的.

 

6.总结

一)所以的厂子都是用来封装对象的创始。
2)工厂方法应用持续:把对象的创造委托给子类,子类落成工厂方法来制造对象。

public abstract class PizzaStore {

    public Pizza orderPizza(int type) {
        Pizza pizza = createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
//子类实现这工厂方法来创建对象
    abstract Pizza createPizza(int type);
}

3)抽象工厂使用对象组合,对象的开创被落成在工厂接口所揭露的方法中。
四)所以工厂形式都因此削减客户端和具体类之间的依赖来完毕解耦。
5)工厂方法允许类将实例化延迟到子类实行。
陆)抽象工厂创制连锁的对象家族,而无需依赖他们的具体类。
七)重视倒置原则,指引我们幸免注重具体项目,而要尽量注重抽象。

public class SimplePizzaFactory {
    public Pizza createPizza(String type) {
        Pizza pizza = null;

        if(type.equals("cheese")) {
            pizza = new CheesePizza();
        } else if(type.equals("greek")){
            pizza = new GreekPizza();
        } else if(type.equals("pepperoni")){
            pizza = new PepperoniPizza();
        }

        return pizza;
    }
}

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图