意图
动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。
适用性
- 在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
- 处理那些可以撤消的职责。
- 当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。
Java实现
JavaIO库的使用可能如下
BufferedInputStream bi = new BufferedInputStream(new FileInputStream(filename));
我们都知道FileInputStream是用来读取文件的，BufferedInputStream是提供了缓存的能力。我们分别看下他们的源代码
public class BufferedInputStream extends FilterInputStream
...
public class FilterInputStream extends InputStream
...
public class FileInputStream extends InputStream
...
BufferedInputStream继承了FilterInputStream，FilterInputStream和FileInputStream一样都继承自InputStream.
可以看出InputStream是公共父类。
FilterInputStream是装饰类的公共父类，看看FilterInputStream的源代码就知道了，他只是做了简单的方法委托。
BufferedInputStream继承了FilterInputStream，并添加了缓存的方法（其实就是用一个字节数组保存字节，一次性读出）。
意图
将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。
适用性
- 你想表示对象的部分—整体层次结构。
- 你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。
Java实现
public interface Node {
void check();
void add(Node node) throws Exception;
void remove(Node node) throws Exception;
}
public class ParentNode implements Node {
private List<Node> list = new ArrayList<Node>();
public void check() {
System.out.println("ParentNode is checked");
for(Node n : list){
n.check();
}
}
public void add(Node node) {
list.add(node);
}
public void remove(Node node) {
list.remove(node);
}
}
意图
将一个类的接口转换成另外一个客户希望的接口。Adapter 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
适用性
- 你想使用一个已经存在的类，而它的接口不符合你的需求。
- 你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。
- （仅适用于对象Adapter）你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。
Java实现
假设目前做一个新系统，有如下代码结构。
public interface Car{
public void drive();
}
public class Benz implements Car{
public void drive(){
System.out.println("Benz run");
}
}
public class Cruze implements Car{
public void drive(){
System.out.println("Cruze run");
}
}
有一个老系统，里面有如下代码
public class Smart{
public void run(){
System.out.println("Smart run");
}
}
意图
为其他对象提供一种代理以控制对这个对象的访问。
适用性
在需要用比较通用和复杂的对象指针代替简单的指针的时候，使用Proxy模式。下面是一些可以使用Proxy模式常见情况：
- 远程代理（Remote Proxy）为一个对象在不同的地址空间提供局部代表。
- 虚代理（Virtual Proxy）根据需要创建开销很大的对象。
- 保护代理（Protection Proxy）控制对原始对象的访问。保护代理用于对象应该有不同 的访问权限的时候。
- 智能指引（Smart Reference）取代了简单的指针，它在访问对象时执行一些附加操作。 它的典型用途包括：
- 对指向实际对象的引用计数，这样当该对象没有引用时，可以自动释放它（也称为SmartPointers）。
- 当第一次引用一个持久对象时，将它装入内存。
- 在访问一个实际对象前，检查是否已经锁定了它，以确保其他对象不能改变它。
Java实现
//工厂接口
public interface ItemFactory{
public Item getItem();
}
//工厂实现,Item就不实现了，随便怎么写都行
public class ItemFactoryImpl implements ItemFactory{
public Item getItem(){
return new Item();
}
}
//商店类，就是代理
public class Shop implements ItemFactory{
private ItemFactory factory = new ItemFactoryImpl();
public Item getItem(){
System.out.println("附加服务");
return factory.getItem();
}
}
//实际调用
public class Main{
public static void main(String[] args){
ItemFactory f = new Shop();
f.getItem();
}
}
意图
为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
适用性
- 当你要为一个复杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越复杂。大多数模式使用时都会产生更多更小的类。这使得子系统更具可重用性，也更容易对子系统进行定制，但这也给那些不需要定制子系统的用户带来一些使用上的困难。Facade可以提供一个简单的缺省视图，这一视图对大多数用户来说已经足够，而那些需要更多的可定制性的用户可以越过Facade层。
- 客户程序与抽象类的实现部分之间存在着很大的依赖性。引入Facade将这个子系统与客户以及其他的子系统分离，可以提高子系统的独立性和可移植性。
- 当你需要构建一个层次结构的子系统时，使用门面模式定义子系统中每层的入口点。如果子系统之间是相互依赖的，你可以让它们仅通过Facade进行通讯，从而简化了它们之间的依赖关系。
Java实现
public class Camara {
public void turnOn(){
System.out.println("开启摄像头！");
}
public void turnOff(){
System.out.println("关闭摄像头！");
}
}
public class Light {
public void turnOn(){
System.out.println("开灯！");
}
public void turnOff(){
System.out.println("关灯！");
}
}
意图
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
适用性
- 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
- 当构造过程必须允许被构造的对象有不同的表示时。
Java实现
// 待构建产品
class Starbucks {
private String size;
private String drink;
public void setSize(String size) {
this.size = size;
}
public void setDrink(String drink) {
this.drink = drink;
}
}
//抽象builder
abstract class StarbucksBuilder {
protected Starbucks starbucks;
public Starbucks getStarbucks() {
return starbucks;
}
public void createStarbucks() {
starbucks = new Starbucks();
System.out.println("a drink is created");
}
public abstract void buildSize();
public abstract void buildDrink();
}
意图
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
适用性
- 当要实例化的类是在运行时刻指定时，例如，通过动态装载；或者
- 为了避免创建一个与产品类层次平行的工厂类层次时；或者
- 当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。
Java实现
//浅拷贝
public class A implements Cloneable{
private String str;
private B b;
public void setStr(String str){
this.str = str;
}
public String getStr(){
return str;
}
public B getB() {
return b;
}
public void setB(B b) {
this.b = b;
}
@Override
protected Object clone(){
A a = null;
try {
a = (A) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return a;
}
public static void main(String[] args) {
A a = new A();
a.setStr("Hello");
B b = new B();
b.setStr("Hello B");
a.setB(b);
System.out.println("a-str:" + a.getStr());
System.out.println("a-b:" + a.getB().getStr());
A ac = null;
ac = (A) a.clone();
System.out.println("ac-str:" + ac.getStr());
System.out.println("ac-b:" + ac.getB().getStr());
a.setStr("Hello A");
b.setStr("Hello BB");
a.setB(b);
System.out.println("a-str:" + a.getStr());
System.out.println("a-b:" + a.getB().getStr());
System.out.println("ac-str:" + ac.getStr());
System.out.println("ac-b:" + ac.getB().getStr());
}
}
