设计模式之行为模式

摘要: java设计模式之结构模式，可以看作结构模式的一种典型应用，主要是用在不同的功能类之间。设计模式主要追求是功能和功能之间的解耦和代码的高可复用性，这是大型项目的重中之重。

设计模式之行为模式

一、概述

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<Observer> vector = new Vector<Observer>();
@Override
public void add(Observer observer) {
//添加
vector.add(observer);

}
@Override
public void del(Observer observer) {
// 删除
vector.remove(observer);
}
@Override
public void notifyObserver() {
// 轮循
Enumeration<Observer> 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 中间类

通过中间类组合来各种功能类，降低不同功能之间的耦合，组合的灵活应用。一般作为框架的主类，包含了不同模块的所有功能。