访问者
完成测评系统需求
- 将观众分为男人和女人,对歌手进行测评,当看完某个歌手表演后,得到他们对
该歌手不同的评价(评价 有不同的种类,比如 成功、失败 等)
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) 统一遍历问题
注意事项
优点
- 提供一个统一的方法遍历对象,客户不用再考虑聚合的类型,使用一种方法就可以
遍历对象了。 - 隐藏了聚合的内部结构,客户端要遍历聚合的时候只能取到迭代器,而不会知道聚
合的具体组成。 - 提供了一种设计思想,就是一个类应该只有一个引起变化的原因(叫做单一责任
原则)。在聚合类中,我们把迭代器分开,就是要把管理对象集合和遍历对象集
合的责任分开,这样一来集合改变的话,只影响到聚合对象。而如果遍历方式改变
的话,只影响到了迭代器。 - 当要展示一组相似对象,或者遍历一组相同对象时使用, 适合使用迭代器模式
缺点
每个聚合对象都要一个迭代器,会生成多个迭代器不好管理类