单例模式（饿汉式，懒汉式）

单例

单例模式就是一个对象只有唯一实例，

新建一个类

public class Singleton {
	private Integer id;
	private String name;
}

建一个测试类

public class Test {
	public static void main(String[] args) {
		//通过无参的构造方法创建实例化对象，系统默认提供一个无参的构造方法
		Singleton s1 = new Singleton();
		Singleton s2 = new Singleton();
		if(s1 == s2){
			System.out.println("同一个实例");
		}else{
			System.out.println("不同的实例");
		}
	}
	
}
//运行结果是   ---> 不同的实例
正常模式下的实例化对象，是创建不同的实例

单例（饿汉式）

将构造方法私有化，这样外界就无法创建对象的实例

//构造方法私有化,外部无法创建对象
	private Singleton(){
		
	}
	//并创建对象的唯一实例
	static Singleton instance = new Singleton();

这时我们可以通过 —> 类名.对象 直接调用唯一的实例

Singleton s3 = Singleton.instance;
		Singleton s4 = Singleton.instance;
		if(s3 == s4){
			System.out.println("同一个实例");
		}else{
			System.out.println("不同的实例");
		}
		运行结果--->同一个实例

但是一般情况下我们会将唯一的实例给私有化

//创建类的唯一实例 静态的 私有的
	private static Singleton instance = new Singleton();

这时外部就无法通过 类名.对象 的方法获取实例
我们可以提供一个获取实例的方法

//创建获取唯一实例的方法
	public static Singleton getInstance(){
		return instance;
	}

Singleton s3 = Singleton.getInstance();
		Singleton s4 = Singleton.getInstance();
		if(s3 == s4){
			System.out.println("同一个实例");
		}else{
			System.out.println("不同的实例");
		}
	}
	//运行结果     同一个实例

那么为什么叫饿汉式呢？
我们创建了类的唯一实例，而且是static修饰的，那么这个实例是什么时候加载的呢？

所有静态static修饰的东西，都是在类加载的时候生成执行的

因此在类加载的时候，类的唯一实例就已经被创建，（着急忙慌的吃不饱，因此叫饿汉式）

懒汉式

//构造方法私有化,外部无法创建对象
	private Singleton(){
		
	}
	
	//声明(而非创建)类的唯一实例 静态的 私有的
	private static Singleton instance ; 

//创建唯一实例的方法
	public static Singleton getInstance(){
		if(instance == null){
			instance = new Singleton();
		}
		return instance;
	}

Singleton s5 = Singleton.getInstance();
		Singleton s6 = Singleton.getInstance();
		if(s5 == s6){
			System.out.println("同一个实例");
		}else{
			System.out.println("不同的实例");
		}
		//运行结果 ---> 同一个实例

类加载的时候并没有创建类的唯一实例，只有当用户获取实例的时候才会判断是否创建，显而易见：第一次获取实例时为空，创建类的唯一实例，之后便不需要创建（俗称懒汉式）