黑马程序员----单例设计模式

单例设计模式创建

其中Single ss = Single.s;就可以对对象进行操作，那是不是public static Single getInstance()就是废话了？

答案：不是，public static Single getInstance();是对这个引用变量的一个控制，如：加条件判断。

    补充：有了方法就有了可控的可能。

问题：private static Single s = new Single(); 中私有化的静态变量也能进行类名访问？是不是只要是被static修饰后都可以直接用类名访问？

单例设计模式画图：

/*
设计模式：对问题行之有效的解决方式。其实它是一种思想。

1,单例设计模式。（单个实例设计模式）
	解决的问题：就是可以保证一个类在内存中的对象唯一性。

必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

如何保证对象唯一性呢？
1，不允许其他程序用new创建该类对象。
2，在该类创建一个本类实例。
3，对外提供一个方法让其他程序可以获取该对象。

步骤：
1，私有化该类构造函数。
2，通过new在本类中创建一个本类对象。
3，定义一个公有的方法，将创建的对象返回。



*/

//饿汉式
class Single//类一加载，对象就已经存在了。
{
	private static Single s = new Single();

	private Single(){}

	public static Single getInstance()//可以设定条件，成员变量一般不暴露出去，因为不可控
	{//此处返回类型自己练习时写错
		return s;
	}
}


//懒汉式
class Single2//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。
			//延迟加载形式。 
{
	private static Single2 s = null;

	private Single2(){}

	public static Single2 getInstance()
	{
		if(s==null)
			s = new Single2();
		return s;
		//return s = new Single2();  
		//此处练习时写错，初步判断是因为return （不能执行赋值语句）

	}
}


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

		System.out.println(s1==s2);
		
//		Single ss = Single.s;

//		Test t1 = new Test();
//		Test t2 = new Test();
		Test t1 = Test.getInstance();
		Test t2 = Test.getInstance();
		t1.setNum(10);
		t2.setNum(20);
		System.out.println(t1.getNum());
		System.out.println(t2.getNum());
	}
}

//单例设计模式中详细解读如下：
class Test
{
	private int num;

	// 类中自己实例对象 private 对对象进行私有化(不需要暴露出去)
	//static 是因为getInstance()方法也是静态的。
	private static Test t = new Test(); 

	//私有化构造函数，为了不让类外建立对象
	private Test(){}


	//虽然Test t 引用变量已经静态修饰，可以实现Test s = Test.t;但不可控
	//getInstance()能实现对对象的控制，如：进行条件判断。
	//public 是让此方法对外提供，static是因为主函数是静态的
	//Test是此方法返回的是一个类
	public static Test getInstance()
	{
		return t;
	}

	//以下方法就不需要静态了，因为此类一加载，对象就存在了，直接类名调用。
	public void setNum(int num)
	{
		this.num = num;
	}
	public int getNum()
	{
		return num;
	}

}