java 构造方法私有化及单态模式

构造方法私有化及单态模式

构造方法封装

类的封装性不光体现在对属性的封装上，实际上方法也是可以被封装的，当然在方法封装中也包含了对构造方法的封装。例如：以下的代码，就是对构造方法进行了封装。

[java] view
plaincopyprint?

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

此时，被私有化构造方法的Singleton类，不能在外部直接私有化，既然在外部不可以使用，那么如果在内部呢？

[java] view
plaincopyprint?

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

一个类的构造方法私有化之后，则只能从其类的内部取得实例化对象，那么此时要考虑的问题就是如何把内部生成的instance对象拿到外部类，这样外部就可以直接通过对象进行实例化。

正常情况下，instance属性只能通过Singleton类的实例化对象才可以进行调用，如果在没有实例化对象的时候依然可以取得instance，则就需要将instance声明成static访问类型，因为使用static声明的变量，可以直接使用类名称进行访问。

[java] view
plaincopyprint?

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

正常情况下这些属性应该封装才对，所以以上的代码最好修改为以下的形式：

[java] view
plaincopyprint?

1. class Singleton{
2. private static Singleton instance = new Singleton() ; // 在内部产生本类的实例化对象
3. public static Singleton getInstance(){  // 通过静态方法取得instance对象
4. return instance ;
5. }
6. private Singleton(){  // 将构造方法进行了封装，私有化
7. }
8. public void print(){
9. System.out.println("Hello World!!!") ;
10. }
11. };
12. public class SingletonDemo05{
13. public static void main(String args[]){
14. Singleton s1 = null ; // 声明对象
15. s1 = Singleton.getInstance() ; // 取得实例化对象
16. s1.print() ;  // 调用方法
17. }
18. };

构造私有化之后，就可以通过以上的形式取得实例化对象。

程序的意义？

以上的代码不如直接实例化操作来的直接，为什么还要这样去做呢？

如果现在产生了本类的三个对象。

[java] view
plaincopyprint?

1. class Singleton{
2. private static Singleton instance = new Singleton() ; // 在内部产生本类的实例化对象
3. public static Singleton getInstance(){  // 通过静态方法取得instance对象
4. return instance ;
5. }
6. private Singleton(){  // 将构造方法进行了封装，私有化
7. }
8. public void print(){
9. System.out.println("Hello World!!!") ;
10. }
11. };
12. public class SingletonDemo05{
13. public static void main(String args[]){
14. Singleton s1 = null ; // 声明对象
15. Singleton s2 = null ; // 声明对象
16. Singleton s3 = null ; // 声明对象
17. s1 = Singleton.getInstance() ; // 取得实例化对象
18. s2 = Singleton.getInstance() ; // 取得实例化对象
19. s3 = Singleton.getInstance() ; // 取得实例化对象
20. s1.print() ;  // 调用方法
21. s2.print() ;  // 调用方法
22. s3.print() ;  // 调用方法
23. }
24. };

不管外部声明了多少个Singleton的对象，但是最终结果都是通过getInstance()方法取得的实例化对象，也就是说，此时S1、S2、S3实际上都使用了一个对象的引用：instance

那么这样的设计在设计模式上来讲，属于单态设计模式（单例设计模式）：Singleton

如果现在不希望一个类产生过多的对象的话，则就必须使用单态设计模式，而且使用单态设计模式在以后的JAVA学习中会经常碰到，因为在JAVA的支持的类库中，大量的采用了此种设计模式。

所谓的单态就是在入口处（构造方法）限制了对象的实例化操作。

单态设计模式的意义

实际上这样的应用，读者应该早就能有所了解了，读者应该都会很清楚在windows中有一个回收站的程序，除了桌面上的回收站之外，每个硬盘上都有一个回收站，实际上每个硬盘的回收站和桌面上的回收站都是同一个，那么也就是说在整个操作系统上只有一个回收站实例，各个地方只是引用此实例而已。

总结：

单例模式步骤：

1.将类中的构造方法私有化。

2.在内部通过静态私有化属性实例化对象。

3.创建公共函数返回静态私有化属性。