单态模式

Question

public class Singleton
{
  private static Singleton _instance=new Singleton();
public static Singleton getInstance()
{
return _instance;
}
}
当我调用Singleton ff=Singleton.getInstance();的时候是不是都要实例化一次；
如果是ff是一个实例 我再调用一次不Singleton zz=Singleton.getInstance();
也是在实例化一次吗？如果ff与zz不就两个实例了吗？
如果不是每次都实例化，那执行同一个方法不就会有可能同步的问题吗？

Answer 1

我的理解:
只有一个实例private static Singleton _instance=new Singleton(); ,它是静态的,Singleton ff=Singleton.getInstance();只是返回这个实例的引用

Answer 2

你无论Singleton ff=Singleton.getInstance();
还是Singleton zz=Singleton.getInstance();获得的都是一个对象，你可以做个小实验啊，看它们地址是否相同 

Answer 3

public class Test { public static void main(String[] args) {
Singleton sl = Singleton.getInstance();
Singleton ll = Singleton.getInstance();
System.out.println(sl == ll);
}
}class Singleton {
private Singleton() {//这句别忘了，否则就不是单态模式了
}
private static Singleton _instance = new Singleton(); public static Singleton getInstance() {
return _instance;
}
} 结果是true

Answer 4

单例模式不是这样写的：public class Singleton 
{ 
  private static Singleton _instance=new Singleton(); 
private Singleton(){}//这里构造必须私有。
public static Singleton getInstance() 
{ 
return _instance; 
} 
} 
他永远只保证内存中只有一个singleton对象。如果对象不存在的话，就创建一个，如果存在的话，就直接返回该对象。static的对象是长驻内存的

Answer 5

顶，这才是单态，构造方法也是要private的

Answer 6

是同一个对象， 因为 ： 
静态（static）对象 （Singleton）在 JVM 中只被加载一次。

Answer 7

 两种单例模式- 摘自JAVA与模式
1.Eager
public class EagerSingleton{
private static final EagerSingleton m_instance = new EagerSingleton();

private EagerSingleton(){

}
public static EagerSingleton getInstance(){
return m_instance;
}
}
2.Lazypublic class LazySingleton{
private static LazySingleton m_instance = null;

private LazySingleton(){

}
synchronized public static LazySingleton getInstance(){
if(m_instance == null){
m_instance = new LazySingleton();
}
return m_instance;
}
}

Answer 8

这个才是正解，而且lazy情况下别忘了synchronized

Answer 9

单态不是这样写的
给你写一个
public class Test
{
  private static  Test test = null;
  private Test(){}  public static Test getInstance()
  {
      if(test==null)
      {
         test = new Test();
      }
      else
      return test;
  }
}
这个方式写你会容易理解.

Answer 10

单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。
特点：
1.一个类只能有一个实例
2.自己创建这个实例
3.整个系统都要使用这个实例
单例模式有两种形式：
1.饿汉式单例类public class Singleton
{
    // 注意这是 private 只供内部调用，不允许在类外执行 new 操作
    private Singleton(){}
    // 在自己内部定义自己一个实例
    private static Singleton instance = new Singleton();
    // 这里提供了一个供外部访问本class的静态方法，可以直接访问
　　public static Singleton getInstance()
    {
　　　　return instance; 　　
　　 } 
}
2.懒汉式单例类public class Singleton
{
    private static Singleton instance = null;    // 这个方法比上面有所改进，只是第一次使用时生成实例
    public static synchronized Singleton getInstance()
    {
        if (instance==null)
        {
            instance＝new Singleton();
        }        return instance;
    }
}
第二中形式是lazy initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。 
注意到lazy initialization 形式中的 synchronized，这个 synchronized 很重要，假如没有 synchronized，那么使用 getInstance() 是有可能得到多个 Singleton 实例。

Answer 11

补充：不论哪种方式，private Singleton(){} 都不可少(上边不小心漏了)