黑马程序员02_单例设计模式

单例设计模式

知识点一：单例模式概述

设计模式：

解决某一类问题最行之有效的方法。java中23种设计模式。

单例设计模式：

解决一个类在内存只存在一个对象。

运用时机：

当需要将该事物的对象保证在内存中唯一时使用，比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。

使对象唯一需保证：

1、为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象

2、还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。

3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三部用代码体现的一种形式（饿汉式）：

1、将构造函数私有化。

2、在类中创建一个本类对象。

3、提供一个方法可以获取到该对象。

如

class Single
{
	private  Single(){}    //1、将构造函数私有化。
	private static Single s = new Single();  //2、在类中创建一个本类对象。
	public static  Single getInstance()   //3、提供一个方法可以获取到该对象。
	{
		return s;
	}
}

调用方法：

class SingleDemo 
{
	public static void main(String[] args) 
	{
			Single ss = Single.getInstance();
　　Single s1 = Single.getInstance();
　　}
} 

　　

 

 

知识点二：单例模式的使用

一般的模式程序分析：

public class Test{
	public static void main(String[] args) 
	{
		Single s1 = new Single();
		Single s2 = new Single();
		s1.setNumber(20);
		System.out.println(s2.getNumber());
	}
}
	
class Single 
{
	private int a;
	public void setNumber(int a)
	{
		this.a = a;
	}
	public int getNumber()
	{
		return a;
	}
}

执行结果为：0

陈潞的分析：new了两个不同的对象s1与s2，它们都有自己私有的值a，s1只是设置了自己的a，s2中a的值没有初始化，还是默认的0。

使用单利模式后的形式：

对于事物该怎么描述，还怎么描述。只需将固定的三步加上即可。

public class Test4{
	public static void main(String[] args) 
	{
		Single s1 = Single.getIstance();
		Single s2 = Single.getIstance();
		s1.setNumber(20);
		System.out.println(s2.getNumber());
	}
}
	
class Single 
{
	private static int a;
	private Single(){}                          //1、将构造函数私有化。
	private static Single s = new Single(); //2、在类中创建一个本类对象。
	public static Single getIstance()       //3、提供方法可以获取到该对象。
	{
		return s;
	}
	public  void setNumber(int a)
	{
		this.a = a;
	}
	public static int getNumber()
	{
		return a;
	}
}

执行结果为：20

陈潞的分析：使用单例模式产生的两个对象指向同一引用，实际上都是同一个类自身的对象。所以s1和s2的a都是同一个值。

• 单例模式的另一种形式（懒汉式）：

懒汉式概述：对象是方法被调用时，才初始化，也叫做对象的延时加载。

代码如下：

class Single
{
	private static Single s = null;
	private Single(){}
	public static Single getInstance()
	{
		if(s==null)
		return s;
	}
}

• 懒汉式优点：

Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。可以节省内存

• 懒汉式缺点：

多线程可能会产生问题，解决方法有两种：

第一种解决冲突：在方法上加锁，但是效率比较低，代码如下：

class Single
{
	private static Single s = null;
	private Single(){}
	public static synchronized Single getInstance()
	{
		if(s==null)
		return s;
	}
}

第二种解决冲突：多重判断，适时加锁，效率高，但是代码比较麻烦，

class Single
{
	private static Single s = null;
	private Single(){}
	public static Single getInstance()
	{
		if(s==null)
		{
			synchronized(Single.class)
			{				
				if(s==null)
					s = new Single();
			}
		}
		return s;
	}
}