1.中介者模式
中介者模式包含以下主要角色：
-
抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
-
具体中介者（ConcreteMediator）角色：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。
-
抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
-
具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。
抽象中介者：
//抽象中介者类
public abstract class Mediator {
//沟通的方法
public abstract void constact(String message, Person person);
}具体中介者：
//具体的中介者角色类
public class MediatorStructure extends Mediator {
//聚合房主和租房者对象
private HouseOwner houseOwner;
private Tenant tenant;
public HouseOwner getHouseOwner() {
return houseOwner;
}
public void setHouseOwner(HouseOwner houseOwner) {
this.houseOwner = houseOwner;
}
public Tenant getTenant() {
return tenant;
}
public void setTenant(Tenant tenant) {
this.tenant = tenant;
}
@Override
public void constact(String message, Person person) {
if(person == houseOwner) {
tenant.getMessage(message);
} else {
houseOwner.getMessage(message);
}
}
}
抽象同事类：
//抽象同事类
public abstract class Person {
protected String name;
protected Mediator mediator;
public Person(String name, Mediator mediator) {
this.name = name;
this.mediator = mediator;
}
//和中介联系（沟通）
public void constact(String message) {
mediator.constact(message, this);
}
}
具体同事类：
//租房者：具体的同事角色类
public class Tenant extends Person {
public Tenant(String name, Mediator mediator) {
super(name, mediator);
}
//获取信息
public void getMessage(String message) {
System.out.println("租房者" + name + "获取到的信息是：" + message);
}
}
//房主类： 具体的同事角色类
public class HouseOwner extends Person {
public HouseOwner(String name, Mediator mediator) {
super(name, mediator);
}
//获取信息
public void getMessage(String message) {
System.out.println("房主" + name + "获取到的信息是：" + message);
}
}
测试类：
public class Client {
public static void main(String[] args) {
//创建中介者对象
MediatorStructure mediator = new MediatorStructure();
//创建租房者对象
Tenant tenant = new Tenant("李四", mediator);
//创建房主对象
HouseOwner houseOwner = new HouseOwner("张三", mediator);
//中介者要知道具体的房主和租房者
mediator.setTenant(tenant);
mediator.setHouseOwner(houseOwner);
tenant.constact("我要租三室的房子！！！");
houseOwner.constact("我这里有三室的房子，你要租吗？");
//房主张三获取到的信息是：我要租三室的房子！！！
//租房者李四获取到的信息是：我这里有三室的房子，你要租吗？
}
}2.迭代器模式
迭代器模式主要包含以下角色：
-
抽象聚合（Aggregate）角色：定义存储、添加、删除聚合元素以及创建迭代器对象的接口。
-
具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
-
抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、next() 等方法。
-
具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。
存储的实体类：
public class Student {
private String name;
private String number;
public Student() {
}
public Student(String name, String number) {
this.name = name;
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", number='" + number + '\'' +
'}';
}
}
抽象聚合：
//抽象聚合角色接口
public interface StudentAggregate {
//添加学生功能
void addStudent(Student stu);
//删除学生功能
void removeStudent(Student stu);
//获取迭代器对象功能
StudentIterator getStudentIterator();
}
具体聚合：
import java.util.ArrayList;
import java.util.List;
//具体聚合角色类
public class StudentAggregateImpl implements StudentAggregate {
private List<Student> list = new ArrayList<>();
@Override
public void addStudent(Student stu) {
list.add(stu);
}
@Override
public void removeStudent(Student stu) {
list.remove(stu);
}
@Override
//获取迭代器对象
public StudentIterator getStudentIterator() {
return new StudentIteratorImpl(list);
}
}抽象迭代器：
//抽象迭代器角色接口
public interface StudentIterator {
//判断是否还有元素
boolean hasNext();
//获取下一个元素
Student next();
}
具体迭代器：
import java.util.List;
//具体迭代器角色类
public class StudentIteratorImpl implements StudentIterator {
private List<Student> list;
private int position = 0;//用来记录遍历时的位置
public StudentIteratorImpl(List<Student> list) {
this.list = list;
}
@Override
public boolean hasNext() {
return position < list.size();
}
@Override
public Student next() {
//从集合中获取指定位置的元素
Student currentStudent = list.get(position);
position++;
return currentStudent;
}
}
Java源码中的集合迭代器
public class IteratorDemo {
public static void main(String[] args) {
ArrayList<Integer> arr = new ArrayList<>();
for (int i = 0; i < 20; i++) {
arr.add(i);
}
Iterator<Integer> iterator = arr.iterator();
while (iterator.hasNext()) {
Integer next = iterator.next();
System.out.println(next);
}
}
}public class ArrayList<E>{
public Iterator<E> iterator() {
return new 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() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
}
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());
}
}
3.访问者模式
访问者模式包含以下主要角色:
-
抽象访问者（Visitor）角色：定义了对每一个元素
（Element）访问的行为，它的参数就是可以访问的元素，它的方法个数理论上来讲与元素类个数（Element的实现类个数）是一样的，从这点不难看出，访问者模式要求元素类的个数不能改变。 -
具体访问者（ConcreteVisitor）角色：给出对每一个元素类访问时所产生的具体行为。
-
抽象元素（Element）角色：定义了一个接受访问者的方法（
accept），其意义是指，每一个元素都要可以被访问者访问。 -
具体元素（ConcreteElement）角色： 提供接受访问方法的具体实现，而这个具体的实现，通常情况下是使用访问者提供的访问该元素类的方法。
-
对象结构（Object Structure）角色：定义当中所提到的对象结构，对象结构是一个抽象表述，具体点可以理解为一个具有容器性质或者复合对象特性的类，它会含有一组元素（
Element），并且可以迭代这些元素，供访问者访问。
抽象访问者：
//喂食的人：抽象访问者角色类
public interface Person {
//喂食宠物狗
void feed(Cat cat);
//喂食宠物猫
void feed(Dog dog);
}
具体访问者：
//主人：体访问者角色类
public class Owner implements Person {
@Override
public void feed(Cat cat) {
System.out.println("主人喂食猫");
}
@Override
public void feed(Dog dog) {
System.out.println("主人喂食狗");
}
}
//其他人:具体访问者角色类
public class Someone implements Person {
@Override
public void feed(Cat cat) {
System.out.println("其他人喂食猫");
}
@Override
public void feed(Dog dog) {
System.out.println("其他人喂食狗");
}
}抽象元素：
//宠物：抽象元素角色类
public interface Animal {
//接受访问者访问的功能
void accept(Person person);
}
具体元素：
//宠物猫：具体元素角色类
public class Cat implements Animal {
@Override
public void accept(Person person) {
person.feed(this); //访问者给宠物猫喂食
System.out.println("好好吃，喵喵喵。。。");
}
}
//宠物狗：具体元素角色类
public class Dog implements Animal {
@Override
public void accept(Person person) {
person.feed(this); //访问者给宠物猫喂食
System.out.println("好好吃，汪汪汪。。。");
}
}
对象结构：
//对象结构类
public class Home {
//声明一个集合对象，用来存储元素对象
private List<Animal> nodeList = new ArrayList<>();
//添加元素功能
public void add(Animal animal) {
nodeList.add(animal);
}
public void action(Person person) {
//遍历集合，获取每一个元素，让访问者访问每一个元素
for (Animal animal : nodeList) {
animal.accept(person);
}
}
}测试类 ：
public class Client {
public static void main(String[] args) {
//创建Home对象
Home home = new Home();
//添加元素到Home对象中
home.add(new Dog());
home.add(new Cat());
//创建主人对象
Owner owner = new Owner();
//让主人喂食所有的宠物
home.action(owner);
}
}优缺点
1，优点：
-
扩展性好
在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能。
-
复用性好
通过访问者来定义整个对象结构通用的功能，从而提高复用程度。
-
分离无关行为
通过访问者来分离无关的行为，把相关的行为封装在一起，构成一个访问者，这样每一个访问者的功能都比较单一。
2，缺点：
-
对象结构变化很困难
在访问者模式中，每增加一个新的元素类，都要在每一个具体访问者类中增加相应的具体操作，这违背了“开闭原则”。
-
违反了依赖倒置原则
访问者模式依赖了具体类，而没有依赖抽象类。
使用场景
-
对象结构相对稳定，但其操作算法经常变化的程序。
-
对象结构中的对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构。
双分派技术
访问者模式用到了一种双分派的技术。
分派
变量被声明时的类型叫做变量的静态类型，有些人又把静态类型叫做明显类型；而变量所引用的对象的真实类型又叫做变量的实际类型。比如 Map map = new HashMap() ，map变量的静态类型是 Map ，实际类型是 HashMap 。根据对象的类型而对方法进行的选择，就是分派(Dispatch)，分派(Dispatch)又分为两种，即静态分派和动态分派。
静态分派(Static Dispatch)
发生在编译时期，分派根据静态类型信息发生。静态分派对于我们来说并不陌生，方法重载就是静态分派。
！！！重载方法的分派是根据静态类型进行的，这个分派过程在编译时期就完成了！！！
/**
* 静态分派
* 发生在编译时期，分派根据静态类型信息发生。
* 方法重载就是静态分派。
*
* ！！！重载方法的分派是根据静态类型进行的，这个分派过程在编译时期就完成了
*/
public class demo2 {
public static void main(String[] args) {
Animal a = new Animal();
Animal a1 = new Dog();
Animal a2 = new Cat();
Execute exe = new Execute();
exe.execute(a);//Animal
exe.execute(a1);//Animal
exe.execute(a2);//Animal
}
}
class Animal {
}
class Dog extends Animal {
}
class Cat extends Animal {
}
class Execute {
public void execute(Animal a) {
System.out.println("Animal");
}
public void execute(Dog d) {
System.out.println("dog");
}
public void execute(Cat c) {
System.out.println("cat");
}
}动态分派(Dynamic Dispatch)
发生在运行时期，动态分派动态地置换掉某个方法。Java通过方法的重写支持动态分派。
/**
* 动态分派
* 发生在运行时期，动态分派动态地置换掉某个方法
* Java通过方法的重写支持动态分派。
*/
public class demo1 {
public static void main(String[] args) {
Animal a = new Dog();
a.execute();//dog
Animal a1 = new Cat();
a1.execute();//cat
}
}
class Animal {
public void execute() {
System.out.println("Animal");
}
}
class Dog extends Animal {
@Override
public void execute() {
System.out.println("dog");
}
}
class Cat extends Animal {
@Override
public void execute() {
System.out.println("cat");
}
}
双分派
* 第一次分派：将Execute对象做为参数传递给Animal类型的变量调用的方法。这里是方法重写，所以是动态分派
* 第二次分派：将自己this（也就是实际类型）作为参数传递进去，这里的Execute类中有多个重载的方法，所以是静态分派
/**
* 双分派
* 第一次分派：将Execute对象做为参数传递给Animal类型的变量调用的方法。这里是方法重写，所以是动态分派
* 第二次分派：将自己this（也就是实际类型）作为参数传递进去，这里的Execute类中有多个重载的方法，所以是静态分派
*/
class demo3 {
public static void main(String[] args) {
Animal a = new Animal();
Animal d = new Dog();
Animal c = new Cat();
Execute exe = new Execute();
a.accept(exe);//animal
d.accept(exe);//dog
c.accept(exe);//cat
}
}
class Animal {
public void accept(Execute exe) {
exe.execute(this);
}
}
class Dog extends Animal {
public void accept(Execute exe) {
exe.execute(this);
}
}
class Cat extends Animal {
public void accept(Execute exe) {
exe.execute(this);
}
}
class Execute {
public void execute(Animal a) {
System.out.println("animal");
}
public void execute(Dog d) {
System.out.println("dog");
}
public void execute(Cat c) {
System.out.println("cat");
}
}
215
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
