题目描述

在军队中，一般根据战争规模的大小和重要性由不同级别的长官（Officer)来下达作战命令，情报人员向上级递交军情（如敌人的数量），作战命令需要上级批准，如果直接上级不具备下达命令的权力，则上级又传给上级，直到有人可以决定为止。现使用职责链模式来模拟该过程，客户类（Client)模拟情报人员，首先向级别最低的班长（Banzhang)递交任务书（Mission)，即军情，如果超出班长的权力范围，则传递给排长（Paizhang)，排长如果也不能处理则传递给营长（Yingzhang)，如果营长也不能处理则需要开会讨论。我们设置这几级长官的权力范围分别是：
①敌人数量＜10，班长下达作战命令。
②10≤敌人数量＜50，排长下达作战命令。
③50≤敌人数量＜200，营长下达作战命令。
④敌人数量≥200，需要开会讨论再下达作战命令。
请使用职责链模块实现，绘制类图、类图说明并编程实现。

类结构图及相关说明

Officer类:抽象处理者，设计为抽象类，由于不同的具体处理者Banzhang类、Paizhang类、Yingzhang类处理请求的方法不同，因此在其中定义了抽象请求处理方法sendMission()。每一个处理方法的下家还是一个处理者，故在抽象处理者Officer类中定义了一个抽象处理者类型的对象officer作为其对下家的引用，通过该引用处理中可以连成一条链。通过链式调用将任务层层下发。
Banzhang类:具体处理者，是抽象处理者Officer类的子类，可以处理用户的请求Mission类，在具体处理者类Banzhang类中实现了抽象处理者Officer类中定义的抽象请求处理方法sendMission()，在处理请求之前需要进行判断，看是否有相应的处理权限，如果可以处理请求就处理它，否则将请求转发给后继者，在具体处理者Officer类中可以访问链中的下一个对象，以便请求的转发。
Paizhang类:具体处理者，是抽象处理者Officer类的子类，可以处理用户的请求Mission类，在具体处理者类Paizhang类中实现了抽象处理者Officer类中定义的抽象请求处理方法sendMission，在处理请求之前需要进行判断，看是否有相应的处理权限，如果可以处理请求就处理它，否则将请求转发给后继者，在具体处理者Officer类中可以访问链中的下一个对象，以便请求的转发。
Yingzhang类:具体处理者，是抽象处理者Officer类的子类，可以处理用户的请求Mission类，在具体处理者类Yingzhang类中实现了抽象处理者Officer类中定义的抽象请求处理方法sendMission()，在处理请求之前需要进行判断，看是否有相应的处理权限，如果可以处理请求就处理它，否则将请求转发给后继者，在具体处理者Officer类中可以访问链中的下一个对象，以便请求的转发。
Mission类：设置任务内容及敌人数量，充当请求类。

程序代码

Mission类

//充当请求类
public class Mission {
    private String soldierName; //情报人员
    private int enemyNumber; //敌人数量
    public Mission(){
        super();
    }
    public Mission(String soldierName, int enemyNumber){
        super();
        this.soldierName = soldierName;
        this.enemyNumber = enemyNumber;
    }
    public String getSoldierName() {
        return soldierName;
    }
    public void setSoldierName(String soldierName) {
        this.soldierName = soldierName;
    }
    public int getEnemyNumber() {
        return enemyNumber;
    }
    public void setEnemyNumber(int enemyNumber) {
        this.enemyNumber = enemyNumber;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Officer类

//抽象处理者，抽象类，
public abstract class Officer {
    protected  String name; 
    //定义一个抽象处理者类的对象，作为其对下家的引用
    protected Officer officer; //维持对下家的引用
    public Officer(String name){
        this.name = name;
    }
    public void setOfficer(Officer officer) {
        this.officer = officer;
    }
    //声明抽象的的请求方法，具体实现交由子类完成
    public abstract void sendMission(Mission mission);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Banzhang类

//具体处理者，是抽象处理者的子类，可以处理用户请求，并实现抽象处理者中定义的抽象请求处理方法
public class Banzhang extends Officer{
    public Banzhang(String name){
        super(name);
    }
    @Override
    public void sendMission(Mission mission) {
        //请求满足条件
        if(mission.getEnemyNumber()>0 && mission.getEnemyNumber()<10){
            //处理请求
            //敌人数量＜10，班长下达作战命令
            System.out.println("班长"+name+"接到"+mission.getSoldierName()+"的军情"+"，敌人数量为："+mission.getEnemyNumber()+"，可以下达作战指令");
        }else{
            if(this.officer!=null)
            {
                this.officer.sendMission(mission); //转发请求
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Paizhang类

//具体处理者，是抽象处理者的子类，可以处理用户请求，并实现抽象处理者中定义的抽象请求处理方法
public class Paizhang extends Officer{
    public Paizhang(String name){
        super(name);
    }
    @Override
    public void sendMission(Mission mission) {
        //请求满足条件
        if(mission.getEnemyNumber()>=10 && mission.getEnemyNumber()<50){
            //处理请求
            //10≤敌人数量＜50，排长下达作战命令
            System.out.println("排长"+name+"接到"+mission.getSoldierName()+"的军情"+"，敌人数量为："+mission.getEnemyNumber()+"，可以下达作战指令");
        }else{
            if(this.officer!=null)
            {
                this.officer.sendMission(mission);//转发请求
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Yingzhang类

//具体处理者，是抽象处理者的子类，可以处理用户请求，并实现抽象处理者中定义的抽象请求处理方法
public class Yingzhang extends Officer{
    public Yingzhang(String name){
        super(name);
    }
    @Override
    public void sendMission(Mission mission) {
        //请求满足条件
        if(mission.getEnemyNumber()>=50 && mission.getEnemyNumber()<200){
            //处理请求
            //③50≤敌人数量＜200，营长下达作战命令
            System.out.println("营长"+name+"接到"+mission.getSoldierName()+"的军情"+"，敌人数量为："+mission.getEnemyNumber()+"，可以下达作战指令");
        }else{
            //处理请求
            //敌人数量≥200，需要开会讨论再下达作战命令
            System.out.println("营长"+name+"接到"+mission.getSoldierName()+"的军情"+",敌人数量为"+mission.getEnemyNumber()+",敌人太多了，我们开会讨论一下吧！");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Client类

//客户端测试类
public class Client {
    public static void main(String[] args) {
        Officer bangzhang = new Banzhang("张三");
        Officer paizhang = new Paizhang("李四");
        Officer yingzhang = new Yingzhang("王五");
        //创建职责链
        bangzhang.setOfficer(paizhang);
        paizhang.setOfficer(yingzhang);
        //发送请求，请求对象通常为自定义类型
        Mission mission1 = new Mission("小明",7);
        bangzhang.sendMission(mission1);

        Mission mission2 = new Mission("小红",17);
        bangzhang.sendMission(mission2);

        Mission mission3 = new Mission("小强",177);
        bangzhang.sendMission(mission3);

        Mission mission4 = new Mission("小白",777);
        bangzhang.sendMission(mission4);
   } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

运行结果