责任链模式Chain of Responsibility
使多个对象都有机会处理请求，从而避免请求的发送者和接受者间的耦合关系，并沿着这条链传递请求，直到有对象处理它为止
责任链模式关键是建立链接关系，在链中决定谁来处理请求
//抽象处理者
public abstract class Handle{
private Handle nextHandle;//链的下一个节点
public final Response handleMessage(Request request){
Response response = null;
if(this.getHandlerLevel().equals(request.getRequestLevel())){
response=this.echo(request);
}
else{
if(this.nextHandle != null){
response = this.nextHandle.handleMessage(request);
}
else{//没有适当处理者，自行处理}
}
return response;
}
public void setNext(Handle handle){this.nextHandle=handle;}
protected abstract Level getHandlerLevel();//每个处理者都有一个处理级别，对应链中位置
protected abstract Response echo(Request request);//每个处理这都有处理任务
}
//处理级别
public class Level{}
//请求类
public class Request{
public Level getRequestLevel(){}//获取请求级别
}
//回显类
public class Response(){}//返回处理后的数据
请求和处理分离，提高系统灵活性
性能不佳，调试不便
装饰模式Decorator Pattern
动态为一个对象添加一些额外的职责
//基本抽象类
public abstract class Component{
public abstract void action();
}
//具体工作类
public class ConcreteComponent extends Component{
@Override
public void action(){}//具体实现方法
}
//抽象装饰类
public Decorator extends Component{
private Component component = null;
public Decorator(Component component){this.component=component;}
@Override
public void action(){
this.component.action();
}
}
//具体装饰类
public ConcreteDecorator extends Component{
public ConcreteDecorator(Component component){super(component);}
private void method(){}//装饰方法
public void action(){//重写父类action方法
this.method();
super.action();
}
}
可以添加多个装饰类，层级嵌套，多层次装饰会提高系统复杂度
装饰模式可以替代继承，解决类膨胀问题
策略模式Strategy Pattern
定义一组算法，将每个算法都封装起来，并且可以使他们之间相互转换
//抽象算法
public interface Strategy{
public void doSomething();
}
//具体算法类
public class ConcreteStrategy implements Strategy{
public void doSomething(){}
}
//封装算法
public class Context{
private Strategy strategy = null;
public Context(Strategy strategy){this.strategy=strategy;}
public void doAnything(){//封装后的算法方法
this.strategy.doSomething();
}
}
适配器模式Adapter Pattern
将一个类的接口变换成客户端期待的另一种接口，从而使原本因接口不匹配而无法一起工作的两个类一起工作
//目标角色
public interface Target{
public void request();//目标方法
}
//实际目标角色
public class ConcreteTarget implements Target{
public void request(){}
}
//源角色
public class Source{
public void method();//源方法
}
//适配器类
public class Adapter extends Source implements Target{
public void request(){
super.method();
}
}
适配器可以让两个没有任何关系的类在一起运行，提高类复用性，灵活性非常高
类对象适配器通过对源角色的继承完成拼接，即extends Source
对象适配器通过对源角色对象的关联完成拼接，即private Source source
适配器模式是一个补救模式，用于解决扩展应用时出现的接口不兼容问题
迭代器模式Iterator Pattern
提供一种方法访问容器对象的各个元素而又不暴露该对象内部细节
//抽象迭代器
public interface Iterator{
public Object next();//遍历到下一个元素
public boolean hasNext();//是否遍历到尾部
public boolean remove();//删除当前指向元素
}
//具体迭代器
public class ConcreteIterator extends Iterator{
private Vector vector = new Vector();
public int cursor = 0;//定义当前游标
public ConcreteIterator(Vector vector){this.vector = vector;}
public boolean hasNext(){
if(this.cursor == this.vector.size()){
return false;
}
return true;
}
public Object next(){
Object result = null;
if(this.hasNext()){
result = this.vector.get(this.cursor++);
}else{
result = null;
}
return result;
}
public boolean remove(){
this.vector.remove(this.cursor);
return true;
}
}
迭代器模式在现代语言中得到广泛应用
组合模式Composite Pattern
将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性
//抽象构件类
public abstract class Component{
public void doSomething(){}//共有业务逻辑
}
//树枝构件
public c1ass Composite extends Component{
private ArrayList<Component> componentArray = new ArrayList<Component>();//构件容器
public void add(Component component){this.componentArray.add(component);}//增删容器
public void remove(Component component){this.componentArray.remove(component);}
pubic ArrayList<Component> getChildren(){
return this.componentArray;
}
}
//树叶构件
pubic class Leaf extends Component{
public void doSomething(){}
}
高层模块调用简单，节点可以自由增加，符合开闭原则
在实际场景中需要直接使用实现类，无法使用抽象，违背依赖倒置原则
观察者模式Observer Pattern
定义对象间一对多的依赖关系，使得每当一个对象改变状态，所有依赖它的对象都得到通知自动更新
//抽象观察者类
public abstract class Observer{
public abstract void update();
}
//具体观察者
public class ConcreteObserver{
public void update(){//}
}
//抽象被观察者
pubic abstract class Subject{
private Vector<Observer> observers = new Vector<Observer>();
public void add(Observer component){this.observers.add(component);}//增删容器
public void remove(Observer component){this.observers.remove(component);}
public void notify(){
for(Observer 0:this.observers){
o.update();
}
}
}
//具体被观察者
public class ConcreteSubject{
public void doSomething(){}//具体业务
}
观察者和被观察者抽象耦合
外观模式Facade Pattern
子系统的外部与其内部通信必须通过一个统一的对象进行，外观模式通过提供一个高层次接口，使得子系统更易于使用
//子系统
pubic class Class1{public void method();}
pubic class Class1{public void method();}
pubic class Class1{public void method();}
//外观对象
public class Facade{
private Class1 c1 = new Class1();
private Class1 c2 = new Class2();
private Class1 c3 = new Class3();
public void method1(){
//子系统业务处理
}
}
和中介者模式很像？中介者模式是让两个类不直接发生关系，而是通过中介者联系，中介者并不偏向于任一方，双方通过中介者互相和另一方发生关系，关系是双向的；外观模式也是让两个类不直接发生关系，但是外观偏向于某一方，另一方通过外观和某一方发生关系，但某一方不一定甚至不会通过外观和另一方发生关系，也就是关系偏向于单向关系
减少系统相互依赖，提高灵活性，安全性。
不符合开闭原则，对修改关闭，对扩展开放
备忘录模式Memento Pattern
在不破坏封装性的前提下，捕获一个对象内部状态。并在该对象之外保存这个状态，一边以后可以将之恢复
根据单一职责原则，备份行为应该交由另一个类来完成
//需要备份类
public class Originator{
private Stirng state = "";//内部状态
public void setState(){this.state = state;}
public void getState(){return this.state;}
public Memento createMemento(){
return new Memento(this.state);
}
public void restoreMemento(Memento memento){
this.setState(memento.getState);
}
}
//备忘录角色,可以保存多个状态
public class Memento{
private String state;
public Memento(String state){this.state = state;}
public void setState(){this.state = state;}
public void getState(){return this.state;}
}
//备忘录管理员角色，可以保存多个备忘录
public class Caretaker{
private Memento memento;
public Memento getMemento(){
return memento;
}
public void setMemento(Memento memento){
this.memento = memento;
}
}
访问者模式Visitor Pattern
封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作
即把操作数据的方法独立封装在单独的类中，使之可以动态修改操作
//抽象元素
pubic abstract class Element{
pubic abstract void doSomething();
public abstract void accept(IVisitor visitor);
}
//具体元素
pubic class ConcreteElement extends Element{
public void doSomething(){}//业务逻辑
public void accept(IVisitor visitor){visitor.visit(this);}
}
//抽象访问者
pubic interface class IVisitor{
pubic void visit(ConcreteElement el);
}
//具体访问者
pubic class Visitor implements IVisitor{
pubic void visit(ConcreateElement el){el.doSomething();}
}
符合单一职责原则，易于扩展，灵活性高
违背依赖倒置原则，访问者依赖具体元素而不是抽象。
具体元素对访问者公布细节，违背迪米特原则
状态模式State Pattern
当一个对象内在状态改变时允许其改变行为，从外部看好像这个对象对应的类发生了改变一样
//抽象状态
pubic abstract class State{
protected Context context;//定义一个环境角色
public void setContext(Context context){this.context=context;}
//行为1
public abstract void Handle1();
//行为2
public abstract void Handle2();
}
//具体状态
pubic class ConcreteState1 extends State{
public void Handle1(){//内部逻辑}
public void Handle2(){
//设置当前状态为state2
super.context.setCurrentState(Context.STATE2);
super.context.handle2();
}
}
pubic class ConcreteState2 extends State{
public void Handle1(){
super.context.setCurrentState(Context.STATE1);
super.context.handle1();
}
public void Handle2(){//内部逻辑}
}
//环境角色
public class Context{
public final static State STATE1 = new ConcreteState1();
public final static State STATE2 = new ConcreteState2();
private State currentState;//当前状态
pubic State getCurrentState(){return currentState;}
public void setCurrentState(State state){
this.currentState=state;
this.currentState.setContext(this);
}
//行为委托
public void Handle1(){
this.currentState.handle1();
}
public void Handle2(){
this.currentState.Handle2();
}}
简化状态判断语句的使用，提高系统可维护性。
遵循开闭原则和单一职责原则
解释器模式Interpreter Pattern
给定一门语言，根据文法表示，定义解释器可以解释语言中句子
享元模式Flyweight Pattern
使用共享对象可有效支持大量细粒度对象
//抽象享元角色
pubic abstract class FlyWeight{
//内部状态
private String intrinsic;
//外部状态
protected final String Extrinsic;
//要求享元角色必须接受外部状态
public FlyWeight(String Extrinsic){
this.Extrinsic=Extrinsic;
}
//定义业务操作
public abstract void operator();
//内部状态getter/setter
}
//具体享元角色
pubic class ConcreteFlyWeight extends FlyWeight{
public ConcreteFlyWeight(String Extrinsic){
super(Extrinsic);
}
pubic void operator(){//业务逻辑}
}
//享元工厂
pubic class FlyWeightFactory{
private static HashMap<String,FlyWeight> pool = new HashMap<String,FlyWeight>();
//享元工厂
public static FlyWeight getFlyWeight(String Extrinsic){
FlyWeight flyweight=null;
if(pool.containsKey(Extrinsic)){
flyweight = pool.get(Extrinsic);
}else{
flyweight = new ConcreteFlyWeight(Extrinsic);
pool.put(Extrinsic,flyweight)l
}
return flyweight;
}
}
桥梁模式Bridge Pattern
将抽象和实现解耦，使得两者可以独立变化
//实现化角色
pubic interface Implementor{
public void doSomething();
}
//具体实现化角色
pubic class ConcreteImplementor{
public void doSomething();
}
//抽象化角色
pubic abstract class Abstraction{
private Implementor imp;//实现化角色引用
pubic Abstraction(Implementor imp){this.imp = imp;}//约束子类必须实现该构造方法
public Implementor getImp(){return imp;}
//自身的行为和属性
public void request(){
this.imp.doSomething();
}
}
//具体抽象化角色
pubic class RefinedAbstraction extends Abstraction{
public RefinedAbstraction(Implementor imp){super(imp);}
//修正父类方法
public void request(){
super.request();
super.getImp().doSomething();
}
}
设计模式小计——23种设计模式3,布布扣,bubuko.com