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