zoukankan      html  css  js  c++  java
  • 设计模式一 Simple Factory, Factory Method, Abstract Factory以及Builder模式简述

    虽然现在博客园上关于设计模式的文章已经有很多,但还是写一篇来凑下热闹,也算是对自己多这几种模式得使用总结。

    Factory Pattern 工厂模式和 Builder Patter 建造者模式都是通过定义接口来将类的定义和实现区分开来。下面一步一步来做说明

    1. Simple Factory 简单工厂

     简单工厂只是将类简单抽象化,以Pizza为例,我们定义好Pizza的接口,实现继承Pizza的类PizzaA和PizzaB,然后简单工厂提供方法根据传进来的参数类型确定像调用者返回PizzaA或者PizzaB的实例

    代码
        public interface Pizza
        {
            
    void DoPizza();
        }

        
    public class PizzaA : Pizza
        {
            
    public void DoPizza()
            {
                Console.WriteLine(
    "pizza A");
            }
        }

        
    public class PizzaB : Pizza
        {
            
    public void DoPizza()
            {
                Console.WriteLine(
    "pizza B");
            }
        }
       
    public static class SimplePizzaFacotry
        {
            
    public static Pizza Create(string type)
            {
                
    if (type == "PizzaA")
                    
    return new PizzaA();
                
    else
                    
    return new PizzaB();
            }
        }

        
    // Usage
        public class SimplePizzaFacotryOrder
        {
            
    public void OrderPizza()
            {
                Pizza pizza 
    = SimplePizzaFacotry.Create("PizzaA");
                pizza.DoPizza();
            }
        }

    2. Factory Method工厂方法 

    工厂方式是在简单工厂模式基础上进一步抽象来符合OO设计的要求。这里将Factory抽象化为接口或抽象类,然后继承类负责具体实现。此时增加一个FactoryManage来负责返回那个工厂类实现的实例。代码示例如下 

    代码
    // Pizza, PizzaA, PizzaB继续使用简单工厂定义

        
    public abstract class PizzaFactory
        {
            
    public abstract Pizza Create();
        }

        
    public class PizzaAFactory : PizzaFactory
        {
            
    public override Pizza Create()
            {
                
    return new PizzaA();
                
    //throw new NotImplementedException();
            }
        }

        
    public class PizzaBFactory : PizzaFactory
        {
            
    public override Pizza Create()
            {
                
    return new PizzaB();
                
    //throw new NotImplementedException();
            }
        }

        
    public abstract class PizzaMethodManager
        {
            
    public static PizzaFactory Factory = new PizzaAFactory();
        }
        
        
    //usage 
        public class FactoryMethodPizzaOrder
        {
            
    public FactoryMethodPizzaOrder()
            {
                Pizza pizza 
    = PizzaMethodManager.Factory.Create();
            }
        }

      3. Abstract Factory 抽象工厂

     抽象工厂和工厂方法基本上一样,区别在于此时抽象工厂可以来实现一系列相关类的实现。继续用Pizza举例,这里将Pizza分为Dough和Sauce即面团和酱,然后定义HutPizza和PapaPizza的面团Dougn, Sauce以及Pizza的实现。示例如下

    代码
        public interface IDough
        {
           
    void DoDough();
        }

        
    public interface ISauce
        {
            
    void DoSauce();
        }

        
    public class PapaDough : IDough
        {
            
    public void DoDough()
            {
                Console.WriteLine(
    "Papa Jone's Dough");
            }
        }

        
    public class PapaSource : ISauce
        {
            
    public void DoSauce()
            {
                Console.WriteLine(
    "Papa Jone's Sauce");
            }
        }

        
    public class HutDough : IDough
        {
            
    public void DoDough()
            {
                Console.WriteLine(
    "Pizza Hut's Dough");
            }
        }

        
    public class HutSource : ISauce
        {
            
    public void DoSauce()
            {
                Console.WriteLine(
    "Pizza Hut's Sauce");
            }
        }

        
    public interface IPizzaFactory
        {
            IDough PrepareDough();
            ISauce AddSauce();
        }

        
    public class PapaPizzaFacotry : IPizzaFactory
        {
            
    public IDough PrepareDough()
            {
                
    return new PapaDough();
            }

            
    public ISauce AddSauce()
            {
                
    return new PapaSource();
            }
        }

        
    public class HutPizzaFacotry : IPizzaFactory
        {
            
    public IDough PrepareDough()
            {
                
    return new HutDough();
            }

            
    public ISauce AddSauce()
            {
                
    return new HutSource();
            }
        }

        
    public abstract class AbstractPizzaManager
        {
            
    public static IPizzaFactory Facotry = new PapaPizzaFacotry();
        }

        
    // Usage
        public class OrderPizzaAbstract
        {
            
    public void OrderPizza()
            {
                IDough dough 
    = AbstractPizzaManager.Facotry.PrepareDough();
                ISauce sauce 
    = AbstractPizzaManager.Facotry.AddSauce();
                dough.DoDough();
                sauce.DoSauce();
            }
        }

      

     4. Builder Pattern 建造者模式

     Builder和抽象工厂类似,也是建立一系列对象的实现。区别在于Builder建立的一对象有依赖关系而Factory的对象只是有关联。依旧以Pizza为例,pizza的做法是先做面团(饼底),然后放Sauce(Cheese或者其他的东西),然后放Topping(火腿,香肠之类的)。举例如下

    代码
        class PizzaBD
        {
            
    public string Dough { getset; }
            
    public string Sauce { getset; }
            
    public string Topping { getset; }
        }
         
        
    abstract class PizzaBuilder
        {
            
    public PizzaBD pizza { getprotected set; }
         
            
    public void CreatePizza()
            {
                pizza 
    = new PizzaBD();
            }
         
            
    public abstract void BuildDough();
            
    public abstract void BuildSauce();
            
    public abstract void BuildTopping();
        }
         
        
    class HawaiianPizzaBuilder : PizzaBuilder
        {
            
    public override void  BuildDough()
            {
                pizza.Dough 
    = "Cross";
            }
         
            
    public override void BuildSauce()
            {
                pizza.Sauce 
    = "Mild";
            }
         
            
    public override void BuildTopping()
            {
                pizza.Topping 
    = "Ham+Pineapple";
            }
        }
         
        
    class SpicyPizzaBuilder : PizzaBuilder
        {
            
    public override void BuildDough()
            {
                pizza.Dough 
    = "Pan Baked";
            }
         
            
    public override void BuildSauce()
            {
                pizza.Sauce 
    = "Hot";
            }
         
            
    public override void BuildTopping()
            {
                pizza.Topping 
    = "Pepperoni+Salami";
            }
        }
         
        
    class Cook
        {
            
    public PizzaBuilder PizzaBuilder { getset; }

            
    public PizzaBD Pizza { get { return PizzaBuilder.pizza; } }
         
            
    public void MakePizza()
            {
                PizzaBuilder.CreatePizza();
                PizzaBuilder.BuildDough();
                PizzaBuilder.BuildSauce();
                PizzaBuilder.BuildTopping();
            }
        }
         
        
    // usage 
        public class CallBuilder
        {
            
    public void OrderPizza()
            {
                Cook cook 
    = new Cook();
                cook.PizzaBuilder 
    = new SpicyPizzaBuilder();
                cook.MakePizza();
                cook.PizzaBuilder 
    = new HawaiianPizzaBuilder();
                cook.MakePizza();
            }
        }

      5. Facade Pattern 外观模式

     提到了Builder模式,也就顺便提一下Facade模式。两者类似处在于都是建立一系列对象,区别在于Builder模式创建一系列有依赖关系的子类,而Facade模式则是建立一个将复杂的子类简化和集中化的通道。还是以Pizza为例,客户吃完付款,需要Waiter收取现金/卡,然后财务做账/transfer之后打印发票,返回。对客户来说后端多的一系列动作他并不关心,PizzaPayFacade提供给客户一个Pay方法,方法里面完成这一系列的动作[可能包括类的实现]。代码稍后提供。大家可以先参考First We try, then we trust的Facade说明的代码示例 http://www.cnblogs.com/zhenyulu/articles/55992.html

  • 相关阅读:
    《Microsoft Sql server 2008 Internals》读书笔记第十一章DBCC Internals(2)
    《Microsoft Sql server 2008 Internals》读书笔记第十一章DBCC Internals(9)
    《Microsoft Sql server 2008 Internals》读书笔记第九章Plan Caching and Recompilation(10)
    CKEditor在asp.net环境下的使用一例
    《Microsoft Sql server 2008 Internals》读书笔记第五章Table(7)
    《Microsoft Sql server 2008 Internals》读书笔记第九章Plan Caching and Recompilation(11)
    千万数据的连续ID表,快速读取其中指定的某1000条数据?
    javascript中的float运算精度
    .Net与Java的互操作(.NET StockTrader微软官方示例应用程序)
    《Microsoft Sql server 2008 Internals》读书笔记第十一章DBCC Internals(6)
  • 原文地址:https://www.cnblogs.com/lyrix/p/1660946.html
Copyright © 2011-2022 走看看