这两种方式如果实际应用怎么用

单例设计模式：解决一个类在内存中只存在一个对象。

想要保证对象唯一：
1、为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象
2、还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象
3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

代码体现：
1、将构造函数私有化
2、在类中创建一个本类对象
3、提供一个方法可以获取到该对象


代码一：
class Single
{
private Single(){}
private static Single s = new Single();
private static Single getInstance()
{
return s;
}
}
特点：先初始化对象，即Single类一进内存，就已经创建好了对象
被称为：饿汉式

代码二：
class Single
{
private Single(){}
private static Single s = null;
private static synchronized Single getInstance()
{
if(s == null)
s = new Single();

return s;
}
}
特点：对象是方法北调用时，才初始化。即Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象
被称为：懒汉式

建议使用饿汉式

懒汉式是，只有用到这个用例的时候，再将他实例化，不会浪费，效率要高一些。
饿汉式则是程序只要开始，就将他实例化，到用到他的时候就省去了再实例的时间，所以速度和反应快。不过占用资源

/*
        单列式设计模式
        目的是让程序只建立一次对象
        所以类中的构造函数权限为private
        提供静态方法和静态成员变量
*/

class Demo1 {
        public static void main(String[] args) {
                ton t1 = ton.getTon();
                ton t2 = ton.getTon();
                System.out.println(t1 == t2);
                tontwo tt1 = tontwo.getTontwo();
                tontwo tt2 = tontwo.getTontwo();
                System.out.println(tt1 == tt2);
        }
}
//饿汉式
class ton {
        private static ton t = new ton();
        private ton() {}
        public static ton getTon() {
                return t;
        }

}
//懒汉是
class tontwo {
        private static tontwo t;
        private tontwo() {}
        public static tontwo getTontwo() {
                if (t == null) {
                        new tontwo();
                }
                return t;
        }
}
//执行结果

С呲號→佔缐 发表于 2013-4-2 20:57
懒汉式是，只有用到这个用例的时候，再将他实例化，不会浪费，效率要高一些。
饿汉式则是程序只要开始，就 ...

谢谢啊，好不容易得一分:handshake

毕老师的课堂笔记，希望对你有帮助，代码注释部分，请自行删除添加，以便测试：
单例设计模式

面试时常见问题：
1，请说说饿汉式和懒汉式的区别？
    懒汉式的特点是让实例延时加载
2，懒汉式延时加载有没有问题？
    有，如果多线程访问时会出现安全问题
3，怎么解决？
    可以加同步解决，用同步函数和同步代码块都行，但同步函数稍微有些低效，用双重判断同步代码块能解决效率问题
4，加同步的时候，使用的锁是哪一个？
    该类所属的字节码文件对象

1. //饿汉式
   
2. /*
   
3. class Single
   
4. {
   
5.         private static final Single s = new Single();
   
6.         private Single(){}
   
7.         public static Single getInstance()
   
8.         {
   
9.                 return s;
   
10.         }
    
11. }
    
12. */
    
13. 
    
14. //懒汉式
    
15. class Single
    
16. {
    
17.         private static Single s = null;
    
18.         private Single(){}
    
19.         public static Single getInstance()
    
20.         {
    
21.                 if(s==null)
    
22.                 {
    
23.                         synchronized(Single.class)
    
24.                         {
    
25.                                 if(s==null)
    
26.                                         s = new Single();
    
27.                         }
    
28.                 }
    
29.                 return s;
    
30.         }
    
31. }
    
32. 
    
33. class SingleDemo
    
34. {
    
35.         public static void main(String[] args)
    
36.         {
    
37.                 System.out.println("Hello World!");
    
38.         }
    
39. }
    

复制代码