单例模式 转

单例模式单例模式是一种常见的设计模式，
单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。
单例模式有一下特点：
1、 单例类只能有一个实例。
2、单例类必须自己自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

一、懒汉式单例在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例。

单例模式-懒汉式单例

package Singleton;

public class LazySingleton {
	/*** 私有静态对象,加载时候不做初始化      */    
	   private static
 LazySingleton m_intance=null;     
	    /*** 私有构造方法,避免外部创建实例      */    
并不是完全不能创建

	    private
 LazySingleton(){}    
	    /*** 静态工厂方法,返回此类的唯一实例.* 当发现实例没有初始化的时候,才初始化. * @return LazySingleton */    
	   public static synchronized 
 LazySingleton getInstance(){
	        if(m_intance==null){
	           m_intance=new LazySingleton();
	         }
	         return m_intance;
	    }
	

	public static void main(String[] args) {
		LazySingleton lazySingleton = LazySingleton.getInstance();  
		LazySingleton lazySingleton1 = LazySingleton.getInstance();
		LazySingleton lazySingleton2= new LazySingleton();
		  if(lazySingleton==lazySingleton1){
		   System.out.println(" 同一个对象实例");
		  }else{
		   System.out.println("不是同一个对象实例");
		  }
//		  同一个对象实例

		  
		  if(lazySingleton==lazySingleton2){
			   System.out.println(" 同一个对象实例");
			  }else{
			   System.out.println("不是同一个对象实例");
			  }
//		  不是同一个对象实例

没有构造方法也能new

		  
	}
}

 

public class LazySingleton {    
   /*** 私有静态对象,加载时候不做初始化      */    
   private static LazySingleton m_intance=null;     
    /*** 私有构造方法,避免外部创建实例      */    
    private LazySingleton(){}    
    /*** 静态工厂方法,返回此类的唯一实例.* 当发现实例没有初始化的时候,才初始化. * @return LazySingleton */    
    synchronized public static LazySingleton getInstance(){
        if(m_intance==null){
           m_intance=new LazySingleton();
         }
         return m_intance;
    }
}

//测试一下单例模式
  LazySingleton lazySingleton = LazySingleton.getInstance();  
  LazySingleton lazySingleton1 = LazySingleton.getInstance();
  
  if(lazySingleton==lazySingleton1)){
   System.out.println(" 同一个对象实例");
  }else{
   System.out.println("不是同一个对象实例");
  }

二、饿汉式单例在类被加载的时候，唯一实例已经被创建。这个设计模式在Java中容易实现，在别的语言中难以实现。

/*** 单例模式-饿汉式单例*/
public class EagerSingleton {    
    /**私有的(private)唯一(static final)实例成员,在类加载的时候就创建好了单例对象*/
    private static final EagerSingleton m_instance = new EagerSingleton();
    /*** 私有构造方法,避免外部创建实例      */    
    private EagerSingleton() {}     //提供了一个空的构造方法
    /*** 静态工厂方法,返回此类的唯一实例.* @return EagerSingleton      */    
    public static EagerSingleton getInstance() {
       return m_instance;    
    }
}

//下面来判断一下有没有达到单例效果(系统运行的时候只出来一个空例) 
EagerSingleton eagerSingleton = EagerSingleton.getInstance();  
EagerSingleton eagerSingleton1 = EagerSingleton.getInstance();
  
  if(eagerSingleton==eagerSingleton1)){
   System.out.println(" 同一个对象实例");
  }else{
   System.out.println("不是同一个对象实例");
  }

三、登记式单例这个单例实际上维护的是一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从工厂直接返回，对于 没有登记的，则先登记，而后返回。
/*** 单例模式- 登记式单例*/
public class RegSingleton {    
    /*** 登记薄,用来存放所有登记的实例      */    
    private static Map<String, RegSingleton> m_registry = new HashMap();    
    //在类加载的时候添加一个实例到登记薄    
        static {
           RegSingleton x = new RegSingleton();
           m_registry.put(x.getClass().getName(), x);
        }    
        /*** 受保护的默认构造方法*/    
        protected RegSingleton() {}    
        /*** 静态工厂方法,返回指定登记对象的唯一实例;
             * 对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回
             * @param name
             * @return
                RegSingleton      */    
public static RegSingleton getInstance(String name) {        
      if (name == null) {            
            name = "RegSingleton";         
       }        
       if (m_registry.get(name) == null) {
            try {
                 m_registry.put(name, (RegSingleton) Class.forName(name).newInstance());
            } catch (InstantiationException e) {                
                  e.printStackTrace();            
            } catch (IllegalAccessException e) {                
                   e.printStackTrace();            
           } catch (ClassNotFoundException e) {                
                   e.printStackTrace();           
            }        
        }        
        return m_registry.get(name);    
}    

/** * 一个示意性的商业方法      * @return String      */    
public String about() {        
      return "Hello,I am RegSingleton!";    
}}

四、单例模式的一个应用该应用是配置文件管理类。为了本例能正确运行，我在C盘下先建立了一个xxxx.properties文件，内容如 下：-------------------

user=rootpassword=leizhimin这个配置文件管理类的代码如下：
单例模式应用-单例类应用-配置文件管理*/
public class ConfigManager {    
/*** 属性文件全名*/    
private static final String PFILE = "C:\\xxx.properties";