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 ，我运行了一下，也是可以的，这样不是更方便么？？

首先好像不是更方便了啊，，在一个方法里边新建一个对象比把其他的方法都定义成static应该是简单多了吧，其次很多情况都不需要把所有方法静态，因为消耗了更多系统资源啊。费力不讨好哦。

定义太多静态  会占用更多的系统资源  一般而言 能不定义  就不定义  

因为这样他就不是一个对象了，而是一个个分散的数据，面向对象中很重要的思想就是封装
要把一些零散的，有明显关联的数据，和功能，封装成一个对象，然后对其进行操作
按照你说的那么办，那就不是面向对象的思想，而是面向过程的思想，
这就是以前搞C的，转到java以后，要过的一关，就是代码要按照面向对象的思想来写。
当然上面答得也有一些道理，静态成员的生命周期最长，定义静态过多太消耗资源。
从某种程度来说这个解释也合理，但肯定不是最主要的原因

第二种方式为了解决线程安全问题，每次调用都会判断，效率大大降低。。

可以使用双重判断解决上面的问题，不过这样一来，还是第一种方便

1. class Singleton {
   
2. 
   
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. }

复制代码

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

      如果你的第二段代码是从老师课件抄的，那就是老师笔误，忘了private了。

第一种形式: 定义一个类，它的构造函数为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的。
一般认为第一种形式要更加安全些 ，总的来说各有优点的单例设计模式吧。