初识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();
};

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

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