设计模式(一)

单例模式

• 实现某个类的实例只有一个。

public class Singleton {  

private static Singleton singleton;  

private Singleton () { 

}  

public static Singleton getInstance () {  

if (singleton == null ) { 

singleton = new Singleton(); 

}  

return singleton; 

} 

}

观察者模式

在对象之间定义了一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象会收到通知并自动更新。

（ 其实就是发布订阅模式，发布者发布信息，订阅者获取信息，订阅了就能收到信息，没订阅就收不到信息。 ）

包含了四个角色：

• 抽象被观察者角色：也就是一个抽象主题，它把所有对观察者对象的引用保存在一个集合中，每个主题都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。
• 抽象观察者角色：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。
• 具体被观察者角色：也就是一个具体的主题，在集体主题的内部状态改变时，所有登记过的观察者发出通知。（通过一个List来保存登记的观察者，当发布信息时，通过便利这个List集合）
• 具体观察者角色：实现抽象观察者角色所需要的更新接口，一边使本身的状态与制图的状态相协调。（通过接受到的信息来做出响应）

推荐： https://www.cnblogs.com/luohanguo/p/7825656.html

工厂模式

• 简单工厂模式

由一个工厂对象根据收到的消息决定要创建哪一个类的对象实例。

package my.oschina.net .design.factory;

public class SimplePizzaFactory {

/**

* 根据传入的type参数，返回相应的pizza

* @param type

* @return

*/

public Pizza createPizza(String type) { //一般这个方法为static

Pizza pizza = null ;

if (type.equals("cheese" )) {

pizza = new CheesePizza();

} else if (type.equals("pepperoni" )) {

pizza = new PepperoniPizza();

} else if (type.equals("clam" )) {

pizza = new ClamPizza();

} else if (type.equals("veggie" )) {

pizza = new VeggiePizza();

}

return pizza;

}

}

• 工厂方法模式

定义一个创建对象的工厂接口，让子类决定实例化哪一个类，将实际创建工作推迟到子类当中。

（ 这个和简单工厂有区别，简单工厂模式只有一个工厂，工厂方法模式对每一个产品都有相应的工厂。）

• 抽象工厂模式

抽象工厂是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

与工厂方法模式不同的是，工厂方法模式中的工厂只生产单一的产品，而抽象工厂模式中的工厂生产多个产品

interface IProduct1 {

public void show();

}

interface IProduct2 {

public void show();

}

class Product1 implements IProduct1 {

public void show() {

System.out.println( "这是1型产品" );

}

}

class Product2 implements IProduct2 {

public void show() {

System.out.println( "这是2型产品" );

}

}

interface IFactory {

public IProduct1 createProduct1();

public IProduct2 createProduct2();

}

class Factory implements IFactory{

public IProduct1 createProduct1() {

return new Product1();

}

public IProduct2 createProduct2() {

return new Product2();

}

}

public class Client {

public static void main(String[] args){

IFactory factory = new Factory();

factory.createProduct1().show();

factory.createProduct2().show();

}

}

代理模式

编程思想： 不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。

代理模式包含如下角色：

ISubject ：抽象主题角色，是一个接口。该接口是对象和它的代理共用的接口。

RealSubject ：真实主题角色，是实现抽象主题接口的类。

Proxy ：代理角色，内部含有对真实对象RealSubject的引用，从而可以操作真实对象。代理对象提供与真实对象相同的接口，以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。

实现动态代理的关键技术是反射。

• 静态代理

静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类.

推荐： http://www.runoob.com/design-pattern/proxy-pattern.html

• 动态代理

多个主题类对应一个代理类，共享“前处理，后处理”功能，动态调用所需主题，大大减小了程序规模，这就是动态代理模式的特点。

推荐： https://blog.csdn.net/goskalrie/article/details/52458773