单例模式(Singleton)

设计模式：是对问题行之有效的解决方式，其实就是一种思想。
单例设计模式：解决的问题其实就是（可以保证一个类在内存中的“对象的唯一性”）。
java中单例模式是一种常见的设计模式，单例模式分为三种：懒汉式单利、饿汉式单例、登记式单例。
单例模式的特点有：
1.单例类只能有一个实例。

2.单例类必须自己创建自己唯一的实例。

3.单例类必须给所有其他对象提供这一实例。

饿汉式：

package com.lsh.example;

/*
 * //单例模式的设计步骤：
 * 1，私有化构造函数
 * 2，创建本类对象(通过new来创建对象)并且私有化
 * 3，对外提供一个公共的访问方法
 * 
*/

//饿汉式单例模式：类一加载，对象就已经存在了（类初始化时，对象已实例化）。
public class Singleton1 {
	
	//私有化默认构造函数
	private Singleton1(){}
	//自行实例化对象
	private static final Singleton1 singleton = new Singleton1();
	//对外提供一个公共的访问方法（静态工厂方法）
	public static Singleton1 getInstance(){
		
		return singleton;
	}	
}

懒汉式：

package com.lsh.example;

//懒汉式单例模式：（在第一次调用对象内部的方法的时候实例化）
//类加载时，是没有对象的，只有调用了getInstance方法时才会创建对象（延迟加载形式）。
public class Singleton2 {
	//私有化默认构造函数
	private Singleton2(){}
	//
	private static Singleton2 singleton2 = null;
	
	//对外提供一个公共的访问方法（静态工厂方法）
	public static synchronized Singleton2 getInstance(){
		if(singleton2 == null){
			//只实例化一次
			singleton2 = new Singleton2();
		}
		return singleton2;
	}
}

测试：

class TestSingleont;

package com.lsh.example;

public class TestSingleton {
	private String name;
	private int age;

	//私有化构造函数
	private TestSingleton() {}
	
	//自行创建本类实例(两种方式：懒汉式或者饿汉式)这里只用其中一种.
	// private static TestSingleton ts = new TestSingleton();
	private static TestSingleton ts = null;
	
	//对外提供一个公共的访问方法（静态工厂方法）
	public static synchronized TestSingleton getInstance(){
		if(ts == null){
			//只实例化一次
			ts = new TestSingleton();
		}
		return ts;
	}

	//set,get方法
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	//提供一个方法
	public void getInfo(){
		System.out.println("out message："+name+","+age);
	}
	
}

class Test:

package com.lsh.example;

public class Test {
	public static void main(String[] args) {
		//通过类名直接调用本类getInstance()方法，实例化对象.
		TestSingleton ts1 = TestSingleton.getInstance();
		TestSingleton ts2 = TestSingleton.getInstance();
		ts1.setName("jack");
		ts1.setAge(25);
		System.out.println("输出结果为："+ts1.getName()+":"+ts1.getAge());
		
		ts2.setName("rose");
		ts2.setAge(20);
		System.out.println("输出结果为："+ts2.getName()+":"+ts2.getAge());
		
		ts1.getInfo();
		ts2.getInfo();
		
		if(ts1 == ts2){
			System.out.println("输出结果为：ts1与ts2是同一个实例");
		}else if(ts1 != ts2){
			System.out.println("输出结果为：ts1与ts2不是同一个实例");
		}else{
			System.out.println("输出结果为：app错误");
		}
		
	}
}

输出结果为：
Console:
输出结果为：jack:25
输出结果为：rose:20
out message：rose,20
out message：rose,20
输出结果为：ts1与ts2是同一个实例


 //可以看出：ts1.setName("jack");ts1.setAge(25);
 * ts2重新实例对象后【ts2.setName("rose");ts2.setAge(20);】
 * ts2.getInfo();和ts2.getInfo();的输出结果是一样的，ts1和ts2对应的是同一个实例。
 * 因此可知单例模式为面向对象的应用程序提供了对象唯一的访问点，不管它实现何种功能，
 * 整个应用程序都会共享一个实例对象。
 * */