GOF设计模式

创建：

1.工厂模式：

相当于new，可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如赋值 查询数据库等。如果创建sample实例时所做的初始化工作是很长一段代码，如果写入构造函数中，那你的代码很难看了

2.抽象工厂：横向拆分//个人感觉不怎么好用

A{},A1 extends A{}, A2 extends A{},

B{} B1 extends B{}, B2 extends B{},

abstract class Factory{

public abstract A creator(String name);

public abstract B creator(String name);

}

Fac! extends Factory{

public A creator( String name ) { return new A1 }

public B creator( String name ){return new B1}

}

Fac2 extends Factory{

public A creator( String name ) { return new A2 }

public B creator( String name ){return new B2}

}

2.设计模式之Prototype(原型)

Prototype模式允许一个对象再创建另外一个可定制的对象，因为Java中的提供clone()方法来实现对象的克隆,所以Prototype模式实现一下子变得很简单.

AbstractSpoon spoon = new SoupSpoon();

AbstractSpoon spoon2 = spoon.clone();

3.设计模式之Builder

是为了将构建复杂对象的过程和它的部件解耦.注意: 是解耦创建过程和具体部件.

class Car extends Product {

partA partA;

partB partB;

void buildA() {}

void buildB() {}

}

class Builder {

Car car;

Builder(Car car) { this.car = car; }

void construct() {

car.buildA();

car.buildB();

}

}

mian(){

Car = new Car()

Builder b=new Builder(car);

b.construct();

Product p=car;

}

4.设计模式之Singleton(单例)

单例模式可以用来保存状态，也可以用来作为工具，保证整个内存只生成一个实例。如果你的应用基于容器，那么Singleton模式少用或者不用，可以使用相关替代技术，因为他们大多是分布式部署。

public class Singleton {

private static Singleton instance = new Singleton();

private Singleton() {}

public static Singleton getInstance() { return instance;}

}

结构：

5.设计模式之Facade(外观)

需要将多次用到的不变的部分提炼出来，作为一个函数。比如数据库连接操作。

6.设计模式之proxy(代理)

7.设计模式之Adapter(适配器)

为了将两个不兼容的类纠合在一起使用，可以在这两种接口之间创建一个混合接口(混血儿).即adapter。实现Adapter方式,其实"think inJava"的"类再生"一节中已经提到,有两种方式：组合(composition)和继承(inheritance).

8.设计模式之Composite(组合)

想到Composite就应该想到树形结构图，组合体内这些对象都有共同接口,当组合体一个对象的方法被调用执行时，Composite将遍历(Iterator)那个对象为根结点的整个树形结构,寻找同样包含这个方法的对象并实现调用执行。

abstract class Container{

private String name;

private List<Container> components=new ArrayList<Container>();

public void add(Container ct) { this.components.add(ct); }

public double totalPrice()

{

double total=0.;

Iterator<Container> iter=components.iterator();

while(iter.hasNext())

total+=((Container)iter.next()).totalPrice();

return total;

}

}

class Table extends Container{

public double totalPrice(){return 5+super.totalPrice(); }

}

class Drawer extends Container{

public double totalPrice(){return 1+super.totalPrice(); }

}

//////////////////////////////////////////////////////////////////////////////

main(){

Table table=new Table();

Drawer drawer=new Drawer();

table.add(drawer);

System.out.println(table.totalPrice());

}

9.设计模式之Decorator(装饰) //功能上有点类似拦截器或者过滤器，

我们通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能。实际上Java 的I/O API就是使用Decorator实现的,

FileReader fr = new FileReader(filename);

BufferedReader br = new BufferedReader(fr);

//////////////////////////////////////////////////////////////

class A {

void doSomething() {}

}

class B {

A a;

B(A a) {this.a = a;}

void doSomethind() {

....

a.doSomething();

}

}

10.设计模式之Bridge

11.设计模式之Flyweight

12.设计模式之Template

定义一个操作中算法的骨架,将一些步骤的执行延迟到其子类中.

abstract class A {

abstract void doSomething();

void execute() {

doSomething();

}

}

class B extends A{

void doSomething(){}

}

13.设计模式之Memento(备忘机制)

即设计一个个原始类同样的类作为备忘录 //,个人感觉多此一举，多创建了一个类，其实可以用同样类的一个实例保存。

class Orig{

int status;

public Memo getMemo(){return new Memo(this);}

public void setMemo(Memo m){this.status=m.status;}

}

class Memo{

int status;

Memo(Orig orig){this.status=orig.status;}

}

14.设计模式之Observer

类似于监听器，但是是顺序执行的单线程，

class Parameter { //用于区别参数是要传递给哪个观察者。本来不需，若提供双参数notify即不用此类

private String filderName;

private Object arg;

public Parameter(String filderName, Object arg){...};

}

class Person extends Observable{ //被观察者

private String name;

private String address;

public void setName(String name) {

this.name = name;

super.setChanged();

super.notifyObservers(new Parameter("name",name)); //缺陷再次，只能传递一个参数，遍历所有观察值

}//address的set同

}

public class NameObserver implements Observer {

public void update(Observable o, Object arg) {

if (arg instanceof Param)

if(((Param)arg).getArg().equals("fieldername")) //区别参数

doSomething();

System.out.println("there is something wrong with the parameter");

}

}

//////////////////////////////////////////////////////////////////////////////

mian(){

Product product=new Product();

NameObserver nameobs=new NameObserver();

AddressObserver priceobs=new AddressObserver();

product.addObserver(nameobs);

product.addObserver(priceobs);

product.setName("myName");

product.setPrice("myAddress");

}

15。设计模式之Chain of Responsibility(职责链)

参见j2ee中的redirectDispatcher()方法；用来处理类似函数太长，或是该函数不能完成任务，交另一函数处理。

16.设计模式之Command

类似于协议，给定那个符号执行那个操作。将这些命令封装成在一个类中,然后用户(调用者)再对这个类进行操作,这就是Command模式,换句话说,本来用户(调用者)是直接调用这些命令的,如菜单上打开文档(调用者),就直接指向打开文档的代码,使用Command模式,就是在这两者之间增加一个中间者,将这种直接关系拗断,同时两者之间都隔离,基本没有关系了.

17.设计模式之State

顾名思意，根据状态的变换执行响应的操作

18.设计模式之Strategy(策略)

Strategy策略模式主要是定义一系列的算法,把这些算法一个个封装成单独的类.即一般的继承关系。

19.设计模式之Mediator(中介者)

各个对象之间的交互操作非常多;每个对象的行为操作都依赖彼此对方,修改一个对象的行为,同时会涉及到修改很多其他对象的行为,如果使用Mediator模式,可以使各个对象间的耦合松散,只需关心和 Mediator的关系,使多对多的关系变成了一对多的关系,可以降低系统的复杂性,提高可修改扩展性. //参照数据库多对多的设计模式

20.设计模式之Interpreter(解释器)

定义语言的文法 ,并且建立一个解释器来解释该语言中的句子.Interpreter似乎使用面不是很广,它描述了一个语言解释器是如何构成的,在实际应用中,我们可能很少去构造一个语言的文法.

21.设计模式之Visitor

//感觉多此一举，更加难以理解

Java的Collection(包括Vector和Hashtable)是我们最经常使用的技术,可是Collection好象是个黑色大染缸,本来有各种鲜明类型特征的对象一旦放入后,再取出时,这些类型就消失了.那么我们势必要用If来判断。

如果对象集合中的对象集合经常有变化, 那么不但Visitor实现要变化，Visistable也要增加相应行为，GOF建议是,不如在这些对象类中直接逐个定义操作，无需使用访问者设计模式。

但是在Java中，Java的Reflect技术解决了这个问题，因此结合reflect反射机制，可以使得访问者模式适用范围更广了。

Reflect技术是在运行期间动态获取对象类型和方法的一种技术