大话设计模式 (程杰 著)

第1章 代码无错就是优?　　　　　　　　[简单工厂模式] (已看)

第2章 商场促销　　　　　　　　　　　  [策略模式]  (已看)

第3章 拍摄UFO　　　　　　　　　　　  [单一职责原则]  (已看)

第4章 考研求职两不误　　　　　　　　  [开放-封闭原则]  (已看)

第5章 会修电脑不会修收音机?　　　　　[依赖倒转原则]  (已看)

第6章 穿什么有这么重要?　　　　　　　[装饰模式]  (已看)

第7章 为别人做嫁衣　　　　　　　　　  [代理模式]  (已看)

第8章 雷锋依然在人间　　　　　　　　  [工厂方法模式]  (已看)

第9章 简历复印　　　　　　　　　　　  [原型模式]  (已看)

第10章 考题抄错会做也白搭　　　　　　[模板方法模式]  (已看)

第11章 无熟人难办事?　　　　　　　　  [迪米特法则]  (已看)

第12章 牛市股票还会亏钱?　　　　　　  [外观模式]  (已看)

第13章 好菜每回味不同　　　　　　　　[建造者模式]  (已看)

第14章 老板回来,我不知道　　　　　　   [观察者模式]  (已看)

第15章 就不能不换DB模式　　　　　　   [抽象工厂模式]  (已看)

第16章 无尽加班何时休　　　　　　　　 [状态模式]  (已看)

第17章 在NBA我需要翻译　　　　　　　 [适配器模式]  (已看)

第18章 如果再回到从前　　　　　　　　 [备忘录模式]  (已看)

第19章 分公司=一部门　　　　　　　　  [组合模式]  (已看)

第20章 想走?可以!先买票　　　　　　     [迭代器模式]  (已看)

第21章 有些类也需要计划生育　　　　　 [单例模式]  (已看)

第22章 手机软件何时统一　　　　　　　 [桥接模式]  (已看)

第23章 烤羊肉串引来的思考　　　　　　 [命令模式]  (已看)

第24章 加薪非要老总批?　　　　　　　  [职责链模式] (已看)

第25章 世界需要和平　　　　　　　　    [中介者模式] (已看)

第26章 项目多也别傻做　　　　　　　　 [享元模式] (已看)

第27章 其实你不懂老板的心　　　　　　 [解释器模式] (已看)

第28章 男人和女人　　　　　　　　　　[访问者模式] (已看)

第29章 OOTV杯超级模式大赛　　　　　 [模式总结] (已看)   

 

 

第1章 代码无错就是优?　　　　　　　　[简单工厂模式]

using System;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            Operation opAdd = OperationFactory.CreateOperate("+");
            opAdd.NumberA = 1;
            opAdd.NumberB = 2;
            Console.WriteLine(opAdd.GetResult());

            Operation opSub = OperationFactory.CreateOperate("-");
            opSub.NumberA = 1;
            opSub.NumberB = 2;
            Console.WriteLine(opSub.GetResult());
        }
    }

    public abstract class Operation {
        private double numberA = 0;
        private double numberB = 0;

        public double NumberA {
            get { return numberA; }
            set { numberA = value; }
        }

        public double NumberB {
            get { return numberB; }
            set { numberB = value; }
        }

        public virtual double GetResult() {
            double result = 0;
            return result;
        }
    }

    public class OperationAdd : Operation {
        public override double GetResult() {
            return NumberA + NumberB;
        }
    }

    public class OperationSub : Operation {
        public override double GetResult() {
            return NumberA - NumberB;
        }
    }


    public class OperationFactory {
        public static Operation CreateOperate(string operate) {
            Operation oper = null;
            switch (operate) {
                case "+":
                    oper = new OperationAdd();
                    break;
                case "-":
                    oper = new OperationSub();
                    break;
            }

            return oper;
        }
    }
}

View Code

聚合表示一种弱的'拥有'关系,体现的是A对象可以包含B对象,但B对象不是A对象的一部分

合成(Composition,也有翻译成'组合'的)是一种强的'拥有'关系,体现了严格的部分和整体的关系,部分和整体的生命周期一样

第2章 商场促销　　　　　　　　　　　  [策略模式]

using System;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            int condition = 2;
            CashContext cashContext = null;

            switch (condition) {
                case 1:
                    cashContext = new CashContext(new CashNormal());
                    break;
                case 2:
                    cashContext = new CashContext(new CashDiscount(0.8));
                    break;
            }

            Console.WriteLine(cashContext.getResult(100));
        }
    }


    public class CashContext {
        private CashSuper cashSuper = null;

        public CashContext(CashSuper cashSuper) {
            this.cashSuper = cashSuper;
        }

        public double getResult(double money) {
            return cashSuper.acceptCash(money);
        }
    }
    
    
    public abstract class CashSuper {
        public abstract double acceptCash(double money);
    }

    public class CashNormal : CashSuper {
        public override double acceptCash(double money) {
            return money;
        }
    }

    public class CashDiscount : CashSuper {
        private double discount;

        public CashDiscount(double discount) {
            this.discount = discount;
        } 
        
        public override double acceptCash(double money) {
            return money * discount;
        }
    }
}

View Code

[策略模式(Strategy)它定义了算法家族,分别封装起来,让它们之间可以互相替换,此模式让算法的变化,不会影响到使用算法的客户]

面向对象的编程,并不是类越多越好,类的划分是为了封装,但分类的基础是抽象,具有相同属性和功能的对象的抽象集合才是类.

第3章 拍摄UFO　　　　　　　　　　　  [单一职责原则]

[单一职责原则(SRP)]就一个类而言,应该仅有一个引起它变化的原因.

如果一个类承担的职责过多,就等于把这些职责耦合在一起,一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力.

这种耦合会导致脆弱的设计,当变化发生时,设计会遭受到意想不到的破坏

软件设计真正要做的许多内容,就是发现职责并把那些职责相互分离.

如果你能够想到多于一个动机去改变一个类,那么这个类就具有多于一个的职责

第4章 考研求职两不误　　　　　　　　  [开放-封闭原则]

[开放-封闭原则]是说软件实体(类,模块,函数等等)应该可以扩展,但是不可修改

无论模块是多么的'封闭',都会存在一些无法对之封闭的变化.既然不可能完全封闭,设计人员必须对于他设计的模块应该对哪种变化封闭做出选择。

他必须先猜测出最有可能发生的变化种类,然后构造抽象来隔离那些变化.

等到变化发生时立即采取行动

在我们最初编写代码时,假设变化不会发生.当变化发生时,我们就创建抽象来隔离以后发生的同类变化

面对需求,对程序的改动是通过增加新代码进行的,而不是更改现有的代码

我们希望的是在开发工作展开不久就知道可能发生的变化.查明可能发生的变化所等待的时间越长,要创建正确的抽象就越困难

开放-封闭原则是面向对象设计的核心所在.遵循这个原则可以带来面向对象技术所声称的巨大好处,也就是可维护,可扩展,可复用,灵活性好.

开发人员应该仅对程序中呈现出频繁变化的那些部分做出抽象,然而,对于应用程序中的每个部分都刻意地进行抽象同样不是一个好主意》

拒绝不成熟的抽象和抽象本身一样重要

第5章 会修电脑不会修收音机?　　　　　[依赖倒转原则]

[依赖倒置原则]A.高层模块不应该依赖低层模块.两个都应该依赖抽象.B.抽象不应该依赖细节.细节应该依赖抽象.

针对接口编程,不要对实现编程.

[里氏代换原则]子类型必须能够替换掉它们的父类型

一个软件实体如果使用的是一个父类的话,那么一定适用于其子类,而且它察觉不出父类对象和子类对象的区别.

也就是说,在软件里面,把父类都替换成它的子类,程序的行为没有变化

只有当子类可以替换掉父类,软件单位的功能不受到影响时,父类才能真正被复用,而子类也能够在父类的基础上增加新的行为

由于子类型的可替换性才使得使用父类类型的模块在无需修改的情况下就可以扩展

依赖倒转其实可以说是面向对象设计的标志,用哪种语言来编写程序不重要,如果编写时考虑的都是如何针对抽象编程而不是针对细节编程,

即程序中所有的依赖关系都是终止于抽象类或者接口,那就是面向对象的设计,反之那就是过程化的设计了.

第6章 穿什么有这么重要?　　　　　　　[装饰模式]

using System;



namespace ConsoleApplication1 {
    public class Program {
        public static void Main(string[] args) {
            ConcreteComponent c = new ConcreteComponent();
            ConcreteDecoratorA d1 = new ConcreteDecoratorA();
            ConcreteDecoratorB d2 = new ConcreteDecoratorB();

            d1.SetComponent(c);
            d2.SetComponent(d1);
            d2.Operation();
        }
    }

    public abstract class Component {
        public abstract void Operation();
    }

    public class ConcreteComponent : Component {
        public override void Operation() {
            Console.WriteLine("具体对象的操作");
        }
    }


    public abstract class Decorator : Component {

        public Component component;

        public void SetComponent(Component component) {
            this.component = component;
        }
        
        public override void Operation() {
            if (component != null) {
                component.Operation();    
            }
        }
    }

    public class ConcreteDecoratorA : Decorator {
        private string addedState;

        public override void Operation() {
            base.Operation();
            addedState = "New State";
            Console.WriteLine("具体装饰对象A的操作");
        }
    }

    public class ConcreteDecoratorB : Decorator {
        public override void Operation() {
            base.Operation();
            AddedBehavior();
            Console.WriteLine("具体装饰对象B的操作");
        }

        private void AddedBehavior() {
            
        }
    }
    
}

View Code

[装饰模式(Decorator)]动态地给一个对象添加一些额外的职责,就增加功能来说,装饰模式比生成子类更为灵活

第7章 为别人做嫁衣　　　　　　　　　  [代理模式]

using System;

namespace ConsoleApplication1 {
    public class Program {
        public static void Main(string[] args) {
            Proxy proxy = new Proxy();
            proxy.Request();
            
        }
    }

    public abstract class Subject {
        public abstract void Request();
    }

    public class RealSubject : Subject {
        public override void Request() {
            Console.WriteLine("真实的请求");
        }
    }

    public class Proxy : Subject {
        private RealSubject realSubject;


        public override void Request() {
            if (realSubject == null) {
                realSubject = new RealSubject();
            }
            
            realSubject.Request();
        }
    }
}

View Code

[代理模式(Proxy)]为其他对象提供一种代理以控制对这个对象的访问

第8章 雷锋依然在人间　　　　　　　　  [工厂方法模式]

using System;

namespace ConsoleApplication1 {
    public class Program {
        public static void Main(string[] args) {
            IFactory factory = new AddFactory();
            
            Operation operation = factory.CreateOperation();
            operation.NumberA = 1;
            operation.NumberB = 2;
            
            Console.WriteLine(operation.GetResult());

        }
    }

    public abstract class Operation {
        private double numberA = 0;
        private double numberB = 0;

        public double NumberA {
            get { return numberA; }
            set { numberA = value; }
        }

        public double NumberB {
            get { return numberB; }
            set { numberB = value; }
        }

        public virtual double GetResult() {
            double result = 0;
            return result;
        }
    }

    public class OperationAdd : Operation {
        public override double GetResult() {
            return NumberA + NumberB;
        }
    }

    public class OperationSub : Operation {
        public override double GetResult() {
            return NumberA - NumberB;
        }
    }

    public interface IFactory {
        Operation CreateOperation();
    }

    public class AddFactory : IFactory {
        public Operation CreateOperation() {
            return new OperationAdd();
        }
    }

    public class SubFactory : IFactory {
        public Operation CreateOperation() {
            return new OperationSub();
        }
    }
    
}

View Code

[工厂方法模式(Factory Method)]定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类.

第9章 简历复印　　　　　　　　　　　  [原型模式]

using System;
using System.Net.Security;

namespace ConsoleApplication1 {
    public class Program {
        public static void Main(string[] args) {
            ConcretePrototype1 p1 = new ConcretePrototype1("I");
            ConcretePrototype1 c1 = (ConcretePrototype1) p1.Clone();
            Console.WriteLine("Cloned: {0}",c1.Id);
            
        }
    }

    public abstract class Prototype {
        private string id;

        public Prototype(string id) {
            this.id = id;
        }

        public string Id {
            get { return id; }
        }

        public abstract Prototype Clone();
    }

    public class ConcretePrototype1 : Prototype {
        public ConcretePrototype1(string id) : base(id) {

        }

        public override Prototype Clone() {
            return (Prototype)this.MemberwiseClone();
        }
    }

    public class ConcretePrototype2 : Prototype {
        public ConcretePrototype2(string id) : base(id) {
            
        }

        public override Prototype Clone() {
            return (Prototype)this.MemberwiseClone();
        }
    }
}

View Code

[原型模式(Prototype)]用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象

第10章 考题抄错会做也白搭　　　　　　[模板方法模式]

using System;
using System.Diagnostics.CodeAnalysis;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            AbstractClass c;
            c = new ConcreteClassA();
            c.TemplateMethod();
            
            c = new ConcreteClassB();
            c.TemplateMethod();            
        }
    }

    public abstract class AbstractClass {
        public abstract void PrimitiveOperation1();
        public abstract void PrimitiveOperation2();

        public void TemplateMethod() {
            PrimitiveOperation1();
            PrimitiveOperation2();
            Console.WriteLine("");
        }
    }

    public class ConcreteClassA : AbstractClass {
        public override void PrimitiveOperation1() {
            Console.WriteLine("具体类A方法1的实现");
        }

        public override void PrimitiveOperation2() {
            Console.WriteLine("具体类A方法2的实现");
        }
    }

    public class ConcreteClassB : AbstractClass {
        public override void PrimitiveOperation1() {
            Console.WriteLine("具体类B方法1的实现");
        }

        public override void PrimitiveOperation2() {
            Console.WriteLine("具体类B方法2的实现");
        }
    }
}

View Code

[模板方法模式]定义一个操作中的算法的骨架,而将一些步骤延迟到子类中.模板方法使得子类可以不改变一个算法的结构既可重定义该算法的某些特定步骤.

第11章 无熟人难办事?　　　　　　　　  [迪米特法则]

[迪米特法则(LoD)]如果两个类不必彼此直接通信,那么这两个类就不应当发生直接的作用.如果其中一个类需要调用另一个类的某一个方法的话,可以通过第三者转发这个调用.

在类的结构设计上,每一个类都应当尽量降低成员的访问权限.

迪米特法则其根本思想,是强调了类之间的松耦合.

类之间的耦合越弱,越有利于复用,一个处在弱耦合的类被修改,不会对有关系的类造成波及.

第12章 牛市股票还会亏钱?　　　　　　  [外观模式]

using System;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            Facade facade = new Facade();
            facade.MethodA();
            facade.MethodB();                        
        }
    }

    public class SubSystemOne {
        public void MethodOne() {
            Console.WriteLine("子系统方法一");
        }
    }

    public class SubSystemTwo {
        public void MethodTwo() {
            Console.WriteLine("子系统方法二");
        }
    }

    public class SubSystemThree {
        public void MethodThree() {
            Console.WriteLine("子系统方法三");
        }
    }

    public class SubSystemFour {
        public void MethodFour() {
            Console.WriteLine("子系统方法四");
        }
    }

    public class Facade {
        private SubSystemOne one;
        private SubSystemTwo two;
        private SubSystemThree three;
        private SubSystemFour four;

        public Facade() {
            one = new SubSystemOne();
            two = new SubSystemTwo();
            three = new SubSystemThree();
            four = new SubSystemFour();
        }

        public void MethodA() {
            Console.WriteLine("\n方法组A() ---- ");
            one.MethodOne();
            two.MethodTwo();
            four.MethodFour();
        }

        public void MethodB() {
            Console.WriteLine("\n方法组B() ---- ");
            two.MethodTwo();
            three.MethodThree();
        }
    }
}

View Code

[外观模式(Facade)]为子系统中的一组接口提供一个一致的界面,此模式定义了一个高层接口,这个接口使得这一子系统更加容易使用

首先,在设计初期阶段,应该要有意识的将不同的两个层分离.

其次,在开发阶段,子系统往往因为不断的重构演化而变得越来越复杂,增加外观Facade可以提供一个简单的接口,减少它们之间的依赖.

第三,在维护一个遗留的大型系统时,可能这个系统已经非常难以维护和扩展了,为新系统开发一个外观Facade类,来提供设计粗糙或高度复杂的遗留代码的比较清晰简单的接口,

　　 让新系统与Facade对象交互,Facade与遗留代码交互所有复杂的工作.

第13章 好菜每回味不同　　　　　　　　[建造者模式]

using System;
using System.Collections.Generic;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            Director director = new Director();
            
            Builder b1 = new ConcreteBuilder1();
            Builder b2 = new ConcreteBuilder2();
            
            director.Construct(b1);
            Product p1 = b1.GetResult();
            p1.Show();
            
            director.Construct(b2);
            Product p2 = b2.GetResult();
            p2.Show();
        }
    }

    public class Product {
        private IList<string> parts = new List<string>();

        public void Add(string part) {
            parts.Add(part);
        }

        public void Show() {
            Console.WriteLine("\n产品 创建 ----");
            foreach (string part in parts) {
                Console.WriteLine(part);
            }
        }
    }

    public abstract class Builder {
        public abstract void BuildPartA();
        public abstract void BuildPartB();
        public abstract Product GetResult();
    }
    
    public class ConcreteBuilder1 : Builder {
        private Product product = new Product();

        public override void BuildPartA() {
            product.Add("部件A");
        }

        public override void BuildPartB() {
            product.Add("部件B");
        }

        public override Product GetResult() {
            return product;
        }
    }

    public class ConcreteBuilder2 : Builder {
        private Product product = new Product();

        public override void BuildPartA() {
            product.Add("部件X");
        }

        public override void BuildPartB() {
            product.Add("部件Y");
        }

        public override Product GetResult() {
            return product;
        }
    }

    public class Director {
        public void Construct(Builder builder) {
            builder.BuildPartA();
            builder.BuildPartB();
        }
    }
}

View Code

[建造者模式(Builder)]将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示

第14章 老板回来,我不知道　　　　　　   [观察者模式]

using System;
using System.Collections.Generic;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            ConcreteSubject s = new ConcreteSubject();
            s.Attach(new ConcreteObserver(s, "X"));
            s.Attach(new ConcreteObserver(s, "Y"));
            s.Attach(new ConcreteObserver(s,"Z"));


            s.SubjectState = "123";
            s.Notify();

            s.SubjectState = "ABC";
            s.Notify();
        }
    }

    public abstract class Subject {
        private IList observers = new List();

        public void Attach(Observer observer) {
            observers.Add(observer);
        }

        public void Detach(Observer observer) {
            observers.Remove(observer);
        }

        public void Notify() {
            foreach (Observer o in observers) {
                o.Update();
            }
        }
    }

    public class ConcreteSubject : Subject {
        private string subjectState;

        public string SubjectState {
            get { return subjectState;}
            set { subjectState = value; }
        }
    }
    
    public abstract class Observer {
        public abstract void Update();
    }

    public class ConcreteObserver : Observer {

        private string name;
        private string observerState;
        private ConcreteSubject subject;

        public ConcreteObserver(ConcreteSubject subject, string name) {
            this.subject = subject;
            this.name = name;
        }
        
        public override void Update() {
            observerState = subject.SubjectState;
            Console.WriteLine("观察者{0}的新状态是{1}", name, observerState);
        }

        public ConcreteSubject Subject {
            get { return subject; }
            set { subject = value; }
        }
    }
}

View Code

[观察者模式]定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象.这个主题对象在状态发生变化时,会通知所有观察者对象,使它们能够自动更新自己

将一个系统分割成一系列相互协作的类有一个很不好的副作用,那就是需要维护相关对象间的一致性.我们不希望为了维持一致性而使各类紧密耦合,这样会给维护,扩展和重用都带来不便

观察者模式所做的工作其实就是在解除耦合.让耦合的双方都依赖于抽象,而不是依赖于具体.从而使得各自的变化都不会影响另一边的变化.

第15章 就不能不换DB模式　　　　　　   [抽象工厂模式]

using System;

namespace ConsoleApplication1 {
    public class Program {
        public static void Main(string[] args) {
            User user = new User();
            Department department = new Department();
            
            IFactory factory = new AccessFactory();
            IUser iuser = factory.CreateUser();
            iuser.Insert(user);
            iuser.GetUser(1);
            IDepartment idepartment = factory.CreateDepartment();
            idepartment.Insert(department);
            idepartment.GetDepartment(1);

        }
    }

    public class User {
        public int ID { get; set; }
    }

    public class Department {
        public int ID { get; set; }
    }


    public interface IUser {
        void Insert(User user);
        User GetUser(int id);
    }

    public class SqlServerUser : IUser {
        public void Insert(User user) {
            Console.WriteLine("在SQL Server中给User表增加一条记录");
        }

        public User GetUser(int id) {
            Console.WriteLine("在SQL Server中根据ID得到User表的一条记录");
            return null;
        }   
    }

    public class AccessUser : IUser {
        public void Insert(User user) {
            Console.WriteLine("在Acces中给User表增加一条记录");
        }

        public User GetUser(int id) {
            Console.WriteLine("在Access中根据ID得到User表的一条记录");
            return null;
        }
    }

    public interface IDepartment {
        void Insert(Department department);
        Department GetDepartment(int id);
    }

    public class SqlServerDepartment : IDepartment {
        public void Insert(Department department) {
            Console.WriteLine("在SQL Server中给Department表增加一条记录");
        }

        public Department GetDepartment(int id) {
            Console.WriteLine("在SQL Server中根据ID得到Department表的一条记录");
            return null;
        }
    }

    public class AccessDepartment : IDepartment {
        public void Insert(Department department) {
            Console.WriteLine("在Acces中给Department表增加一条记录");
        }

        public Department GetDepartment(int id) {
            Console.WriteLine("在Access中根据ID得到Department表的一条记录");
            return null;
        }
    }

    public interface IFactory {
        IUser CreateUser();
        IDepartment CreateDepartment();
    }

    public class SqlServerFactory : IFactory {
        public IUser CreateUser() {
            return new SqlServerUser();
        }

        public IDepartment CreateDepartment() {
            return new SqlServerDepartment();
        }
    }


    public class AccessFactory : IFactory {
        public IUser CreateUser() {
            return new AccessUser();
        }

        public IDepartment CreateDepartment() {
            return new AccessDepartment();
        }
    }
}

View Code

[抽象工厂模式(Abstract Factory)]提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类

第16章 无尽加班何时休　　　　　　　　 [状态模式]

using System;
using System.Collections.Generic;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            Work work = new Work();
            work.Hour = 9;
            work.WriteProgram();
            work.Hour = 10;
            work.WriteProgram();
            work.Hour = 12;
            work.WriteProgram();
            work.Hour = 13;
            work.WriteProgram();
            work.Hour = 14;
            work.WriteProgram();
            work.Hour = 17;
            work.TaskFinished = false;
            work.WriteProgram();
            work.Hour = 19;
            work.WriteProgram();
            work.Hour = 22;
            work.WriteProgram();
        }
    }

    
    
    public abstract class State {
        public abstract void WriteProgram(Work w);
    }

    public class ForenoonState : State {
        public override void WriteProgram(Work w) {
            if (w.Hour < 12) {
                Console.WriteLine("当前时间: {0}点 上午工作,精神百倍",w.Hour);
            } else {
                w.SetState(new NoonState());
                w.WriteProgram();
            }
        }
    }

    public class NoonState : State {
        public override void WriteProgram(Work w) {
            if (w.Hour < 13) {
                Console.WriteLine("当前时间: {0}点 饿了,午饭:犯困,午休.",w.Hour);
            } else {
                w.SetState(new AfternoonState());
                w.WriteProgram();
            }
        }
    }

    public class AfternoonState : State {
        public override void WriteProgram(Work w) {
            if (w.Hour < 17) {
                Console.WriteLine("当前时间: {0}点 下午状态还不错,继续努力",w.Hour);
            } else {
                w.SetState(new EveningState());
                w.WriteProgram();
            }
        }
    }

    public class EveningState : State {
        public override void WriteProgram(Work w) {
            if (w.TaskFinished) {
                w.SetState(new RestState());
                w.WriteProgram();
            } else {
                if (w.Hour < 21) {
                    Console.WriteLine("当前时间: {0}点 加班哦,疲惫之极",w.Hour);
                } else {
                    w.SetState(new SleepingState());
                    w.WriteProgram();
                }
            }
        }
    }

    public class SleepingState : State {
        public override void WriteProgram(Work w) {
            Console.WriteLine("当前时间: {0}点 不行了,睡着了.",w.Hour);
        }
    }

    public class RestState : State {
        public override void WriteProgram(Work w) {
            Console.WriteLine("当前时间: {0}点 下班回家了",w.Hour);
        }
    }


    public class Work {
        private State current;
        private double hour;
        private bool finish = false;
        
        public Work() {
            current = new ForenoonState();
        }

        public double Hour {
            get { return hour; }
            set { hour = value; }
        }

        public bool TaskFinished {
            get { return finish; }
            set { finish = value; }
        }

        public void SetState(State s) {
            current = s;
        }

        public void WriteProgram() {
            current.WriteProgram(this);
        }
    }
}

View Code

[状态模式(State)]当一个对象的内在状态改变时允许改变其行为,这个对象看起来像是改变了其类

状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况.

把状态的判断逻辑转移到表示不同状态的一系列类当中,可以把复杂的判断逻辑简化

第17章 在NBA我需要翻译　　　　　　　 [适配器模式]

using System;
using System.Collections.Generic;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            
            Target target = new Target();
            target.Request();
            
            Target adapter = new Adapter();
            adapter.Request();
        }
    }

    public class Target {
        public virtual void Request() {
            Console.WriteLine("普通请求!");
        }
    }

    public class Adaptee {
        public void SepcificRequest() {
            Console.WriteLine("特殊请求!");
        }
    }

    public class Adapter : Target {
        private Adaptee adaptee = new Adaptee();

        public override void Request() {
            adaptee.SepcificRequest();
        }
    }

}

View Code

[适配器模式(Adapter)]将一个类的接口转换成客户希望的另外一个接口.Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作

第18章 如果再回到从前　　　　　　　　 [备忘录模式]

using System;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            Originator o = new Originator();
            o.State = "On";
            o.Show();
            
            Caretaker c = new Caretaker();
            c.Memento = o.CreateMemento();

            o.State = "Off";
            o.Show();
            
            o.SetMemento(c.Memento);
            o.Show();
        }
    }

    public class Originator {
        private string state;

        public string State {
            get { return state; }
            set { state = value; }
        }

        public Memento CreateMemento() {
            return new Memento(state);
        }

        public void SetMemento(Memento memento) {
            state = memento.State;
        }

        public void Show() {
            Console.WriteLine("State="+ state);
        }
    }

    public class Memento {
        private string state;

        public Memento(string state) {
            this.state = state;
        }

        public string State {
            get { return state; }
        }
    }

    public class Caretaker {
        private Memento memento;

        public Memento Memento {
            get { return memento; }
            set { memento = value; }
        }
    }
}

View Code

[备忘录(Memento)]在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样以后就可将该对象恢复到原先保存的状态.

第19章 分公司=一部门　　　　　　　　  [组合模式]

using System;
using System.Collections.Generic;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            Composite root = new Composite("root");
            root.Add(new Leaf("Leaf A"));
            root.Add(new Leaf("Leaf B"));
            
            Composite comp = new Composite("Composite X");
            comp.Add(new Leaf("Leaf XA"));
            comp.Add(new Leaf("Leaf XB"));
            
            Composite comp2 = new Composite("Composite XX");
            comp2.Add(new Leaf("Leaf XXA"));
            comp2.Add(new Leaf("Leaf XXB"));
            comp.Add(comp2);
            
            root.Add(comp);
            
            root.Add(new Leaf("Leaf C"));
            
            Leaf leaf = new Leaf("Leaf D");
            root.Add(leaf);
            root.Remove(leaf);
            
            root.Display(1);
            
            
        }
    }


    public abstract class Component {
        protected string name;

        public Component(string name) {
            this.name = name;
        }

        public abstract void Add(Component c);
        public abstract void Remove(Component c);
        public abstract void Display(int depth);
    }

    public class Leaf : Component {

        public Leaf(string name) : base(name) {
            
        }
        
        public override void Add(Component c) {
            Console.WriteLine("Can't add to a leaf");
        }

        public override void Remove(Component c) {
            Console.WriteLine("Can't remove from a leaf");
        }

        public override void Display(int depth) {
            Console.WriteLine(new string('-',depth) + name);
        }
    }


    public class Composite : Component {
        private List children = new List();

        public Composite(string name) : base(name) {
            
        }

        public override void Add(Component c) {
            children.Add(c);
        }

        public override void Remove(Component c) {
            children.Remove(c);
        }

        public override void Display(int depth) {
            Console.WriteLine(new string('-',depth) + name);

            foreach (Component component in children) {
                component.Display(depth + 2);
            }
        }
        
    }
}

View Code

[组合模式(Composite)]将对象组合成树形结构以表示'部分-整体'的层次结构.组合模式使得用户对单个对象和组合对象的使用具有一致性

第20章 想走?可以!先买票　　　　　　     [迭代器模式]

using System;
using System.Collections.Generic;

namespace ConsoleApplication1 {
    public class Program {
        public static void Main(string[] args) {
            ConcreteAggregate a = new ConcreteAggregate();

            a[0] = "大鸟";
            a[1] = "小菜";
            a[2] = "行李";
            a[3] = "老外";
            a[4] = "公交内部员工";
            a[5] = "小偷";

            Iterator i = new ConcreteIterator(a);
            object item = i.First();
            while (!i.IsDone()) {
                Console.WriteLine("{0} 请买车票!",i.CurrentItem());
                i.Next();
            }
        }
    }


    public abstract class Iterator {
        public abstract object First();
        public abstract object Next();
        public abstract bool IsDone();
        public abstract object CurrentItem();
    }

    public abstract class Aggregate {
        public abstract Iterator CreateIterator();
    }

    public class ConcreteIterator : Iterator {

        private ConcreteAggregate aggregate;
        private int current = 0;

        public ConcreteIterator(ConcreteAggregate aggregate) {
            this.aggregate = aggregate;
        }

        public override object First() {
            return aggregate[0];
        }

        public override object Next() {
            object ret = null;
            current++;
            if (current < aggregate.Count) {
                ret = aggregate[current];
            }

            return ret;
        }

        public override bool IsDone() {
            return current >= aggregate.Count ? true : false;
        }

        public override object CurrentItem() {
            return aggregate[current];
        }
    }


    public class ConcreteAggregate : Aggregate {
        public IList<object> items = new List<object>();

        public override Iterator CreateIterator() {
            return new ConcreteIterator(this);
        }

        public int Count {
            get { return items.Count; }
        }

        public object this[int index] {
            get { return items[index]; }
            set { items.Insert(index, value); }
        }
    }
}

View Code

[迭代器模式(Iterator)]提供一种方法顺序访问一个聚合对象中各个元素,而又不暴露该对象的内部表示

第21章 有些类也需要计划生育　　　　　 [单例模式]

using System;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            Singleton s1 = Singleton.GetInstance();
            Singleton s2 = Singleton.GetInstance();

            if (s1 == s2) {
                Console.WriteLine("两个对象是相同的实例");
            }
            
        }
    }


    public class Singleton {
        private static Singleton instance;

        private Singleton() {
            
        }

        public static Singleton GetInstance() {
            if (instance == null) {
                instance = new Singleton();
            }

            return instance;
        }
    }

}

View Code

[单例模式(Singleton)]保证一个类仅有一个实例,并提供一个访问它的全局访问点

通常我们可以让一个全局变量使得一个对象被访问,但它不能防止你实例化多个对象.一个最好的办法就是,

让类自身负责保存它的唯一实例.这个类可以保证没有其他实例可以被创建,并且它可以提供一个访问该实例的方法

第22章 手机软件何时统一　　　　　　　 [桥接模式]

using System;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            Abstraction ab = new RefinedAbstraction();
            ab.SetImplementor(new ConcreteImplementorA());
            ab.Operation();
            
            ab.SetImplementor(new ConcreteImplementorB());
            ab.Operation();
        }
    }

    public abstract class Implementor {
        public abstract void Operation();
    }

    public class ConcreteImplementorA : Implementor {
        public override void Operation() {
            Console.WriteLine("具体实现A的方法执行");
        }
    }

    public class ConcreteImplementorB : Implementor {
        public override void Operation() {
            Console.WriteLine("具体实现B的方法执行");
        }
    }

    public class Abstraction {
        protected Implementor implementor;

        public void SetImplementor(Implementor implementor) {
            this.implementor = implementor;
        }

        public virtual void Operation() {
            implementor.Operation();
        }
    }

    public class RefinedAbstraction : Abstraction {
        public override void Operation() {
            implementor.Operation();
        }
    }
}

View Code

[桥接模式(Bridge)]将抽象部分与它的实现部分分离,使它们都可以独立地变化

什么叫抽象与它的实现分离,这并不是说,让抽象类与其派生类分离,因为这没有任何意义.

实现指的是抽象类和它的派生类用来实现自己的对象

[合成/聚合复用原则(CARP)]尽量使用合成/聚合,尽量不要使用类继承

聚合表示一种弱的"拥有"关系,体现的是A对象可以包含B对象,但B对象不是A对象的一部分;合成则是一种强的"拥有“关系,

体现了严格的部分和整体的关系,部分和整体的生命周期一样.

合成/聚合复用原则的好处是:优先使用对象的合成/聚合将有助于你保持每个类被封装,并被集中在单个任务上.

这样类和类继承层次会保持较小规模,并且不太可能增长为不可控制的庞然大物

对象的继承关系是在编译时就定义好了,所以无法在运行时改变从父类继承的实现.

子类的实现与它的父类有非常紧密的依赖关系,以至于父类实现中的任何变化必然会导致子类发生变化.

当你需要复用子类时,如果继承下来的实现不适合解决新的问题,则父类必须重写或被其他更适合的类替换.

这种依赖关系限制了灵活性并最终限制了复用性

第23章 烤羊肉串引来的思考　　　　　　 [命令模式]

using System;
using System.Collections.Generic;

namespace ConsoleApplication1 {
    public class Program {
        public static void Main(string[] args) {
            Receiver r = new Receiver();
            Command c = new ConcreteCommand(r);
            Invoker i = new Invoker();
            i.SetCommand(c);
            i.ExecuteCommand();
        }
    }
    
    

    public abstract class Command {
        protected Receiver receiver;

        public Command(Receiver receiver) {
            this.receiver = receiver;
        }

        public abstract void Execute();
    }

    public class ConcreteCommand : Command {
        public ConcreteCommand(Receiver receiver) : base(receiver) {
            
        }

        public override void Execute() {
            receiver.Action();
        }
    }

    public class Receiver {
        public void Action() {
            Console.WriteLine("执行请求!");
        }
    }

    public class Invoker {
        private Command command;

        public void SetCommand(Command command) {
            this.command = command;
        }

        public void ExecuteCommand() {
            command.Execute();
        }
    }
}

View Code

[命令模式(Command)]将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤销的操作

敏捷开发原则告诉我们,不要为代码添加基于猜测的,实际不需要的功能.如果不清楚一个系统是否需要命令模式,一般就不要着急去实现它,

事实上,在需要的时候通过重构实现这个模式并不困难,只有在真正需要如撤销/恢复操作等功能时,把原来的代码重构为命令模式才有意义

第24章 加薪非要老总批?　　　　　　　  [职责链模式]

using System;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            Handler h1 = new ConcreteHandler1();
            Handler h2 = new ConcreteHandler2();
            Handler h3 = new ConcreteHandler3();
            h1.SetSuccessor(h2);
            h2.SetSuccessor(h3);

            int[] requests = {
      2, 15, 14, 22, 18, 3, 27, 20};

            foreach (int request in requests) {
                h1.HandleRequest(request);
            }
        }
    }

    public abstract class Handler {
        protected Handler successor;

        public void SetSuccessor(Handler successor) {
            this.successor = successor;
        }

        public abstract void HandleRequest(int request);
    }

    public class ConcreteHandler1 : Handler {
        public override void HandleRequest(int request) {
            if (request >= 0 && request < 10) {
                Console.WriteLine("{0} 处理请求 {1}",this.GetType().Name,request);
            } else if (successor != null) {
                successor.HandleRequest(request);
            }
        }
    }

    public class ConcreteHandler2 : Handler {
        public override void HandleRequest(int request) {
            if (request >= 10 && request < 20) {
                Console.WriteLine("{0} 处理请求 {1}",this.GetType().Name,request);
            } else if (successor != null) {
                successor.HandleRequest(request);
            }
        }
    }

    public class ConcreteHandler3 : Handler {
        public override void HandleRequest(int request) {
            if (request >= 20 && request < 30) {
                Console.WriteLine("{0} 处理请求 {1}",this.GetType().Name,request);
            } else if (successor != null) {
                successor.HandleRequest(request);
            }
        }
    }

}

View Code

[职责链模式(Chain of Responsibility)]使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系
将这个对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止.
当客户提交一个请求时,请求是沿链传递直至有一个ConcreteHandler对象负责处理它
接收者和发送者都没有对方的明确信息,且链中的对象自己也并不知道链的结构.结果是职责链可简化对象的相互连接,
它们仅需要保持一个指向其后继者的引用,而不需保持它所有的候选接受者的引用
随时地增加或修改处理一个请求的结构.增强了给对象指派职责的灵活性

第25章 世界需要和平　　　　　　　　    [中介者模式]

通过中介者对象,可以将系统的网状结构变成以中介者为中心的星形结构,每个具体对象不再通过直接的联系与另一个对象发生相互作用,
而是通过"中介者"对象与另一个对象发生相互作用.中介者对象的设计,使得系统的结构不会因为新对象的引入造成大量的修改工作.

using System;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            ConcreteMediator m = new ConcreteMediator();
            ConcreteColleauge1 c1 = new ConcreteColleauge1(m);
            ConcreteColleague2 c2 = new ConcreteColleague2(m);

            m.Colleauge1 = c1;
            m.Colleague2 = c2;
            
            c1.Send("吃过饭了吗?");
            c2.Send("没有呢,你打算请客?");
        }
    }

    public abstract class Mediator {
        public abstract void Send(string message, Colleague colleauge);
    }

    public abstract class Colleague {
        protected Mediator mediator;

        public Colleague(Mediator mediator) {
            this.mediator = mediator;
        }               
    }
    
    

    public class ConcreteMediator : Mediator {
        private ConcreteColleauge1 colleague1;
        private ConcreteColleague2 colleague2;

        public ConcreteColleauge1 Colleauge1 {
            set { colleague1 = value; }
        }

        public ConcreteColleague2 Colleague2 {
            set { colleague2 = value; }
        }

        public override void Send(string message, Colleague colleague) {
            if (colleague == colleague1) {
                colleague2.Notify(message);
            } else {
                colleague1.Notify(message);  
            }
        }
    }
    
    

    public class ConcreteColleauge1 : Colleague {

        public ConcreteColleauge1(Mediator mediator) : base(mediator) {

        }

        public void Send(string message) {
            mediator.Send(message,this);
        }

        public void Notify(string message) {
            Console.WriteLine("同事1得到信息:" + message);
        }
    }

    public class ConcreteColleague2 : Colleague {

        public ConcreteColleague2(Mediator mediator) : base(mediator) {
            
        }

        public void Send(string message) {
            mediator.Send(message,this);
        }
        
        public void Notify(string message) {
            Console.WriteLine("同事2得到信息:" + message);
        }
    }
}

View Code

[中介者模式(Mediator)]用一个中介对象来封装一系列的对象交互.中介者使对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互

中介者模式很容易在系统中应用,也很容易在系统中误用.当系统出现了"多对多"交互复杂的对象群时,不要急于使用中介者模式,而要先反思你的系统在设计上是不是合理

Mediator的出现减少了各个Colleague的耦合,使得可以独立地改变和复用各个Colleague类和Mediator.

由于把对象如何协作进行了抽象,将中介作为一个独立的概念并将其封装在一个对象中,这样关注的对象就从对象各自本身的行为转移到它们之间的交互上来,

也就是站在一个更宏观的角度去看待系统.

第26章 项目多也别傻做　　　　　　　　 [享元模式]

using System;
using System.Collections.Generic;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            int extrinsicstate = 22;
            
            FlyweightFactory f = new FlyweightFactory();
            
            Flyweight fx = f.GetFlyweight("X");
            fx.Operation(--extrinsicstate);

            Flyweight fy = f.GetFlyweight("Y");
            fy.Operation(--extrinsicstate);

            Flyweight fz = f.GetFlyweight("Z");
            fz.Operation(--extrinsicstate);
            
            UnsharedConcreteFlyweight uf = new UnsharedConcreteFlyweight();
            uf.Operation(--extrinsicstate);
            
        }
    }

    public abstract class Flyweight {
        public abstract void Operation(int extrinsicstate);
    }

    public class ConcreteFlyweight : Flyweight {
        public override void Operation(int extrinsicstate) {
            Console.WriteLine("具体Flyweight:" + extrinsicstate);
        }
    }

    public class UnsharedConcreteFlyweight : Flyweight {
        public override void Operation(int extrinsicstate) {
            Console.WriteLine("不共享的具体Flyweight:" + extrinsicstate);
        }
    }

    public class FlyweightFactory {
        private Dictionary<string,Flyweight> flyweights = new Dictionary<string, Flyweight>();

        public FlyweightFactory() {
            flyweights.Add("X",new ConcreteFlyweight());
            flyweights.Add("Y",new ConcreteFlyweight());
            flyweights.Add("Z",new ConcreteFlyweight());
        }

        public Flyweight GetFlyweight(string key) {
            return flyweights[key];
        }
    }
}

View Code

[享元模式(Flyweight)]运用共享技术有效地支持大量细粒度的对象.
享元模式可以避免大量非常类似的开销.在程序设计中,有时需要生成大量细粒度的类实例来表示数据.
如果能发现这些实例除了几个参数外基本上都是相同的,有时就能够受大幅度地减少需要实例化的类的数量.
如果能把那些参数移到类实例的外面,再方法调用时将它们传递进来,就可以通过共享大幅度地减少单个实例的数目
如果一个应用程序使用了大量的对象,而大量的这些对象造成了很大的存储开销时就应该考虑使用;
还有就是对象的大多数状态可以外部状态,如果删除对象的外部状态,那么可以用相对较少的共享对象取代很多组对象,
此时可以考虑使用享元模式

第27章 其实你不懂老板的心　　　　　　 [解释器模式]

using System;
using System.Collections.Generic;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            Context context = new Context();
            IList list = new List();
            list.Add(new TerminalExpression());
            list.Add(new NonterminalExpression());
            list.Add(new TerminalExpression());
            list.Add(new TerminalExpression());

            foreach (AbstractExpression exp in list) {
                exp.Interpret(context);
            }
        }
    }

    public abstract class AbstractExpression {
        public abstract void Interpret(Context context);
    }

    public class TerminalExpression : AbstractExpression {
        public override void Interpret(Context context) {
            Console.WriteLine("终端解释器");
        }
    }

    public class NonterminalExpression : AbstractExpression {
        public override void Interpret(Context context) {
            Console.WriteLine("非终端解释器");
        }
    }

    public class Context {
        private string input;
        private string output;
        
        
        public string Input {
            get { return input; }
            set { input = value; }
        }

        public string Output {
            get { return output; }
            set { output = value; }
        }
    }
}

View Code

[解释器模式(interpreter)]给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子
如果一种特定类型的问题发生的频率足够高,那么可能就值得将该问题的各个实例表述为一个简单语言的句子.
这样就可以构建一个解释器,该解释器通过解释这些句子来解决该问题.
当有一个语言需要解释执行,并且你可将该语言中的句子表示为一个抽象语法树时,可使用解释器模式
用了解释器模式,就意味着可以很容易地改变和扩展文法,因为该模式使用类来表示文法规则,你可使用继承来改变或扩展该文法.
也比较容易实现文法,因为定义抽象语法树中各个节点的类的实现大体类似,这些类都易于直接编写
解释器模式也有不足的,解释器模式为文法中的每一条规则至少定义了一个类,因此包含许多规则的文法可能难以管理和维护.
建议当文法非常复杂时,使用其他的技术如语法分析程序或编译器生成器来处理.

第28章 男人和女人　　　　　　　　　　[访问者模式]

using System;
using System.Collections.Generic;

namespace Test2 {
    class Program {
        static void Main(string[] args) {
            ObjectStructure o = new ObjectStructure();
            o.Attach(new ConcreteElementA());
            o.Attach(new ConcreteElementB());
            
            ConcreteVisitor1 v1 = new ConcreteVisitor1();
            ConcreteVisitor2 v2 = new ConcreteVisitor2();
            o.Accept(v1);
            o.Accept(v2);
        }
    }

    public abstract class Element {
        public abstract void Accept(Visitor visitor);
    }

    public class ConcreteElementA : Element {
        public override void Accept(Visitor visitor) {
            visitor.VisitConcreteElementA(this);
        }

        public void OperationA() {
            
        }
    }

    public class ConcreteElementB : Element {
        public override void Accept(Visitor visitor) {
            visitor.VisitConcreteElementB(this);
        }

        public void OperationB() {
            
        }
    }
    
    public abstract class Visitor {
        public abstract void VisitConcreteElementA(ConcreteElementA concreteElementA);
        public abstract void VisitConcreteElementB(ConcreteElementB concreteElementB);
    }

    public class ConcreteVisitor1 : Visitor {
        public override void VisitConcreteElementA(ConcreteElementA concreteElementA) {
            Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name);
        }

        public override void VisitConcreteElementB(ConcreteElementB conreteElementB) {
            Console.WriteLine("{0}被{1}访问", conreteElementB.GetType().Name, this.GetType().Name);
        }
    }
    
    public class ConcreteVisitor2 : Visitor {
        public override void VisitConcreteElementA(ConcreteElementA concreteElementA) {
            Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name);
        }

        public override void VisitConcreteElementB(ConcreteElementB conreteElementB) {
            Console.WriteLine("{0}被{1}访问", conreteElementB.GetType().Name, this.GetType().Name);
        }
    }

    public class ObjectStructure {
        private IList elements = new List();

        public void Attach(Element element) {
            elements.Add(element);
        }

        public void Detach(Element element) {
            elements.Remove(element);
        }

        public void Accept(Visitor visitor) {
            foreach (Element e in elements) {
                e.Accept(visitor);
            }
        }
    }
}

View Code

[访问者模式(Visitor)]表示一个作用于某对象结构中的各元素的操作.它使你可以在不改变各元素的前提下定义作用于这些元素的新操作

第29章 OOTV杯超级模式大赛　　　　　 [模式总结]　　　

转载于:https://www.cnblogs.com/revoid/p/9486668.html