黑马程序员技术交流社区

标题: 对于单例模式的一点感想 [打印本页]
作者: 张宁    时间: 2013-3-9 14:52
标题: 对于单例模式的一点感想
  1. public class Singleton {
  2. 　　private Singleton(){}　
  3. 　　private static Singleton ss= new Singleton();
  4. 　
  5. 　　public static Singleton getInstance() {
  6. 　　　　return ss; 　　
  7. 　　 }  
  8. }  
  9. 第二种形式:  
  10. public class Singleton {  
  11. 　　private static Singleton instance = null;
  12. 　　public static synchronized Singleton getInstance() {
  13. 　　 　
  14. 　　if (instance==null)
  15. 　　　　ss＝new Singleton();
  16. return ss; 　　}  
  17. }
复制代码
既然老师说单例模式是为了解决一个类中只存在一个对象，也就是说，为了让所有的改变都针对一个对象，觉得在一个方法里边新建一个对象实在有点困惑，为何不把该类的构造函数定义为private的，然后其他的方法都定义成static ，我运行了一下，也是可以的，这样不是更方便么？？
作者: 沈文杰    时间: 2013-3-9 18:59
首先好像不是更方便了啊，，在一个方法里边新建一个对象比把其他的方法都定义成static应该是简单多了吧，其次很多情况都不需要把所有方法静态，因为消耗了更多系统资源啊。费力不讨好哦。
作者: amen0205    时间: 2013-3-9 19:48
定义太多静态  会占用更多的系统资源  一般而言 能不定义  就不定义  
作者: 移动小坦克    时间: 2013-3-9 20:16
因为这样他就不是一个对象了，而是一个个分散的数据，面向对象中很重要的思想就是封装
要把一些零散的，有明显关联的数据，和功能，封装成一个对象，然后对其进行操作
按照你说的那么办，那就不是面向对象的思想，而是面向过程的思想，
这就是以前搞C的，转到java以后，要过的一关，就是代码要按照面向对象的思想来写。
当然上面答得也有一些道理，静态成员的生命周期最长，定义静态过多太消耗资源。
从某种程度来说这个解释也合理，但肯定不是最主要的原因
作者: 王亚东    时间: 2013-3-9 20:31
本帖最后由 王亚东 于 2013-3-9 20:35 编辑

第二种方式为了解决线程安全问题，每次调用都会判断，效率大大降低。。
作者: 王亚东    时间: 2013-3-9 20:43
可以使用双重判断解决上面的问题，不过这样一来，还是第一种方便
  1. class Singleton {

  3.         private static Singleton instance = null;
  4.         public static synchronized Singleton getInstance() {
  5.                 if(instance == null){
  6.                         synchronized (Singleton.class) {
  7.                                 if (instance==null){
  8.                                         instance=new Singleton();
  9.                                 }
  10.                         }
  11.                 }
  12.                 return instance;
  13.         }
  14. }
复制代码
作者: 李辉    时间: 2013-3-9 21:15
本帖最后由 李辉 于 2013-3-9 21:21 编辑

       你的第一段代码叫饿汉式单例，第二种段代码是一个错误版的懒汉式，你没有把构造函数设置为private，如果不把构造函数都设置为私有的，那Singleton类就可以创建无数个对象。
      我都没看懂你问的问题！单例模式本来就要把构造函数设置为private，你却问为什么不把构造函数设置为private！{:soso_e132:}
      懒汉式的特点是延迟加载，缺点是多线程执行时需要同步。 同时为了避免每次执行时都判定同步，在同步代码块的外层加了一个intance是否为空的判断。对应的代码就是楼上王亚东写的，不过他也没有把构造函数设置为private。
      最后，利用枚举也可以实现单例，而且很方便。

      如果你的第二段代码是从老师课件抄的，那就是老师笔误，忘了private了。
作者: 黑马潘浩    时间: 2013-3-9 21:33
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例化，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
public class Singleton {
private Singleton(){}
　　 //在自己内部定义自己一个实例，
　　 //注意这是private 只供内部调用
　　 private static Singleton instance = new Singleton();
　　 //这里提供了一个供外部访问本class的静态方法，可以直接访问
　　 public static Singleton getInstance() {
　　　　 return instance; 　　
　　 }
}
第二种形式:
public class Singleton {
　　private static Singleton instance = null;
　　public static synchronized Singleton getInstance() {
　　//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance＝new Singleton();
return instance; 　　}
}
定义一个类，它的构造函数为private的，所有方法为static的。
一般认为第一种形式要更加安全些 ，总的来说各有优点的单例设计模式吧。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2