xingzhe

将抽象和行为划分开来，各自独立变化且能动态结合。

不希望抽象部分和行为部分有一种固定的绑定关系。

如果一个抽象类或接口有多个具体实现(子类、concrete subclass),这些子类之间关系可能有以下两种情况:
1. 这多个子类之间概念是并列的,如前面举例,打桩,有两个concrete class:方形桩和圆形桩;这两个形状上的桩是并列的,没有概念上的重复。

2.这多个子类之中有内容概念上重叠.那么需要我们把抽象共同部分和行为共同部分各自独立开来,原来是准备放在一个接口里,现在需要设计两个接口：抽象接口和行为接口，分别放置抽象和行为.

class CoffeeImp;

class CoffeeImpFactory
{
public:
CoffeeImpFactory(CoffeeImp* coffeeImpIn)
{
coffeeImp = coffeeImpIn;
}
static CoffeeImp* getTheCoffeeImp()
{
return coffeeImp;
}
private:
static CoffeeImp* coffeeImp;
};

CoffeeImp* CoffeeImpFactory::coffeeImp = NULL;

class Coffee
{
public:
void setCoffeeImp()
{
pconffeeImp = CoffeeImpFactory::getTheCoffeeImp();
}
CoffeeImp* getCoffeeImp()
{
return pconffeeImp;
}
virtual void pourCoffee() = 0;
private:
CoffeeImp* pconffeeImp;
};

class CoffeeImp
{
public:
virtual void pourCoffeeImp() = 0;
};

class MiddleSizeCoffee:public Coffee
{
public:
MiddleSizeCoffee()
{
setCoffeeImp();
}
virtual void pourCoffee()
{
printf("%s\n","Middle size coffee!");
for(int i = 0; i < 2; ++i)
getCoffeeImp()->pourCoffeeImp();
}
};

class BigSizeCoffee:public Coffee
{
public:
BigSizeCoffee()
{
setCoffeeImp();
}
virtual void pourCoffee()
{
printf("%s\n","Big size coffee!");
for(int i = 0; i < 5 ; ++i)
getCoffeeImp()->pourCoffeeImp();
}
};

class MilkCoffeeImp:public CoffeeImp
{
public:
MilkCoffeeImp(){};
virtual void pourCoffeeImp()
{
printf("%s\n","add Milk");
}

};

class WaterCoffeeImp:public CoffeeImp
{
public:
WaterCoffeeImp(){}
virtual void pourCoffeeImp()
{
printf("%s\n","add water");
}
};

int main(void) //主函数。
{
//milk coffee
CoffeeImpFactory* coffeeImpSingleton = new CoffeeImpFactory(new MilkCoffeeImp());

//middle size milk coffee
MiddleSizeCoffee* middlesizecoffee = new MiddleSizeCoffee;
middlesizecoffee->pourCoffee();

//big size milk coffee
BigSizeCoffee* bigsizecoffee = new BigSizeCoffee;
bigsizecoffee->pourCoffee();

delete coffeeImpSingleton;
delete middlesizecoffee;
middlesizecoffee =NULL;
delete bigsizecoffee;
bigsizecoffee = NULL;

//wate coffee
coffeeImpSingleton = new CoffeeImpFactory(new WaterCoffeeImp());

//middle size water coffee
middlesizecoffee = new MiddleSizeCoffee;
middlesizecoffee->pourCoffee();

//big size water coffee
bigsizecoffee = new BigSizeCoffee;
bigsizecoffee->pourCoffee();

delete middlesizecoffee;
middlesizecoffee =NULL;
delete bigsizecoffee;
bigsizecoffee = NULL;
delete coffeeImpSingleton;
coffeeImpSingleton = NULL;

return 0;
}

//1 mathod
class Singleton
{
public:
protected:
Singleton(){};

protected:
static Singleton* _instance;
private:
Singleton(const Singleton& other);
Singleton& operator =(const Singleton& other);
};
Singleton* Singleton::_instance = NULL;

class ConcreteSingleton:public Singleton
{
public:
static Singleton* CreateInstance();
protected:
ConcreteSingleton(){};
private:
ConcreteSingleton(const ConcreteSingleton& other);
ConcreteSingleton& operator = (const ConcreteSingleton& other);
};

Singleton* ConcreteSingleton::CreateInstance()
{
return (_instance==NULL)?_instance= new ConcreteSingleton:0;
}

//2 method

class Singleton
{
protected:
Singleton() {}
private:
Singleton(const Singleton&) ;
Singleton& operator=(const Singleton&) ;
} ;

// class ConcreteSingleton
class ConcreteSingleton : public Singleton
{
public:
static Singleton* Instance() { static ConcreteSingleton _instance ; return &_instance ; }
protected:
ConcreteSingleton() {}
} ;

//3 method
template < class T >
class Singleton
{
public:
static T* Instance() { static T _instance ; return &_instance ; }
protected:
Singleton() {}
private:
Singleton(const Singleton &) ;
Singleton& operator=(const Singleton&) ;
} ;

class ConcreteSingleton : public Singleton< ConcreteSingleton > {} ;

作用：将一个类的接口转换成客户希望的另外一个接口，解决两个已有接口之间不匹配的问题。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

就是将需求转接给一个已经实现的类。

1.类适配器：private 继承Adaptee（实现继承）

class IAdaptee
{
public:
void SpecialRequest()
{
return;
}
};
class Target
{
public:
virtual void Request() = 0;

};

class Aadptor:public Target, private IAdaptee
{
public:
virtual void Request()
{
SpecialRequest();
}

};
void main(void) //主函数。
{
class Aadptor adptor;
adptor.Request();
}
2.对象适配器

class IAdaptee
{
public:
void SpecialRequest()
{
return;
}
};
class Target
{
public:
virtual void Request() = 0;

};

class Aadptor:public Target
{
public:
virtual void Request()
{
adaptee.SpecialRequest();
}
private:
class IAdaptee adaptee;

};
void main(void) //主函数。
{
class Aadptor adptor;
adptor.Request();
}

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。

示例代码：

class Document
{
};
class MyDocumemt:public Document
{

};

class App
{
public:
void OpenDocument()
{
CreateDocument();
}
virtual Document* CreateDocument()=0;

};
class MyApp:public App
{
public:
virtual Document* CreateDocument()
{
return new MyDocumemt;
}
};

void main(void) //主函数。
{
class MyApp app;
app.OpenDocument();
}

在某些情况下，比如仅仅为了创建适当的Product对象而派生新的Creator子类，并且创建不同Product的方法一致时，可以考虑用模板代替继承。如：

　　模板与继承的本质区别之一是：模板：行为不依赖于类型。继承：行为依赖于类型。(Effective C++ Item 41) 事实上，在很多模式中都存在着可以用模板代替继承的情况，其根本原因就在于子类的行为是一致的。

class Product
{

};

class MyProduct:public Product
{
public:
MyProduct()
{
int i = 0;
}
};

class Creator
{
public:
virtual Product* CreateProduct() = 0;
};

template
class ConcreateCreator:public Creator
{
public:
virtual Product* CreateProduct()
{
return new T;
}
};

void main(void) //主函数。
{
ConcreateCreator MyConcreateCreator;
MyConcreateCreator.CreateProduct();
}

//不直接实例化类的情况下创建一系列相关的产品对象

class Door
{

};
class Room
{

};
class ADoor: public Door
{

};
class ARoom: public Room
{

};

class BDoor: public Door
{

};
class BRoom:public Room
{

};
class Factory
{
public:
virtual Door* CreateDoor() = 0;
virtual Room* CreateRoom() = 0;
};
class AFactory:public Factory
{
public:
virtual Door* CreateDoor()
{
return new ADoor;
}
virtual Room* CreateRoom()
{
return new ARoom;
}
};

class BFactory:public Factory
{
public:
virtual Door* CreateDoor()
{
return new BDoor;
}

virtual Room* CreateRoom()
{
return new BRoom;
}

};

void CreateGame(class Factory &factory)
{
Door * pDoor = factory.CreateDoor();
Room * pRoom = factory.CreateRoom();
}
void main(void) //主函数。
{
class AFactory factory;
CreateGame(factory);
}