设计模式

案例引入

编写程序展示一个学校院系结构: 需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系

【传统方式】

将学院看做是学校的子类，系是学院的子类，小的组织继承大的组织

分析： 在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系， 因此这种方案，不能很好实现遍历操作（有可能计算机学院的系是使用数组存储的，信息工程学院的系是使用集合存储的，遍历的方式不太一样，因此不能统一遍历）

【改进】

使用迭代器模式

介绍

基础介绍

• 迭代器模式属于行为型模式
• 如果我们的元素集是用不同的方式实现，有数组、java的集合类或其他方式，当客户端要遍历这些元素集的元素的时就要使用多种遍历方式，而且还会暴露元素的内部结构，这时可以考虑使用迭代器模式解决
• 迭代器模式提供一种遍历元素集元素的统一接口，用一致的方法遍历元素集的元素，不需要知道元素集对象的底层表示，即不需要暴露元素集对象内部的结构

  应用场景

  • 当要展示一组相似对象，或者遍历一组相同对象时使用，适合使用迭代器模式

    登场角色

    

    

    • lterator(迭代器): 该角色负责定义按顺序逐个遍历元素的接口(API)，可以使用Java自带的，含有 hasNext、next、remove 等方法
    • Concretelterator(具体的迭代器)：具体的选代器类，实现Iterator角色所定义的接口(API)
    • Aggregate(元素集)：一个统一的元素集接口，将客户端和具体元素集解耦，定义了创建Iterator角色的接口(API)
    • ConcreteAggregate(具体的元素集): 负责实现Aggregate角色所定义的接口(API)。它会创建出具体的迭代器，即Concretelterator角色，该迭代器可以用于遍历元素集
    • Client(客户端)：通过Iterator、Aggregate依赖其各自的子类

      案例实现

      案例一

      

      实现

      【计算机学院迭代器】

      package com.atguigu.iterator;
      import java.util.Iterator;
      public class ComputerCollegeIterator implements Iterator {
      /**
      * 这里我们需要Department是以怎样的方式存放（如果不知道，没办法重写Iterator的方法）=>已知计算机学院存放系的时候是数组耳朵方式
      */
      Department[] departments;
      /**
      * 遍历的位置
      */
      int position = 0;
      public ComputerCollegeIterator(Department[] departments) {
      this.departments = departments;
      }
      /**
      * 判断是否还有下一个元素
      * @return
      */
      @Override
      public boolean hasNext() {
      if (position >= departments.length || departments[position] == null) {
      return false;
      } else {
      return true;
      }
      }
      @Override
      public Object next() {
      Department department = departments[position];
      position += 1;
      return department;
      }
      /**
      * 删除的方法，默认空实现
      */
      public void remove() {
      }
      }
      

      【信息工程学院迭代器】

      package com.atguigu.iterator;
      import java.util.Iterator;
      import java.util.List;
      public class InfoColleageIterator implements Iterator {
      /**
      * 信息工程学院是以List方式存放系
      */
      List departmentList;
      /**
      * 索引
      */
      int index = 0;
      public InfoColleageIterator(List departmentList) {
      this.departmentList = departmentList;
      }
      /**
      * 判断list中还有没有下一个元素
      * @return
      */
      @Override
      public boolean hasNext() {
      if (index >= departmentList.size() - 1) {
      return false;
      } else {
      return true;
      }
      }
      @Override
      public Object next() {
      Department department = departmentList.get(index++);
      return department;
      }
      /**
      * 空实现remove
      */
      public void remove() {
      }
      }
      

      【学院接口】

      package com.atguigu.iterator;
      import java.util.Iterator;
      public interface College {
      public String getName();
      /**
      * 增加系的方法
      *
      * @param name
      * @param desc
      */
      public void addDepartment(String name, String desc);
      /**
      * 返回一个迭代器来执行遍历功能
      *
      * @return
      */
      public Iterator createIterator();
      }
      

      【计算机学院】

      package com.atguigu.iterator;
      import java.util.Iterator;
      public class ComputerCollege implements College {
      Department[] departments;
      /**
      * 保存当前数组的对象个数
      */
      int numOfDepartment = 0;
      public ComputerCollege() {
      departments = new Department[5];
      addDepartment("Java专业", " Java专业 ");
      addDepartment("PHP专业", " PHP专业 ");
      addDepartment("大数据专业", " 大数据专业 ");
      }
      @Override
      public String getName() {
      return "计算机学院";
      }
      @Override
      public void addDepartment(String name, String desc) {
      Department department = new Department(name, desc);
      departments[numOfDepartment] = department;
      numOfDepartment += 1;
      }
      /**
      * 获取迭代器
      * @return
      */
      @Override
      public Iterator createIterator() {
      return new ComputerCollegeIterator(departments);
      }
      }
      

      【信息工程学院】

      package com.atguigu.iterator;
      import java.util.ArrayList;
      import java.util.Iterator;
      import java.util.List;
      public class InfoCollege implements College {
      List departmentList;
      public InfoCollege() {
      departmentList = new ArrayList();
      addDepartment("信息安全专业", " 信息安全专业 ");
      addDepartment("网络安全专业", " 网络安全专业 ");
      addDepartment("服务器安全专业", "服务器安全专业 ");
      }
      @Override
      public String getName() {
      return "信息工程学院";
      }
      @Override
      public void addDepartment(String name, String desc) {
      Department department = new Department(name, desc);
      departmentList.add(department);
      }
      /**
      * 获取迭代器
      * @return
      */
      @Override
      public Iterator createIterator() {
      return new InfoColleageIterator(departmentList);
      }
      }
      

      【遍历输出类】

      package com.atguigu.iterator;
      import java.util.Iterator;
      import java.util.List;
      public class OutPutImpl {
      /**
      * 学院集合
      */
      List collegeList;
      public OutPutImpl(List collegeList) {
      this.collegeList = collegeList;
      }
      /**
      * 遍历所有学院，然后调用printDepartment 输出各个学院的系
      */
      public void printCollege() {
      //从collegeList 取出所有学院, Java 中的 List 已经实现Iterator
      Iterator iterator = collegeList.iterator();
      while (iterator.hasNext()) {
      //取出一个学院
      College college = iterator.next();
      System.out.println("=== " + college.getName() + "=====");
      //得到学院的对应迭代器
      printDepartment(college.createIterator());
      }
      }
      /**
      * 使用学院的迭代器 输出学院的系
      * @param iterator
      */
      public void printDepartment(Iterator iterator) {
      while (iterator.hasNext()) {
      Department d = (Department) iterator.next();
      System.out.println(d.getName());
      }
      }
      }
      

      【主类】

      package com.atguigu.iterator;
      import java.util.ArrayList;
      import java.util.List;
      public class Client {
      public static void main(String[] args) {
      // 创建学院集合
      List collegeList = new ArrayList();
      // 添加学院
      ComputerCollege computerCollege = new ComputerCollege();
      InfoCollege infoCollege = new InfoCollege();
      collegeList.add(computerCollege);
      collegeList.add(infoCollege);
      OutPutImpl outPutImpl = new OutPutImpl(collegeList);
      outPutImpl.printCollege();
      }
      }
      

      【运行】

      === 计算机学院=====
      Java专业
      PHP专业
      大数据专业
      === 信息工程学院=====
      信息安全专业
      网络安全专业
      Process finished with exit code 0
      

      案例二

      

      实现

      【Aggregate接口】

      package com.atguigu.iterator.Sample;
      /**
      * 要遍历的元素集的接口，实现这个接口的类一般可以保存多个元素
      */
      public interface Aggregate {
      /**
      * 生成用于遍历的迭代器
      * @return
      */
      public abstract Iterator iterator();
      }
      

      【Iterator接口：可以直接使用JDK自带的，也可以自己直接写一个】

      package com.atguigu.iterator.Sample;
      public interface Iterator {
      /**
      * 是否有下一个元素
      * @return
      */
      public abstract boolean hasNext();
      /**
      * 获取下一个元素
      * @return
      */
      public abstract Object next();
      }
      

      【被存储的元素：Book】

      package com.atguigu.iterator.Sample;
      /**
      * 要存储的元素
      */
      public class Book {
      private String name;
      public Book(String name) {
      this.name = name;
      }
      public String getName() {
      return name;
      }
      }
      

      【书架：具体的Aggregate】

      package com.test.iterator.Sample;
      /**
      * 书架，存放书的元素集
      */
      public class BookShelf implements Aggregate {
      // 不让外界直接操作书籍数组
      private Book[] books;
      private int last = 0;
      public BookShelf(int maxsize) {
      this.books = new Book[maxsize];
      }
      public Book getBookAt(int index) {
      return books[index];
      }
      public void appendBook(Book book) {
      this.books[last] = book;
      last++;
      }
      public int getLength() {
      return last;
      }
      public Iterator iterator() {
      // 返回书架的遍历迭代器
      return new BookShelfIterator(this);
      }
      }
      

      【书架遍历迭代器实现】

      package com.atguigu.iterator.Sample;
      public class BookShelfIterator implements Iterator {
      private BookShelf bookShelf;
      private int index;
      public BookShelfIterator(BookShelf bookShelf) {
      this.bookShelf = bookShelf;
      this.index = 0;
      }
      public boolean hasNext() {
      if (index < bookShelf.getLength()) {
      return true;
      } else {
      return false;
      }
      }
      public Object next() {
      Book book = bookShelf.getBookAt(index);
      // 取出下本书籍后，索引+1
      index++;
      return book;
      }
      }
      

      【主类】

      package com.atguigu.iterator.Sample;
      public class Main {
      public static void main(String[] args) {
      BookShelf bookShelf = new BookShelf(4);
      bookShelf.appendBook(new Book("Around the World in 80 Days"));
      bookShelf.appendBook(new Book("Bible"));
      bookShelf.appendBook(new Book("Cinderella"));
      bookShelf.appendBook(new Book("Daddy-Long-Legs"));
      // 获取书架的遍历迭代器
      Iterator it = bookShelf.iterator();
      // 开始遍历
      while (it.hasNext()) {
      Book book = (Book)it.next();
      System.out.println(book.getName());
      }
      }
      }
      

      【运行】

      Around the World in 80 Days
      Bible
      Cinderella
      Daddy-Long-Legs
      Process finished with exit code 0
      

      迭代器模式在JDK源码中的应用

      

      

      

      

      • lterator接口由系统提供
      • 内部类ltr充当具体实现迭代器Iterator的内部类
      • List充当了元素集接口，含有一个iterator() 方法，返回一个选代器对象
      • ArrayList 是实现元素集接口List的子类，实现了iterator()
      • 迭代器模式解决了不同元素集(ArrayList，LinkedList)的统一遍历问题

        总结

        【优点】

        • 提供一个统一的方法来遍历不同的元素集中的对象，客户不用再考虑元素集的类型，使用一种方法就可以遍历对象了
        • 隐藏了元素集的内部结构，客户端要遍历元素集的时候只能取到迭代器，而不会知道元素集的具体组成（比如说不知道使用什么数据结构存储的）
        • 提供了一种设计思想，就是一个类应该只有一个引起变化的原因 (叫做单一责任原则)。在元素集类中，我们把迭代器分开，就是要把管理元素集和遍历元素集的责任分开，这样一来元素集改变的话，只要修改元素集对象；而如果遍历方式改变的话，只要修改迭代器

          【缺点】

          • 每个元素集对象都要一个迭代器，会生成多个选代器不好管理类

            【思考】

            问：为什么一定要考虑引人迭代器模式呢？如果是数组，直接使用for循环语句进行遍历处理不就可以了吗?

            • 引人Iterator后可以将遍历与元素集的实现分离开来。如果书架的实现方式不再使用数组存储，而是使用集合，那就只需要修改具体的迭代器和具体元素集即可，客户端并不需要修改，还是可以直接使用Iterator迭代器进行遍历
            • 方便实现多种不同的迭代方式，如正序遍历、倒序遍历、跳跃遍历……，想要拓展遍历方式，只需要给ConcreteAggregate编写新的ConcreteIterator即可，不需要修改元素集类的相关代码