码迷,mamicode.com
首页 > 编程语言 > 详细

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

时间:2015-04-20 18:29:22      阅读:210      评论:0      收藏:0      [点我收藏+]

标签:java

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


构造方法封装

类的封装性不光体现在对属性的封装上,实际上方法也是可以被封装的,当然在方法封装中也包含了对构造方法的封装。例如:以下的代码,就是对构造方法进行了封装。
  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.   
  14. };  



此时,被私有化构造方法的Singleton类,不能在外部直接私有化,既然在外部不可以使用,那么如果在内部呢?
  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.   
  14. };  



一个类的构造方法私有化之后,则只能从其类的内部取得实例化对象,那么此时要考虑的问题就是如何把内部生成的instance对象拿到外部类,这样外部就可以直接通过对象进行实例化。
正常情况下,instance属性只能通过Singleton类的实例化对象才可以进行调用,如果在没有实例化对象的时候依然可以取得instance,则就需要将instance声明成static访问类型,因为使用static声明的变量,可以直接使用类名称进行访问。
  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.   
  16. };  



正常情况下这些属性应该封装才对,所以以上的代码最好修改为以下的形式:
  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.   
  19. };  



构造私有化之后,就可以通过以上的形式取得实例化对象。
程序的意义?
以上的代码不如直接实例化操作来的直接,为什么还要这样去做呢?
如果现在产生了本类的三个对象。
  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.创建公共函数返回静态私有化属性。

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

标签:java

原文地址:http://blog.csdn.net/sqc3375177/article/details/45152975

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!