利用枚举  
enum a{
A
}
只有一个对象 这样设置的单例模式
和普通的单例模式
懒汉式
class Single
{
        private static Single s = null;
        private Single(){}
        public static Single getInstance()
        {
                if(s==null)
                        s = new Single();
                return s;
        }
}
在使用上有什么区别？？？还是有什么局限性？

首先得了解什么是单利设计模式 ：
单利设计模式是用来保证类在内存中只有一个对象。       
      (1)思路 A:外界不能创建对象
                 B:本身要创建一个对象
                 C:提供公共的访问方式

                如果体现思路呢？
                A:私有构造
                B:在成员位置创建一个对象
                C:提供静态的公共方法获取对象
        (3)单例设计模式的两种方式
                A:饿汉式 当类加载的时候，就创建对象。
                       
                class Student
                {
                        private Student(){}
                       
                        private static Student s = new Student();
                       
                        public static Student getInstance()
                        {
                                return s;
                        }
                }

                B:懒汉式 当使用的使用，才去创建对象。

                class Student
                {
                        private Student(){}

                        private static Student s = null;
                       
                        public static Student getInstance()//明确返回类型 是一个学生类
                        {
                                if(s==null) //如果为空
                                {
                                       
                                        s = new Student();//就创建一个学生对象
                                }
                                return s;
                        }
                }
//希望你能够理解

《高效Java 第二版》中的说法：单元素的枚举类型已经成为实现Singleton的最佳方法。
为了理解这个观点，先来了解一点相关的枚举知识，这里只是强化和总结一下枚举的一些重要观点，
更多基本的枚举的使用，请参看Java编程入门资料。
Java的枚举类型实质上是功能齐全的类，因此可以有自己的属性和方法。
Java枚举类型的基本思想是通过公有的静态final域为每个枚举常量导出实例的类。
从某个角度讲，枚举是单例的泛型化，本质上是单元素的枚举。
用枚举来实现单例非常简单，只需要编写一个包含单个元素的枚举类型即可。示例代码如下:
使用枚举来实现单例模式的示例  
  public enum Singleton {  

            /*定义一个枚举的元素,它就代表了Singleton的一个实例  */  
           uniqueInstance;     
           /* 示意方法，单例可以有自己的操作*/
  
     public void singletonOperation(){
  
          //功能处理    }
}
使用枚举来实现单实例控制会更加简洁，而且无偿地提供了序列化的机制，并由JVM从根本上提供保障，
绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式。

用枚举创建的单例是在这个类被加载时，就已经在内存中创建了实例对象，即没有延迟加载，而懒汉式在程序运行时一开始没有创建实例对象，
s = new Single();当程序运行到这句语句时才会创建对象，即延迟加载，这个应该是最大的区别了。
而且楼主写的懒汉式没有用到双重判断，在多线程的程序中可能会出现错误，
class Single
{
        private static Single s = null;
        private Single(){}
        public static Single getInstance()
        {
                if(s==null)//当第一个线程运行完这一句后，可能释放执行权，给其他线程，其他线程进来后，判断出s==null，就会执行下一句，而第一个线程之后夺回执行权又会再创建一个对象，就不能保证是一个对象了
                        s = new Single();
                return s;
        }
}

用双重判断加同步代码块可以保证多线程的安全，不过会降低程序程序运行效率，所以推荐使用饿汉式和枚举单例
class Single
{
private static Single s = null;
private Single(){

}
public static Single getInstance(){
  if(s == null){
   synchronized(Single.class){
    if(s == null){
     s = new Single();
    }
   }
  }
  return s;
}
}