行为型模式概述（行为型模式的分类）

行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。

行为型模式分为类行为模式和对象行为模式，前者采用继承机制来在类间分派行为，后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象行为模式比类行为模式具有更大的灵活性。

行为型模式是 GoF 设计模式中最为庞大的一类，它包含以下 11 种模式。

1. 模板方法（Template Method）模式：定义一个操作中的算法骨架，将算法的一些步骤延迟到子类中，使得子类在可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
2. 策略（Strategy）模式：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。
3. 命令（Command）模式：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。
4. 职责链（Chain of Responsibility）模式：把请求从链中的一个对象传到下一个对象，直到请求被响应为止。通过这种方式去除对象之间的耦合。
5. 状态（State）模式：允许一个对象在其内部状态发生改变时改变其行为能力。
6. 观察者（Observer）模式：多个对象间存在一对多关系，当一个对象发生改变时，把这种改变通知给其他多个对象，从而影响其他对象的行为。
7. 中介者（Mediator）模式：定义一个中介对象来简化原有对象之间的交互关系，降低系统中对象间的耦合度，使原有对象之间不必相互了解。
8. 迭代器（Iterator）模式：提供一种方法来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。
9. 访问者（Visitor）模式：在不改变集合元素的前提下，为一个集合中的每个元素提供多种访问方式，即每个元素有多个访问者对象访问。
10. 备忘录（Memento）模式：在不破坏封装性的前提下，获取并保存一个对象的内部状态，以便以后恢复它。
11. 解释器（Interpreter）模式：提供如何定义语言的文法，以及对语言句子的解释方法，即解释器。

以上 11 种行为型模式，除了模板方法模式和解释器模式是类行为型模式，其他的全部属于对象行为型模式，下面我们将详细介绍它们的特点、结构与应用。

13.模板方法模式

在面向对象程序设计过程中，程序员常常会遇到这种情况：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。

例如，去银行办理业务一般要经过以下4个流程：取号、排队、办理具体业务、对银行工作人员进行评分等，其中取号、排队和对银行工作人员进行评分的业务对每个客户是一样的，可以在父类中实现，但是办理具体业务却因人而异，它可能是存款、取款或者转账等，可以延迟到子类中实现。

这样的例子在生活中还有很多，例如，一个人每天会起床、吃饭、做事、睡觉等，其中“做事”的内容每天可能不同。我们把这些规定了流程或格式的实例定义成模板，允许使用者根据自己的需求去更新它，例如，简历模板、论文模板、Word 中模板文件等。

以下介绍的模板方法模式将解决以上类似的问题。

模式的定义与特点

模板方法（Template Method）模式的定义如下：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。它是一种类行为型模式。

该模式的主要优点如下。

1. 它封装了不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。
2. 它在父类中提取了公共的部分代码，便于代码复用。
3. 部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。

该模式的主要缺点如下。

1. 对每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大，设计也更加抽象。
2. 父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构，它提高了代码阅读的难度。

模式的结构与实现

模板方法模式需要注意抽象类与具体子类之间的协作。它用到了虚函数的多态性技术以及“不用调用我，让我来调用你”的反向控制技术。现在来介绍它们的基本结构。

1. 模式的结构

模板方法模式包含以下主要角色。

(1) 抽象类（Abstract Class）：负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。这些方法的定义如下。

① 模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。

② 基本方法：是整个算法中的一个步骤，包含以下几种类型。

• 抽象方法：在抽象类中申明，由具体子类实现。
• 具体方法：在抽象类中已经实现，在具体子类中可以继承或重写它。
• 钩子方法：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。

(2) 具体子类（Concrete Class）：实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的一个组成步骤。

模板方法模式的结构图如图 1 所示。

图1 模板方法模式的结构图

2. 模式的实现

模板方法模式的代码如下：

package templateMethod;
public class TemplateMethodPattern
 {
    public static void main(String[] args)
    {
        AbstractClass tm=new ConcreteClass();
        tm.TemplateMethod();
    }
}
 //抽象类
 abstract class AbstractClass
 {
     public void TemplateMethod() //模板方法
     {
         SpecificMethod();
         abstractMethod1();
         abstractMethod2();
     }
     public void SpecificMethod() //具体方法
     {
         System.out.println("抽象类中的具体方法被调用...");
     }
     public abstract void abstractMethod1(); //抽象方法1
     public abstract void abstractMethod2(); //抽象方法2
 }
 //具体子类
 class ConcreteClass extends AbstractClass
 {
     public void abstractMethod1()
     {
         System.out.println("抽象方法1的实现被调用...");
     }
     public void abstractMethod2()
     {
         System.out.println("抽象方法2的实现被调用...");
     }
 }

程序的运行结果如下：
抽象类中的具体方法被调用…
抽象方法1的实现被调用…
抽象方法2的实现被调用…

模式的应用实例

【例1】用模板方法模式实现出国留学手续设计程序。

分析：出国留学手续一般经过以下流程：索取学校资料，提出入学申请，办理因私出国护照、出境卡和公证，申请签证，体检、订机票、准备行装，抵达目标学校等，其中有些业务对各个学校是一样的，但有些业务因学校不同而不同，所以比较适合用模板方法模式来实现。

在本实例中，我们先定义一个出国留学的抽象类 StudyAbroad，里面包含了一个模板方法 TemplateMethod()，该方法中包含了办理出国留学手续流程中的各个基本方法，其中有些方法的处理由于各国都一样，所以在抽象类中就可以实现，但有些方法的处理各国是不同的，必须在其具体子类（如美国留学类 StudyInAmerica）中实现。如果再增加一个国家，只要增加一个子类就可以了，图 2 所示是其结构图。

图2 出国留学手续设计程序的结构图

程序代码如下：

package templateMethod;
public class StudyAbroadProcess
{
    public static void main(String[] args)
    {
        StudyAbroad tm=new StudyInAmerica();
        tm.TemplateMethod();
    }
}
//抽象类: 出国留学
abstract class StudyAbroad
{
    public void TemplateMethod() //模板方法
    {
        LookingForSchool(); //索取学校资料
        ApplyForEnrol();    //入学申请      
        ApplyForPassport(); //办理因私出国护照、出境卡和公证
        ApplyForVisa();     //申请签证
        ReadyGoAbroad();    //体检、订机票、准备行装
        Arriving();         //抵达
    }
    public void ApplyForPassport()
    {
        System.out.println("三.办理因私出国护照、出境卡和公证：");
        System.out.println("  1）持录取通知书、本人户口簿或身份证向户口所在地公安机关申请办理因私出国护照和出境卡。");
        System.out.println("  2）办理出生公证书，学历、学位和成绩公证，经历证书，亲属关系公证，经济担保公证。");
    }
    public void ApplyForVisa()
    {
        System.out.println("四.申请签证：");
        System.out.println("  1）准备申请国外境签证所需的各种资料，包括个人学历、成绩单、工作经历的证明；个人及家庭收入、资金和财产证明；家庭成员的关系证明等；");
        System.out.println("  2）向拟留学国家驻华使(领)馆申请入境签证。申请时需按要求填写有关表格，递交必需的证明材料，缴纳签证。有的国家(比如美国、英国、加拿大等)在申请签证时会要求申请人前往使(领)馆进行面试。");
    }
    public void ReadyGoAbroad()
    {
        System.out.println("五.体检、订机票、准备行装：");
        System.out.println("  1）进行身体检查、免疫检查和接种传染病疫苗；");
        System.out.println("  2）确定机票时间、航班和转机地点。");
    }
    public abstract void LookingForSchool();//索取学校资料
    public abstract void ApplyForEnrol();   //入学申请
    public abstract void Arriving();        //抵达
}
//具体子类: 美国留学
class StudyInAmerica extends StudyAbroad
{
    @Override
    public void LookingForSchool()
    {
        System.out.println("一.索取学校以下资料：");
        System.out.println("  1）对留学意向国家的政治、经济、文化背景和教育体制、学术水平进行较为全面的了解；");
        System.out.println("  2）全面了解和掌握国外学校的情况，包括历史、学费、学制、专业、师资配备、教学设施、学术地位、学生人数等；");
        System.out.println("  3）了解该学校的住宿、交通、医疗保险情况如何；");
        System.out.println("  4）该学校在中国是否有授权代理招生的留学中介公司？");
        System.out.println("  5）掌握留学签证情况；");
        System.out.println("  6）该国政府是否允许留学生合法打工？");
        System.out.println("  8）毕业之后可否移民？");
        System.out.println("  9）文凭是否受到我国认可？");
    }
    @Override
    public void ApplyForEnrol()
    {
        System.out.println("二.入学申请：");
        System.out.println("  1）填写报名表；");
        System.out.println("  2）将报名表、个人学历证明、最近的学习成绩单、推荐信、个人简历、托福或雅思语言考试成绩单等资料寄往所申请的学校；");
        System.out.println("  3）为了给签证办理留有充裕的时间，建议越早申请越好，一般提前1年就比较从容。");
    }
    @Override
    public void Arriving()
    {
        System.out.println("六.抵达目标学校：");
        System.out.println("  1）安排住宿；");
        System.out.println("  2）了解校园及周边环境。");
    }
}

程序的运行结果如下：
一.索取学校以下资料：
1）对留学意向国家的政治、经济、文化背景和教育体制、学术水平进行较为全面的了解；
2）全面了解和掌握国外学校的情况，包括历史、学费、学制、专业、师资配备、教学设施、学术地位、学生人数等；
3）了解该学校的住宿、交通、医疗保险情况如何；
4）该学校在中国是否有授权代理招生的留学中介公司？
5）掌握留学签证情况；
6）该国政府是否允许留学生合法打工？
8）毕业之后可否移民？
9）文凭是否受到我国认可？
二.入学申请：
1）填写报名表；
2）将报名表、个人学历证明、最近的学习成绩单、推荐信、个人简历、托福或雅思语言考试成绩单等资料寄往所申请的学校；
3）为了给签证办理留有充裕的时间，建议越早申请越好，一般提前1年就比较从容。
三.办理因私出国护照、出境卡和公证：
1）持录取通知书、本人户口簿或身份证向户口所在地公安机关申请办理因私出国护照和出境卡。
2）办理出生公证书，学历、学位和成绩公证，经历证书，亲属关系公证，经济担保公证。
四.申请签证：
1）准备申请国外境签证所需的各种资料，包括个人学历、成绩单、工作经历的证明；个人及家庭收入、资金和财产证明；家庭成员的关系证明等；
2）向拟留学国家驻华使(领)馆申请入境签证。申请时需按要求填写有关表格，递交必需的证明材料，缴纳签证。有的国家(比如美国、英国、加拿大等)在申请签证时会要求申请人前往使(领)馆进行面试。
五.体检、订机票、准备行装：
1）进行身体检查、免疫检查和接种传染病疫苗；
2）确定机票时间、航班和转机地点。
六.抵达目标学校：
1）安排住宿；
2）了解校园及周边环境。

模式的应用场景

模板方法模式通常适用于以下场景。

1. 算法的整体步骤很固定，但其中个别部分易变时，这时候可以使用模板方法模式，将容易变的部分抽象出来，供子类实现。
2. 当多个子类存在公共的行为时，可以将其提取出来并集中到一个公共父类中以避免代码重复。首先，要识别现有代码中的不同之处，并且将不同之处分离为新的操作。最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。
3. 当需要控制子类的扩展时，模板方法只在特定点调用钩子操作，这样就只允许在这些点进行扩展。

模式的扩展

在模板方法模式中，基本方法包含：抽象方法、具体方法和钩子方法，正确使用“钩子方法”可以使得子类控制父类的行为。如下面例子中，可以通过在具体子类中重写钩子方法 HookMethod1() 和 HookMethod2() 来改变抽象父类中的运行结果，其结构图如图 3 所示。

图3 含钩子方法的模板方法模式的结构图

程序代码如下：

package templateMethod;
public class HookTemplateMethod
{
    public static void main(String[] args)
    {
        HookAbstractClass tm=new HookConcreteClass();
        tm.TemplateMethod();
    }
}
//含钩子方法的抽象类
abstract class HookAbstractClass
{
    public void TemplateMethod() //模板方法
    {
        abstractMethod1();
        HookMethod1();
        if(HookMethod2())
        {
            SpecificMethod();
        }
        abstractMethod2();
    }
    public void SpecificMethod() //具体方法
    {
        System.out.println("抽象类中的具体方法被调用...");
    }
    public void HookMethod1(){}  //钩子方法1
    public boolean HookMethod2() //钩子方法2
    {
        return true;
    }
    public abstract void abstractMethod1(); //抽象方法1
    public abstract void abstractMethod2(); //抽象方法2
}
//含钩子方法的具体子类
class HookConcreteClass extends HookAbstractClass
{
    public void abstractMethod1()
    {
        System.out.println("抽象方法1的实现被调用...");
    }
    public void abstractMethod2()
    {
        System.out.println("抽象方法2的实现被调用...");
    }
    public void HookMethod1()
    {
        System.out.println("钩子方法1被重写...");
    }
    public boolean HookMethod2()
    {
        return false;
    }
}

程序的运行结果如下：
抽象方法1的实现被调用…
钩子方法1被重写…
抽象方法2的实现被调用…

14.策略模式

在现实生活中常常遇到实现某种目标存在多种策略可供选择的情况，例如，出行旅游可以乘坐飞机、乘坐火车、骑自行车或自己开私家车等，超市促销可以釆用打折、送商品、送积分等方法。

在软件开发中也常常遇到类似的情况，当实现某一个功能存在多种算法或者策略，我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能，如数据排序策略有冒泡排序、选择排序、插入排序、二叉树排序等。

如果使用多重条件转移语句实现（即硬编码），不但使条件语句变得很复杂，而且增加、删除或更换算法要修改原代码，不易维护，违背开闭原则。如果采用策略模式就能很好解决该问题。

策略模式的定义与特点

策略（Strategy）模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。

策略模式的主要优点如下。

1. 多重条件语句不易维护，而使用策略模式可以避免使用多重条件语句。
2. 策略模式提供了一系列的可供重用的算法族，恰当使用继承可以把算法族的公共代码转移到父类里面，从而避免重复的代码。
3. 策略模式可以提供相同行为的不同实现，客户可以根据不同时间或空间要求选择不同的。
4. 策略模式提供了对开闭原则的完美支持，可以在不修改原代码的情况下，灵活增加新算法。
5. 策略模式把算法的使用放到环境类中，而算法的实现移到具体策略类中，实现了二者的分离。

其主要缺点如下。

1. 客户端必须理解所有策略算法的区别，以便适时选择恰当的算法类。
2. 策略模式造成很多的策略类。

策略模式的结构与实现

策略模式是准备一组算法，并将这组算法封装到一系列的策略类里面，作为一个抽象策略类的子类。策略模式的重心不是如何实现算法，而是如何组织这些算法，从而让程序结构更加灵活，具有更好的维护性和扩展性，现在我们来分析其基本结构和实现方法。

1. 模式的结构

策略模式的主要角色如下。

1. 抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。
2. 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。
3. 环境（Context）类：持有一个策略类的引用，最终给客户端调用。

其结构图如图 1 所示。

图1 策略模式的结构图

2. 模式的实现

策略模式的实现代码如下：

package strategy;
public class StrategyPattern {
    public static void main(String[] args) {
        Context c = new Context();
        Strategy s = new ConcreteStrategyA();
        c.setStrategy(s);
        c.strategyMethod();
        System.out.println("-----------------");
        s = new ConcreteStrategyB();
        c.setStrategy(s);
        c.strategyMethod();
    }
}
//抽象策略类
interface Strategy {
    public void strategyMethod(); //策略方法
}
//具体策略类A
class ConcreteStrategyA implements Strategy {
    public void strategyMethod() {
        System.out.println("具体策略A的策略方法被访问！");
    }
}
//具体策略类B
class ConcreteStrategyB implements Strategy {
    public void strategyMethod() {
        System.out.println("具体策略B的策略方法被访问！");
    }
}
//环境类
class Context {
    private Strategy strategy;
    public Strategy getStrategy() {
        return strategy;
    }
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    public void strategyMethod() {
        strategy.strategyMethod();
    }
}

程序运行结果如下：

具体策略A的策略方法被访问！

具体策略B的策略方法被访问！

策略模式的应用实例

【例1】策略模式在“大闸蟹”做菜中的应用。

分析：关于大闸蟹的做法有很多种，我们以清蒸大闸蟹和红烧大闸蟹两种方法为例，介绍策略模式的应用。

首先，定义一个大闸蟹加工的抽象策略类（CrabCooking），里面包含了一个做菜的抽象方法 CookingMethod()；然后，定义清蒸大闸蟹（SteamedCrabs）和红烧大闸蟹（BraisedCrabs）的具体策略类，它们实现了抽象策略类中的抽象方法；由于本程序要显示做好的结果图（点此下载要显示的结果图），所以将具体策略类定义成 JLabel 的子类；最后，定义一个厨房（Kitchen）环境类，它具有设置和选择做菜策略的方法；客户类通过厨房类获取做菜策略，并把做菜结果图在窗体中显示出来，图 2 所示是其结构图。

图2 大闸蟹做菜策略的结构图

程序代码如下：

package strategy;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class CrabCookingStrategy implements ItemListener
{
private JFrame f;
private JRadioButton qz,hs;
private JPanel CenterJP,SouthJP;
private Kitchen cf;    //厨房
private CrabCooking qzx,hsx;    //大闸蟹加工者   
CrabCookingStrategy()
{
f=new JFrame("策略模式在大闸蟹做菜中的应用");
f.setBounds(100,100,500,400);
f.setVisible(true);
f.setResizable(false);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
SouthJP=new JPanel();
CenterJP=new JPanel();
f.add("South",SouthJP);
f.add("Center",CenterJP);
qz=new JRadioButton("清蒸大闸蟹");
hs=new JRadioButton("红烧大闸蟹");
qz.addItemListener(this);
hs.addItemListener(this);
ButtonGroup group=new ButtonGroup();
group.add(qz);
group.add(hs);
SouthJP.add(qz);
SouthJP.add(hs);
//---------------------------------
cf=new Kitchen();    //厨房
qzx=new SteamedCrabs();    //清蒸大闸蟹类
hsx=new BraisedCrabs();    //红烧大闸蟹类
}
public void itemStateChanged(ItemEvent e)
{
JRadioButton jc=(JRadioButton) e.getSource();
if(jc==qz)
{
cf.setStrategy(qzx);
cf.CookingMethod(); //清蒸
}
else if(jc==hs)
{
cf.setStrategy(hsx);
cf.CookingMethod(); //红烧
}
CenterJP.removeAll();
CenterJP.repaint();
CenterJP.add((Component)cf.getStrategy());
f.setVisible(true);
}
public static void main(String[] args)
{
new CrabCookingStrategy();
}
}
//抽象策略类：大闸蟹加工类
interface CrabCooking
{
public void CookingMethod();    //做菜方法
}
//具体策略类：清蒸大闸蟹
class SteamedCrabs extends JLabel implements CrabCooking
{
private static final long serialVersionUID=1L;
public void CookingMethod()
{
this.setIcon(new ImageIcon("src/strategy/SteamedCrabs.jpg"));
this.setHorizontalAlignment(CENTER);
}
}
//具体策略类：红烧大闸蟹
class BraisedCrabs extends JLabel implements CrabCooking
{
private static final long serialVersionUID=1L;
public void CookingMethod()
{
this.setIcon(new ImageIcon("src/strategy/BraisedCrabs.jpg"));
this.setHorizontalAlignment(CENTER);
}
}
//环境类：厨房
class Kitchen
{
private CrabCooking strategy;    //抽象策略
public void setStrategy(CrabCooking strategy)
{
this.strategy=strategy;
}
public CrabCooking getStrategy()
{
return strategy;
}
public void CookingMethod()
{
strategy.CookingMethod();    //做菜   
}
}

程序运行结果如图 3 所示。

图3 大闸蟹做菜结果

【例2】用策略模式实现从韶关去婺源旅游的出行方式。

分析：从韶关去婺源旅游有以下几种出行方式：坐火车、坐汽车和自驾车，所以该实例用策略模式比较适合，图 4 所示是其结构图。

图4 婺源旅游结构图

策略模式的应用场景

策略模式在很多地方用到，如 Java SE 中的容器布局管理就是一个典型的实例，Java SE 中的每个容器都存在多种布局供用户选择。在程序设计中，通常在以下几种情况中使用策略模式较多。

1. 一个系统需要动态地在几种算法中选择一种时，可将每个算法封装到策略类中。
2. 一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现，可将每个条件分支移入它们各自的策略类中以代替这些条件语句。
3. 系统中各算法彼此完全独立，且要求对客户隐藏具体算法的实现细节时。
4. 系统要求使用算法的客户不应该知道其操作的数据时，可使用策略模式来隐藏与算法相关的数据结构。
5. 多个类只区别在表现行为不同，可以使用策略模式，在运行时动态选择具体要执行的行为。

策略模式的扩展

在一个使用策略模式的系统中，当存在的策略很多时，客户端管理所有策略算法将变得很复杂，如果在环境类中使用策略工厂模式来管理这些策略类将大大减少客户端的工作复杂度，其结构图如图 5 所示。

图5 策略工厂模式的结构图

15.命令模式

在软件开发系统中，常常出现“方法的请求者”与“方法的实现者”之间存在紧密的耦合关系。这不利于软件功能的扩展与维护。例如，想对行为进行“撤销、重做、记录”等处理都很不方便，因此“如何将方法的请求者与方法的实现者解耦？”变得很重要，命令模式能很好地解决这个问题。

在现实生活中，这样的例子也很多，例如，电视机遥控器（命令发送者）通过按钮（具体命令）来遥控电视机（命令接收者），还有计算机键盘上的“功能键”等。

命令模式的定义与特点

命令（Command）模式的定义如下：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行储存、传递、调用、增加与管理。

命令模式的主要优点如下。

1. 降低系统的耦合度。命令模式能将调用操作的对象与实现该操作的对象解耦。
2. 增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，它满足“开闭原则”，对扩展比较灵活。
3. 可以实现宏命令。命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令。
4. 方便实现 Undo 和 Redo 操作。命令模式可以与后面介绍的备忘录模式结合，实现命令的撤销与恢复。

其缺点是：可能产生大量具体命令类。因为计对每一个具体操作都需要设计一个具体命令类，这将增加系统的复杂性。

命令模式的结构与实现

可以将系统中的相关操作抽象成命令，使调用者与实现者相关分离，其结构如下。

1. 模式的结构

命令模式包含以下主要角色。

1. 抽象命令类（Command）角色：声明执行命令的接口，拥有执行命令的抽象方法 execute()。
2. 具体命令角色（Concrete Command）角色：是抽象命令类的具体实现类，它拥有接收者对象，并通过调用接收者的功能来完成命令要执行的操作。
3. 实现者/接收者（Receiver）角色：执行命令功能的相关操作，是具体命令对象业务的真正实现者。
4. 调用者/请求者（Invoker）角色：是请求的发送者，它通常拥有很多的命令对象，并通过访问命令对象来执行相关请求，它不直接访问接收者。

其结构图如图 1 所示。

图1 命令模式的结构图

2. 模式的实现

命令模式的代码如下：

 package command;
 public class CommandPattern
 {
 public static void main(String[] args)
 {
 Command cmd=new ConcreteCommand();
 Invoker ir=new Invoker(cmd);
 System.out.println("客户访问调用者的call()方法...");
 ir.call();
 }
 }
 //调用者
 class Invoker
 {
 private Command command;
 public Invoker(Command command)
 {
 this.command=command;
 }
 public void setCommand(Command command)
 {
 this.command=command;
 }
 public void call()
 {
 System.out.println("调用者执行命令command...");
 command.execute();
 }
 }
 //抽象命令
 interface Command
 {
 public abstract void execute();
 }
 //具体命令
 class ConcreteCommand implements Command
 {
 private Receiver receiver;
 ConcreteCommand()
 {
 receiver=new Receiver();
 }
 public void execute()
 {
 receiver.action();
 }
 }
 //接收者
 class Receiver
 {
 public void action()
 {
 System.out.println("接收者的action()方法被调用...");
 }
 }

程序的运行结果如下：
客户访问调用者的call()方法…
调用者执行命令command…
接收者的action()方法被调用…

命令模式的应用实例

【例1】用命令模式实现客户去餐馆吃早餐的实例。

分析：客户去餐馆可选择的早餐有肠粉、河粉和馄饨等，客户可向服务员选择以上早餐中的若干种，服务员将客户的请求交给相关的厨师去做。这里的点早餐相当于“命令”，服务员相当于“调用者”，厨师相当于“接收者”，所以用命令模式实现比较合适。

首先，定义一个早餐类（Breakfast），它是抽象命令类，有抽象方法 cooking()，说明要做什么；再定义其子类肠粉类（ChangFen）、馄饨类（HunTun）和河粉类（HeFen），它们是具体命令类，实现早餐类的 cooking() 方法，但它们不会具体做，而是交给具体的厨师去做；具体厨师类有肠粉厨师（ChangFenChef）、馄蚀厨师（HunTunChef）和河粉厨师（HeFenChef），他们是命令的接收者，由于本实例要显示厨师做菜的效果图（点此下载要显示的效果图），所以把每个厨师类定义为 JFrame 的子类；最后，定义服务员类（Waiter），它接收客户的做菜请求，并发出做菜的命令。客户类是通过服务员类来点菜的，图 2 所示是其结构图。

图2 客户在餐馆吃早餐的结构图

程序代码如下：

package command;
import javax.swing.*;
public class CookingCommand
{
public static void main(String[] args)
{
Breakfast food1=new ChangFen();
Breakfast food2=new HunTun();
Breakfast food3=new HeFen();
Waiter fwy=new Waiter();
fwy.setChangFen(food1);//设置肠粉菜单
fwy.setHunTun(food2);  //设置河粉菜单
fwy.setHeFen(food3);   //设置馄饨菜单
fwy.chooseChangFen();  //选择肠粉
fwy.chooseHeFen();     //选择河粉
fwy.chooseHunTun();    //选择馄饨
}
}
//调用者：服务员
class Waiter
{
private Breakfast changFen,hunTun,heFen;
public void setChangFen(Breakfast f)
{
changFen=f;
}
public void setHunTun(Breakfast f)
{
hunTun=f;
}
public void setHeFen(Breakfast f)
{
heFen=f;
}
public void chooseChangFen()
{
changFen.cooking();
}
public void chooseHunTun()
{
hunTun.cooking();
}
public void chooseHeFen()
{
heFen.cooking();
}
}
//抽象命令：早餐
interface Breakfast
{
public abstract void cooking();
}
//具体命令：肠粉
class ChangFen implements Breakfast
{
private ChangFenChef receiver;
ChangFen()
{
receiver=new ChangFenChef();
}
public void cooking()
{
receiver.cooking();
}
}
//具体命令：馄饨
class HunTun implements Breakfast
{
private HunTunChef receiver;
HunTun()
{
receiver=new HunTunChef();
}
public void cooking()
{
receiver.cooking();
}
}
//具体命令：河粉
class HeFen implements Breakfast
{
private HeFenChef receiver;
HeFen()
{
receiver=new HeFenChef();
}
public void cooking()
{
receiver.cooking();
}
}
//接收者：肠粉厨师
class ChangFenChef extends JFrame
{
private static final long serialVersionUID = 1L;
JLabel l=new JLabel();
ChangFenChef()
{
super("煮肠粉");
l.setIcon(new ImageIcon("src/command/ChangFen.jpg"));
this.add(l);
this.setLocation(30, 30);
this.pack();
this.setResizable(false);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void cooking()
{
this.setVisible(true);
}
}
//接收者：馄饨厨师
class HunTunChef extends JFrame
{
private static final long serialVersionUID=1L;
JLabel l=new JLabel();
HunTunChef()
{
super("煮馄饨");
l.setIcon(new ImageIcon("src/command/HunTun.jpg"));
this.add(l);
this.setLocation(350, 50);
this.pack();
this.setResizable(false);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void cooking()
{
this.setVisible(true);
}
}
//接收者：河粉厨师
class HeFenChef extends JFrame
{
private static final long serialVersionUID=1L;
JLabel l=new JLabel();
HeFenChef()
{
super("煮河粉");
l.setIcon(new ImageIcon("src/command/HeFen.jpg"));
this.add(l);
this.setLocation(200, 280);
this.pack();
this.setResizable(false);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void cooking()
{
this.setVisible(true);
}
}

程序的运行结果如图 2 所示。

图2 客户在餐馆吃早餐的运行结果

命令模式的应用场景

命令模式通常适用于以下场景。

1. 当系统需要将请求调用者与请求接收者解耦时，命令模式使得调用者和接收者不直接交互。
2. 当系统需要随机请求命令或经常增加或删除命令时，命令模式比较方便实现这些功能。
3. 当系统需要执行一组操作时，命令模式可以定义宏命令来实现该功能。
4. 当系统需要支持命令的撤销（Undo）操作和恢复（Redo）操作时，可以将命令对象存储起来，采用备忘录模式来实现。

命令模式的扩展

在软件开发中，有时将命令模式与前面学的组合模式联合使用，这就构成了宏命令模式，也叫组合命令模式。宏命令包含了一组命令，它充当了具体命令与调用者的双重角色，执行它时将递归调用它所包含的所有命令，其具体结构图如图 3 所示。

图3 组合命令模式的结构图

程序代码如下：

 package command;
 import java.util.ArrayList;
 public class CompositeCommandPattern
 {
 public static void main(String[] args)
 {
 AbstractCommand cmd1=new ConcreteCommand1();
 AbstractCommand cmd2=new ConcreteCommand2();
 CompositeInvoker ir=new CompositeInvoker();
 ir.add(cmd1);
 ir.add(cmd2);
 System.out.println("客户访问调用者的execute()方法...");
 ir.execute();
 }
 }
 //抽象命令
 interface AbstractCommand
 {
 public abstract void execute();
 }
 //树叶构件: 具体命令1
 class ConcreteCommand1 implements AbstractCommand
 {
 private CompositeReceiver receiver;
 ConcreteCommand1()
 {
 receiver=new CompositeReceiver();
 }
 public void execute()
 {
 receiver.action1();
 }
 }
 //树叶构件: 具体命令2
 class ConcreteCommand2 implements AbstractCommand
 {
 private CompositeReceiver receiver;
 ConcreteCommand2()
 {
 receiver=new CompositeReceiver();
 }
 public void execute()
 {
 receiver.action2();
 }
 }
 //树枝构件: 调用者
 class CompositeInvoker implements AbstractCommand
 {
 private ArrayList<AbstractCommand> children = new ArrayList<AbstractCommand>();
 public void add(AbstractCommand c)
 {
 children.add(c);
 }
 public void remove(AbstractCommand c)
 {
 children.remove(c);
 }
 public AbstractCommand getChild(int i)
 {
 return children.get(i);
 }
 public void execute()
 {
 for(Object obj:children)
 {
 ((AbstractCommand)obj).execute();
 }
 }
 }
 //接收者
 class CompositeReceiver
 {
 public void action1()
 {
 System.out.println("接收者的action1()方法被调用...");
 }
 public void action2()
 {
 System.out.println("接收者的action2()方法被调用...");
 }
 }

程序的运行结果如下：
客户访问调用者的execute()方法…
接收者的action1()方法被调用…
接收者的action2()方法被调用…

当然，命令模式还可以同备忘录（Memento）模式组合使用，这样就变成了可撤销的命令模式，这将在后面介绍。

16.责任链模式（职责链模式）

在现实生活中，常常会出现这样的事例：一个请求有多个对象可以处理，但每个对象的处理条件或权限不同。例如，公司员工请假，可批假的领导有部门负责人、副总经理、总经理等，但每个领导能批准的天数不同，员工必须根据自己要请假的天数去找不同的领导签名，也就是说员工必须记住每个领导的姓名、电话和地址等信息，这增加了难度。这样的例子还有很多，如找领导出差报销、生活中的“击鼓传花”游戏等。

在计算机软硬件中也有相关例子，如总线网中数据报传送，每台计算机根据目标地址是否同自己的地址相同来决定是否接收；还有异常处理中，处理程序根据异常的类型决定自己是否处理该异常；还有 Struts2 的拦截器、JSP 和 Servlet 的 Filter 等，所有这些，如果用责任链模式都能很好解决。

模式的定义与特点

责任链（Chain of Responsibility）模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

注意：责任链模式也叫职责链模式。

在责任链模式中，客户只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递过程，所以责任链将请求的发送者和请求的处理者解耦了。

责任链模式是一种对象行为型模式，其主要优点如下。

1. 降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构，发送者和接收者也无须拥有对方的明确信息。
2. 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
3. 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。
4. 责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。
5. 责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

其主要缺点如下。

1. 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
2. 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。
3. 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。

模式的结构与实现

通常情况下，可以通过数据链表来实现职责链模式的数据结构。

1. 模式的结构

职责链模式主要包含以下角色。

1. 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
2. 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
3. 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

其结构图如图 1 所示。客户端可按图 2 所示设置责任链。

图1 责任链模式的结构图

图2 责任链

2. 模式的实现

职责链模式的实现代码如下：

package chainOfResponsibility;
public class ChainOfResponsibilityPattern
{
public static void main(String[] args)
{
//组装责任链 
Handler handler1=new ConcreteHandler1();
Handler handler2=new ConcreteHandler2();
handler1.setNext(handler2);
//提交请求 
handler1.handleRequest("two");
}
}
//抽象处理者角色
abstract class Handler
{
private Handler next;
public void setNext(Handler next)
{
this.next=next;
}
public Handler getNext()
{
return next;
}
//处理请求的方法
public abstract void handleRequest(String request);
}
//具体处理者角色1
class ConcreteHandler1 extends Handler
{
public void handleRequest(String request)
{
if(request.equals("one"))
{
System.out.println("具体处理者1负责处理该请求！");
}
else
{
if(getNext()!=null)
{
getNext().handleRequest(request);
}
else
{
System.out.println("没有人处理该请求！");
}
}
}
}
//具体处理者角色2
class ConcreteHandler2 extends Handler
{
public void handleRequest(String request)
{
if(request.equals("two"))
{
System.out.println("具体处理者2负责处理该请求！");
}
else
{
if(getNext()!=null)
{
getNext().handleRequest(request);
}
else
{
System.out.println("没有人处理该请求！");
}
}
}
}

程序运行结果如下：
具体处理者2负责处理该请求！

模式的应用实例

【例1】用责任链模式设计一个请假条审批模块。

分析：假如规定学生请假小于或等于 2 天，班主任可以批准；小于或等于 7 天，系主任可以批准；小于或等于 10 天，院长可以批准；其他情况不予批准；这个实例适合使用职责链模式实现。

首先，定义一个领导类（Leader），它是抽象处理者，包含了一个指向下一位领导的指针 next 和一个处理假条的抽象处理方法 handleRequest(int LeaveDays)；然后，定义班主任类（ClassAdviser）、系主任类（DepartmentHead）和院长类（Dean），它们是抽象处理者的子类，是具体处理者，必须根据自己的权力去实现父类的 handleRequest(int LeaveDays) 方法，如果无权处理就将假条交给下一位具体处理者，直到最后；客户类负责创建处理链，并将假条交给链头的具体处理者（班主任）。图 3 所示是其结构图。

图3 请假条审批模块的结构图

程序代码如下：

 package chainOfResponsibility;
 public class LeaveApprovalTest
 {
 public static void main(String[] args)
 {
 //组装责任链 
 Leader teacher1=new ClassAdviser();
 Leader teacher2=new DepartmentHead();
 Leader teacher3=new Dean();
 //Leader teacher4=new DeanOfStudies();
 teacher1.setNext(teacher2);
 teacher2.setNext(teacher3);
 //teacher3.setNext(teacher4);
 //提交请求 
 teacher1.handleRequest(8);
 }
 }
 //抽象处理者：领导类
 abstract class Leader
 {
 private Leader next;
 public void setNext(Leader next)
 {
 this.next=next;
 }
 public Leader getNext()
 {
 return next;
 }
 //处理请求的方法
 public abstract void handleRequest(int LeaveDays);
 }
 //具体处理者1：班主任类
 class ClassAdviser extends Leader
 {
 public void handleRequest(int LeaveDays)
 {
 if(LeaveDays<=2)
 {
 System.out.println("班主任批准您请假" + LeaveDays + "天。");
 }
 else
 {
 if(getNext() != null)
 {
 getNext().handleRequest(LeaveDays);
 }
 else
 {
 System.out.println("请假天数太多，没有人批准该假条！");
 }
 }
 }
 }
 //具体处理者2：系主任类
 class DepartmentHead extends Leader
 {
 public void handleRequest(int LeaveDays)
 {
 if(LeaveDays<=7)
 {
 System.out.println("系主任批准您请假" + LeaveDays + "天。");
 }
 else
 {
 if(getNext() != null)
 {
 getNext().handleRequest(LeaveDays);
 }
 else
 {
 System.out.println("请假天数太多，没有人批准该假条！");
 }
 }
 }
 }
 //具体处理者3：院长类
 class Dean extends Leader
 {
 public void handleRequest(int LeaveDays)
 {
 if(LeaveDays<=10)
 {
 System.out.println("院长批准您请假" + LeaveDays + "天。");
 }
 else
 {
 if(getNext() != null)
 {
 getNext().handleRequest(LeaveDays);
 }
 else
 {
 System.out.println("请假天数太多，没有人批准该假条！");
 }
 }
 }
 }
 //具体处理者4：教务处长类
 class DeanOfStudies extends Leader
 {
 public void handleRequest(int LeaveDays)
 {
 if(LeaveDays<=20)
 {
 System.out.println("教务处长批准您请假"+LeaveDays+"天。");
 }
 else
 {
 if(getNext()!=null)
 {
 getNext().handleRequest(LeaveDays);
 }
 else
 {
 System.out.println("请假天数太多，没有人批准该假条！");
 }
 }
 }
 }

程序运行结果如下：
院长批准您请假8天。

假如增加一个教务处长类，可以批准学生请假 20 天，也非常简单，代码如下：

//具体处理者4:教务处长类
class DeanOfStudies extends Leader
{
public void handleRequest(int LeaveDays)
{
if(LeaveDays<=20)
{
System.out.println("教务处长批准您请假"+LeaveDays+"天。");
}
else
{
if(getNext()!=null)
{
getNext().handleRequest(LeaveDays);
}
else
{
System.out.println("请假天数太多，没有人批准该假条！");
}
}
}
}

模式的应用场景

前边已经讲述了关于责任链模式的结构与特点，下面介绍其应用场景，责任链模式通常在以下几种情况使用。

1. 有多个对象可以处理一个请求，哪个对象处理该请求由运行时刻自动确定。
2. 可动态指定一组对象处理请求，或添加新的处理者。
3. 在不明确指定请求处理者的情况下，向多个处理者中的一个提交请求。

模式的扩展

职责链模式存在以下两种情况。

1. 纯的职责链模式：一个请求必须被某一个处理者对象所接收，且一个具体处理者对某个请求的处理只能采用以下两种行为之一：自己处理（承担责任）；把责任推给下家处理。
2. 不纯的职责链模式：允许出现某一个具体处理者对象在承担了请求的一部分责任后又将剩余的责任传给下家的情况，且一个请求可以最终不被任何接收端对象所接收。

17.状态模式

在软件开发过程中，应用程序中的有些对象可能会根据不同的情况做出不同的行为，我们把这种对象称为有状态的对象，而把影响对象行为的一个或多个动态变化的属性称为状态。当有状态的对象与外部事件产生互动时，其内部状态会发生改变，从而使得其行为也随之发生改变。如人的情绪有高兴的时候和伤心的时候，不同的情绪有不同的行为，当然外界也会影响其情绪变化。

对这种有状态的对象编程，传统的解决方案是：将这些所有可能发生的情况全都考虑到，然后使用 if-else 语句来做状态判断，再进行不同情况的处理。但当对象的状态很多时，程序会变得很复杂。而且增加新的状态要添加新的 if-else 语句，这违背了“开闭原则”，不利于程序的扩展。

以上问题如果采用“状态模式”就能很好地得到解决。状态模式的解决思想是：当控制一个对象状态转换的条件表达式过于复杂时，把相关“判断逻辑”提取出来，放到一系列的状态类当中，这样可以把原来复杂的逻辑判断简单化。

状态模式的定义与特点

状态（State）模式的定义：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。

状态模式是一种对象行为型模式，其主要优点如下。

1. 状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”。
2. 减少对象间的相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖。
3. 有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换。

状态模式的主要缺点如下。

1. 状态模式的使用必然会增加系统的类与对象的个数。
2. 状态模式的结构与实现都较为复杂，如果使用不当会导致程序结构和代码的混乱。

状态模式的结构与实现

状态模式把受环境改变的对象行为包装在不同的状态对象里，其意图是让一个对象在其内部状态改变的时候，其行为也随之改变。现在我们来分析其基本结构和实现方法。

1. 模式的结构

状态模式包含以下主要角色。

1. 环境（Context）角色：也称为上下文，它定义了客户感兴趣的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。
2. 抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为。
3. 具体状态（Concrete State）角色：实现抽象状态所对应的行为。

其结构图如图 1 所示。

图1 状态模式的结构图

2. 模式的实现

状态模式的实现代码如下：

package state;
public class StatePatternClient
{
public static void main(String[] args)
{
Context context=new Context();    //创建环境       
context.Handle();    //处理请求
context.Handle();
context.Handle();
context.Handle();
}
}
//环境类
class Context
{
private State state;
//定义环境类的初始状态
public Context()
{
this.state=new ConcreteStateA();
}
//设置新状态
public void setState(State state)
{
this.state=state;
}
//读取状态
public State getState()
{
return(state);
}
//对请求做处理
public void Handle()
{
state.Handle(this);
}
}
//抽象状态类
abstract class State
{
public abstract void Handle(Context context);
}
//具体状态A类
class ConcreteStateA extends State
{
public void Handle(Context context)
{
System.out.println("当前状态是 A.");
context.setState(new ConcreteStateB());
}
}
//具体状态B类
class ConcreteStateB extends State
{
public void Handle(Context context)
{
System.out.println("当前状态是 B.");
context.setState(new ConcreteStateA());
}
}

程序运行结果如下：
当前状态是 A.
当前状态是 B.
当前状态是 A.
当前状态是 B.

状态模式的应用实例

【例1】用“状态模式”设计一个学生成绩的状态转换程序。

分析：本实例包含了“不及格”“中等”和“优秀” 3 种状态，当学生的分数小于 60 分时为“不及格”状态，当分数大于等于 60 分且小于 90 分时为“中等”状态，当分数大于等于 90 分时为“优秀”状态，我们用状态模式来实现这个程序。

首先，定义一个抽象状态类（AbstractState），其中包含了环境属性、状态名属性和当前分数属性，以及加减分方法 addScore(intx) 和检查当前状态的抽象方法 checkState()；然后，定义“不及格”状态类 LowState、“中等”状态类 MiddleState 和“优秀”状态类 HighState，它们是具体状态类，实现 checkState() 方法，负责检査自己的状态，并根据情况转换；最后，定义环境类（ScoreContext），其中包含了当前状态对象和加减分的方法 add(int score)，客户类通过该方法来改变成绩状态。图 2 所示是其结构图。

图2 学生成绩的状态转换程序的结构图

程序代码如下：

package state;
public class ScoreStateTest
{
public static void main(String[] args)
{
ScoreContext account=new ScoreContext();
System.out.println("学生成绩状态测试：");
account.add(30);
account.add(40);
account.add(25);
account.add(-15);
account.add(-25);
}
}
//环境类
class ScoreContext
{
private AbstractState state;
ScoreContext()
{
state=new LowState(this);
}
public void setState(AbstractState state)
{
this.state=state;
}
public AbstractState getState()
{
return state;
}
public void add(int score)
{
state.addScore(score);
}
}
//抽象状态类
abstract class AbstractState
{
protected ScoreContext hj;  //环境
protected String stateName; //状态名
protected int score; //分数
public abstract void checkState(); //检查当前状态
public void addScore(int x)
{
score+=x;
System.out.print("加上："+x+"分，\t当前分数："+score );
checkState();
System.out.println("分，\t当前状态："+hj.getState().stateName);
}
}
//具体状态类：不及格
class LowState extends AbstractState
{
public LowState(ScoreContext h)
{
hj=h;
stateName="不及格";
score=0;
}
public LowState(AbstractState state)
{
hj=state.hj;
stateName="不及格";
score=state.score;
}
public void checkState()
{
if(score>=90)
{
hj.setState(new HighState(this));
}
else if(score>=60)
{
hj.setState(new MiddleState(this));
}
}
}
//具体状态类：中等
class MiddleState extends AbstractState
{
public MiddleState(AbstractState state)
{
hj=state.hj;
stateName="中等";
score=state.score;
}
public void checkState()
{
if(score<60)
{
hj.setState(new LowState(this));
}
else if(score>=90)
{
hj.setState(new HighState(this));
}
}
}
//具体状态类：优秀
class HighState extends AbstractState
{
public HighState(AbstractState state)
{
hj=state.hj;
stateName="优秀";
score=state.score;
}
public void checkState()
{
if(score<60)
{
hj.setState(new LowState(this));
}
else if(score<90)
{
hj.setState(new MiddleState(this));
}
}
}

程序运行结果如下：
学生成绩状态测试：
加上：30分， 当前分数：30分， 当前状态：不及格
加上：40分， 当前分数：70分， 当前状态：中等
加上：25分， 当前分数：95分， 当前状态：优秀
加上：-15分， 当前分数：80分， 当前状态：中等
加上：-25分， 当前分数：55分， 当前状态：不及格

【例2】用“状态模式”设计一个多线程的状态转换程序。

分析：多线程存在 5 种状态，分别为新建状态、就绪状态、运行状态、阻塞状态和死亡状态，各个状态当遇到相关方法调用或事件触发时会转换到其他状态，其状态转换规律如图 3 所示。

图3 线程状态转换图

现在先定义一个抽象状态类（TheadState），然后为图 3 所示的每个状态设计一个具体状态类，它们是新建状态（New）、就绪状态（Runnable ）、运行状态（Running）、阻塞状态（Blocked）和死亡状态（Dead），每个状态中有触发它们转变状态的方法，环境类（ThreadContext）中先生成一个初始状态（New），并提供相关触发方法，图 4 所示是线程状态转换程序的结构图。

图4 线程状态转换程序的结构图

程序代码如下：

package state;
public class ThreadStateTest
{
public static void main(String[] args)
{
ThreadContext context=new ThreadContext();
context.start();
context.getCPU();
context.suspend();
context.resume();
context.getCPU();
context.stop();
}
}
//环境类
class ThreadContext
{
private ThreadState state;
ThreadContext()
{
state=new New();
}
public void setState(ThreadState state)
{
this.state=state;
}
public ThreadState getState()
{
return state;
}
public void start()
{
((New) state).start(this);
}
public void getCPU()
{
((Runnable) state).getCPU(this);
}
public void suspend()
{
((Running) state).suspend(this);
}
public void stop()
{
((Running) state).stop(this);
}
public void resume()
{
((Blocked) state).resume(this);
}
}
//抽象状态类：线程状态
abstract class ThreadState
{
protected String stateName; //状态名
}
//具体状态类：新建状态
class New extends ThreadState
{
public New()
{
stateName="新建状态";
System.out.println("当前线程处于：新建状态.");
}
public void start(ThreadContext hj)
{
System.out.print("调用start()方法-->");
if(stateName.equals("新建状态"))
{
hj.setState(new Runnable());
}
else
{
System.out.println("当前线程不是新建状态，不能调用start()方法.");
}
}
}
//具体状态类：就绪状态
class Runnable extends ThreadState
{
public Runnable()
{
stateName="就绪状态";
System.out.println("当前线程处于：就绪状态.");
}
public void getCPU(ThreadContext hj)
{
System.out.print("获得CPU时间-->");
if(stateName.equals("就绪状态"))
{
hj.setState(new Running());
}
else
{
System.out.println("当前线程不是就绪状态，不能获取CPU.");
}
}
}
//具体状态类：运行状态
class Running extends ThreadState
{
public Running()
{
stateName="运行状态";
System.out.println("当前线程处于：运行状态.");
}
public void suspend(ThreadContext hj)
{
System.out.print("调用suspend()方法-->");
if(stateName.equals("运行状态"))
{
hj.setState(new Blocked());
}
else
{
System.out.println("当前线程不是运行状态，不能调用suspend()方法.");
}
}
public void stop(ThreadContext hj)
{
System.out.print("调用stop()方法-->");
if(stateName.equals("运行状态"))
{
hj.setState(new Dead());
}
else
{
System.out.println("当前线程不是运行状态，不能调用stop()方法.");
}
}
}
//具体状态类：阻塞状态
class Blocked extends ThreadState
{
public Blocked()
{
stateName="阻塞状态";
System.out.println("当前线程处于：阻塞状态.");
}
public void resume(ThreadContext hj)
{
System.out.print("调用resume()方法-->");
if(stateName.equals("阻塞状态"))
{
hj.setState(new Runnable());
}
else
{
System.out.println("当前线程不是阻塞状态，不能调用resume()方法.");
}
}
}
//具体状态类：死亡状态
class Dead extends ThreadState
{
public Dead()
{
stateName="死亡状态";
System.out.println("当前线程处于：死亡状态.");
}
}

程序运行结果如下：
当前线程处于：新建状态.
调用start()方法—>当前线程处于：就绪状态.
获得CPU时间—>当前线程处于：运行状态.
调用suspend()方法—>当前线程处于：阻塞状态.
调用resume()方法—>当前线程处于：就绪状态.
获得CPU时间—>当前线程处于：运行状态.
调用stop()方法—>当前线程处于：死亡状态.

状态模式的应用场景

通常在以下情况下可以考虑使用状态模式。

• 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。
• 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。

状态模式的扩展

在有些情况下，可能有多个环境对象需要共享一组状态，这时需要引入享元模式，将这些具体状态对象放在集合中供程序共享，其结构图如图 5 所示。

图5 共享状态模式的结构图

分析：共享状态模式的不同之处是在环境类中增加了一个 HashMap 来保存相关状态，当需要某种状态时可以从中获取，其程序代码如下：

 package state;
 import java.util.HashMap;
 public class FlyweightStatePattern
 {
 public static void main(String[] args)
 {
 ShareContext context=new ShareContext(); //创建环境       
 context.Handle(); //处理请求
 context.Handle();
 context.Handle();
 context.Handle();
 }
 }
 //环境类
 class ShareContext
 {
 private ShareState state;
 private HashMap<String, ShareState> stateSet=new HashMap<String, ShareState>();
 public ShareContext()
 {
 state=new ConcreteState1();
 stateSet.put("1", state);
 state=new ConcreteState2();
 stateSet.put("2", state);
 state=getState("1");
 }
 //设置新状态
 public void setState(ShareState state)
 {
 this.state=state;
 }
 //读取状态
 public ShareState getState(String key)
 {
 ShareState s=(ShareState)stateSet.get(key);
 return s;
 }
 //对请求做处理
 public void Handle()
 {
 state.Handle(this);
 }
 }
 //抽象状态类
 abstract class ShareState
 {
 public abstract void Handle(ShareContext context);
 }
 //具体状态1类
 class ConcreteState1 extends ShareState
 {
 public void Handle(ShareContext context)
 {
 System.out.println("当前状态是： 状态1");
 context.setState(context.getState("2"));
 }
 }
 //具体状态2类
 class ConcreteState2 extends ShareState
 {
 public void Handle(ShareContext context)
 {
 System.out.println("当前状态是： 状态2");
 context.setState(context.getState("1"));
 }
 }