大B：“静态分派，动态分派，多分派，单分派是visitor模式准备。”
小A：“visitor模式准备？能不能详细讲讲，我不明白。”
大B：“可以。”
1、静态分派：
（1）定义：发生在编译时期，分派根据静态类型信息发生，重载就是静态分派。
（2）什么是静态类型：变量被声明时的类型是静态类型。
什么是动态类型：变量所引用的对象的真实类型。
（3）有两个类，BlackCat，WhiteCat都继承自。
如下调用
class Cat{}
class WhiteCat extends Cat{}
class BlackCat extends Cat{}
public class Person{
public void feed（Cat cat）{
System。out。println（“feed cat”）；
}
public void feed（WhiteCat cat）{
System。out。println（“feed WhiteCat”）；
}
public void feed（BlackCat cat）{
System。out。println（“feed BlackCat”）；
}
public static void main（String[]args）{
Cat wc=new WhiteCat（）；
Cat bc=new BlackCat（）；
Person p=new Person（）；
p。feed（wc）；
p。feed（bc）；
}
}
运行结果是：
feed cat
feed cat
这样的结果是因为重载是静态分派，在编译器执行的，取决于变量的声明类型，因为wc，bc都是Cat所以调用的都是feed（Cat cat）的函数。
2、动态分派
定义：发生在运行期，动态分派，动态的置换掉某个方法。
还是上面类似的例子：
class Cat{
public void eat（）{
System。out。println（“cat eat”）；
}
}
public class BlackCat extends Cat{
public void eat（）{
System。out。println（“black cat eat”）；
}
public static void main（String[]args）{
Cat cat=new BlackCat（）；
cat。eat（）；
}
}这个时候的结果是：
black cat eat
这样的结果是因为在执行期发生了向下转型，就是动态分派了。
3、单分派：
定义：根据一个宗量的类型进行方法的选择。
4、多分派：
（1）定义：根据多于一个宗量的类型对方法的选择。
（2）说明：多分派其实是一系列的单分派组成的，区别的地方就是这些但分派不能分割。
（3）Java是动态单分派，静态多分派语言。
大B：“访问同一类型的集合类是我们最常见的事情了，我们工作中这样的代码太常见了。”
Iterator ie=list。iterator（）；
while（ie。hasNext（））{
Person
p=（Person）ie。next（）；
p。doWork（）；
}
这种访问的特点是集合类中的对象是同一类对象Person，他们拥有功能的方法run，我们调用的恰好是这个共同的方法。在大部份的情况下，这个是可以的，但在一些复杂的情况，如被访问者的继承结构复杂，被访问者的并不是同一类对象，也就是说不是继承自同一个根类。方法名也并不相同。例如Java GUI中的事件就是一个例子。
例如这样的问题，有如下类和方法：
类：PA，方法：runPA（）；
类：PB，方法：runPB（）；
类：PC，方法：runPC（）；
类：PD，方法：runPD（）；
类：PE，方法：runPE（）；
有一个集合类。
List list=new ArrayList（）；
list。add（new PA（））；
list。add（new PB（））；
list。add（new PC（））；
list。add（new PD（））；
list。add（new PE（））；
……
大B：“要求能访问到每个类的对应的方法。我们第一反应应该是这样的。”
Iterator ie=list。iterator（）；
while（ie。hasNext（））{
Object obj=ie。next（）；
if（obj instanceof PA）{
（（PA）obj）。runPA（）；
}else if（obj instanceof PB）{
（（PB）obj）。runPB（）；
}else if（obj instanceof PC）{
（（PC）obj）。runPC（）；
}else if（obj instanceof PD）{
（（PD）obj）。runPD（）；
}else if（obj instanceof PE）{
（（PE）obj）。runPE（）；
}
}
大B：“当数目变多的时候，维护if else是个费力气的事情：仔细分析if，else做的工作，首先判断类型，然后根据类型执行相应的函数。”
小A：“如何才能解决这两个问题呢？”
大B：“首先想到的是Java的多态，多态就是根据参数执行相应的内容，能很容易的解决第二个问题，我们可以写这样一个类。”
public class visitor{
public void run（PA pa）{
pa。runPA（）；
}
public void run（PB pb）{
pb。runPB（）；
}
public void run（PC pc）{
pc。runPC（）；
}
public void run（PD pd）{
pd。runPD（）；
}
public void run（PE pe）{
pe。runPE（）；
}
}
大B：“这样只要调用run方法，传入对应的参数就能执行了。”
小A：“还有一个问题就是判断类型。”
大B：“由于重载（overloading）是静态多分配。Java语言本身是支持‘静态多分配’的。所以造成重载只根据传入对象的定义类型，而不是实际的类型，所以必须在传入前就确定类型，这可是个难的问题，因为在容器中对象全是Object，出来后要是判断是什么类型必须用if（xx instanceof xxx）这种方法。”
小A：“如果用这种方法岂不是又回到了原点，有没有什么更好的办法呢？我们知道Java还有另外一个特点，覆写（overriding），而覆写是‘动态单分配’的，那如何利用这个来实现呢？”
大B：“看下边这个方法：我们让上边的一些类PA、PB、PC、PD、PE都实现一个接口P，加入一个方法，accept（）。”
public void accept（visitor v）{
//把自己传入。
v。run（this）；
}
然後在visitor中加入一个方法
public void run（P p）{
//把自己传入。
p。accept（this）；
}
//这样你在遍历中可以这样写
Visitor v=new Visitor（）；
Iterator ie=list。iterator（）；
while（ie。hasNext（））{
P p=（P）ie。next（）；
p。accept（v）；
}
}
大B：“首先执行的是‘把自己传入2’，在这里由于Java的特性，实际执行的是子类的accept（），也就是实际类的accept然后是‘把自己传入1’，在这里再次把this传入，就明确类型，OK我们巧妙的利用overriding解决了这个问题。其实归纳一下第二部分，一个关键点是‘自己认识自己’，是不是很可笑。”