1. /*
   
2. 单例模式的俩种写法：
   
3. 这个是先初始化对象。
   
4. 称为：饿汉式。
   
5. Single类一进内存就应经创建好了对象。
   
6. class  Single
   
7. {
   
8.         private static Single s = new Single();
   
9.         private Single(){}
   
10.         public static Single getInstance()
    
11.         {
    
12.                 return s;
    
13.         }
    
14. }
    
15. 
    
16. */
    
17. 
    
18. 
    
19. //对象是方法被调用时，才初始化，也叫做对象的延时加载。成为：懒汉式。
    
20. //single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
    
21. class Single
    
22. {
    
23.         private static Single s = null;
    
24.         private Single (){}
    
25.         public static synchronized Single getInstance()
    
26.         {
    
27.                 if(s==null)
    
28.                         s = new Single();
    
29.                 return s;
    
30.         }
    
31. 
    
32. }
    
33. //记录原则：定义单例，建议使用饿汉式
    
34. class
    
35. {
    
36.         public static void main(String[] args)
    
37.         {
    
38.                 System.out.println("Hello World!");
    
39.         }
    
40. }

复制代码

努力学习，天天向上

饿汉式和懒汉式的。

复习了一下，谢谢了

TanZhiPeng1991 发表于 2014-8-14 15:43
复习了一下，谢谢了

共同进步。。

这是人人都发过的话题啊！！

/**
* 单例 1
*
* @Description:饿汉
*/
class Single01 {
        private Single01() {
        }

        private static Single01 single = new Single01();

        public static Single01 getInstance() {
                return single;
        }
}
-------------------------------------------------------------------------------------
/**
* 单例 2
*
* @Description:懒汉
*/
class Single02 {
        private Single02() {
        }

        private static Single02 single = null;

        public static Single02 getInstance() {
                if (single == null) {
                        single = new Single02();
                }
                return single;
        }
}
-------------------------------------------------------------------------------------
/**
* 单例 3
*
* @Description:多线程下使用这个
*/
class Single03 {
        private Single03() {
        }

        private static Single03 single = null;

        public static Single03 getInstance() {
                if (single == null) {
                        synchronized (Single03.class) {
                                if (single == null) {
                                        single = new Single03();
                                }
                        }
                }
                return single;
        }
}
-------------------------------------------------------------------------------------
/**
* 单例 4
*
* @Description:
*/
class Single04 {
        private Single04() {
        }

        public static class Single04Holder {
                public static final Single04 single = new Single04();
        }

        public static Single04 getInstance() {
                return Single04Holder.single;
        }
}
-------------------------------------------------------------------------------------
/**
* 单例 4
*
* @Description:
*/
enum Single05 {
        // SINGLE();
        // public static Single05 getInstance() {
        // return Single05.SINGLE;
        // }
        SINGLE("帅哥", 20);
        private String name;
        private int age;

        private Single05(String name, int age) {
                this.name = name;
                this.age = age;
        }

        public static Single05 getInstance() {
                return Single05.SINGLE;
        }

        @Override
        public String toString() {
                return this.name + "<---age--->" + this.age;
        }
}

public class Test {

        public static void main(String[] args) {
                Single05 single = Single05.getInstance();
                System.out.println(single.toString());
        }
}

帅哥<---age--->20

这样子 速度慢啊！

哥们，谢谢分享！

复习一下

我不会告诉你单例的第三种写法是用枚举:D

昨天刚看到多线程的单例类，说道懒汉式会因为多个线程共同访问时出现安全问题

1. class Single
   
2. {
   
3. private static Single s = null;
   
4. private Single(){}
   
5. public static Single getInstance(){
   
6. if(s==null)//这个地方会因为多个线程共同访问时出现安全问题当一个线程执行到此处，被另一个线程抢走执行资格，有可能会返回多个该类的实例对象
   
7. s = new Single();
   
8. return s;
   
9. }
   
10. }

复制代码

学习一下

思维 发表于 2014-8-14 23:44
我不会告诉你单例的第三种写法是用枚举

那还没看到了

嘿～～ 发表于 2014-8-15 08:45
昨天刚看到多线程的单例类，说道懒汉式会因为多个线程共同访问时出现安全问题 ...

都到多线程了哇哇

wyf20106 发表于 2014-8-15 15:34
那还没看到了

我可以说我在复习之前看过的吗，，，，，，多线程之前看的很烂，一点都不明白，

复习一下！