单例模式中成员变量为啥一定要是private的？

Question

public class Singleton {　　private Singleton(){}　　private static  Singleton instance = new Singleton();
//如果不是private的直接由类名.的方式访问，不也是单例吗？和下面的方法不也是一样的吗？求大牛解释
　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 }
}

Answer 1

Java Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例在。 使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回（garbage collection）。 

Answer 2

一、懒汉式单例
在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例。
 
public class LazySingleton {
     /**
      * 私有静态对象,加载时候不做初始化
      */
     private static LazySingleton m_intance=null;
     /**
      * 私有构造方法,避免外部创建实例
      */
     private LazySingleton(){
     }
     /**
      * 静态工厂方法,返回此类的唯一实例.  
      * 当发现实例没有初始化的时候,才初始化.
      */
     synchronized public static LazySingleton getInstance(){
         if(m_intance==null){
             m_intance=new LazySingleton();
         }
         return m_intance;
     }
}
二、饿汉式单例
在类被加载的时候，唯一实例已经被创建。
 
public class EagerSingleton {
     /**
      * 私有的(private)唯一(static final)实例成员,在类加载的时候就创建好了单例对象
      */
     private static final EagerSingleton m_instance = new EagerSingleton();
     /**
      * 私有构造方法,避免外部创建实例
      */
     private EagerSingleton() {
     }
     /**
      * 静态工厂方法,返回此类的唯一实例.
      * @return EagerSingleton
      */
     public static EagerSingleton getInstance() {
         return m_instance;
     }
}
 
**************************************************************************************                                               懒汉方式，指全局的单例实例在第一次被使用时构建；        
饿汉方式，指全局的单例实例在类装载时构建                     
**************************************************************************************
三、登记式单例
这个单例实际上维护的是一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回。
public class RegSingleton {
     /**
      * 登记薄,用来存放所有登记的实例
      */
     private static Map<String, RegSingleton> m_registry = new HashMap();
     //在类加载的时候添加一个实例到登记薄
     static {
         RegSingleton x = new RegSingleton();
         m_registry.put(x.getClass().getName(), x);
     }
     /**
      * 受保护的默认构造方法
      */
     protected RegSingleton() {
     }
     /**
      * 静态工厂方法,返回指定登记对象的唯一实例;
      * 对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回
      * @param name
      * @return RegSingleton
      */
     public static RegSingleton getInstance(String name) {
         if (name == null) {
             name = "RegSingleton";
         }
         if (m_registry.get(name) == null) {
             try {
                 m_registry.put(name, (RegSingleton) Class.forName(name).newInstance());
             } catch (InstantiationException e) {
                 e.printStackTrace();
             } catch (IllegalAccessException e) {
                 e.printStackTrace();
             } catch (ClassNotFoundException e) {
                 e.printStackTrace();
             }
         }
         return m_registry.get(name);
     }
     /**
      * 一个示意性的商业方法
      * @return String
      */
     public String about() {
         return "Hello,I am RegSingleton!";
     }
}
你可以好好体会一下

Answer 3

直接将private暴露成public，仅从访问层面而言是可以的。但严重降低安全性。我问你，如果有人不小心代码这么写：
  Singleton.instance = null; // 当然不会肯定是null，但也许他不小心让这个返回值变成null了。你咋办？！所以将其封装为private，并且只提供get方法，可以有效提供保护。当然也有其它因素，两三句话解释不清楚，就不说了。