.Net学习 第2季10 简单工厂设计模式

.Net 视频学习第2季 简单工厂设计模式

 

设计模式就是解决一类问题的设计方案，有人总结了23种常见的设计模式，简单工厂是其中一种。

一个简单的工厂会生产不同的商品，例如笔记本工厂会生产不同品牌的笔记本，而客户需要哪一款需要通过询问客户才能得知。简单工厂设计模式的核心就是，尽可能屏蔽各个品牌笔记本的差异，消除其带来的代码冗余，

返回一个笔记本的父类，里面装的是子类对象，通过抽象类来实现多态。

 

例如，笔记本工厂生产4种品牌的笔记本A,B,C,D，如果不用笔记本父类，在main方法中先询问客户需要哪一款，再返回对应的对象，代码就会类似下面的

class Notebook A{}

class Notebook B{}

class Notebook C{}

class Notebook D{}

main()
{
    Console.WriteLine("which type of notebook you want to buy: A/B/C/D?");
    std::string type = Console.ReadLine();
    switch (type)
    {
        case "A":
            NotebookA nb = new NotebookA();
            break;
        case "B":
            NotebookB nb = new NotebookB();
            break;
        case "C":
            NotebookC nb = new NotebookC();
            break;

        case "D":
            NotebookD nb = new NotebookD();
            break;
    }
}

想象一下，如果接下来还要对这个具体的笔记本进行操作，例如读取它的指标，价格，生产所需时间之类，由于主方法里边是一个具体类型的笔记本类的对象，因此这些操作都得switch/case来做，代码冗余很严重，例如每个笔记本都有一个display的方法用于展示自己的参数，代码类似如下。

class Notebook A{display(){...}}

class Notebook B{display(){...}}

class Notebook C{display(){...}}

class Notebook D{display(){...}}

main()
{
    Console.WriteLine("which type of notebook you want to buy: A/B/C/D?");
    std::string type = Console.ReadLine();
    switch (type)
    {
        case "A":
            NotebookA nb = new NotebookA();
            nb.display();
            break;
        case "B":
            NotebookB nb = new NotebookB();
            nb.display();
            break;
        case "C":
            NotebookC nb = new NotebookC();
            nb.display();
            break;
        case "D":
            NotebookD nb = new NotebookD();
            nb.display();
            break;
    }
}

会发现，同样的一句说话nb.display();写了4遍。

 

 

如果选择用多态来实现，主方法里边就只有笔记本父类的对象（当然实际上它装的还是某一个子类的对象），而接下来的操作，只需要调用父类的方法即可（当然实际上方法会被子类方法重写）。需要创建一个笔记本的父类，代码类似如下

abstract class Notebook
{
    public void display();
}

class NotebookA:Notebook{display(){...}}

class NotebookB:Notebook{display(){...}}

class NotebookC:Notebook{display(){...}}

class NotebookD:Notebook{display(){...}}

main()
{
    Console.WriteLine("which type of notebook you want to buy: A/B/C/D?");
    std::string type = Console.ReadLine();
    Notebook nb;
    switch (type)
    {
        case "A":
            nb = new NotebookA();
            break;
        case "B":
            nb = new NotebookB();
            break;
        case "C":
            nb = new NotebookC();
            break;
        case "D":
            nb = new NotebookD();
            break;
    }
    nb.display();
}

 用简单工厂设计模式来实现，就可以减少代码冗余了。

 

简单地说，如果有N个子类，不采用多态，同一个操作，在主方法里边要写N遍（写N个子类调用方法），用多态，在主方法里边只用写一遍（调用父类方法，该方法被子类重写）。简单工厂设计模式的核心就是当不清楚客户需要什么子类对象的时候，返回一个父类对象给客户，里边装的是什么子类对象取决于访问客户的结果。