如题，延迟加载具体来说是什么意思？并且要求写一个延迟加载的单例模式，黑马大神来看看

1. class Test5{
   
2.         private static Test5 s=null;
   
3.         private Test5(){}
   
4.         public static Test5 getInstance()
   
5.         {
   
6.                 if (s==null)
   
7.                 {
   
8.                         synchronized(Test5.class)//该类所属的自解码文件对象
   
9.                         {
   
10.                                 if (s==null)
    
11.                                 {
    
12.                                         s=new Test5();
    
13.                                 }
    
14.                         }
    
15.                        
    
16.                 }
    
17.                 return s;
    
18.         }
    
19. 
    
20. }

复制代码

首先搞清楚单例模式的含义，因为构造函数被私有，不能创建对象，但是里面有公共方法可以调用该类，返回值也是该类对象。延迟加载就是首先初始化属性为空，等你调用公共方法才会创建一个该类对象。

1. package test;
   
2. 
   
3. public class ClassTest {
   
4.         
   
5.         /*
   
6.          * 一个简单的延迟加载类
   
7.          */
   
8.         private static ClassTest test = null;
   
9. 
   
10.         private ClassTest() {
    
11.         }
    
12. 
    
13.         public static ClassTest getClassTest() {
    
14.                 if (test == null) {
    
15.                         test = new ClassTest();
    
16.                 }
    
17.                 return test;
    
18.         }
    
19. }

复制代码

按需加载

  按需加载
/**
* 大多数的域应该正常地进行初始化，而不是延迟初始化。如果为了达到性能目的，或者为了破坏有害的初始化循环
* 而必须延迟初始化一个域，就可以使用相应的延迟初始化方法。
* 对于实例域，就使用双重检查模式;
* 对于静态域，则使用lazy initialization holder class idiom;
* 对于可以接受重复初始化的实例域，也可以考虑使用单重检查模式
* @author Snway
*
*/  
public class LazyInit {  
    private final String field_0 = getFieldValue(); // 正常初始化  
      
    // 延迟加载 方法1  
    private String field_3;  
      
    synchronized String getStr1() {  
        if (field_3 == null)   
            field_3 = getFieldValue();  
        return field_3;  
    }  
      
    // 延迟加载 方法2 出于性能考虑而需要对静态域使用初始化，就使用lazy initialization holder class 模式  
    private static class FieldHolder {  
        static final String field = getFieldValue();  
    }  
      
    static String getField() {  
        return FieldHolder.field;  
    }  
      
    //延迟加载 方法3 如果出于性能考虑而需要对实例域使用延迟初始化，就使用双重检查模式  
    //第一次检查时没有锁定，看看该域是否被初始化了;第二次检查时锁定  
    private volatile String field_1;  
      
    String getField_1() {  
        String result = field_1;  
        if (result == null) { // 第一次检查  
            synchronized(this) { // 第二次检查，要是没有被初始化才进行初始化。  
                result = field_1;  
                if (result == null)  
                    field_1 = result = getFieldValue();  
            }  
        }  
        return result;  
    }  
      
    // 延迟加载 方法4 如果可能需要延迟初始化一个可以接受重复初始化的实例域——单重检查模式  
      
    private volatile String field_2;  
      
    String getField_2() {  
        String result = field_2;  
        if (result == null)  
            field_2 = result = getFieldValue();  
        return result;  
    }  
      
    public static String getFieldValue() {  
        return "xqh";  
    }  
}

如果问题已经解决，请及时修改主题为“提问结束”。
修改主题的方法链接
http://bbs.itheima.com/thread-89313-1-1.html