【韩老师设计模式9】访问者和迭代器模式，双分派，ArrayList
访问者
完成测评系统需求
- 将观众分为男人和女人，对歌手进行测评，当看完某个歌手表演后，得到他们对
该歌手不同的评价(评价 有不同的种类，比如 成功、失败 等)
Person
- Man
- Woman
传统方式的问题分析
- 增加：大人 小孩。增加 一个待定。会很麻烦。
- 如果系统比较小，还是ok的，但是考虑系统增加越来越多新的功能时，对代码改
动较大，违反了ocp原则， 不利于维护 - 扩展性不好，比如 增加了 新的人员类型，或者管理方法，都不好做
- 引出我们会使用新的设计模式 – 访问者模式
concrete
英
/ˈkɒŋkriːt/
美
/ˈkɑːnkriːt/
adj.
确实的，具体的；实在的，有形的；混凝土的；物质的
n.
混凝土
v.
用混凝土覆盖（或做成）；<旧>（使）凝固，（使）凝结；使真实（化），使具体（化）
组成
1) Visitor 是抽象访问者，为该对象结构中的ConcreteElement的每一个类声明一个visit操作
2) ConcreteVisitor ：是一个具体的访问值 实现每个有Visitor 声明的操作，是每个操作实现的部分.
3) ObjectStructure 能枚举它的元素， 可以提供一个高层的接口，用来允许访问者访问元素
4) Element 定义一个accept 方法，接收一个访问者对象
5) ConcreteElement 为具体元素， 实现了accept 方法
Action 依赖Man Woman
-
Success 实现接口，并且依赖 Man。所以是：关联关系，类似：一对一 一对多
-
Fail 实现接口
-
Person 聚合Action
- Man 调用Action的方法，传递this
- Woman
-
ObjectStructure 聚合Person
-
Client 拿到 Action，操作：ObjectStructure ，添加Man。调用方法，参数为：Action
- 我们用 实现类 Success 传递
测评（访问者抽象类）
public abstract class Action {
//得到男性 的测评
public abstract void getManResult(Man man);
//得到女的 测评
public abstract void getWomanResult(Woman woman);
}
实现，真实访问者类
public class Success extends Action {
@Override
public void getManResult(Man man) {
System.out.println(" 男人给的评价该歌手很成功 !");
}
@Override
public void getWomanResult(Woman woman) {
System.out.println(" 女人给的评价该歌手很成功 !");
}
}
//使用 父类
@Override
public void getManResult(Person man) {
if (man instanceof Man){
System.out.println(" 男人给的评价该歌手很成功 !");
}
}
抽象类 人
public abstract class Person {
//提供一个方法，让访问者可以访问
public abstract void accept(Action action);
}
实现类
//说明
//1. 这里我们使用到了双分派, 即首先在客户端程序中，将具体状态作为参数传递Woman中(第一次分派)
//2. 然后Woman 类调用作为参数的 "具体方法" 中方法getWomanResult, 同时将自己(this)作为参数
// 传入，完成第二次的分派
//Success类，getManResult(Man man)
//Woman类，action.getWomanResult(this);
public class Woman extends Person{
@Override
public void accept(Action action) {
//这句代码是核心：反向访问 action 实现类的方法，使用自己作为参数。
//具体元素对访问者公布细节
action.getWomanResult(this);
}
}
数据结构
//数据结构，管理很多人（Man , Woman）
public class ObjectStructure {
//维护了一个集合
private List<Person> persons = new LinkedList<>();
//增加到list
public void attach(Person p) {
persons.add(p);
}
//移除
public void detach(Person p) {
persons.remove(p);
}
//显示测评情况
public void display(Action action) {
for(Person p: persons) {
p.accept(action);
}
}
}
测试
//创建ObjectStructure
ObjectStructure s = new ObjectStructure();
s.attach(new Man());
s.attach(new Woman());
//成功
Success success = new Success();
s.display(success);
System.out.println("===============");
Fail fail = new Fail();
s.display(fail);
System.out.println("=======给的是待定的测评========");
Wait wait = new Wait();
s.display(wait);
男人给的评价该歌手很成功 !
女人给的评价该歌手很成功 !
===============
男人给的评价该歌手失败 !
女人给的评价该歌手失败 !
=======给的是待定的测评========
男人给的评价是该歌手待定 ..
女人给的评价是该歌手待定 ..
双分派
-上面提到了双分派，所谓双分派是指不管类怎么变化，我们都能找到期望的方法运行。
双分派意味着 得到执行的操作 取决于请求的种类 和 两个接收者的类型
- 以上述实例为例，假设我们要添加一个Wait的状态类， 考察Man类和Woman类的反
应，由于使用了双分派， 只需增加一个Action子类即可在客户端调用即可， 不
需要改动任何其他类的代码。
优缺点
优点
- 访问者模式符合单一职责原则、让程序具有优秀的扩展性、灵活性非常高
- 访问者模式可以对功能进行统一，可以做报表、 UI、拦截器与过滤器，适用于数据
结构相对稳定的系统
缺点 - 具体元素对访问者公布细节，也就是说访问者关注了其他类的内部细节，这是迪米
特法则所不建议的, 这样造成了具体元素变更比较困难 - 违背了依赖倒转原则。访问者依赖的是具体元素，而不是抽象元素
- 因此，如果一个系统有比较稳定的数据结构，又有经常变化的功能需求，那么访问
者模式就是比较合适的
迭代器
编写程序展示一个学校院系结构：需求是这样，要在一个页面中展示出学校的院系
组成，一个学校有多个学院，一个学院有多个系。 如图：
计算机学院系=> 数组中
信息工程学院系=> 集合
传统的方式的问题分析
- 将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分
层次的 - 实际上我们的要求是 ： 在一个页面中展示出学校的院系组成，一个学校有多个
学院，一个学院有多个系， 因此这种方案，不能很好实现的遍历的操作
基本介绍
- 迭代器模式（Iterator Pattern） 是常用的设计模式，属于行为型模式
- 如果我们的集合元素是用不同的方式实现的， 有数组，还有java的集合类，
或者还有其他方式，当客户端要遍历这些集合元素的时候就要使用多种遍历
方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。 - 迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，
不需要知道集合对象的底层表示，即： 不暴露其内部的结构
Iterator
public interface Iterator<E> {
boolean hasNext();
E next();
default void remove() {
throw new UnsupportedOperationException("remove");
}
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}
角色分布
对原理类图的说明-即(迭代器模式的角色及职责)
-
Iterator ： 迭代器接口，是系统提供，含义 hasNext, next, remove
2) ConcreteIterator : 具体的迭代器类，管理迭代 -
Aggregate :一个统一的聚合接口， 将客户端和具体聚合解耦
4) ConcreteAggreage：具体的聚合 持有对象集合，并提供一个方法，返回一个迭代器，该迭代器 可以正确遍历集合
5）Client：客户端，通过 Iterator 和 Aggregate 依赖子类。
-
Client使用：Output Impl ，Iterator，College
-
Iterator 这边是输出的方式（怎么迭代）
- Computer College Iterator 一下这四个实现类 聚合：Department
- Info Colleage Iterator
-
College 这边是 真正的数据
- Computer Colleage
- Info Colleage
- 聚合：Output Impl (完成对所有学员的输出)
public class Department {
private String name;
private String desc;
}
计算机学院 迭代器
- 假定：计算机学院 是数组的方式 存放的
public class ComputerCollegeIterator implements Iterator {
//这里我们需要Department 是以怎样的方式存放=>数组
Department[] departments;
int position = 0; //遍历的位置
public ComputerCollegeIterator(Department[] departments) {
this.departments = departments;
}
//判断是否还有下一个元素
@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() {
}
}
使用List存放
public class InfoColleageIterator implements Iterator {
List<Department> departmentList; // 信息工程学院是以List方式存放系
int index = -1;//索引
public InfoColleageIterator(List<Department> departmentList) {
this.departmentList = departmentList;
}
//判断list中还有没有下一个元素
@Override
public boolean hasNext() {
if(index >= departmentList.size() - 1) {
return false;
} else {
index += 1;
return true;
}
}
@Override
public Object next() {
return departmentList.get(index);
}
//空实现remove
}
学院接口
public interface College {
public String getName();
//增加系的方法
public void addDepartment(String name, String desc);
//返回一个迭代器,遍历
public Iterator createIterator();
}
计算机学院
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;
}
@Override
public Iterator createIterator() {
//返回 一个 计算机学院的 迭代器
return new ComputerCollegeIterator(departments);
}
}
信息工程学院
public class InfoCollege implements College {
List<Department> departmentList;
public InfoCollege() {
departmentList = new ArrayList<Department>();
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);
}
@Override
public Iterator createIterator() {
return new InfoColleageIterator(departmentList);
}
}
输出类
public class OutPutImpl {
//学院集合
List<College> collegeList;
public OutPutImpl(List<College> collegeList) {
this.collegeList = collegeList;
}
//遍历所有学院,然后调用printDepartment 输出各个学院的系
public void printCollege() {
//从collegeList 取出所有学院, Java 中的 List 已经实现Iterator
Iterator<College> iterator = collegeList.iterator();
while(iterator.hasNext()) {
//取出一个学院
College college = iterator.next();
System.out.println("=== "+college.getName() +"=====" );
printDepartment(college.createIterator()); //得到对应迭代器
}
}
//输出 学院输出 系
public void printDepartment(Iterator iterator) {
while(iterator.hasNext()) {
Department d = (Department)iterator.next();
System.out.println(d.getName());
}
}
}
测试
//创建学院
List<College> collegeList = new ArrayList<College>();
ComputerCollege computerCollege = new ComputerCollege();
InfoCollege infoCollege = new InfoCollege();
collegeList.add(computerCollege);
//collegeList.add(infoCollege);
OutPutImpl outPutImpl = new OutPutImpl(collegeList);
outPutImpl.printCollege();
=== 计算机学院=====
Java专业
PHP专业
大数据专业
=== 信息工程学院=====
信息安全专业
网络安全专业
服务器安全专业
ArrayList
迭代器模式在JDK-ArrayList集合应用的源码分析
- JDK的ArrayList 集合中就使用了迭代器模式
List<String> a = new ArrayList<>();
a.add("jack");
Iterator Itr = a.iterator();
while (Itr.hasNext()) {
System.out.println(Itr.next());
}
接口 和 数据和迭代器（内部类）
//充当了 聚合接口
public interface List<E> extends Collection<E> {
Iterator<E> iterator();
}
//相当于 计算机学院
public class ArrayList<E> extends AbstractList<E>
implements List<E>{
//Object相当于 department
transient Object[] elementData; // non-private to simplify nested class access
public Iterator<E> iterator() {
//Itr是 内部类，所以 无需 聚合 object数组，而是直接使用的
return new Itr();
}
}
ArrayList内部类 Itr
- 相当于 计算机学院的迭代器
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
//使用 elementData
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
LinkedList
ArrayLinkedList
Vector
LinkedList
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
}
public abstract class AbstractSequentialList<E> extends AbstractList<E> {
public Iterator<E> iterator() {
return listIterator();
}
}
//最终调用 ListItr
private class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
cursor = index;
}
}
角色分析说明
- 内部类Itr 充当具体实现迭代器Iterator 的类， 作为ArrayList 内部类
- List 就是充当了聚合接口，含有一个iterator() 方法，返回一个迭代器对象
- ArrayList 是实现聚合接口List 的子类，实现了iterator()
- Iterator 接口系统提供
- 迭代器模式解决了 不同集合(ArrayList ,LinkedList) 统一遍历问题
注意事项
优点
- 提供一个统一的方法遍历对象，客户不用再考虑聚合的类型，使用一种方法就可以
遍历对象了。 - 隐藏了聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不会知道聚
合的具体组成。 - 提供了一种设计思想，就是一个类应该只有一个引起变化的原因（叫做单一责任
原则）。在聚合类中，我们把迭代器分开，就是要把管理对象集合和遍历对象集
合的责任分开，这样一来集合改变的话，只影响到聚合对象。而如果遍历方式改变
的话，只影响到了迭代器。 - 当要展示一组相似对象，或者遍历一组相同对象时使用, 适合使用迭代器模式
缺点
每个聚合对象都要一个迭代器，会生成多个迭代器不好管理类