软件详细设计总复习（三）【太原理工大学】

题型及分值：
选择 30 分，填空 20 分，判断 10 分，简答 20 分，综合设计 20 分。

文章目录

- 三、行为型模式
- - 1. 命令模式
  - 2. 迭代器模式
  - 3. 观察者模式
  - 4. 状态模式
  - 5. 策略模式

三、行为型模式

1. 命令模式

举个例子，总经理要向公司的所有员工传达一些命令，但他不可能亲自去通知所有人，而是先把要吩咐的话通知给各部门负责人，再由各部门的负责人去向下传达指令，总经理和具体的员工之间是没有直接交流的，这就是命令模式。

将一个请求封装为一个对象，从而让你可以用不同的请求对客户迚行参数化，对请求排队戒者记录请求日志，以及支持可撤销的操作。

整体结构：
① 一个抽象命令类，内置公共命令方法；
② 数个具体命令类，重写父类的命令方法，并在里面调用接收者的接收方法；
③ 数个接收类，内置具体的接收方法；
④ 数个调用者类，即命令类与接收类的桥梁，通过带参构造方法传入命令类，自定义 call 方法，里面调用命令类的命令方法。

public public abstract class Command {
    public abstract void execute( );
}

public class ConcreteCommand extends Command {
    private Receiver receiver; //维持一个对请求接收者对象的引用
    public void execute() {
    receiver.action( ); //调用请求接收者的业务处理方法action( )
    }
}

public class Receiver {
    public void action( ) {
    //具体操作
    }
}

public class Invoker {
    private Command command;
    public Invoker(Command command) {
    this.command = command;
    }
    public void setCommand(Command command) {
        this.command = command;
    } 
    public void call() {
        command.execute( );
    }
}

2. 迭代器模式

迭代器模式，顾名思义，它就是用来访问聚合对象的，对于遥控器和电视机，此时遥控器就是一个迭代器，而电视机就是它所对应的聚合对象，人们根本不需要关心这些频道是如何存储到电视里面的，他们只知道如何去用就可以了。为了拓展方便，需要定义一个抽象迭代器和一个抽象聚合类，在具体的聚合类中自然要调用迭代器中的方法，去进行电视台的迭代，这里可以按照课本上的方法，将具体的迭代器类作为具体聚合类的内部类，就是说我们不必要再去创建具体的迭代器类了，但全部功能都放在具体聚合类中有违开闭原则，因为迭代器也可能增加新的功能，所以也可以直接创一个具体迭代器类，在聚合类中直接传参并调用具体迭代器类即可。

迭代器用于对一个聚合对象进行遍历。通过引入迭代器可以将数据的遍历功能从聚合对象中分离出来，聚合对象只负责存储数据，而遍历数据由迭代器来完成。

整体结构：
① 一个抽象迭代器类；
②一个具体迭代器类，遥控器，内置正、逆遍历方法，及一些判断开始和结尾的方法；
③ 一个抽象聚合类；
④ 数个具体聚合类，不同的电视机，内置频道，及创建迭代器的方法。

public interface TVIterator {

    void next();
    void previous();
    boolean isFirst();
    boolean isLast();
    //设置电视台
    void setChannel(int i);
    //返回当前电视台
    Object currentChannel();

}

public class TVIteratorImpl implements TVIterator {

    Object[] obj;
    private int currentIndex = 0;

    public TVIteratorImpl(Object[] obj) {
        this.obj = obj;
    }

    @Override
    public void next() {
        if (currentIndex < obj.length) {
            currentIndex++;
        }
    }
    @Override
    public void previous() {
        if (currentIndex > 0) {
            currentIndex--;
        }
    }
    @Override
    public boolean isFirst() {
        return currentIndex == 0;
    }
    @Override
    public boolean isLast() {
        return currentIndex == obj.length;
    }
    @Override
    public void setChannel(int i) {
        currentIndex = i;
    }
    @Override
    public Object currentChannel() {
        return obj[currentIndex];
    }

}

public interface Television {
    TVIterator createIterator();
}

public class HuaWeiTelevision implements Television {

    Object[] obj = {"少儿频道", "中央卫视", "山西卫视", "湖南卫视", "电影频道", "江西卫视", "青海卫视"};

    @Override
    public TVIterator createIterator() {
        return new TVIteratorImpl(obj);
    }

}

3. 观察者模式

一个对象的状态或行为的变化将导致其他对象的状态或行为也发生改变，它们之间将产生联劢。
还是以实验内容为例，股民观察股票价格动荡，从而做出反应。一个对象的改变将导致一个或多个其他对象发生改变，并且不知道具体有多少对象将发生改变，也不知道这些对象是谁。解决办法，在系统中创建一个触发链。一个目标可以有很多的观察者，在目标类中添加方法实现对观察者的增加和删除，同时目标类是要发出警告消息的，提供一个notify方法用于通知每一个观察者这里发出一个警告，所有的观察者都必须对此警告作为相应的反应，实现方式是遍历观察者集合，并调用其update方法，观察者类中的update方法就是观察者收到警告后做出的反应。

观察者模式定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。

整体结构：
① 一个目标类，内置添加或删除观察者的方法，所有的观察者都被放在一个集合里面，再写一个通知方法，里面遍历集合中所有的观察者，并调用它们各自的 upDate 方法，当外部调用通知方法的时候，就相当于把通知传达给了各观察者；
② 一个抽象观察者类，提供 update 方法；
③ 数个观察者类，重写抽象观察者中的方法，当面对一个通知的时候所应该做出的反应。

import java.util.ArrayList;

public class Stock {

    private String StockName;
    private int price;
    ArrayList<Investor> investors = new ArrayList<>();

    public void attach(Investor investor) {
        investors.add(investor);
    }

    public void detach(Investor investor) {
        investors.remove(investor);
    }

    public String getStockName() {
        return StockName;
    }

    public void setStockName(String stockName) {
        StockName = stockName;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public void notifyInvestor() {
        System.out.println("\n通知：" + StockName + "股票价格变化幅度已达 5%，最新价格为" + price + "￥。");
        System.out.println("*******************************************************************\n");
        for (Investor i : investors) {
            i.upDate();
        }
    }
    
}

public abstract class Investor {
    public abstract void upDate();
}

public class ConcreteInvestor1 extends Investor {
    @Override
    public void upDate() {
        System.out.println("股民1：怎么又变了，我真的会谢哦~");
    }
}

public class ConcreteInvestor2 extends Investor {
    @Override
    public void upDate() {
        System.out.println("股民2：变得好，正好不想买了~");
    }
}

public class ConcreteInvestor3 extends Investor {
    @Override
    public void upDate() {
        System.out.println("股民3：无欲无求，乃人生最大的乐趣~");
    }
}

4. 状态模式

该模式不太重要又难，所以我们不用硬看这个状态模式。
状态模式允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。

整体结构：
① 一个抽象状态类；
② 数个具体状态类；
③ 数个环境类。

public class Context {
    private State state; //维持一个对抽象状态对象的引用
    private int value; //其他属性值，其变化可能会导致对象的状态变化
    public void setState(State state) {
    this.state = state;
    }
    public void request() {
    state.handle( ); //调用状态对象的业务方法
    }
}

5. 策略模式

策略模式中包含策略类和环境类。具体策略类可以有很多，继承至抽象策略类，环境类其实是使用策略的角色，在环境类中维护一个对抽象策略类的引用实例，用于定义所采用的策略。在测试类中给环境类传入具体策略参数，继而在环境类中调用具体策略类的处理方法，最后在控制台输出结果。

策略模式定义一系列算法，将每一个算法封装起来，并让它们可以相互替换。实现某个目标的途径不止一条，可根据实际情况选择一条合适的途径。
在这里插入图片描述

整体结构：
① 一个抽象策略类；
② 数个具体策略类，重写抽象方法；
③ 一个环境类，客户端传入一种策略，由环境类来调用具体的策略方法。

public interface TravelStrategy {
    void travel();
}

public class AirplaneStrategy implements TravelStrategy {
    @Override
    public void travel() {
        System.out.println("飞机旅行！");
    }
}

public class TrainStrategy implements TravelStrategy {
    @Override
    public void travel() {
        System.out.println("火车旅行！");
    }
}

public class Person {

    private TravelStrategy strategy;
    public void setStrategy(TravelStrategy strategy) {
        this.strategy = strategy;
    }
    public void travel() {
        strategy.travel();
    }

}