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

时间:2023-02-24 11:14:05

     今天学了新东西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();
};

 

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

 

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