3. 行为型模式：共包含十一种模式[1]
行为型模式各个关系
3.1 策略模式(strategy)
策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数
/**
* 策略模式
* ICalculator提供同意的方法，
AbstractCalculator是辅助类，
提供辅助方法，接下来，依次实现下每个类：
* @author Administrator
*
*/
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);
}
}
interface ICalculator{
public int calculate(String exp);
}
/**
* 辅助类
* @author Administrator
*
*/
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;
}
}
class Plus extends AbstractCalculator implements ICalculator{
@Override
public int calculate(String exp) {
int arrayInt[]=split(exp, "\\+");
return arrayInt[0]+arrayInt[1];
}
}
class Minus extends AbstractCalculator implements ICalculator {
@Override
public int calculate(String exp) {
int arrayInt[] = split(exp,"-");
return arrayInt[0]-arrayInt[1];
}
}
class Multiply extends AbstractCalculator implements ICalculator {
@Override
public int calculate(String exp) {
int arrayInt[] = split(exp,"\\*");
return arrayInt[0]*arrayInt[1];
}
}
3.2 模板方法模式(Template Method)
一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用
public abstract class AbstractCalculator {
/*主方法，实现对本类其它方法的调用*/
public final int calculate(String exp,String opt){
int array[] = split(exp,opt);
return calculate(array[0],array[1]);
}
/*被子类重写的方法*/
abstract public int calculate(int num1,int num2);
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 Plus extends AbstractCalculator {
@Override
public int calculate(int num1,int num2) {
return num1 + num2;
}
}
public class StrategyTest {
public static void main(String[] args) {
String exp = "8+8";
AbstractCalculator cal = new Plus();
int result = cal.calculate(exp, "\\+");
System.out.println(result);
}
}
3.3 观察者模式(Observer)
当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。
例：
MySubject类就是我们的主对象，Observer1和Observer2是依赖于MySubject的对象，当MySubject变化时，Observer1和Observer2必然变化。AbstractSubject类中定义着需要监控的对象列表，可以对其进行修改：增加或删除被监控对象，且当MySubject变化时，负责通知在列表内存在的对象
public interface Observer {
public void update();
}
public class Observer1 implements Observer {
@Override
public void update() {
System.out.println("observer1 has received!");
}
}
public class Observer2 implements Observer {
@Override
public void update() {
System.out.println("observer2 has received!");
}
}
public interface Subject {
/*增加观察者*/
public void add(Observer observer);
/*删除观察者*/
public void del(Observer observer);
/*通知所有的观察者*/
public void notifyObservers();
/*自身的操作*/
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 notifyObservers() {
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!");
notifyObservers();
}
}
public class ObserverTest {
public static void main(String[] args) {
Subject sub = new MySubject();
sub.add(new Observer1());
sub.add(new Observer2());
sub.operation();
}
}
输出：
update self!
observer1 has received!
observer2 has received!
3.4 责任链模式
有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对象会处理该请求，所以，责任链模式可以实现，在隐瞒客户端的情况下，对系统进行动态的调整。
public class ChainofresponsibilityTest {
public static void main(String[] args) {
ChainofresponsibilityTest c=new ChainofresponsibilityTest();
MyHandler h1=c.new MyHandler("h1");
MyHandler h2=c.new MyHandler("h2");
MyHandler h3=c.new MyHandler("h3");
h1.setHandler(h2);
h2.setHandler(h3);
h2.operator();
}
interface Handler{
public void operator();
}
abstract class AbstractHandler{
private Handler handler;
public Handler getHandler() {
return handler;
}
public void setHandler(Handler handler) {
this.handler = handler;
}
}
class MyHandler extends AbstractHandler implements Handler{
private String name;
public MyHandler(String name) {
this.name=name;
}
@Override
public void operator() {
System.out.println(name+" ===deal");
if (getHandler()!=null) {
getHandler().operator();
}
}
}
}
3.5 命令模式
司令员下令让士兵去干件事情，从整个事情的角度来考虑，司令员的作用是，发出口令，口令经过传递，传到了士兵耳朵里，士兵去执行。这个过程好在，三者相互解耦，任何一方都不用去依赖其他人，只需要做好自己的事儿就行，司令员要的是结果，不会去关注到底士兵是怎么实现的。
例：Invoker是调用者（司令员），Receiver是被调用者（士兵），MyCommand是命令，实现了Command接口，持有接收对象，看实现代码：
public class CommandTest {
public static void main(String[] args) {
CommandTest ct=new CommandTest();
Receiver receiver=ct.new Receiver();
Command c=ct.new MyCommand(receiver);
Invoker invoker=ct.new Invoker(c);
invoker.action();
}
interface Command{
public void exe();
}
class MyCommand implements Command{
private Receiver receiver;
public MyCommand(Receiver receiver) {
super();
this.receiver = receiver;
}
@Override
public void exe() {
receiver.action();
}
}
class Receiver{
public void action(){
System.out.println("reveiver is action");
}
}
class Invoker{
private Command command;
public Invoker(Command command) {
super();
this.command = command;
}
public void action(){
command.exe();
}
}
}
-
策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 ↩
