相关文章
【合集】Java设计模式
概述
访问者模式用到了一种双分派的技术。
Map map = new HashMap() ，map变量的静态类型（又叫明显类型）是 Map，实际类型（又叫真实类型）是 HashMap 。
根据对象的类型而对方法进行的选择，就是分派。
分派又分为两种，即静态分派和动态分派。
动态分派(通过方法重写支持)
发生在运行时期，动态分派动态地置换掉某个方法。
Java编译器在编译时期并不总是知道哪些代码会被执行，因为编译器仅仅知道对象的静态类型，而不知道对象的真实类型；
而方法的调用则是根据对象的真实类型，而不是静态类型。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
class DynamicDispatch {
public static void main(String[] args) {
Animal dog = new Dog();
// 方法的调用则是根据对象的真实类型，而不是静态类型。
dog.execute(); // dog
Animal cat = new Cat();
// 方法的调用则是根据对象的真实类型，而不是静态类型。
cat.execute(); // cat
}
public static class Animal {
public void execute() {
System.out.println("Animal");
}
}
public static class Dog extends Animal {
@Override
public void execute() {
System.out.println("dog");
}
}
public static class Cat extends Animal {
@Override
public void execute() {
System.out.println("cat");
}
}
}
|
静态分派(通过方法重载支持)
发生在编译时期，分派根据静态类型信息发生。如：方法重载
这个结果可能出乎一些人的意料了，为什么呢？
重载方法的分派是根据静态类型进行的，这个分派过程在编译时期就完成了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
class StaticDispatch {
public static void main(String[] args) {
Animal animal = new Animal();
Animal dog = new Dog();
Animal cat = new Cat();
Execute execute = new Execute();
// 静态分派根据静态类型决定
execute.execute(animal); // Animal
execute.execute(dog); // Animal
execute.execute(cat); // Animal
}
public static class Animal {
}
public static class Dog extends Animal {
}
public static class Cat extends Animal {
}
public static 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");
}
}
}
|
双分派（方法重写+方法重载）
是指在选择一个方法时，既考虑调用者的运行时区别，又要考虑参数的静态类型。
其实现方法其实就是在各个类中依赖了 Execute，再将自己 this 传递过去，从而实现在 Execute 操作的目的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
class DoubleDispatch {
public static void main(String[] args) {
Animal animal = new Animal();
Animal dog = new Dog();
Animal cat = new Cat();
Execute execute = new Execute();
// 第1次分派：accept方法重写，根据真实类型，实现动态分派
animal.accept(execute); // animal
dog.accept(execute); // dog
cat.accept(execute); // cat
}
public static class Animal {
public void accept(Execute exe) {
// 第2次分派：execute方法重载，根据静态类型，实现静态分派
exe.execute(this);
}
}
public static class Dog extends Animal {
@Override
public void accept(Execute exe) {
exe.execute(this);
}
}
public static class Cat extends Animal {
@Override
public void accept(Execute exe) {
exe.execute(this);
}
}
public static 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");
}
}
}
|
