单例模式、Single

矫情吗；* 2022-03-27 13:26 154阅读 0赞

单例设计模式  
单例：唯一的实例，在整个Java系统中，某个类的对象只有唯一的一个。  
形式：  
1、饿（恶）汉式  
无论使用者是否要用这个对象，都先创建这个对象。  
2、懒汉式  
只有在使用者来获取这个对象时，才会创建这个对象。  
无论哪一种单例设计模式的写法：  
（1）这个类的构造器是私有化 -->保证我们的使用者不能随意的创建第二个对象…  
（2）这个唯一的实例必须在本类中创建，并且要用一个静态的变量来存储。

# 一、饿汉式 #

1、用一个公共的静态的常量来保存这个唯一的实例对象  
2、枚举类  
3、用一个私有的静态的常量来保存这个唯一的实例对象，再用一个静态方法返回这个唯一的对象

class Hungry{
    	//（2）用一个静态的变量，来存储这个唯一的对象
    	//这个对象是在类初始化时就创建了
    	public static final Hungry INSTANCE = new Hungry();
    	
    	
    	//(1)构造器私有化
    	private Hungry(){
    		
    	}
    }

enum HungryEnum{
    	INSTANCE
    }

class HungryDemo{
    	//（2）用一个静态的变量，来存储这个唯一的对象
    	//这个对象是在类初始化时就创建了
    	private static final HungryDemo INSTANCE = new HungryDemo();
    	
    	
    	//(1)构造器私有化
    	private HungryDemo(){
    		
    	}
    	
    	public static HungryDemo getInstance(){
    		return INSTANCE;
    	}
    }

# 二、懒汉式 #

class Lazy{
    	//(2)用一个静态的变量来保存这个唯一的实例
    	private static Lazy instance;//这里不能new
    	
    	//(1)构造器私有化
    	private Lazy(){
    		
    	}
    	
    	//对的
    /*	//(3)当你来获取这个对象的时候，再来创建
    	public synchronized static Lazy getInstance(){
    		if(instance == null){
    			instance = new Lazy();
    		}
    		return instance;
    	}*/
    	
    	
    	//(3)当你来获取这个对象的时候，再来创建
    	public static Lazy getInstance(){
    		if(instance == null){//外面这个条件的作用是为了提高效率        当这个对象已经创建过了，那么后面的线程，无论多少个，就没必要等待锁
    			synchronized (Lazy.class) {//Lazy.class获取当前类的Class对象
    				if(instance == null){//里面的条件是为了安全
    					instance = new Lazy();
    				}
    			}
    		}
    		return instance;
    	}

class LazyDemo{
    	//(1)构造器私有化
    	private LazyDemo(){
    		
    	}
    	
    	//内部类
    	private static class Inner{
    		//（2）用静态内部类的一个静态的常量来保存这个唯一的对象
    		public static final LazyDemo INSTANCE = new LazyDemo();
    		
    		static{
    			System.out.println("内部类的静态代码块");
    		}
    	}
    	
    	//当我们调用这个方法时，获取外部类对象，才会导致内部类的加载和初始化，才会导致INSTANCE对象的创建，所以也属于懒汉式
    	public static LazyDemo getInstance (){
    		return Inner.INSTANCE;
    	}
    	
    	//为了测试内部类是否被加载的方法
    	public static void test(){
    		System.out.println("外部类的静态方法");
    	}
    }