public class Test7
{
        Class Dan
        {
              private void Dan()
              { }
              public static void Dan getInstance()
              {
                 If(instance==null)
        {
         Instance=new Dan();
        }
        Return instance;
        }
        }

}
我写的这个为什么不对啊？

1. public class Test7 //懒汉式用了 内部类?
   
2. {
   
3.         Class Dan //class 写成大写Class,错误
   
4.         {
   
5.               private void Dan()
   
6.               { }
   
7.               public static void Dan getInstance() //方法命名有空格,错误
   
8.               {
   
9.                  If(instance==null) //instance 没有定义数据类型.错误
   
10.                  {
    
11.                          Instance=new Dan(); //instance 写成大写,错误
    
12.                  }
    
13.                  Return instance;//return 写成大写,错误.
    
14.               }
    
15.         }
    
16. }

复制代码

1. class Test7
   
2. {
   
3.         static class Dan
   
4.         {
   
5.                 private void Dan()
   
6.                 {
   
7.                 }
   
8.                 private static Dan instance = null;
   
9.                 public static Dan getInstance()
   
10.                 {
    
11.                         if (instance == null)
    
12.                         {
    
13.                                 instance = new Dan();
    
14.                         }
    
15.                         return instance;
    
16.                 }
    
17.         }
    
18. }

复制代码

懒汉式写成内部类好用吗?

1. class Single
   
2. {
   
3.         private static Single s = null;
   
4.         private Single() {};
   
5.         public static Single getInstance()
   
6.         {
   
7.                 if(s==null)
   
8.                         s = new Single();
   
9.                 return s;
   
10.         }
    
11. }

复制代码

这是老师写的标准格式

首先，构造函数没有返回类型，其次你的获取该类的实例对象的函数中返回类型应该是类类型，而不是void类型。

1. //懒汉式
   
2. class Single//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。
   
3.                         //延迟加载形式。
   
4. {
   
5.         private static Single s = null;
   
6. 
   
7.         private Single(){}
   
8. 
   
9.         public static Single getInstance()
   
10.         {
    
11.                 if(s==null)
    
12.                         s = new Single();
    
13.                 return s;
    
14.         }
    
15. }

复制代码

懒汉式可以这样写？

延迟加载的单例设计模式---懒汉式和饿汉式（老师讲过的懒汉式较为重要）
懒汉式：将构造函数私有化，提供一个公共的访问方式，返回一个类对象（创建对象方法）
            懒汉式解决延迟加载有问题，可以加同步解决。加同步方式：同步代码块，同步函数、
            

1. 
   
2. public class Test7 //这里用了内部类
   
3. {
   
4.         Class Dan
   
5.         {
   
6.               private void Dan()//构造函数不需要返回类型
   
7.               { }
   
8.               public static void Dan getInstance()
   
9.               {
   
10.                  If(instance==null)//这里应该是if
    
11.         {
    
12.          Instance=new Dan();//Instance变量没有定义
    
13.         }
    
14.         Return instance;//Instance和instance不是同一个变量
    
15.         }
    
16.         }
    
17. 
    
18. }

复制代码

谢谢你们！

少年，新手吧，发帖子时，代码要用这个放进去，你这弄的代码也太丑了吧。
看看这个帖子，看怎么发帖的
教你怎么在黑马发帖子

singleton单例设计模式：

1. class SingleDemo{
   
2.         private SingleDemo(){}//私有构造函数
   
3.         private static SingleDemo s1 = new SingleDemo();//创建私有并静态本类对象
   
4.         public static SingleDemo getS1(){//公有方法，返回SingleDemo实例对象
   
5.                 return s1;
   
6.         }
   
7. }
   
8. //懒汉式(延迟加载方式)
   
9. class SingleDemo2{
   
10.         private static SingleDemo2 s3;
    
11.         private SingleDemo2(){}
    
12.         public static SingleDemo2 getS3(){
    
13.                 if(s3==null){
    
14.                         s3 = new SingleDemo2();
    
15.                 }
    
16.                 return s3;
    
17.         }
    
18. }
    
19. public class Singleton {
    
20.         /**
    
21.          * @param args
    
22.          */
    
23.         public static void main(String[] args) {
    
24.                 // TODO Auto-generated method stub
    
25.                 SingleDemo s1 = SingleDemo.getS1();
    
26.                 SingleDemo s2 = SingleDemo.getS1();
    
27.                 SingleDemo2 s3 = SingleDemo2.getS3();
    
28.                 SingleDemo2 s4 = SingleDemo2.getS3();
    
29.                 System.out.println(s1==s2);
    
30.                 System.out.println(s3==s4);
    
31. //                输出：true true
    
32.         }
    
33. }

复制代码