class Lazy
{
        private static Lazy l= null;
         private Lazy(){}
         public static Lazy getLazy()
        {
            if(l==null)
            {
                   if(l==null)
                       {
                           l = new Lazy();//为什么把这句加个Lazy结果就是null呢?（就是这句Lazy l = new Lazy();）
                      }
              }
                 return l;
         }
}

这个是单例设计模式中懒汉式的书写格式，如果你Lazy l = new Lazy();就相当于又新建了一个Lazzy对象，由于你在函数开始将Lazzy l 初始化为null了，所以返回 l 时输出为null

1. class Lazy
   
2. {               
   
3.          private static Lazy l= null;
   
4.          private Lazy(){}
   
5.          public static Lazy getLazy()
   
6.          {
   
7.             if(l == null)
   
8.             {
   
9.                  synchronized(Lazy.class)        //在多线程的情况，加上这句更严谨哦。
   
10.                                  {
    
11.                                          if(l == null)
    
12.                        {
    
13.                            l = new Lazy();//为什么把这句加个Lazy结果就是null呢?（就是这句Lazy l = new Lazy();）
    
14.                        }
    
15.                                  }
    
16.                          }
    
17.             
    
18.                          return l;
    
19.          }
    
20. }

复制代码

l = new Lazy();  l  是全局变量，
Lazy l = new Lazy();  -->    Lazy l ;  l = new Lazy();   使用的时局部变量，  return 返回的是全局变量的 l  ,我是这样理解的，

1. class Lazy
   
2. {
   
3.          private static Lazy l= null;
   
4.           private Lazy(){}
   
5.           public static Lazy getLazy()
   
6.          {
   
7.              if(l==null)
   
8.              {
   
9.                     if(l==null)
   
10.                     {
    
11.                       Lazy a = new Lazy();//为什么把这句加个Lazy结果就是null呢?（就是这句Lazy l = new Lazy();）
    
12.                     }
    
13.                                        
    
14.               }
    
15.               return a;
    
16. 
    
17.           }
    
18. }
    
19. class Demo1
    
20. {
    
21.          public static void main(String[] args)
    
22.          {
    
23.                  System.out.println(Lazy.getLazy());
    
24.          }
    
25. 
    
26. }

复制代码

因为把这个换成a,  编译报错是找不到符号。