初识OOAD-面向对象设计模式

     今天学了新东西OOAD，也认识了个新牛，赵德奎，以前华为的，感觉还行，挺正经！

首先介绍了下：经典设计模式：GOF（gang of four）之行为型的observer（观察者模式）

大体是，一个类的属性或成员发生了变化，有相应的类也同时发生变化。实现是通过把额外类的父类指针保存到容器中，然后实现类在要发生变化的函数里，从容器中一各个读取出来，这样起到同时变化的效果。

好处是，通过一个类，能动荡几个类一起发生变化。

代码：class Par{
  public:
        virtual void show()=0;
};

class M{
   private:
      int age;
      vector<Par*> vec;      //定义额外类的父类指针，
   public:
      void setAge(int a){
         age =a;
         vector<Par*>::iterator  b = vec.begin(),e = vec.end();     //保存区间
         while(b!=e){
            (*b)->show();
            b++;
         }
      }

      void add(Par* data){
       vec.push_back(data);
      }
};

class A:public Par{
  public:
     void show(){
        cout << "in a" << endl;
     }
};
class B:public Par{
  public:
    void show(){
        cout << "in b" << endl;
    }
};
class Cd:public Par{
   public:
    void show(){
        cout << "in cd" << endl;
    }
};

int main(){
    M* m = new M;
    m->add(new A);  m->add(new B);    //在add类里做  尾进容器操作
    m->setAge(10);
}

很多东西没有处理，比如析构和异常，这里做为学习就先不添加了。

==============================================================

下边介绍另外的一种模式是：创造型的Singleton（单例模式）

大体是，把构造函数设置为私有，这样只能有且仅有为类实例一个对象，并提供一个访问它的全局访问点。

好处是，好比是打印机和卖票窗口，唯一性。

代码：#include <iostream>
using namespace std;

class Single{
  static Single* single;      //关键点
  private:
     Single(){}
  public:
     static Single* getInstance(){
         if(single==0){
            single = new Single;
         }
         return single;
     }
};
Single* Single::single = 0;

int main(){
   Single* s = Single::getInstance();
   Single* s1 = Single::getInstance();
   cout << s << s1;
}

==============================================================

下边介绍另外的一种模式是：创造型的Abstract Factory（抽象工厂模式）和构造型的Proxy（代理模式）

大体是，让类对象的声明和定义分开，在main里创建一系列需要操作依赖性的接口，无须指定是哪个类，然后去进行操作的中间添加一个代理的类做一些控制和判断。

好处是，使创建对象的声明和定义分离，保障数据的安全。代理类，可以进行控制，对之后的操作有个判断是否进行，好比要浏览一些网战看是否合法才进入等操作。

———                                        ———

|原       <————>代理<————>终端|

|———                                     ———|

 

代码：#include <iostream>
using namespace std;

class P_F{
  public:
   virtual void show(){}       //一定要虚，否则不走子类操作
};
class A_F:public P_F{
  public:
    void show(){
       cout << "in a_f";
    }
};
class B_F:public P_F{
  public:
    void show(){
       cout << "in b_f";
    }
};
class Proxy_F:public P_F{    //代理类。
  private:
    P_F* pf;
  public:
   Proxy_F(P_F* p){     //关键点。
      pf = p;
   }
  public:
    void show(){
      cout << "abc" << endl;
      pf->show();
    }
};
class factory{            //抽象工厂
    public:
       static P_F* create(){
          return new Proxy_F(new B_F);  //创建的是要返回元素的类。
       }
};
int main(){
   P_F* a = factory::create();
   a->show();
}

 

===============================================

最后介绍写构造型的Bridge（桥模式），在分析这个之前，说说别的，相信很多程序员都见过这四种模式了，因为他们是最常用的也是最基础的了。

而我写的都是写基础的东西，起到大家一起温习即可，在这里也希望些朋友多提提宝贵意见，我也会很很采纳。

桥呢，我觉得比较深理解了。书上说的很烦琐也不容易懂，我就说说大白话，即通过桥接的方式，把一个高级类与其他低级类分开后，通过指针和引用连接在一起。北京市是个高级类，黑龙江省是个低级类，低级类里有齐齐哈尔市子类，哈尔滨等子类，然尔通过京哈线就能实现北京到哈或齐的桥接工作。

好处是，我至尽还没用到，所以也没琢磨出。

代码：#include <iostream>
using namespace std;

class windowimpl{
   public:
      virtual void drawLine(){}
};

class xwindowimpl:public windowimpl{
   public:
      void drawLine(){
         cout << "x drawline" << endl;
      }
};

class ywindowimpl:public windowimpl{
    public:
      void drawLine(){
         cout << "y drawline" << endl;
      }
};

class window{
   private:
      windowimpl* impl;   //关键点，桥接手段把window和windowimpl的子类桥接
   public:
      window(windowimpl* imp){
         impl = imp;
      }
   public:
      void drawRect(){
         impl->drawLine();
         impl->drawLine();
      }
      void draw(){
         impl->drawLine();
      }
}

 

int main(){
   window* w = new window(new xwindowimpl);
   w->drawRect();
};

 

还有一些其他的模式都没有写，就写了这五种最经常用的模式，

 

好了不写了 希望读者和我能一起学习。