给妹子讲懂设计模式

【中心思想】开闭原则（Open Closed Principle，OCP）：对扩展开放，对修改关闭。

实现方式：

  • 里氏代换原则（Liskov Substitution Principle, LSP）：
    • 　　【抽象】任何基类可以出现的地方，子类一定可以出现（不可逆哦）。
    • 　　我喜欢吃水果。此处的“水果”可以置换为“苹果”、“香蕉”、“草莓”……
  • 依赖倒置原则（Dependence Inversion Principle, DIP）：
    • 　　【抽象】依赖于抽象，不要依赖于具体。
    • 　　水果可以“吃”的抽象行为，不依赖于苹果需要“洗过之后吃”、香蕉需要“剥皮吃”、草莓需要“摘掉蒂吃”……的具体行为。
  • 接口隔离原则（Interface Segregation Principle, ISP）：
    • 　　【高内聚】一个类对另一个类的依赖应该建立在最小的接口上。
    • 　　接口A：吃。接口B：玩。“苹果”只依赖接口A，可以吃；“苹果手机”只依赖接口B，可以玩；“撒尿牛丸”继承接口A/B，又好吃又好玩！
  • 单一职责原则（Single Responsibility Principle, SRP）：
    • 　　【高内聚】一个类只有一个引起它变化的原因。
    • 　　苹果手机的“使用方式”只有“玩”，但如果有一天多了“吃”，那就需要重构啦。
  • 最少知识原则（Least Knowledge Principle, LKP）：
    • 　　【低耦合】一个对象应该对其他对象保持最少的了解。
    • 　　总监不需要直接指派基层员工工作，而是授权经理指派员工工作~

 

【23种设计模式】分类：

  • 创建型模式：单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。
  • 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
  • 行为型模式：模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

 

【创建型模式A-单例模式】

  • 可以全局访问
  • 保证全局只有一个对象
  • 避免重复创建和销毁
 1 #include <iostream>
 2 
 3 /**
 4  * @Class:  Singleton
 5  * @Brief:  单例模式
 6  */
 7 class Singleton
 8 {
 9 public:
10     static Singleton* get_instance() {
11         if (NULL == _p_instance) {
12             std::cout << "Create singleton" << std::endl;
13             _p_instance = new Singleton();
14         }
15         std::cout << "Get singleton" << std::endl;
16         return _p_instance;
17     }
18 
19 private:
20     Singleton() {}
21 
22     /**
23      * @Class:  Garbo
24      * @Brief:  销毁instance
25      */
26     class Garbo
27     {
28     public:
29         Garbo() { _p_instance = NULL; }
30         ~Garbo() {
31             if (NULL != _p_instance) {
32                 std::cout << "Destory singleton" << std::endl;
33                 delete _p_instance;
34                 _p_instance = NULL;
35             }
36         }
37     };
38 
39     static Singleton* _p_instance;
40     static Garbo _garbo;
41 
42 };
43 
44 Singleton* Singleton::_p_instance;
45 Singleton::Garbo Singleton::_garbo;
46 
47 int main()
48 {
49     Singleton::get_instance();
50     Singleton::get_instance();
51     Singleton::get_instance();
52     Singleton::get_instance();
53     Singleton::get_instance();
54     return 0;
55 }
View Code

 

【创建型模式B-工厂模式】

  • 封装了实例化过程，调用者无需关心，保证了LKP，低耦合
  • 抽象工厂模式可以在工厂类内部进行关联产品的管理，提高可扩展性
  1 #include <iostream>
  2 
  3 /**
  4  * @Class:  IDiablo
  5  * @Brief:  iterface for product Diablo
  6  */
  7 class IDiablo
  8 {
  9 public:
 10     virtual void play() = 0;
 11 };
 12 
 13 /**
 14  * @Class:  IBioHazard
 15  * @Brief:  iterface for product BioHazard
 16  */
 17 class IBioHazard
 18 {
 19 public:
 20     virtual void play() = 0;
 21 };
 22 
 23 /**
 24  * @Class:  DiabloII
 25  * @Brief:  product DiabloII
 26  */
 27 class DiabloII: public IDiablo
 28 {
 29 public:
 30     void play() {
 31         std::cout << "DiabloII is wonderful!!!" << std::endl;
 32     }
 33 };
 34 
 35 /**
 36  * @Class:  DiabloIII
 37  * @Brief:  product DiabloIII
 38  */
 39 class DiabloIII: public IDiablo
 40 {
 41 public:
 42     void play() {
 43         std::cout << "DiabloIII is terrible!!!" << std::endl;
 44     }
 45 };
 46 
 47 /**
 48  * @Class:  BioHazardIV
 49  * @Brief:  product BioHazardIV
 50  */
 51 class BioHazardIV: public IBioHazard
 52 {
 53 public:
 54     void play() {
 55         std::cout << "BioHazardIV is wonderful!!!" << std::endl;
 56     }
 57 };
 58 
 59 /**
 60  * @Class:  BioHazardV
 61  * @Brief:  product BioHazardV
 62  */
 63 class BioHazardV: public IBioHazard
 64 {
 65 public:
 66     void play() {
 67         std::cout << "BioHazardV is terrible!!!" << std::endl;
 68     }
 69 };
 70 
 71 /**
 72  * @Class:  IGameStore
 73  * @Brief:  interface for factory
 74  */
 75 class IGameStore
 76 {
 77 public:
 78     virtual void get_diablo(IDiablo*& p_diablo) = 0;
 79     virtual void get_biohazard(IBioHazard*& p_biohazard) = 0;
 80 };
 81 
 82 /**
 83  * @Class:  OldGameStore
 84  * @Brief:  factory A
 85  */
 86 class OldGameStore: public IGameStore
 87 {
 88 public:
 89     void get_diablo(IDiablo*& p_diablo) {
 90         p_diablo = new DiabloII();
 91     }
 92     void get_biohazard(IBioHazard*& p_biohazard) {
 93         p_biohazard = new BioHazardIV();
 94     }
 95 };
 96 
 97 /**
 98  * @Class:  NewGameStore
 99  * @Brief:  factory B
100  */
101 class NewGameStore: public IGameStore
102 {
103 public:
104     void get_diablo(IDiablo*& p_diablo) {
105         p_diablo = new DiabloIII();
106     }
107     void get_biohazard(IBioHazard*& p_biohazard) {
108         p_biohazard = new BioHazardV();
109     }
110 };
111 
112 int main()
113 {
114     IDiablo* p_old_diablo = NULL;
115     IDiablo* p_new_diablo = NULL;
116     IBioHazard* p_old_bio = NULL;
117     IBioHazard* p_new_bio = NULL;
118     OldGameStore old_game_store;
119     NewGameStore new_game_store;
120 
121     old_game_store.get_diablo(p_old_diablo);
122     new_game_store.get_diablo(p_new_diablo);
123     old_game_store.get_biohazard(p_old_bio);
124     new_game_store.get_biohazard(p_new_bio);
125 
126     if (NULL != p_old_diablo) {
127         p_old_diablo->play();
128     }
129     if (NULL != p_new_diablo) {
130         p_new_diablo->play();
131     }
132     if (NULL != p_old_bio) {
133         p_old_bio->play();
134     }
135     if (NULL != p_new_bio) {
136         p_new_bio->play();
137     }
138 
139     if (NULL != p_old_diablo) {
140         delete p_old_diablo;
141     }
142     if (NULL != p_new_diablo) {
143         delete p_new_diablo;
144     }
145     if (NULL != p_old_bio) {
146         delete p_old_bio;
147     }
148     if (NULL != p_new_bio) {
149         delete p_new_bio;
150     }
151 
152     return 0;
153 }
View Code

 

【创建型模式B-建造者模式】

 

posted on 2014-04-02 13:54  似溦若岚  阅读(145)  评论(0)    收藏  举报

导航