Java设计模式（疯狂Java联盟版）
public class Singleton {
private static Singleton sing; private Singleton() { }
public static Singleton getInstance() { if (sing == null) {
sing = new Singleton(); }
return sing; } }
Test
public class Test {
public static void main(String[] args) { Singleton sing = Singleton.getInstance(); Singleton sing2 = Singleton.getInstance(); System.out.println(sing); System.out.println(sing2); } }
result
singleton.Singleton@1c78e57 singleton.Singleton@1c78e57
1.1.5 原型模式
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
适用性
1.当一个系统应该独立于它的产品创建、构成和表示时。
2.当要实例化的类是在运行时刻指定时，例如，通过动态装载。 3.为了避免创建一个与产品类层次平行的工厂层次时。 4.当一个类的实例只能有几个不同状态组合中的一种时。
建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。
参与者
1. Prototype
声明一个克隆自身的接口。 2. ConcretePrototype
实现一个克隆自身的操作。 3. Client
让一个原型克隆自身从而创建一个新的对象。
类图 例子 Prototype
public class Prototype implements Cloneable {
10
Java设计模式（疯狂Java联盟版）
private String name;
public void setName(String name) { this.name = name; }
public String getName() { return this.name; }
public Object clone(){ try {
return super.clone(); } catch (Exception e) { e.printStackTrace(); return null; } } }
ConcretePrototype
public class ConcretePrototype extends Prototype { public ConcretePrototype(String name) { setName(name); } }
Client
public class Test {
public static void main(String[] args) {
Prototype pro = new ConcretePrototyte(\ Prototype pro2 = (Prototype)pro.clone(); System.out.println(pro.getName()); System.out.println(pro2.getName()); } }
result
prototype prototype
1.2 结构型模式
Adapter ( 适配器模式) Bridge ( 桥接模式 ) Composite ( 组合模式 ) Decorator ( 装饰模式 ) Facade ( 外观模式 ) Flyweight ( 享元模式 ) Proxy ( 代理模式 )
11
Java设计模式（疯狂Java联盟版）
1.2.1 适配器模式
将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
适用性
1.你想使用一个已经存在的类，而它的接口不符合你的需求。
2.你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那接口 可能不一定兼容的类）协同工作。
3.（仅适用于对象Adapter）你想使用一些已经存在的子类，但是不可能对每一个都进行 子类化以匹配它们的接口。对象适配器可以适配它的父类接口。
参与者
1.Target
定义Client使用的与特定领域相关的接口。 2.Client
与符合Target接口的对象协同。 3.Adaptee
定义一个已经存在的接口，这个接口需要适配。 4.Adapter
对Adaptee的接口与Target接口进行适配
类图 例子 Target
public interface Target { void adapteeMethod(); void adapterMethod(); }
Adaptee
public class Adaptee {
public void adapteeMethod() {
System.out.println(\ } }
Adapter
public class Adapter implements Target { private Adaptee adaptee;
public Adapter(Adaptee adaptee) { this.adaptee = adaptee; } public void adapteeMethod() { adaptee.adapteeMethod(); } public void adapterMethod() { System.out.println(\ } }
12
Java设计模式（疯狂Java联盟版）
Client
public class Test {
public static void main(String[] args) {
Target target = new Adapter(new Adaptee()); target.adapteeMethod(); target.adapterMethod(); } }
result
Adaptee method! Adapter method!
1.2.2 桥接模式
将抽象部分与它实现部分分离，使它们都可以独立地变化。
适用性
1.你不希望在抽象和它的实现部分之间有一个固定的绑定关系。
例如这种情况可能是因为，在程序运行时刻实现部分应可以选择或者切换。 2.类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。
这时Bridge模式使你可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充。
3.对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。 4.正如在意图一节的第一个类图中所示的那样，有许多类要生成。 这一种类层次结构说明你必须将一个对象分解成两个部分。
5.想在多个对象间共享实现（可能使用引用计数），但同时要求客户并不知道这一点。
参与者
1.Abstraction
定义抽象类的接口。
维护一个指向Implementor类型对象的指针。 2.RefinedAbstraction
扩充由Abstraction定义的接口。 3.Implementor
定义实现类的接口，该接口不一定要与Abstraction的接口完全一致。 事实上这两个接口可以完全不同。
一般来讲，Implementor接口仅提供基本操作，而Abstraction则定义了基于这些基本操作的较高层次的操作。
4.ConcreteImplementor
实现Implementor接口并定义它的具体实现。
类图 例子 Abstr*ction
public abstract class Person { private Clothing clothing; private String type;
public Clothing getClothing() {
13
Java设计模式（疯狂Java联盟版）
return clothing; }
public void setClothing() {
this.clothing = ClothingFactory.getClothing(); }
public void setType(String type) { this.type = type; }
public String getType() { return this.type; }
public abstract void dress(); }
RefinedAbstraction
public class Man extends Person { public Man() {
setType(\男人\ }
public void dress() {
Clothing clothing = getClothing(); clothing.personDressCloth(this); } }
public class Lady extends Person { public Lady() {
setType(\女人\ }
public void dress() {
Clothing clothing = getClothing(); clothing.personDressCloth(this); } }
Implemento*
public abstract class Clothing {
public abstract void personDressCloth(Person person); }
ConcreteImplemento*
public class Jacket extends Clothing {
public void personDressCloth(Person person) {
System.out.println(person.getType() + \穿马甲\ } }
public class Trouser extends Clothing {
public void personDressCloth(Person person) {
System.out.println(person.getType() + \穿裤子\ }
14