java的设计模式

一、设计模式的分类

总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

其实还有两类：并发型模式和线程池模式。用一个图片来整体描述一下：

二、设计模式的六大原则

1、开闭原则（Open Close Principle）

开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科

3、依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

5、迪米特法则（最少知道原则）（Demeter Principle）

为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

原则是尽量使用合成/聚合的方式，而不是使用继承。

单例模式（Singleton）

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：

1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。

2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。

3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

首先我们写一个简单的单例类：

[java] view plaincopy

1. public class Singleton {  
2.   
3.     /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */  
4.     private static Singleton instance = null;  
5.   
6.     /* 私有构造方法，防止被实例化 */  
7.     private Singleton() {  
8.     }  
9.   
10.     /* 静态工程方法，创建实例 */  
11.     public static Singleton getInstance() {  
12.         if (instance == null) {  
13.             instance = new Singleton();  
14.         }  
15.         return instance;  
16.     }  
17.   
18.     /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */  
19.     public Object readResolve() {  
20.         return instance;  
21.     }  
22. }  

适配器模式

定义：适配器模式将一个类的接口，转换成客户期望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作

适配器的分类

组合：采用组合方式的适配器会成为对象适配器

特点： 把“被适配者”作为一个对象组合到适配器类中，以修改目标接口包装被适配者

package com.adpter.li;
//三相电流接口
public interface ThreePlug {
  //使用三相电流供电
  public void ThreePower();
}

package com.adpter.li;
public class TwoPlug {
  public void TwoPower() {
   System.out.println("使用二相电流供电");
  }
}

package com.adpter.li;
public class NoteBook {
 private ThreePlug tp ;
 public NoteBook(ThreePlug tp) {
  this.tp=tp;
 }
 public void charge() {
  System.out.println("正在充电");
 }
   public static void main(String[] args) {
 TwoPlug tlg=new TwoPlug();
 ThreePlug tlu=new TwoAdapterThree(tlg);
 NoteBook note =new NoteBook(tlu);
 note.charge();
   }
}

package com.adpter.li;
public class TwoAdapterThree implements ThreePlug {
 private TwoPlug tpg ;
 public TwoAdapterThree(TwoPlug tpg) {
  this.tpg=tpg;
 }
 @Override
 public void ThreePower() {
  System.out.println("通过转换二相电流在充电");
         tpg.TwoPower();
 }
}

继承：采用继承方式的称为类适配器

特点：通过多重继承不兼容接口，实现对目标接口的匹配，单一的为某个类而实现适配

观察者模式

定义：对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都得到通知并被自动更新。

实现的两种方式：

推模型：目标对象主动向观察者推送目标的详细信息

推送的信息通常是目标对象的全部或部分数据

拉模型：目标对象在通知观察者的时候，只传递少量信息

如果观察者需要更具体的信息，由观察者主动到目标对象中获取，相当于是观 察者从目标对象中拉数据

比较：1.推模型是假定目标对象知道观察者需要的数据

2.拉模型是目标对象不知道观察者具体需要什么数据，因此把自身传递给观察者，由观察者来取值。

package com.subject.odserver;
import java.util.ArrayList;
import java.util.List;
public class WeatherSubject {
  public List<Observer> observers =new ArrayList<Observer>();
 //添加观察者对象
 public void attach(Observer w) {
  observers.add(w);
 }
 //删除观察者对象
 public void detach(Observer observer) {
  observers.remove(observer);
 }
 protected void notifiyObServers() {
  for (Observer observer : observers) {
   observer.update(this);
  }
 }
}

package com.subject.odserver;
public class CreateSubject extends WeatherSubject {
   private String WeatherContext;
public String getWeatherContext() {
 return WeatherContext;
}
public void setWeatherContext(String weatherContext) {
 WeatherContext = weatherContext;
 this.notifiyObServers();
}
}

package com.subject.odserver;
//创建观察者
public interface Observer {
  public void update(WeatherSubject weatherSubject);
}

package com.subject.odserver;
public class WeatherObserver implements Observer {
 private String ObserverName ;
 private String WeatherContext;
 private String ObserverResult;
 public String getObserverName() {
  return ObserverName;
 }
 public void setObserverName(String observerName) {
  ObserverName = observerName;
 }
 public String getWeatherContext() {
  return WeatherContext;
 }
 public void setWeatherContext(String weatherContext) {
  WeatherContext = weatherContext;
 }
 public String getObserverResult() {
  return ObserverResult;
 }
 public void setObserverResult(String observerResult) {
  ObserverResult = observerResult;
 }
 //把观察者自身传递给目标对象
 public void update(WeatherSubject weatherSubject) {
  WeatherContext =((CreateSubject)weatherSubject).getWeatherContext();
  System.out.println(ObserverName+""+WeatherContext+""+ObserverResult);
 }
}

java实现的观察者模式：

package com.subject.observer.java;
import java.util.Observable;
public class WeatherSubject extends Observable {
    private String context ;
 public String getContext() {
  return context;
 }
 public void setContext(String context) {
  this.context = context;
  this.setChanged();
  this.notifyObservers(context);
  //this.notifyObservers();
 }
}

package com.subject.observer.java;
import java.util.Observable;
import java.util.Observer;
public class WeatherObserver implements Observer {
    private String observerName ;
 public String getObserverName() {
  return observerName;
 }
 public void setObserverName(String observerName) {
  this.observerName = observerName;
 }
 @Override
 public void update(Observable o, Object arg) {
       System.out.println(observerName+"推"+arg);
       System.out.println(observerName+"拉"+((WeatherSubject)o).getContext());
 }
}

package com.subject.observer.java;
public class Client {
    public static void main(String[] args) {
  WeatherSubject ws =new WeatherSubject();
  WeatherObserver ob=new WeatherObserver();
  ob.setObserverName("lzz's my father ");
  WeatherObserver wo =new WeatherObserver();
  wo.setObserverName("lzz's my mother ");
  ws.addObserver(ob);
  ws.addObserver(wo);
  ws.setContext("i love you mom and dad ,be care of your healthy ");
 }
}

观察者的优缺点

优点：

1.观察者模式实现了 观察者和目标之间的抽象耦合

2.观察者模式实现了动态联动

3.观察者模式支持广播通信

缺点：

1. 可能会引起无谓的操作

什么时候选用观察者模式：

1.当一个抽象模型有两个方面，其中一个方面的操作依赖于另一个方面的状态变化

2.如果在更改一个对象的时候，需要同时连带改变其他的对象而且不知道究竟应该有多少对象需要被连带改变

3.当一个对象必须通知他的对象，但是你又希望这个对象和其他被它通知的对象是松散耦合的。