JAVA设计模式----单例

设计模式

设计模式就是日常生活中对问题行之有效的解决方式,是解决问题的思想
java中的单例所解决的问题就是保证一个类在内存中的唯一性.

比如class A 和 class B 需要共同使用一个配置信息,
要求class A对配置信息的更改,class B也必须知道配置信息的更改
这时候就需要保证这个配置信息在内存中的唯一性
如何保证对象的唯一性呢?
1,首先就要保证不要让其他对象自己创建该类对象,
2,我们自己在该类中创建本类对象
3,对外提供一个方法让其他程序可以获得本类对象

步骤如下:
1,私有化构造函数,保证其他类不能通过new来创建该类
2,在本类中new一个本类对象,
3,提供公有方法,将创建的本类对象返回给调用者,返回的本类对象一定是唯一的

代码演示如下:

//单例对象:
class Single{

	//本类中new本类对象
	private static Single = new Single();
	
	//构造方法私有化
	private Single(){}
	
	//对外提供访问方法
	public static Single getInstance(){
		return s ;
	}
	
	
}

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

在实际应用中:

class TestDemo{
	public static void main(String[] args){

		/*
		Test t1 = new Test();
		Test t2 = new Test();
		
		t1.setNum(10);
		t2.setNum(20);
		System.out.println(t1.getNum());//输出结果  10
		System.out.println(t2.getNum());//输出结果  20
		*/
		//此时如果要保证num的值在内存中的唯一性,就需要给Test类添加单例的限制
		/*
			
			1,在Test类中new对象
			2,构造函数私有化
			3,提供公共访问方法来返回本类中new的对象.

		*/
		//由于不能直接创建Test类,只能通过方法调用所
		Test t1 = Test.getInstance();
		Test t2 = Test.getInstance();
		
		//由于Test类在内存中只有一个实例,所以输出的结果是相同的.
		t1.setNum(10);
		t2.setNum(20);
		System.out.println(t1.getNum());//输出结果  20
		System.out.println(t2.getNum());//输出结果  20

	}

}
class Test{
	private int num ;
	//在本类中new本类实例
	//由于静态只能访问静态,所以new本类成员的成员变量也应该使用静态修饰
	//用于给调用者返回时使用
	private static Test t = new Test();
	
	//构造函数私有化
	private Test(){}
	
	//对外提供访问方法,本类不能被实例化,所以需要使用静态方法来提供给调用者,
	
	publid static Test getInstance(){
		return t ;
	}

	public void setNum(int num){
		this.num = num
	}
	public int getNum(){
		return num ;
	}
	
}

内存图解:

单例的另外一种表现方式:

class Single2{
	
	private static Single2 = numm ;
	//
	private Single2(){}
	//公共方法
	public static Single2 getInstance(){
		if(s == numm){
			s = new Single2();
		}
		return s ;
	}
	
}

两种方式的区别:
第一种方式是类一加载,对象就已经存在,
称之为饿汉式
第二种是在类加载的时候还没有对象,只有在调用getInstance()方法的时候才会创建对象,称为延迟加载.
又称之为懒汉式.

推荐在开发中使用饿汉式的开发方式,因为在多线程并发访问时,懒汉式有可能无法保证内存的唯一性.