单态设计模式的实现原来是构造方法的私有化

柔光的暖阳◎ 2022-11-21 01:24 41阅读 0赞

我们知道类的封装可以对属性，也可以对方法。当然也可以**封装构造函数**。

为什么要封装构造函数！！？耐心点看过程，最后你就知道了

**单态设计模式的核心就是将类的构造方法私有化，之后在类的内部产生实例化对象，并通过类的静态方法返回实例化对象的引用。**

**首先**，封装构造函数

class Singleton{ 
    	private Singleton(){ 		// 将构造方法进行了封装，私有化 
    	}
    	public void print(){ 
    		System.out.println("Hello World!!!") ;
    	}
    };
    public class SingletonDemo02{ 
    	public static void main(String args[]){ 
    		Singleton s1 = null ;	// 声明对象
    		s1 = new Singleton() ;	// 错误，无法实例化对象
    	}
    };

我们发现无法实例化对象了，被私有化的方法只能在类内部调用，所以我们可以在类内部进行一个实例化：

class Singleton{ 
    	Singleton instance = new Singleton() ;	// 在内部产生本类的实例化对象
    	private Singleton(){ 		// 将构造方法进行了封装，私有化 
    	}
    	public void print(){ 
    		System.out.println("Hello World!!!") ;
    	}
    };
    public class SingletonDemo03{ 
    	public static void main(String args[]){ 
    		Singleton s1 = null ;	// 声明对象
    	}
    };

但是内部实例化了，问题是我们如何把内部实例化的instance对象拿到外部类使用呢？如果可以的话，外部就可以通过此对象进行实例化了。  
将instance声明为static访问类型

class Singleton{ 
    	static Singleton instance = new Singleton() ;	// 在内部产生本类的实例化对象
    	private Singleton(){ 		// 将构造方法进行了封装，私有化 
    	}
    	public void print(){ 
    		System.out.println("Hello World!!!") ;
    	}
    };
    public class SingletonDemo04{ 
    	public static void main(String args[]){ 
    		Singleton s1 = null ;	// 声明对象
    		s1 = Singleton.instance ;	// 取得实例化对象
    		s1.print() ;		// 调用方法
    	}
    };

正常情况下，类的属性一般需要封装，所以以上代码需要封装  
加上一个获取方法就好了

**构造方法的私有化就是通过以上的方式实现的**  
但是为什么要私有化构造方法呢？  
我们来实例化几个对象试一下：

class Singleton{ 
    	private static Singleton instance = new Singleton() ;	// 在内部产生本类的实例化对象
    	public static Singleton getInstance(){ 		// 通过静态方法取得instance对象
    		return instance ;
    	}
    	private Singleton(){ 		// 将构造方法进行了封装，私有化 
    	}
    	public void print(){ 
    		System.out.println("Hello World!!!") ;
    	}
    };
    public class SingletonDemo05{ 
    	public static void main(String args[]){ 
    		Singleton s1 = null ;	// 声明对象
    		Singleton s2 = null ;	// 声明对象
    		Singleton s3 = null ;	// 声明对象
    		s1 = Singleton.getInstance() ;	// 取得实例化对象
    		s2 = Singleton.getInstance() ;	// 取得实例化对象
    		s3 = Singleton.getInstance() ;	// 取得实例化对象
    		s1.print() ;		// 调用方法
    		s2.print() ;		// 调用方法
    		s3.print() ;		// 调用方法
    		System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
    	}
    };

输出结果是这样的：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3NzMyNw_size_16_color_FFFFFF_t_70_pic_center]  
所以不论我们声明多少个对象，最终都是只引用了类中的instance对象  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3NzMyNw_size_16_color_FFFFFF_t_70_pic_center 1]  
这样的设计模式就属于 **单态设计模式（Singleton）**  
单态就是在入口处(构造方法)限制了对象的实例化操作。  
**单态设计模式的核心就是将类的构造方法私有化，之后在类的内部产生实例化对象，并通过类的静态方法返回实例化对象的引用。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3NzMyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/dc7c3244fa8748a196756bd6bc084fa8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3NzMyNw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/fad93c129f6d44cc87ef18b1441fd409.png