【持续更新】简单记录一下常用的设计模式

设计模式
单例模式

Builder模式

原型模式

工厂方法模式

抽象工厂模式

策略模式

状态模式

责任链模式

解释器模式

命令模式

观察者模式

设计模式

单例模式

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
4000
(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("内容更新了！");