常用的设计模式

@[toc] #设计模式

##单例模式

Double Check Lock

public static Singleton getInstance(){
  if(mInstance == null){
    synchronized(Singleton.class){
      if(mInstance == null){
        mInstance = new Singleton();
      }
    }
  }
  retuen mInstance;
}

静态内部类

  public static Singleton getInstance(){
    retuen SingletonHolder.sInstance;
  }

  private static class SingletonHolder{
    private static final Singleton sInstance = new Singleton();
  }

##Builder模式

存储参数
设置参数，return this
new 对象，传递参数
返回

##原型模式

使用
- 重写clone()
- 浅拷贝：拷贝对象无法修改原型对象的字段，保证了安全性（除了引用型字段，多以也要拷贝引用性字段）
- 深拷贝：对拷贝对象的引用型字段也要拷贝

工厂方法模式

//抽象产品类
public abstract class Dialog(){
  public abstract void show();
}

public class DialogA extends Dialog{
  @Override
  public void show(){
    //showA
  }
}

//抽象工厂
public abstract class Factory{
  public abstract <T extends Dialog>T createDialog(Class<T> clazz);
}

public class DialogAFactory extends Factory{
  public <T extends Dialog>T createDialog(Class<T> clazz){
    Dialog dialog = null;
    try{
      dialog = (Dialog)Class.forName(clazz.getName()).newInstance();
    }catch(Exception e){
      ...
    }
    return (T)dialog;
    
  }
} 

//使用
public static void main(String[] args){
  Factory factory = new DialogFactory();
  DialogA a = factory.createDialog(DialogA.class);
  a.show();
}

抽象工厂模式

角色
- 抽身产品接口
- 具体产品类
- 抽象工厂类
- 具体工厂类：每一个产品不同组成不同具体工厂
面向接口编程，但是工厂类过多，不易拓展

策略模式

角色
- 策略的抽象
- 具体的策略实现
- 操作策略的具体实现
代码

//策略抽象接口
public interface CalculateStrategy{
  int calculatePrice(int km);
}
//具体策略
public class BusStrategy implements CalculateStrategy{
  
  @Override
  public int calculatePrice(int km){
    //...
    return busPrice;
  }
  
}

//Context角色
public class Context{
 	private CalculateStrategy cs;
  	public void seCalculateStrategy(CalculateStrategy cs){
      this.cs = cs;
  	}
  
  	public int calculatePrice(int km){
      return cs.calculatePrice(km);
  	}
  	
  	public static void main(String[] args){
      Context context = new Context();
      context.setCalculateStrategy(new BusStrategy());
      context.calculatePrice(15);
  	}
  
}

状态模式

角色
- 抽象状态类或接口：设置状态下的行为
- 具体状态类或接口：不同状态不同行为
- Context环境类
代码:

//抽象状态：定义行为
public interface UserState{
	public void forward();
  	
  	public void comment();
}

//具体状态：已登录
public class LoginedState implements UserState{
  @Override
  public void forward(){
    //转发
  }
  public void comment(){
    //评论
  }
}

//具体状态：未登录
public class LogoutState implements UserState{
  @Override
  public void forward(){
    //去登陆
  }
  public void comment(){
    //去登陆
  }
}
//使用
public class LoginContext{
  private UserState mUserState = new LogoutState();
  private LoginContext(){}
  
  private static LoginContext mLoginContext = new LoginContext();
  public static LoginContext getInstance(){
    return mLoginContext();
  }
  
  public void setState(UserState userState){
    mUserState = userState;
  }
  
  public void forward(){
    mUserState.forward();
  }
  public void comment(){
    mUserState.comment();
  }
  
}

责任链模式

角色
- 抽象处理者
- 抽象请求者
- 具体处理者
- 具体请求者
代码

//抽象处理者
public abstract class AbstractHandler{
  protect AbstractHandler nextHandler;
  
  public final void handleRequest(AbstractRequest request){
    if(getHandlerLevel() == request.getRequestLevel()){
    	handleRequest(request);
    }else{
      if(nextHandler != null){
        nextHandler.handleRequest(request);
      }else{
        System.out.println("All of handler can not handle the request");
      }
    }
    
  }
  
  protected abstract int getHandlerLevel();
  protected abstract void handleRequest(AbstractRequest request);
  
}

//抽象请求者
public abstract class AbstractRequest{
  private Object obj;
  public AbstractRequest (Object obj){
    this.obj = obj;
  }
  
  public Object getContent(){
    return obj;
  }
  public abstract int getRequestLevel();
  
}

//具体处理者
public class Handler1 extends AbstractHandler{
  @Override
  protected int getHandleLevel(){
    return 1;
  }
  
  @Override
  protected void handleRequest(AbstractRequest request){
    System.out.println("handler1 handle the request!"+request.getRequestLevel);
  }
  
}

//具体请求者
public class Request1 extends AbstractRequest{
  public Request1(Object obj){
    super(obj);
  }
  
  @Override
  public int getReqestLevel(){
    return 1;
  }
}

//使用
public static void main(String[] args){
  AbstractHandler handler1 = new Handler1();
  AbstractHandler handler2 = new Handler2();

  handler1.nextHandler = handler2;
  handler1.handlerRequest(new Request1("Request1"));
}

解释器模式

角色
- 抽象表达式，抽象的解释方法
- 终结符表达式
- 非终结符表达式
- 环境类Context
- 客户类Client
一般很少用

命令模式

角色
- 接收者，具体逻辑
- 命令抽象接口
- 具体命令
- 请求者
- 客户端
将请求封装成一个对象，从而使用不同请求把客户端参数化：取消、日志、事务

观察者模式

角色
- 抽象主题，被观察者Observable
- 具体主题，Concrete Observable
- 抽象观察者，Obsever
- 具体观察者
对象间一种一对多的依赖关系，每当一个对象改变状态，则所有依赖于它的对象都会通知并被自动更新
代码：

//具体主题
public class Website extends Observable{
  public void postNewPublication(String content){
    setChanged();
    notifyObserver(content);
  }
}

//具体观察者
public class Subscriber extends Observer{
  @Override
	public void update(observable 0,Object content){
      System.out.println("更新的内容是："+content);
	}
}

//使用
main：
  	Website web = new Website();
	Subscriber sub = new Subscriber();
	web.addObserver(sub);
	web.postNewPublication("内容更新了！");