单利模式

单利模式是java的设计模式之一

在单例模式之前，我们会这样写一个Class ，写基本属性和类的相关方法，及构造函数或者带参数的构造函数。下面以默认构造方法为例代码演示

[java]

1. package pers.niaonao.entity;  
2.   
3. /** 
4.  * @author niaonao 
5.  * 非单例模式下的基本类 
6.  */  
7. public class GrilFriendUnSingleton {  
8.   
9.     //默认的构造方法  
10.     public GrilFriendUnSingleton() {  
11.     }  
12.       
13.     private String info = "我是你的新 GrilFriend";  
14.       
15.     /** 
16.      * 获取对象信息的方法 
17.      * @return 
18.      */  
19.     public String getGrilFriend() {  
20.         return info;  
21.     }  
22. }  

package pers.niaonao.entity;

/**
 * @author niaonao
 * 非单例模式下的基本类
 */
public class GrilFriendUnSingleton {

	//默认的构造方法
	public GrilFriendUnSingleton() {
	}
	
	private String info = "我是你的新 GrilFriend";
	
	/**
	 * 获取对象信息的方法
	 * @return
	 */
	public String getGrilFriend() {
		return info;
	}
}

    通过新建该类的实体对象来调用相关方法

[java]

1. package pers.niaonao.test;  
2.   
3. import pers.niaonao.entity.GrilFriendUnSingleton;  
4.   
5. /** 
6.  * @author niaonao 
7.  *  
8.  */  
9. public class TestGrilFriend {  
10.   
11.     public static void main(String[] args) {  
12.           
13.         //对实体类创建两个对象  
14.         GrilFriendUnSingleton n_first_grilfriend = new GrilFriendUnSingleton();  
15.         GrilFriendUnSingleton n_next_grilfriend = new GrilFriendUnSingleton();  
16.           
17.         String info = "n_first_grilfriend 和 n_next_grilfriend";  
18.           
19.         //判断对象是否是同一个实例  
20.         if (n_first_grilfriend != n_next_grilfriend) {  
21.             info += "\n\t不是同一个实例，是两个不同的对象:"  
22.                     + "\n\t魔法为我而存在，" + n_first_grilfriend.getGrilFriend()  
23.                     + "\n\t大小姐驾到，" + n_next_grilfriend.getGrilFriend();  
24.         } else {  
25.             info += "\n\t是同一个实例，同一个对象:"  
26.                     + "\n\t会用不知火流的烈焰烧死你的呦，" + n_first_grilfriend.getGrilFriend()  
27.                     + "\n\t会用不知火流的烈焰烧死你的呦，" + n_next_grilfriend.getGrilFriend();  
28.         }  
29.           
30.         System.out.println(info);  
31.     }  
32. }<span style="font-size: 14px;"></span><span style="color: rgb(0, 0, 0);"></span>  

package pers.niaonao.test;

import pers.niaonao.entity.GrilFriendUnSingleton;

/**
 * @author niaonao
 * 
 */
public class TestGrilFriend {

	public static void main(String[] args) {
		
		//对实体类创建两个对象
		GrilFriendUnSingleton n_first_grilfriend = new GrilFriendUnSingleton();
		GrilFriendUnSingleton n_next_grilfriend = new GrilFriendUnSingleton();
		
		String info = "n_first_grilfriend 和 n_next_grilfriend";
		
		//判断对象是否是同一个实例
		if (n_first_grilfriend != n_next_grilfriend) {
			info += "\n\t不是同一个实例，是两个不同的对象:"
					+ "\n\t魔法为我而存在，" + n_first_grilfriend.getGrilFriend()
					+ "\n\t大小姐驾到，" + n_next_grilfriend.getGrilFriend();
		} else {
			info += "\n\t是同一个实例，同一个对象:"
					+ "\n\t会用不知火流的烈焰烧死你的呦，" + n_first_grilfriend.getGrilFriend()
					+ "\n\t会用不知火流的烈焰烧死你的呦，" + n_next_grilfriend.getGrilFriend();
		}
		
		System.out.println(info);
	}
}

程序执行结果如下：

    我们在系统全局每需要使用该类时，都会在使用该类的地方通过构造方法新建类的实体对象。所以就会出现在系统全局内，存在多个当前类的对象，并且其他地方就使用一次就不使用了，新建了一个对象占用了一定的资源，但没有释放资源，这就造成资源的浪费，也是系统垃圾的一种。

    使用单例模式去写一个class

[java]

1. package pers.niaonao.entity;  
2.   
3. /** 
4.  * @author niaonao 
5.  * 单例模式下的基本类 
6.  */  
7. public class GrilFriendBySingleton {  
8.   
9.     //初始化静态私有变量grilfriend  
10.     private static GrilFriendBySingleton grilfriend = null;  
11.       
12.     /** 
13.      * 构造单例模式基本方法getInstance() 
14.      * 调用该方法，会先判断对象grilfriend是否不为null，即对象是否已存在， 
15.      * 若实例对象已存在则不再创建新对象，否则创建一个新对象给变量grilfriend。 
16.      *  
17.      * 保证当前类只存在一个实体对象。即单例模式 
18.      * @return grilfriend 
19.      */  
20.     public static GrilFriendBySingleton getInstance() {  
21.   
22.         if (null == grilfriend)  
23.             grilfriend = new GrilFriendBySingleton();  
24.   
25.         return grilfriend;  
26.     }  
27.       
28.     //默认的构造方法  
29.     public GrilFriendBySingleton() {  
30.     }  
31.       
32.     private String info = "我是你的新 GrilFriend";  
33.       
34.     /** 
35.      * 获取对象信息的方法 
36.      * @return 
37.      */  
38.     public String getGrilFriend() {  
39.         return info;  
40.     }  
41. }  

package pers.niaonao.entity;

/**
 * @author niaonao
 * 单例模式下的基本类
 */
public class GrilFriendBySingleton {

	//初始化静态私有变量grilfriend
	private static GrilFriendBySingleton grilfriend = null;
	
	/**
	 * 构造单例模式基本方法getInstance()
	 * 调用该方法，会先判断对象grilfriend是否不为null，即对象是否已存在，
	 * 若实例对象已存在则不再创建新对象，否则创建一个新对象给变量grilfriend。
	 * 
	 * 保证当前类只存在一个实体对象。即单例模式
	 * @return grilfriend
	 */
	public static GrilFriendBySingleton getInstance() {

		if (null == grilfriend)
			grilfriend = new GrilFriendBySingleton();

		return grilfriend;
	}
	
	//默认的构造方法
	public GrilFriendBySingleton() {
	}
	
	private String info = "我是你的新 GrilFriend";
	
	/**
	 * 获取对象信息的方法
	 * @return
	 */
	public String getGrilFriend() {
		return info;
	}
}

    测试类 TestGrilFriend 来测试单例模式

[java]

1. package pers.niaonao.test;  
2.   
3. import pers.niaonao.entity.GrilFriendBySingleton;  
4.   
5. /** 
6.  * @author niaonao 
7.  *  
8.  */  
9. public class TestGrilFriend {  
10.   
11.     public static void main(String[] args) {  
12.           
13.         //通过单例模式创建出两个实体常量  
14.         GrilFriendBySingleton n_first_grilfriend = GrilFriendBySingleton.getInstance();  
15.         GrilFriendBySingleton n_next_grilfriend = GrilFriendBySingleton.getInstance();  
16.           
17.         String info = "n_first_grilfriend 和 n_next_grilfriend";  
18.           
19.         //判断对象是否是同一个实例  
20.         if (n_first_grilfriend != n_next_grilfriend) {  
21.             info += "\n\t不是同一个实例，是两个不同的对象:"  
22.                     + "\n\t魔法为我而存在，" + n_first_grilfriend.getGrilFriend()  
23.                     + "\n\t大小姐驾到，" + n_next_grilfriend.getGrilFriend();  
24.         } else {  
25.             info += "\n\t是同一个实例，同一个对象:"  
26.                     + "\n\t会用不知火流的烈焰烧死你的呦，" + n_first_grilfriend.getGrilFriend()  
27.                     + "\n\t会用不知火流的烈焰烧死你的呦，" + n_next_grilfriend.getGrilFriend();  
28.         }  
29.           
30.         System.out.println(info);  
31.     }  
32. }  

package pers.niaonao.test;

import pers.niaonao.entity.GrilFriendBySingleton;

/**
 * @author niaonao
 * 
 */
public class TestGrilFriend {

	public static void main(String[] args) {
		
		//通过单例模式创建出两个实体常量
		GrilFriendBySingleton n_first_grilfriend = GrilFriendBySingleton.getInstance();
		GrilFriendBySingleton n_next_grilfriend = GrilFriendBySingleton.getInstance();
		
		String info = "n_first_grilfriend 和 n_next_grilfriend";
		
		//判断对象是否是同一个实例
		if (n_first_grilfriend != n_next_grilfriend) {
			info += "\n\t不是同一个实例，是两个不同的对象:"
					+ "\n\t魔法为我而存在，" + n_first_grilfriend.getGrilFriend()
					+ "\n\t大小姐驾到，" + n_next_grilfriend.getGrilFriend();
		} else {
			info += "\n\t是同一个实例，同一个对象:"
					+ "\n\t会用不知火流的烈焰烧死你的呦，" + n_first_grilfriend.getGrilFriend()
					+ "\n\t会用不知火流的烈焰烧死你的呦，" + n_next_grilfriend.getGrilFriend();
		}
		
		System.out.println(info);
	}
}

程序执行结果如下：

    即使对 GrilFriendBySingleton 创建了两个变量，但通过单例模式保证是同一个实例，即在内存中是存放在一个位置的一个对象。保证了系统全局内只存在唯一的一个实例。这就是单例模式

    通过前两部分，应该对单例模式有一定的理解及认识，并能运用单例在实际开发中。下面说一下单例模式的定义，意义。

    对单例模式的定义是，保证一个类只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。

• 必须保证一个类只能有一个实例
  
• 必须是这个类自行创建这个实例
• 必须自行向整个系统提供这实例
  

    最后标准单例模式代码演示：

[java]

1. public class Singleton {  
2.     private static Singleton uniqueInstance = null;  
3.    
4.     private Singleton() {  
5.        // Exists only to defeat instantiation.  
6.     }  
7.    
8.     public static Singleton getInstance() {  
9.        if (uniqueInstance == null) {  
10.            uniqueInstance = new Singleton();  
11.        }  
12.        return uniqueInstance;  
13.     }  
14.     // Other methods...  
15. }