class Single
{
        private static final Single s = new Single;   什么意思
        private Single(){} 什么意思
        public static Single getInstance()什么意思
        {
                return s;
        }
}

class Single2
{
        private static Single s = null;什么意思
        private Single(){}  什么意思
        public static Single getInstance()
        {
                if(s==null)什么意思
                {
                        s = new Single;什么意思
                }
                return s;
        }
}


还是不太明白两者有什么区别？

class Single
{
        private static final Single s = new Single();  //定义一个常量来缓存创建的实例
        private Single(){} //将此构造器封装
        public static Single getInstance()//提供一个静态方法，来获取Single的实例
        {
                return s;
        }
}
class Single2
{
        private static Single s = null;//定义一个静态变量来缓存创建的实例
        private Single(){} //将此构造器封装
        public static Single getInstance()
        {
                if(s==null)//还没有创建Single对象
                {
                        s = new Single();//创建一个Singleton对象，并将其缓存起来
                }
                return s;
        }
}
这两个都是单例设计模式，第一个是饿汉式，它是Single类一进内存，就已经创建好了对象。第二个是懒汉式，Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。

你这是单例设计模式的两种形式：
（1）饿汉式（一进来就创建对象）
class Single
{
         private static final Single s = new Single;     //由于将来要提供对象，所以，我要创建对象。而这个对象，也不想再外界被人看到。所以，用private修饰。由于s  在           getInstance()被使用，所以，这里也要用static修饰
         private Single(){}                                    //构造私有是因为不想外界创建该类对象。
         public static Single getInstance()   //外界要直接访问此方式获取对象，所以，用static修饰
         {
                 return s;   
         }
}
（2）懒汉式
class Single2
{
         private static Single s = null;                    //由于使用的时候，才需要创建对象，所以，一开始默认给个null。
         private Single(){}                             // //构造私有是因为不想外界创建该类对象。
         public static Single getInstance()
         {
                 if(s==null)                               //使用的时候创建对象
                 {
                         s = new Single;             判断若是null则给他创建对象
                 }
                 return s;
         }
}
两者区别就是：饿汉式一开始就创建对象并实例化，而懒汉式则是使用的时候创建对象

单例设计模式
特点：只能有一个对象，自己建立对象、、、
饿汉式：
class Single
{
        private static final Single s = new Single;   建立一个私有对象
        private Single(){} 私有构造方法
        public static Single getInstance()对外提供的方法
        {
                return s;
        }
}
懒汉式：
class Single2
{
        private static Single s = null;
        private Single(){}  
        public static Single getInstance()
        {
                if(s==null)
                {
                        s = new Single;
                }
                return s;
        }
}

class Single
{
        private static final Single s = new Single;  //实例化一个Single对象赋给Single常量
        private Single(){} //显示声明一个私有的无参构造函数
        public static Single getInstance()//声明一个静态的Single类型的方法返回常量s
        {
                return s;
        }
}

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


两个类的区别就是实例化的次序不一样，第一个是调用getInstance()方法前就实例化了，类2则是调用的时候实例化。单例二中final必须写，而单例一可以不写，单例二是对象的延时加载。

你的两个类都是单例里面的知识
首先，单例的意思就是类里面定义私有的一个对象，并定义一个获取对象的方法，不让其他的类再去new新的对象，只能调用方法来得到对象。
单力设计模式分为两种。
第一种就是你写的第一个程序，叫做饿汉式，他是类一加载到内存空间里，就创建好了对象。
第二种就是你写的第二个程序，叫做懒汉式，类加载进内存的时候，对象还没被new出来，只有在你调用获取对象方法的时候，才会创建对象。

单例的原理就是：
new一个对象，私有，不管是饿汉式还是懒汉式，都需要new一个，
把构造方法私有，构造方法私有后，其他类就不能创建本类对象。private Single(){}
还要提供获取对象的方法，而且是要定义成公有的：public static Single getInstance()

马良 发表于 2012-11-24 11:47
你的两个类都是单例里面的知识
首先，单例的意思就是类里面定义私有的一个对象，并定义一个获取对象的方法 ...

非常感谢，明白啦

潘天功 发表于 2012-11-24 11:40
你这是单例设计模式的两种形式：
（1）饿汉式（一进来就创建对象）
class Single

非常感谢，讲的很细致

李贺晓 发表于 2012-11-24 11:29
class Single
{
        private static final Single s = new Single();  //定义一个常量来缓存创建的实例 ...

非常感谢，