1. public class SingleDemo {
   
2.         private static final SingleDemo s = new SingleDemo();
   
3.         private SingleDemo(){                         //构造方法私有化
   
4.         }
   
5.         public static SingleDemo getInstance(){
   
6.                 return s;
   
7.         }
   
8. }
   
9. //懒汉式
   
10. class SingleDemo02 {
    
11.         private static SingleDemo02 s;
    
12.         private SingleDemo02(){               //构造方法私有化
    
13.         }
    
14.         public static SingleDemo02 getInstance(){
    
15.                 if(s==null)
    
16.                         synchronized (s){
    
17.                                 if(s==null)
    
18.                                         s = new SingleDemo02();
    
19.                         }
    
20.                 return s;
    
21.         }
    
22.         
    
23. }

复制代码

好像没错啊！！都中级黑马!还能有错，岂不是丢了黑马的人？？

(1)饿汉式 开发用这种方式。
        class Student
        {
                private Student(){}

                private static Student s = new Student();

                public static Student getInstance()
                {
                        return s;
                }
        }
        (2)懒汉式 面试写这种方式。
        class Teacher
        {
                private Teacher(){}

                private static Teacher t;

                public static Teacher getInstance()
                {
                        if(t==null)
                        {
                                t = new Teacher();
                        }
                        return t;
                }
        }

饿汉式：
class Single{
        private static final Single s = new Single();
        private Single(){}
        public static Single getInstance(){
                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;
        }
}

都是这么强悍呀

private static final SingleDemo s = new SingleDemo();

问题好像出在这句话，不知道是不是和你加了final 有关系，不记得毕老师加过final。
俺是初学者，要是说错了，请指出，共同学习。哈~

董霁辉 发表于 2013-3-28 21:35
问题好像出在这句话，不知道是不是和你加了final 有关系，不记得毕老师加过final。
俺是初学者，要是说错 ...

这个是可加可不加的！

张昶 发表于 2013-3-28 21:30
饿汉式：
class Single{
        private static final Single s = new Single();

这个是我想要的！

lucy198921 发表于 2013-3-28 21:28
(1)饿汉式 开发用这种方式。
        class Student
        {

你的这个只能得80分！

似水像火 发表于 2013-3-28 21:20
好像没错啊！！都中级黑马!还能有错，岂不是丢了黑马的人？？

就是加了同步不太确定！其他的都还好！同步代码不好搞！

似水像火 发表于 2013-3-28 21:20
好像没错啊！！都中级黑马!还能有错，岂不是丢了黑马的人？？

就是加了同步不太确定！其他的都还好！同步代码不好搞！

懒汉式
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;
        }
}

我想说我那样加锁可不可以！