设计模式之行为模式
一、概述
1.1 简介
java设计模式的分类中创建模式管理类在jvm中的生成和存在方式，结构模式可以看作是对存在的功能类的增强和延伸，充分利用了面向对象的三大特性：封装、继承、多态。那么个行为模式则是对不同功能类相互引用，相互联系做了示范作用，可以看作是结构模式的典型应用。
二、实例
2.1 父类和子类
总结：1、在抽象类中提供一个公共功能，在其它子类中实现相同方法名、不同作用的功能（方法重写）。2、策略模式是利用接口、模版模式利用了抽象类的抽象方法（和接口一样）。3、利用装饰模式来构建功能模块，查看框架源码可，可以发现很多功能模块都是这么写的。策略模式：//功能public interface ICalculator { public int calculate(String exp);}//公共抽象类public abstract class AbstractCalculator { // 抽象辅助类,提供公共功能 public int[] split(String exp, String opt) { String array[] = exp.split(opt); int arrayInt[] = new int[2]; arrayInt[0] = Integer.parseInt(array[0]); arrayInt[1] = Integer.parseInt(array[1]); return arrayInt; }}//子类实现public class Minus extends AbstractCalculator implements ICalculator { @Override public int calculate(String exp) { int arrayInt[] = split(exp, "\\*"); return arrayInt[0] * arrayInt[1]; }}public class Multiply extends AbstractCalculator implements ICalculator { @Override public int calculate(String exp) { int arrayInt[] = split(exp, "\\+"); return arrayInt[0] + arrayInt[1]; }}//使用public class StrategyTest { public static void main(String[] args) { String exp = "2+8"; ICalculator cal = new Plus(); int result = cal.calculate(exp); System.out.println(result); } //对同类问题的封装，一个抽象类实现公共功能，在利用不同子类实现不同实现功能}模版模式：//公共抽象类public abstract class AbstractCalculator { // 抽象辅助类,提供公共功能 public int[] split(String exp, String opt) { String array[] = exp.split(opt); int arrayInt[] = new int[2]; arrayInt[0] = Integer.parseInt(array[0]); arrayInt[1] = Integer.parseInt(array[1]); return arrayInt; } // 主要方法 public final int calculate(String exp, String opt) { int array[] = split(exp, opt); return calculate(exp, opt); } // 子类重新的方法 public abstract int calculator(int num1, int num2);}//子类public class Minus extends AbstractCalculator { @Override public int calculator(int num1, int num2) { // TODO Auto-generated method stub return num1 * num2; }}public class Multiply extends AbstractCalculator { @Override public int calculator(int num1, int num2) { // TODO Auto-generated method stub return num1 * num2; }}//测试public class StrategyTest { public static void main(String[] args) { String exp = "2+8"; AbstractCalculator avcal = new Plus(); int result = avcal.calculate(exp, "\\+"); System.out.println(result); } // 一个抽象类实现公共功能，利用抽象方法子类必须重写，来实现接口功能，当然可以不写接口} 2.2 多个类之间
总结：这4种模式是java面向对象思想的很经典使用，各大框架都很常用。1.观察者模式：利用一个观察类，存放所有相同接口的子类，当一个类发生变化，进行轮训改变所有的类//观察类接口public interface Subject { // 增加观察者 public void add(Observer observer); // 删除观察者 public void del(Observer observer); // 通知所用的观察者 public void notifyObserver(); // 自身的操作 public void operation();}//观察类public abstract class AbstractSubject implements Subject { private Vector vector = new Vector (); @Override public void add(Observer observer) { //添加 vector.add(observer); } @Override public void del(Observer observer) { // 删除 vector.remove(observer); } @Override public void notifyObserver() { // 轮循 Enumeration enumo = vector.elements(); while (enumo.hasMoreElements()) { enumo.nextElement().update(); } }}//观察类实现public class MySubject extends AbstractSubject { @Override public void operation() { System.out.println("update self!"); //这里可以添加我们需要的改变触发形式 notifyObserver(); }}//相同功能、当然也可以叫做挂载点public interface Observer { public void update();} //具体的子类public class Observer2 implements Observer { @Override public void update() { System.out.println("observer2 has received"); }}public class Observer1 implements Observer { @Override public void update() { System.out.println("observer1 has received"); }}//测试public class ObserverTest { // 观察模式：通过一个观察类实现来遍历通知 public static void main(String[] args) { Subject sub = new MySubject(); sub.add(new Observer1()); sub.add(new Observer2()); sub.operation(); }}2.迭代模式：将公共方法单独拿出来，对原有的功能强化。主要是对一类模块的功能添加// 迭代器功能public interface Interator { // 迭代功能 public Object previous(); // 后移 public Object next(); public boolean hasNext(); // 取得第一个元素 public Object first();}//迭代器实现类：就像java里面的集合，如果需要添加新的公共功能，则可以利用这种方式public class MyIterator implements Interator { private Collection collection; private int pos = -1; // 采用的装饰模式，将聚合类放入 public MyIterator(Collection collection) { this.collection = collection; } @Override public Object previous() { if (pos > 0) { pos--; } return collection.get(pos); } @Override public Object next() { if (pos < collection.size() - 1) { pos++; } return collection.get(pos); } @Override public boolean hasNext() { if (pos < collection.size() - 1) { return true; } else { return false; } } @Override public Object first() { pos = 0; return collection.get(pos); }}//聚集对象public interface Collection { //装饰模式 public Interator iterator(); // 取得集合对象 public Object get(int i); // 集合大小 public int size();}//聚集对象实现public class MyCollection implements Collection { public String string[] = { "A", "B", "C", "D", "E" }; @Override public Interator iterator() { // 用装饰模式，在迭代器中操作功能 // 使用代理模式：在聚合类中实现迭代器 // 只要实现了聚合类必然实现了迭代器 return new MyIterator(this); } @Override public Object get(int i) { return string[i]; } @Override public int size() { return string.length; }}//测试public class Test { public static void main(String[] args) { Collection collection = new MyCollection(); Interator it = collection.iterator(); while (it.hasNext()) { System.out.println(it.next()); } }}3.责任链模式：利用装饰模式(java接口可以当作变量引用)，来相互嵌套//挂载点public interface Handler { public void operater();}//抽象类实现public abstract class AbstractHandler { // 对操作类进行封装 // ？可以直接在子类中封装 private Handler handler; public Handler getHandler() { return handler; } public void setHandler(Handler handler) { this.handler = handler; }}//具体子类public class MyHandler extends AbstractHandler implements Handler { private String name; public MyHandler(String name) { this.name = name; } // 操作 @Override public void operater() { System.out.println(name + "deal!"); if (getHandler() != null) { getHandler().operater(); } }}//测试public class Test { public static void main(String[] args) { MyHandler h1 = new MyHandler("h1"); MyHandler h2 = new MyHandler("h1"); MyHandler h3 = new MyHandler("h1"); // 通过接口引用，将有相方法的类，通过地址链接起来 h1.setHandler(h2); h2.setHandler(h3); h1.operater(); }}// 也可以直接在子类中实现public class MyHandler2 { private String name; // 对操作类进行封装 // ？可以直接在子类中封装 private Handler handler; public Handler getHandler() { return handler; } public void setHandler(Handler handler) { this.handler = handler; } public MyHandler2(String name) { this.name = name; } // 操作 public void operater() { System.out.println(name + "deal!"); if (getHandler() != null) { getHandler().operater(); } }}4.命令模式：讲一个事件的每一个部分都分开实现，然后在相互调用。从而达到相互不影响//命令接口：功能一public interface Command { public void exe(); }//接受者接口：功能二public interface Recevier { public void action();}//执行者接口：功能三public interface Invoker { public void send();}//命令实现public class MyCommand implements Command { private Recevier reciver; // 装饰器 public MyCommand(Recevier reciver) { this.reciver = reciver; } @Override public void exe() { reciver.action(); }}//接受这实现public class FirestReceiver implements Recevier { @Override public void action() { System.out.println(" first: commond reciver!"); }}//发送者实现public class MyInvoker implements Invoker{ // 执行者 private Command command; public MyInvoker(Command command) { this.command = command; } public void send() { command.exe(); }}//测试public class Test { public static void main(String[] args) { Recevier receiver = new FirestReceiver(); Command cmd = new MyCommand(receiver);// 命令 Invoker invoker = new MyInvoker(cmd);// 命令发布者 invoker.send();// 执行 // 先将发布者、命令、接受者都解耦。然后通过装饰器：执行结果 // 和责任模式相似、都是通过对（相同接口）的来相互调用。 }} 2.3 类的状态
主要通过中间类存放类的状态，然后通过状态复制恢复。
2.4 中间类
通过中间类组合来各种功能类，降低不同功能之间的耦合，组合的灵活应用。一般作为框架的主类，包含了不同模块的所有功能。