设计模式小计——23种设计模式2

模板方法模式Template Method Pattern
定义一个操作的算法的框架，是的子类可以不改变算法结构即可重定义该算法一些特定步骤
public abstract class AbstractClass{//抽象模板类
protected abstract void method1();//算法步骤1
protected abstract void method2();//算法步骤2
public void templateMethod(){//模板方法，定义算法结构
this.method1();this.method2();
}
}
public class ConcreateClass extends AbstractClass{//具体模板类
protected void method1(){}
protected void method2(){}
}
封装不变部分(模板方法)，扩展可变部分(算法步骤)
行为由父类控制，子类实现
建造者模式Builder Pattern
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
//产品类
public class Product{
public void method(){}
}
//抽象建造者
public abstract class Builder{
public abstract void setPart();//产品类逻辑处理
public abstract Product buildProduct();
}
//具体建造者
public c1ass ConcreateBulider extends Builder{
private Product product = new Product();
public void setPart(){}
public Product buildProduct(){return product;}
}
//产品构建类
public class Direct{
private Builder builder = new ConcreateBulider();
public Product getAProduct(){//构建不同产品
builder.setPart();
//产品逻辑处理
return builder.buildProduct();
}
}
建造者模式关注的是产品类零件类型和装配顺序，这是它与工厂方法模式最大的不同。
建造者模式最主要的功能是基本方法的调用顺序安排，顺序不同产生对象不同。
代理模式Proxy Pattern
为其他对象提供一种代理以控制对这个对象得访问
其他许多模式，如状态模式，策略模式，访问者模式本质上都是在特殊场合采用得代理模式
//抽象主题类
public interface Subject{
public void request();//定义访问方法
}
//真实主题类
public class ReadSubject extends Subject{
public void request(){}//真实访问方法
}
//代理类
public class Proxy extends Subject{
private Subject subject = null;//要代理的类
public Proxy(Proxy subject){this.subject=subject}//要代理类
public void request(){subject.request();}//代理实现访问

}
职责清晰，高扩展性，智能化
代理模式扩展
普通代理，客户端只能访问代理角色，不能访问真实角色，真实角色在代理类中被创建，无法在客户端单独创建
Subject subject = new SUbject(this,...);//Proxy类
调用者只知代理而不用知道真实角色，屏蔽了真实角色对高层模块得影响
强制代理，通过真实角色查找代理角色，在真实角色类中创建代理对象，在真实角色类的访问方法中检验代理
虚拟代理，在代理类得每个访问方法中判断真实类是否初始化，如没有，则初始化
动态代理，运行阶段才指定代理对象，使用反射机制（重点）
原型模式Prototype Pattern
用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象
核心是实现clone方法，完成对对象得拷贝，实现Cloneable接口，实现clone方法的覆盖（继承自Object）
public class PrototypeClass implements Cloneable{
@Override
public PrototypeClass clone(){
PrototypeClass proto = null;
try{
proto = (PrototypeClass)super.clone();
}catch(CloneNotSupportedException e){}
return proto;
}
}
原型模式是内存二进制流的拷贝，比new一个对象性能好，构造函数不会执行
浅拷贝，深拷贝。Object提供的方法clone只是拷贝对象，其内部的数组，引用对象都不拷贝，还是指向原来的地址。深拷贝可以通过对内部数组，引用进行再次拷贝来实现
中介者模式Mediator Pattern
用一个中介对象封装一系列对象交互，使各对象不需要显示地相互作用，从而使耦合松散，可以独立改变他们之间得交互
//通用抽象中介类
public abstract class Mediator{
protected Colleague1 c1;
protected Colleague2 c2;
//实现setter/getter方法把同事类注入，依赖注入
public abstract void doSomething();
}
//通用中介类
public class ConcreteMediator{
public void doSomething(){
super.c1.method1();
super.c2.method2();
}
}
//抽象同事类
public abstract Colleague(){
protected Mediator mediator;//中介
public Colleague(Mediator mediator){this.mediator=mediator;}
}
//同事类1
public class Colleague1(){
public Colleague1(Mediator mediator){super(mediator);}
public method1(){}//自己的业务逻辑
public depMethod1(){
//内部逻辑
super.mediator.doSomething();//交互业务    
}//中介处理
}
public class Colleague2(){
public Colleague2(Mediator mediator){super(mediator);}
public method2(){}//自己的业务逻辑
}
减少类间依赖，降低类间耦合
命令模式Command Pattern
将请求封装成对象，对请求排队或者写入日志，从而提供撤销恢复功能
//通用Receiver类
public abstract class Receiver{//执行方
public abstract void doSomething();//业务功能
}
//具体Receiver类
public class ConcreteReceiver extends Receiver{//具体执行方
public void doSomething(){}
}
//抽象Command类
public abstract class Command{//抽象命令类
public abstract void execute();//执行命令的方法
}
//具体Command类
public class ConcreateCommand extends Command{//具体命令类
private Receiver receiver;
public ConcreateCommand(Receiver receiver){this.receiver=receiver;}
public void execute(){this.receiver.doSomething();//实现命令}
}
//调用者Invoke类
public class Invoke{
private Command command;
public Invoke(Command command){this.command=command;}
public void action(){this.command.execute();//执行命令}
}
请求方和执行方之间没有任何依赖关系，高度封装
命令易于扩展
命令模式的撤销恢复功能，执行方增加一个rollBack()方法用于对任务进行回滚，同时添加命令的撤销命令，调用回滚方法。