夜光序言：
他会出现的吧，只是那些数不尽的美好瞬间，夏日傍晚的烧烤摊儿、新开的甜品店，人潮拥挤的街头，就这样被我一个人匆匆路过。
正文：
以道御术 / 以术识道
package 访问者模式.歌手评分;
public abstract class Action {
//得到男性的测评
public abstract void getManResult(Man man);
//得到女性的测评
public abstract void getWomanResult(Woman woman);
}
package 访问者模式.歌手评分;
public class Fail extends Action{
@Override
public void getManResult(Man man) {
System.out.println("圣子给的评价是很失败~~");
}
@Override
public void getWomanResult(Woman woman) {
System.out.println("圣女给的评价是很失败~~");
}
}
package 访问者模式.歌手评分;
public class Man extends Person{
@Override
public void accept(Action action) {
action.getManResult(this); //夜光：这个里面传什么很关键
//本质上认为是什么，我们就传什么，这里是this
}
}
package 访问者模式.歌手评分;
import java.util.LinkedList;
import java.util.List;
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); //写一个foreach循环
}
}
}
package 访问者模式.歌手评分;
public abstract class Person {
//提供一个方法，让访问者可以访问
public abstract void accept(Action action);
}
package 访问者模式.歌手评分;
public class Success extends Action{
@Override
public void getManResult(Man man) {
System.out.println("圣子给的评价是很成功~~");
}
@Override
public void getWomanResult(Woman woman) {
System.out.println("圣女给的评价是很成功~~");
}
}
package 访问者模式.歌手评分;
//我们再写一个类
//嗯唔
public class Wait extends Action{
@Override
public void getManResult(Man man) {
System.out.println("圣子给的评价是成绩待定");
}
@Override
public void getWomanResult(Woman woman) {
System.out.println("圣女给的评价是成绩待定");
}
}
package 访问者模式.歌手评分;
//这里：
//1. 使用到了双分派，即首先在客户端程序中，将具体的状态作为参数传递woman（第一次分派）
//2. 然后woman 类调用作为参数的"具体方法"中方法getWomanResult
//同时将自己（this）作为参数，完成第二次分派
public class Woman extends Person{
@Override
public void accept(Action action) {
action.getWomanResult(this);
}
}
package 访问者模式.歌手评分;
public class Client {
public static void main(String[] args) {
//创建ObjectStructure
ObjectStructure objectStructure = new ObjectStructure();
objectStructure.attach(new Man());
objectStructure.attach(new Woman());
//成功
System.out.println("===============成功的评价=================");
Success success = new Success();
objectStructure.display(success);
System.out.println("================失败的评价================");
Fail fail = new Fail();
objectStructure.display(fail);
System.out.println("================待定的评价================");
Wait wait = new Wait();
objectStructure.display(wait);
}
}
下面我们讲解一下迭代器模式
package 迭代器模式.统一遍历问题;
import java.util.ArrayList;
import java.util.List;
//测试一下
public class Client {
public static void main(String[] args) {
//创建学院
List<College> collegeList = new ArrayList<>();
ComputerCollege computerCollege = new ComputerCollege();
InfoCollege infoCollege = new InfoCollege();
collegeList.add(computerCollege);
collegeList.add(infoCollege);
//我们就拿到一个输出类的对象
OutPutImpl outPut = new OutPutImpl(collegeList);
outPut.printCollege();
}
}
package 迭代器模式.统一遍历问题;
import java.util.Iterator;
//接口，核心的方法是返回
public interface College {
public String getName();
//增加系的方法
public void addDepartment(String name,String desc);
//返回一个迭代器，用来遍历
public Iterator createIterator();
}
package 迭代器模式.统一遍历问题;
import java.util.Iterator;
public class ComputerCollege implements College{
Department[] departments;
int numOfDepatment = 0; //保存当前数组的对象个数
public ComputerCollege(){
departments = new Department[5];
addDepartment("网络工程专业","5G技术");
addDepartment("电子工程专业","5G技术");
addDepartment("通讯工程专业","5G技术");
addDepartment("软件工程专业","5G技术");
}
@Override
public String getName() {
return "计算机学院";
}
@Override
public void addDepartment(String name, String desc) {
Department department = new Department(name, desc);
departments[numOfDepatment] = department;
numOfDepatment += 1;
}
@Override
public Iterator createIterator() {
return new ComputerCollegeIterator(departments);
}
}
package 迭代器模式.统一遍历问题;
import java.util.Iterator;
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;
}
{
return true;
}
}
@Override
public Object next() {
Department department = departments[position];
position +=1;
return department;
}
//删除的方法，默认空实现
public void remove(){
}
}
package 迭代器模式.统一遍历问题;
public class Department {
private String name;
private String desc;
//提供构造器
public Department(String name, String desc) {
this.name = name;
this.desc = desc;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
}
package 迭代器模式.统一遍历问题;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class InfoCollege implements College{
//需要一个控制输出 list
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 InfoCollegeIterator(departmentList);
}
}
package 迭代器模式.统一遍历问题;
import java.util.Iterator;
import java.util.List;
public class InfoCollegeIterator implements Iterator {
//夜光：这里我们换一种方式，用list
List<Department> departmentList; //信息工程学院是以list方式存放系
int index = -1; //定义一个索引
//下面还是构造器
public InfoCollegeIterator(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 void remove(){
}
}
