• 设计模式日常学习(七)

    6.5 状态模式

    6.5.1 概述

    【例】通过按钮来控制一个电梯的状态，一个电梯有开门状态，关门状态，停止状态，运行状态。每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯门现在处于运行时状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作。

    类图如下：

    1. public interface ILift {
    2.     //电梯的4个状态
    3.     //开门状态
    4.     public final static int OPENING_STATE = 1;
    5.     //关门状态
    6.     public final static int CLOSING_STATE = 2;
    7.     //运行状态
    8.     public final static int RUNNING_STATE = 3;
    9.     //停止状态
    10.     public final static int STOPPING_STATE = 4;
    11. ​
    12.     //设置电梯的状态
    13.     public void setState(int state);
    14. ​
    15.     //电梯的动作
    16.     public void open();
    17.     public void close();
    18.     public void run();
    19.     public void stop();
    20. }
    21. ​
    22. public class Lift implements ILift {
    23.     private int state;
    24. ​
    25.     @Override
    26.     public void setState(int state) {
    27.         this.state = state;
    28.     }
    29. ​
    30.     //执行关门动作
    31.     @Override
    32.     public void close() {
    33.         switch (this.state) {
    34.             case OPENING_STATE:
    35.                 System.out.println("电梯关门了。。。");//只有开门状态可以关闭电梯门，可以对应电梯状态表来看
    36.                 this.setState(CLOSING_STATE);//关门之后电梯就是关闭状态了
    37.                 break;
    38.             case CLOSING_STATE:
    39.                 //do nothing //已经是关门状态，不能关门
    40.                 break;
    41.             case RUNNING_STATE:
    42.                 //do nothing //运行时电梯门是关着的，不能关门
    43.                 break;
    44.             case STOPPING_STATE:
    45.                 //do nothing //停止时电梯也是关着的，不能关门
    46.                 break;
    47.         }
    48.     }
    49. ​
    50.     //执行开门动作
    51.     @Override
    52.     public void open() {
    53.         switch (this.state) {
    54.             case OPENING_STATE://门已经开了，不能再开门了
    55.                 //do nothing
    56.                 break;
    57.             case CLOSING_STATE://关门状态，门打开:
    58.                 System.out.println("电梯门打开了。。。");
    59.                 this.setState(OPENING_STATE);
    60.                 break;
    61.             case RUNNING_STATE:
    62.                 //do nothing 运行时电梯不能开门
    63.                 break;
    64.             case STOPPING_STATE:
    65.                 System.out.println("电梯门开了。。。");//电梯停了，可以开门了
    66.                 this.setState(OPENING_STATE);
    67.                 break;
    68.         }
    69.     }
    70. ​
    71.     //执行运行动作
    72.     @Override
    73.     public void run() {
    74.         switch (this.state) {
    75.             case OPENING_STATE://电梯不能开着门就走
    76.                 //do nothing
    77.                 break;
    78.             case CLOSING_STATE://门关了，可以运行了
    79.                 System.out.println("电梯开始运行了。。。");
    80.                 this.setState(RUNNING_STATE);//现在是运行状态
    81.                 break;
    82.             case RUNNING_STATE:
    83.                 //do nothing 已经是运行状态了
    84.                 break;
    85.             case STOPPING_STATE:
    86.                 System.out.println("电梯开始运行了。。。");
    87.                 this.setState(RUNNING_STATE);
    88.                 break;
    89.         }
    90.     }
    91. ​
    92.     //执行停止动作
    93.     @Override
    94.     public void stop() {
    95.         switch (this.state) {
    96.             case OPENING_STATE: //开门的电梯已经是是停止的了(正常情况下)
    97.                 //do nothing
    98.                 break;
    99.             case CLOSING_STATE://关门时才可以停止
    100.                 System.out.println("电梯停止了。。。");
    101.                 this.setState(STOPPING_STATE);
    102.                 break;
    103.             case RUNNING_STATE://运行时当然可以停止了
    104.                 System.out.println("电梯停止了。。。");
    105.                 this.setState(STOPPING_STATE);
    106.                 break;
    107.             case STOPPING_STATE:
    108.                 //do nothing
    109.                 break;
    110.         }
    111.     }
    112. }
    113. ​
    114. public class Client {
    115.     public static void main(String[] args) {
    116.         Lift lift = new Lift();
    117.         lift.setState(ILift.STOPPING_STATE);//电梯是停止的
    118.         lift.open();//开门
    119.         lift.close();//关门
    120.         lift.run();//运行
    121.         lift.stop();//停止
    122.     }
    123. }

    问题分析：

    • 使用了大量的switch…case这样的判断（if…else也是一样)，使程序的可阅读性变差。
    • 扩展性很差。如果新加了断电的状态，我们需要修改上面判断逻辑

    定义：

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

    6.5.2 结构

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

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

    6.5.3 案例实现

    对上述电梯的案例使用状态模式进行改进。类图如下：

    1. //抽象状态类
    2. public abstract class LiftState {
    3.     //定义一个环境角色，也就是封装状态的变化引起的功能变化
    4.     protected Context context;
    5. ​
    6.     public void setContext(Context context) {
    7.         this.context = context;
    8.     }
    9. ​
    10.     //电梯开门动作
    11.     public abstract void open();
    12. ​
    13.     //电梯关门动作
    14.     public abstract void close();
    15. ​
    16.     //电梯运行动作
    17.     public abstract void run();
    18. ​
    19.     //电梯停止动作
    20.     public abstract void stop();
    21. }
    22. ​
    23. //开启状态
    24. public class OpenningState extends LiftState {
    25. ​
    26.     //开启当然可以关闭了，我就想测试一下电梯门开关功能
    27.     @Override
    28.     public void open() {
    29.         System.out.println("电梯门开启...");
    30.     }
    31. ​
    32.     @Override
    33.     public void close() {
    34.         //状态修改
    35.         super.context.setLiftState(Context.closeingState);
    36.         //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
    37.         super.context.getLiftState().close();
    38.     }
    39. ​
    40.     //电梯门不能开着就跑，这里什么也不做
    41.     @Override
    42.     public void run() {
    43.         //do nothing
    44.     }
    45. ​
    46.     //开门状态已经是停止的了
    47.     @Override
    48.     public void stop() {
    49.         //do nothing
    50.     }
    51. }
    52. ​
    53. //运行状态
    54. public class RunningState extends LiftState {
    55. ​
    56.     //运行的时候开电梯门？你疯了！电梯不会给你开的
    57.     @Override
    58.     public void open() {
    59.         //do nothing
    60.     }
    61. ​
    62.     //电梯门关闭？这是肯定了
    63.     @Override
    64.     public void close() {//虽然可以关门，但这个动作不归我执行
    65.         //do nothing
    66.     }
    67. ​
    68.     //这是在运行状态下要实现的方法
    69.     @Override
    70.     public void run() {
    71.         System.out.println("电梯正在运行...");
    72.     }
    73. ​
    74.     //这个事绝对是合理的，光运行不停止还有谁敢做这个电梯？！估计只有上帝了
    75.     @Override
    76.     public void stop() {
    77.         super.context.setLiftState(Context.stoppingState);
    78.         super.context.stop();
    79.     }
    80. }
    81. ​
    82. //停止状态
    83. public class StoppingState extends LiftState {
    84. ​
    85.     //停止状态，开门，那是要的！
    86.     @Override
    87.     public void open() {
    88.         //状态修改
    89.         super.context.setLiftState(Context.openningState);
    90.         //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
    91.         super.context.getLiftState().open();
    92.     }
    93. ​
    94.     @Override
    95.     public void close() {//虽然可以关门，但这个动作不归我执行
    96.         //状态修改
    97.         super.context.setLiftState(Context.closeingState);
    98.         //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
    99.         super.context.getLiftState().close();
    100.     }
    101. ​
    102.     //停止状态再跑起来，正常的很
    103.     @Override
    104.     public void run() {
    105.         //状态修改
    106.         super.context.setLiftState(Context.runningState);
    107.         //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
    108.         super.context.getLiftState().run();
    109.     }
    110. ​
    111.     //停止状态是怎么发生的呢？当然是停止方法执行了
    112.     @Override
    113.     public void stop() {
    114.         System.out.println("电梯停止了...");
    115.     }
    116. }
    117. ​
    118. //关闭状态
    119. public class ClosingState extends LiftState {
    120. ​
    121.     @Override
    122.     //电梯门关闭，这是关闭状态要实现的动作
    123.     public void close() {
    124.         System.out.println("电梯门关闭...");
    125.     }
    126. ​
    127.     //电梯门关了再打开，逗你玩呢，那这个允许呀
    128.     @Override
    129.     public void open() {
    130.         super.context.setLiftState(Context.openningState);
    131.         super.context.open();
    132.     }
    133. ​
    134. ​
    135.     //电梯门关了就跑，这是再正常不过了
    136.     @Override
    137.     public void run() {
    138.         super.context.setLiftState(Context.runningState);
    139.         super.context.run();
    140.     }
    141. ​
    142.     //电梯门关着，我就不按楼层
    143.     @Override
    144.     public void stop() {
    145.         super.context.setLiftState(Context.stoppingState);
    146.         super.context.stop();
    147.     }
    148. }
    149. ​
    150. //环境角色
    151. public class Context {
    152.     //定义出所有的电梯状态
    153.     public final static OpenningState openningState = new OpenningState();//开门状态，这时候电梯只能关闭
    154.     public final static ClosingState closeingState = new ClosingState();//关闭状态，这时候电梯可以运行、停止和开门
    155.     public final static RunningState runningState = new RunningState();//运行状态，这时候电梯只能停止
    156.     public final static StoppingState stoppingState = new StoppingState();//停止状态，这时候电梯可以开门、运行
    157. ​
    158. ​
    159.     //定义一个当前电梯状态
    160.     private LiftState liftState;
    161. ​
    162.     public LiftState getLiftState() {
    163.         return this.liftState;
    164.     }
    165. ​
    166.     public void setLiftState(LiftState liftState) {
    167.         //当前环境改变
    168.         this.liftState = liftState;
    169.         //把当前的环境通知到各个实现类中
    170.         this.liftState.setContext(this);
    171.     }
    172. ​
    173.     public void open() {
    174.         this.liftState.open();
    175.     }
    176. ​
    177.     public void close() {
    178.         this.liftState.close();
    179.     }
    180. ​
    181.     public void run() {
    182.         this.liftState.run();
    183.     }
    184. ​
    185.     public void stop() {
    186.         this.liftState.stop();
    187.     }
    188. }
    189. ​
    190. //测试类
    191. public class Client {
    192.     public static void main(String[] args) {
    193.         Context context = new Context();
    194.         context.setLiftState(new ClosingState());
    195. ​
    196.         context.open();
    197.         context.close();
    198.         context.run();
    199.         context.stop();
    200.     }
    201. }

    6.5.4 优缺点

    1，优点：

    • 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
    • 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。

    2，缺点：

    • 状态模式的使用必然会增加系统类和对象的个数。
    • 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
    • 状态模式对"开闭原则"的支持并不太好。

    6.5.5 使用场景

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

    6.6 观察者模式

    6.6.1 概述

    定义：

    又被称为发布-订阅（Publish/Subscribe）模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。

    6.6.2 结构

    在观察者模式中有如下角色：

    • Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
    • ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
    • Observer：抽象观察者，是观察者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
    • ConcrereObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。

    6.6.3 案例实现

    【例】微信公众号

    在使用微信公众号时，大家都会有这样的体验，当你关注的公众号中有新内容更新的话，它就会推送给关注公众号的微信用户端。我们使用观察者模式来模拟这样的场景，微信用户就是观察者，微信公众号是被观察者，有多个的微信用户关注了程序猿这个公众号。

    类图如下：

    定义抽象观察者类，里面定义一个更新的方法

    public interface Observer {
    void update(String message);
}

    定义具体观察者类，微信用户是观察者，里面实现了更新的方法

    public class WeixinUser implements Observer {
    // 微信用户名
    private String name;
​
    public WeixinUser(String name) {
        this.name = name;
    }
    @Override
    public void update(String message) {
        System.out.println(name + "-" + message);
    }
}

    定义抽象主题类，提供了attach、detach、notify三个方法

    public interface Subject {
    //增加订阅者
    public void attach(Observer observer);
​
    //删除订阅者
    public void detach(Observer observer);
    
    //通知订阅者更新消息
    public void notify(String message);
}

    微信公众号是具体主题（具体被观察者），里面存储了订阅该公众号的微信用户，并实现了抽象主题中的方法

    public class SubscriptionSubject implements Subject {
    //储存订阅公众号的微信用户
    private List weixinUserlist = new ArrayList();
​
    @Override
    public void attach(Observer observer) {
        weixinUserlist.add(observer);
    }
​
    @Override
    public void detach(Observer observer) {
        weixinUserlist.remove(observer);
    }
​
    @Override
    public void notify(String message) {
        for (Observer observer : weixinUserlist) {
            observer.update(message);
        }
    }
}

    客户端程序

    public class Client {
    public static void main(String[] args) {
        SubscriptionSubject mSubscriptionSubject=new SubscriptionSubject();
        //创建微信用户
        WeixinUser user1=new WeixinUser("孙悟空");
        WeixinUser user2=new WeixinUser("猪悟能");
        WeixinUser user3=new WeixinUser("沙悟净");
        //订阅公众号
        mSubscriptionSubject.attach(user1);
        mSubscriptionSubject.attach(user2);
        mSubscriptionSubject.attach(user3);
        //公众号更新发出消息给订阅的微信用户
        mSubscriptionSubject.notify("传智黑马的专栏更新了");
    }
}

    6.6.4 优缺点

    1，优点：

    • 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。
    • 被观察者发送通知，所有注册的观察者都会收到信息【可以实现广播机制】

    2，缺点：

    • 如果观察者非常多的话，那么所有的观察者收到被观察者发送的通知会耗时
    • 如果被观察者有循环依赖的话，那么被观察者发送通知会使观察者循环调用，会导致系统崩溃

    6.6.5 使用场景

    • 对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。
    • 当一个抽象模型有两个方面，其中一个方面依赖于另一方面时。

    6.6.6 JDK中提供的实现

    在 Java 中，通过 java.util.Observable 类和 java.util.Observer 接口定义了观察者模式，只要实现它们的子类就可以编写观察者模式实例。

    1，Observable类

    Observable 类是抽象目标类（被观察者），它有一个 Vector 集合成员变量，用于保存所有要通知的观察者对象，下面来介绍它最重要的 3 个方法。

    • void addObserver(Observer o) 方法：用于将新的观察者对象添加到集合中。
    • void notifyObservers(Object arg) 方法：调用集合中的所有观察者对象的 update方法，通知它们数据发生改变。通常越晚加入集合的观察者越先得到通知。
    • void setChange() 方法：用来设置一个 boolean 类型的内部标志，注明目标对象发生了变化。当它为true时，notifyObservers() 才会通知观察者。

    2，Observer 接口

    Observer 接口是抽象观察者，它监视目标对象的变化，当目标对象发生变化时，观察者得到通知，并调用 update 方法，进行相应的工作。

    【例】警察抓小偷

    警察抓小偷也可以使用观察者模式来实现，警察是观察者，小偷是被观察者。代码如下：

    小偷是一个被观察者，所以需要继承Observable类

    public class Thief extends Observable {
​
    private String name;
​
    public Thief(String name) {
        this.name = name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
​
    public String getName() {
        return name;
    }
​
    public void steal() {
        System.out.println("小偷：我偷东西了，有没有人来抓我！！！");
        super.setChanged(); //changed  = true
        super.notifyObservers();
    }
}

    警察是一个观察者，所以需要让其实现Observer接口

    public class Policemen implements Observer {

    1. ​
    2.     private String name;
    3. ​
    4.     public Policemen(String name) {
    5.         this.name = name;
    6.     }
    7.     public void setName(String name) {
    8.         this.name = name;
    9.     }
    10. ​
    11.     public String getName() {
    12.         return name;
    13.     }
    14. ​
    15.     @Override
    16.     public void update(Observable o, Object arg) {
    17.         System.out.println("警察：" + ((Thief) o).getName() + "，我已经盯你很久了，你可以保持沉默，但你所说的将成为呈堂证供！！！");
    18.     }
    19. }
    20. public class Policemen implements Observer {
    21. ​
    22.     private String name;
    23. ​
    24.     public Policemen(String name) {
    25.         this.name = name;
    26.     }
    27.     public void setName(String name) {
    28.         this.name = name;
    29.     }
    30. ​
    31.     public String getName() {
    32.         return name;
    33.     }
    34. ​
    35.     @Override
    36.     public void update(Observable o, Object arg) {
    37.         System.out.println("警察：" + ((Thief) o).getName() + "，我已经盯你很久了，你可以保持沉默，但你所说的将成为呈堂证供！！！");
    38.     }
    39. }

    6.7 中介者模式

    6.7.1 概述

    一般来说，同事类之间的关系是比较复杂的，多个同事类之间互相关联时，他们之间的关系会呈现为复杂的网状结构，这是一种过度耦合的架构，即不利于类的复用，也不稳定。例如在下左图中，有六个同事类对象，假如对象1发生变化，那么将会有4个对象受到影响。如果对象2发生变化，那么将会有5个对象受到影响。也就是说，同事类之间直接关联的设计是不好的。

    如果引入中介者模式，那么同事类之间的关系将变为星型结构，从下右图中可以看到，任何一个类的变动，只会影响的类本身，以及中介者，这样就减小了系统的耦合。一个好的设计，必定不会把所有的对象关系处理逻辑封装在本类中，而是使用一个专门的类来管理那些不属于自己的行为。

    定义：

    又叫调停模式，定义一个中介角色来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。

    6.7.2 结构

    中介者模式包含以下主要角色：

    • 抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
    • 具体中介者（ConcreteMediator）角色：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。
    • 抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
    • 具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

    6.7.3 案例实现

    【例】租房

    现在租房基本都是通过房屋中介，房主将房屋托管给房屋中介，而租房者从房屋中介获取房屋信息。房屋中介充当租房者与房屋所有者之间的中介者。

    类图如下：

    1. //抽象中介者
    2. public abstract class Mediator {
    3.     //申明一个联络方法
    4.     public abstract void constact(String message,Person person);
    5. }
    6. ​
    7. //抽象同事类
    8. public abstract class Person {
    9.     protected String name;
    10.     protected Mediator mediator;
    11. ​
    12.     public Person(String name,Mediator mediator){
    13.         this.name = name;
    14.         this.mediator = mediator;
    15.     }
    16. }
    17. ​
    18. //具体同事类 房屋拥有者
    19. public class HouseOwner extends Person {
    20. ​
    21.     public HouseOwner(String name, Mediator mediator) {
    22.         super(name, mediator);
    23.     }
    24. ​
    25.     //与中介者联系
    26.     public void constact(String message){
    27.         mediator.constact(message, this);
    28.     }
    29. ​
    30.     //获取信息
    31.     public void getMessage(String message){
    32.         System.out.println("房主" + name +"获取到的信息：" + message);
    33.     }
    34. }
    35. ​
    36. //具体同事类 承租人
    37. public class Tenant extends Person {
    38.     public Tenant(String name, Mediator mediator) {
    39.         super(name, mediator);
    40.     }
    41. ​
    42.     //与中介者联系
    43.     public void constact(String message){
    44.         mediator.constact(message, this);
    45.     }
    46. ​
    47.     //获取信息
    48.     public void getMessage(String message){
    49.         System.out.println("租房者" + name +"获取到的信息：" + message);
    50.     }
    51. }
    52. ​
    53. //中介机构
    54. public class MediatorStructure extends Mediator {
    55.     //首先中介结构必须知道所有房主和租房者的信息
    56.     private HouseOwner houseOwner;
    57.     private Tenant tenant;
    58. ​
    59.     public HouseOwner getHouseOwner() {
    60.         return houseOwner;
    61.     }
    62. ​
    63.     public void setHouseOwner(HouseOwner houseOwner) {
    64.         this.houseOwner = houseOwner;
    65.     }
    66. ​
    67.     public Tenant getTenant() {
    68.         return tenant;
    69.     }
    70. ​
    71.     public void setTenant(Tenant tenant) {
    72.         this.tenant = tenant;
    73.     }
    74. ​
    75.     public void constact(String message, Person person) {
    76.         if (person == houseOwner) {          //如果是房主，则租房者获得信息
    77.             tenant.getMessage(message);
    78.         } else {       //反正则是房主获得信息
    79.             houseOwner.getMessage(message);
    80.         }
    81.     }
    82. }
    83. ​
    84. //测试类
    85. public class Client {
    86.     public static void main(String[] args) {
    87.         //一个房主、一个租房者、一个中介机构
    88.         MediatorStructure mediator = new MediatorStructure();
    89. ​
    90.         //房主和租房者只需要知道中介机构即可
    91.         HouseOwner houseOwner = new HouseOwner("张三", mediator);
    92.         Tenant tenant = new Tenant("李四", mediator);
    93. ​
    94.         //中介结构要知道房主和租房者
    95.         mediator.setHouseOwner(houseOwner);
    96.         mediator.setTenant(tenant);
    97. ​
    98.         tenant.constact("需要租三室的房子");
    99.         houseOwner.constact("我这有三室的房子，你需要租吗？");
    100.     }
    101. }

    6.7.4 优缺点

    1，优点：

    • 松散耦合中介者模式通过把多个同事对象之间的交互封装到中介者对象里面，从而使得同事对象之间松散耦合，基本上可以做到互补依赖。这样一来，同事对象就可以独立地变化和复用，而不再像以前那样“牵一处而动全身”了。
    • 集中控制交互多个同事对象的交互，被封装在中介者对象里面集中管理，使得这些交互行为发生变化的时候，只需要修改中介者对象就可以了，当然如果是已经做好的系统，那么就扩展中介者对象，而各个同事类不需要做修改。
    • 一对多关联转变为一对一的关联没有使用中介者模式的时候，同事对象之间的关系通常是一对多的，引入中介者对象以后，中介者对象和同事对象的关系通常变成双向的一对一，这会让对象的关系更容易理解和实现。

    2，缺点：

    当同事类太多时，中介者的职责将很大，它会变得复杂而庞大，以至于系统难以维护。

    6.7.5 使用场景

    • 系统中对象之间存在复杂的引用关系，系统结构混乱且难以理解。
    • 当想创建一个运行于多个类之间的对象，又不想生成新的子类时。

    6.8 迭代器模式

    6.8.1 概述

    定义：

    提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

    6.8.2 结构

    迭代器模式主要包含以下角色：

    • 抽象聚合（Aggregate）角色：定义存储、添加、删除聚合元素以及创建迭代器对象的接口。
    • 具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
    • 抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、next() 等方法。
    • 具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

    6.8.3 案例实现

    【例】定义一个可以存储学生对象的容器对象，将遍历该容器的功能交由迭代器实现，涉及到的类如下：

    定义迭代器接口，声明hasNext、next方法

    public interface StudentIterator {
    boolean hasNext();
    Student next();
}

    定义具体的迭代器类，重写所有的抽象方法

    public class StudentIteratorImpl implements StudentIterator {
    private List list;
    private int position = 0;
​
    public StudentIteratorImpl(List list) {
        this.list = list;
    }
​
    @Override
    public boolean hasNext() {
        return position < list.size();
    }
​
    @Override
    public Student next() {
        Student currentStudent = list.get(position);
        position ++;
        return currentStudent;
    }
}

    定义抽象容器类，包含添加元素，删除元素，获取迭代器对象的方法

    public interface StudentAggregate {
    void addStudent(Student student);
​
    void removeStudent(Student student);
​
    StudentIterator getStudentIterator();
}

    定义具体的容器类，重写所有的方法

    public class StudentAggregateImpl implements StudentAggregate {
​
    private List list = new ArrayList();  // 学生列表
​
    @Override
    public void addStudent(Student student) {
        this.list.add(student);
    }
​
    @Override
    public void removeStudent(Student student) {
        this.list.remove(student);
    }
​
    @Override
    public StudentIterator getStudentIterator() {
        return new StudentIteratorImpl(list);
    }
}

    6.8.4 优缺点

    1，优点：

    • 它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类以支持新的遍历方式。
    • 迭代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计。
    • 在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足 “开闭原则” 的要求。

    2，缺点：

    增加了类的个数，这在一定程度上增加了系统的复杂性。

    6.8.5 使用场景

    • 当需要为聚合对象提供多种遍历方式时。
    • 当需要为遍历不同的聚合结构提供一个统一的接口时。
    • 当访问一个聚合对象的内容而无须暴露其内部细节的表示时。

    6.8.6 JDK源码解析

    迭代器模式在JAVA的很多集合类中被广泛应用，接下来看看JAVA源码中是如何使用迭代器模式的。

    List list = new ArrayList<>();
Iterator iterator = list.iterator(); //list.iterator()方法返回的肯定是Iterator接口的子实现类对象
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

    看完这段代码是不是很熟悉，与我们上面代码基本类似。单列集合都使用到了迭代器，我们以ArrayList举例来说明

    1. List：抽象聚合类
    2. ArrayList：具体的聚合类
    3. Iterator：抽象迭代器
    4. list.iterator()：返回的是实现了 Iterator 接口的具体迭代器对象

    具体的来看看 ArrayList的代码实现

    1. public class ArrayList extends AbstractList
    2.         implements List, RandomAccess, Cloneable, java.io.Serializable {
    3.     
    4.     public Iterator iterator() {
    5.         return new Itr();
    6.     }
    7.     
    8.     private class Itr implements Iterator {
    9.         int cursor;       // 下一个要返回元素的索引
    10.         int lastRet = -1; // 上一个返回元素的索引
    11.         int expectedModCount = modCount;
    12. ​
    13.         Itr() {}
    14.         
    15.         //判断是否还有元素
    16.         public boolean hasNext() {
    17.             return cursor != size;
    18.         }
    19. ​
    20.         //获取下一个元素
    21.         public E next() {
    22.             checkForComodification();
    23.             int i = cursor;
    24.             if (i >= size)
    25.                 throw new NoSuchElementException();
    26.             Object[] elementData = ArrayList.this.elementData;
    27.             if (i >= elementData.length)
    28.                 throw new ConcurrentModificationException();
    29.             cursor = i + 1;
    30.             return (E) elementData[lastRet = i];
    31.         }
    32.         ...
    33. }

    这部分代码还是比较简单，大致就是在 iterator 方法中返回了一个实例化的 Iterator 对象。Itr是一个内部类，它实现了 Iterator 接口并重写了其中的抽象方法。

    注意：

    当我们在使用JAVA开发的时候，想使用迭代器模式的话，只要让我们自己定义的容器类实现java.util.Iterable并实现其中的iterator()方法使其返回一个 java.util.Iterator 的实现类就可以了。

  • 相关阅读:
    Linux 虚拟化
    ASEMI代理艾赛斯二极管DSA300I100NA，肖特基DSA300I100NA
    cesiumEditor
    Linux 远程数据同步工具详解
    设置环境变量不用重启的办法
    指针笔试题（帮助你全面理解指针！！！）
    IPv4内网与公IPv4地址范围
    Web3.0实战(02)-联盟链入门讲解
    采购供应链可见性的详细介绍（数智化采购供应链系统）
    JAVA导出Excel文件
  • 原文地址：https://blog.csdn.net/weixin_60257072/article/details/128087728