public   class  Singleton  {   
  
   static   class  SingletonHolder  {   
     static  Singleton instance  =   new  Singleton();   
  }    
  
   public   static  Singleton getInstance()  {   
     return  SingletonHolder.instance;   
  }    
  
}   

这个写法的发明者是Google公司的Bob lee。
他还写了个轻量级IoC容器，据说不要配制文件，性能比spring快100倍。感觉100倍有些夸张，不过可以看看。

最后的部分：
看完本文，如果你对visitor模式有更多的兴趣，想了解更多请看如下几篇文章。
1,静态分派，动态分派，多分派，单分派 --------------   visitor模式准备
2,访问差异类型的集合类 ------------------------   visitor模式入门
3,visitor模式理论及学术概念-------------－-----   visitor模式进一步(本文）
4，重载overloading和覆写overriding哪个更早执行--   visitor帮助篇
虽然排列顺序是1,2,3,4 但是我个人建议的学习方式是2,1,3,4因为这个顺序更方便一般人理解

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);
    }

}

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();
    }
}

看完本文，如果你对visitor模式有更多的兴趣，想了解更多请看如下几篇文章。
1,静态分派，动态分派，多分派，单分派 --------------   visitor模式准备(本文）
2,访问差异类型的集合类 ------------------------   visitor模式入门
3,visitor模式理论及学术概念-------------－-----   visitor模式进一步
4，重载overloading和覆写overriding哪个更早执行--   visitor帮助篇
虽然排列顺序是1,2,3,4但是我个人建议的学习方式是2,1,3,4因为这个顺序更方便一般人理解

1 Iterator ie  =  list.iterator();
2 while (ie.hasNext()) {
3     Person p  =  (Person)ie.next();
4     p.doWork();
5 }

这种访问的特点是集合类中的对象是同一类对象Person，他们拥有功能的方法run,我们调用的恰好是这个共同的方法。
在大部份的情况下，这个是可以的，但在一些复杂的情况，如被访问者的继承结构复杂，被访问者的并不是同一类对象，
也就是说不是继承自同一个根类。方法名也并不相同。例如Java GUI中的事件就是一个例子。
例如这样的问题，有如下类和方法:
类：PA ,方法：runPA();
类：PB ,方法：runPB();
类：PC ,方法：runPC();
类：PD ,方法：runPD();
类：PE ,方法：runPE();
有一个集合类List
List list = new ArrayList();
list.add(new PA());
list.add(new PB());
list.add(new PC());
list.add(new PD());
list.add(new PE());
....
二:解决
要求能访问到每个类的对应的方法。我们第一反应应该是这样的。

 1 Iterator ie  =  list.iterator();
 2 while (ie.hasNext()) {
 3     Object obj  =  ie.next();
 4      if  (obj  instanceof  PA) {
 5         ((PA)obj).runPA();
 6     } else   if (obj  instanceof  PB) {
 7         ((PB)obj).runPB();
 8     } else   if (obj  instanceof  PC) {
 9         ((PC)obj).runPC();
10     } else   if (obj  instanceof  PD) {
11         ((PD)obj).runPD();
12     } else   if (obj  instanceof  PE) {
13         ((PE)obj).runPE();
14     }
15 }

三：新问题及分析解决
当数目变多的时候，维护if else是个费力气的事情：
仔细分析if,else做的工作，首先判断类型，然後根据类型执行相应的函数
如何才能解决这两个问题呢？首先想到的是java的多态，多态就是根据参数执行相应的内容，
能很容易的解决第二个问题，我们可以写这样一个类：

 1 public   class  visitor {
 2      public   void  run(PA pa) {
 3         pa.runPA();
 4     }
 5      public   void  run(PB pb) {
 6         pb.runPB();
 7     }
 8      public   void  run(PC pc) {
 9         pc.runPC();
10     }
11      public   void  run(PD pd) {
12         pd.runPD();
13     }
14      public   void  run(PE pe) {
15         pe.runPE();
16     }
17 }

这样只要调用run方法，传入对应的参数就能执行了。
还有一个问题就是判断类型。由于重载(overloading)是静态多分配（java语言本身是支持"静态多分配"的。
关于这个概念请看这里)所以造成重载只根据传入对象的定义类型，而不是实际的类型，所以必须在传入前就确定类型，
这可是个难的问题,因为在容器中对象全是Object，出来后要是判断是什么类型必须用
if (xx instanceof xxx)这种方法，如果用这种方法启不是又回到了原点，有没有什么更好的办法呢？

我们知到Java还有另外一个特点，覆写(overriding)，而覆写是"动态单分配"的（关于这个概念见这里)，
那如何利用这个来实现呢？看下边这个方法:
 我们让上边的一些类PA PB PC PD PE都实现一个接口P,加入一个方法,accept();

 1 public   void  accept(visitor v) {
 2      // 把自己传入1
 3     v.run( this );
 4 }
 5 然後在visitor中加入一个方法
 6 public   void  run(P p) {
 7      // 把自己传入2
 8     p.accept( this );
 9 }
10 // 这样你在遍历中可以这样写
11 Visitor v  =   new  Visitor();
12 Iterator ie  =  list.iterator();
13 while (ie.hasNext()) {
14     P p  =  (P)ie.next();
15         p.accept(v);
16     }
17 }

首先执行的是"把自己传入2"，在这里由于Java的特性，实际执行的是子类的accept(),也就是实际类的accept
然後是"把自己传入1"，在这里再次把this传入，就明确类型，ok我们巧妙的利用overriding解决了这个问题
其实归纳一下第二部分，一个关键点是"自己认识自己"，是不是很可笑。
其实在计算计技术领域的很多技术上看起来很高深的东西，其实就是现有社会中人的生活方式的一种映射
而且这种方式是简单的不能再简单的方式。上边的全部过程基本上是一个简单的visitor模式实现,visitor模式
已经是设计模式中比较复杂的模式了，但其实原理简单到你想笑。看看下边这个比喻也许你的理解会更深刻。

四：一个帮助理解的比喻：
题目：指挥工人工作
条件：你有10个全能工人，10样相同工作。
需求：做完工作
实现：大喊一声所有人去工作

条件变了，工人不是全能，但是工作相同，ok问题不大
条件再变,工作不是相同，但工人是全能，ok问题不大