夜光序言:
他会出现的吧,只是那些数不尽的美好瞬间,夏日傍晚的烧烤摊儿、新开的甜品店,人潮拥挤的街头,就这样被我一个人匆匆路过。
正文:
以道御术 / 以术识道
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(){
}
}