解读设计模式

技术是死的,功能是活的。如何实现一个功能有很多种方式,如何快速灵活高效的实现这些功能就是一门艺术了。这其中可能会组合式的用到设计模式,这就是架构。当你会使用设计模式的时候我相信你会爱上它!
一、创建型模式
1、工厂方法模式:使用继承,动态实例化不同的对象执行相同的方法。
2、抽象工厂模式:
3、单例模式:通过static关键字保证系统中一个类只有一个实例
4、建造者模式:
5、原型模式:需要和单例模式对比,类似单例模式,原型模式可以new出不同的对象
二、结构型模式
6、适配器模式:
7、装饰器模式:使用依赖倒置原则,在对象的方法上又封装一层(组合优于继承,组合+继承)。
8、代理模式:
9、外观模式:
10、桥接模式:
11、组合模式:
12、亨元模式:
三、行为型模式
13、策略模式:
14、模板方法模式:
15、观察者模式:使用事件的方式提前把观察者的反应注册到被观察者的事件中,等待被观察者触发
16、迭代子模式:
17、责任链模式:
18、命令模式:
19、备忘录模式:
20、状态模式:
21、访问者模式:
22、中介者模式:
23、解释器模式:

四、设计模式六大原则

1、单一职责原则:增加功能,从方法级别上是增加方法而不是修改方法,从类的级别上是增加类而不是修改类。对扩展开放,对修改关闭,多使用抽象类和接口。(适当使用)
2、里氏替换原则:基类可以被子类替换,使用抽象类继承,不使用具体类继承。
3、依赖倒置原则:要依赖于抽象,不要依赖于具体,针对接口编程,不针对实现编程。
4、接口隔离原则:使用多个隔离的接口,比使用单个接口好,建立最小的接口。
5、迪米特法则:一个软件实体应当尽可能少地与其他实体发生相互作用,通过中间类建立联系。
6、开闭原则:尽量使用合成/聚合,而不是使用继承。

 

单例模式:

    public class SingletonClass
    {
        private static SingletonClass instance = null;
        public static SingletonClass Instance
        {
            get
            {
                if (instance == null)
                {
                    instance = new SingletonClass();
                }
                return instance;
            }
        }
       
        private SingletonClass() { }

        public void MyFuntion()
        {
            //do some thing
        }
    }

    //简写方式
    public class SingletonClass2
    {
        public static SingletonClass2 Instance = new SingletonClass2();
        private SingletonClass2() { }
        public void MyFuntion()
        {
            //do some thing
        }
    }

    //调用示例
    public class TestSingletonClass
    {
        public void DoSomeThing()
        {
            SingletonClass.Instance.MyFuntion();
            SingletonClass2.Instance.MyFuntion();
        }
    }
View Code

 

装饰器模式: 

    //可扩展任意类型的学生
    public abstract class AbstractStudentBase
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public abstract void StudentDay();//学生的一天
    }
    public class XiaoXueSheng : AbstractStudentBase
    {
        public override void StudentDay()
        {
            Console.WriteLine("小学生一天开始");
        }
    }
    public class DaXueSheng : AbstractStudentBase
    {
        public override void StudentDay()
        {
            Console.WriteLine("大学生一天开始");
        }
    }


    //装饰器,可扩展任意行为(组合+继承)
    public class DecoratorStudentBase : AbstractStudentBase
    {
        private AbstractStudentBase _Student = null;

        public DecoratorStudentBase(AbstractStudentBase student)
        {
            this._Student = student;
        }

        public override void StudentDay()
        {
            //Console.WriteLine("**********************************");
            this._Student.StudentDay();
            //Console.WriteLine("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
        }
    }

    //学习,可以扩展任意学习任意课程
    public class Study : DecoratorStudentBase
    {
        public Study(AbstractStudentBase student) : base(student)
        {
        }

        public override void StudentDay()
        {
            base.StudentDay();
            Console.WriteLine("学习");
        }
    }


    //学生一边学习一边兼职,可以扩展任何兼职,并装饰到任意学生身上
    public class JianZhi : DecoratorStudentBase
    {
        public JianZhi(AbstractStudentBase student) : base(student)
        {
        }

        public override void StudentDay()
        {
            base.StudentDay();
            Console.WriteLine("学习完成之后去兼职");
        }
    }
    //比如做家教
    public class JianZhiJiaJiao : JianZhi
    {
        public JianZhiJiaJiao(AbstractStudentBase student) : base(student)
        {
        }

        public override void StudentDay()
        {
            base.StudentDay();
            Console.WriteLine("兼职家教");
        }
    }

    //学生一边学习一边玩游戏
    public class PlayGame : DecoratorStudentBase
    {
        public PlayGame(AbstractStudentBase student) : base(student)
        {
        }

        public override void StudentDay()
        {
            base.StudentDay();
            Console.WriteLine("开始玩游戏");
        }
    }
    //比如玩王者荣耀、吃鸡,可以扩展任何游戏,并装饰到任意学生身上
    public class PlayGameWangZhe : PlayGame
    {
        public PlayGameWangZhe(AbstractStudentBase student) : base(student)
        {
        }

        public override void StudentDay()
        {
            base.StudentDay();
            Console.WriteLine("王者荣耀游戏");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            AbstractStudentBase xiaoXueSheng = new XiaoXueSheng();
            xiaoXueSheng = new Study(xiaoXueSheng);
            xiaoXueSheng.StudentDay();//小学生只知道学习


            AbstractStudentBase daXueSheng = new DaXueSheng();
            daXueSheng = new Study(daXueSheng);
            daXueSheng = new JianZhiJiaJiao(daXueSheng);
            daXueSheng = new PlayGameWangZhe(daXueSheng);
            //继续加...
            daXueSheng.StudentDay();//大学生一边学习,一边做家教,一边玩王者荣耀,可扩展任意行为,比如说交女朋友
        }
    }
View Code

 

依赖倒置原则

    public interface ICar
    {
        public void Run();
    }
    public interface IDriver
    {
        public void DriverCar(ICar car);
    }


    public class BM : ICar
    {
        public void Run()
        {
            //do some thing
        }
    }
    public class Driver : IDriver
    {
        public void DriverCar(ICar car)
        {
            car.Run();
        }
    }
    //调用示例
    public class TestDriveCar
    {
        public void SomeOneDriveCar()
        {
            IDriver zhangSan = new Driver();
            ICar BaoMa = new BM();
            zhangSan.DriverCar(BaoMa);
        }
    }

 

观察者模式(两种方式,一种使用面向对象思想把观察者的对象添加到被观察中,一种是使用微软自带的事件添加到被观察的事件中)
最经典的示例:猫叫,老鼠跑,孩子哭,妈妈醒来......

    public class Cat
    {
        private List<Observer> obServerList=new List<Observer>();
        public void Add(Observer obServer)
        {
            obServer.Add(obServer);
        }
        public void Remove(Observer obServer)
        {
            obServer.Remove(obServer);
        }
        public void Miao_Observer()//猫叫
        {
            foreach(Observer obServer in obServerList)
            {
                obServer.ActionFuntion();
            }
        }


        public Action OnCatMiaoHandler;
        public void Miao_Event()//猫叫
        {
            foreach(Action action in OnCatMiaoHandler.GetInvocationList())
            {
                action.Invoke();
            }
        }
    }
    //调用示例
    public class TestCat
    {
        Mouse mouse1=new Mouse();
        Child child1=new Child();
        void Miao_ObserverTest()
        {
            Cat cat =new Cat();
            cat.Add(mouse1);
            cat.Add(child1);

            cat.Miao_Observer();
        }
        void Miao_EventTest()
        {
            Cat cat =new Cat();
            cat.OnCatMiaoHandler+=mouse1.Run;
            cat.OnCatMiaoHandler+=child1.Cry;

            cat.Miao_Event();
        }
    }


     public abstract class Observer
       {
         public abstract void ActionFuntion();
       }
    public class Mouse:Observer
    {
        public void ActionFuntion()
        {
            this.Run();
        }
        public void Run()//老鼠跑
        {

        }
    }
    public class Child:Observer
    {
          public void ActionFuntion()
        {
            this.Cry();
        }
        public void Cry()//孩子哭
        {

        }
    }

游戏中的示例:当玩家攻击了其中之一的敌人时,那个队伍的所有敌人都会注意到玩家,在攻击范围的敌人会掉血,并且开始攻击玩家
参考:http://blog.csdn.net/sinat_20559947/article/details/50046201

 

 

未完待续...

 

posted @ 2017-03-31 11:38  bestzhao点com  阅读(568)  评论(0编辑  收藏  举报