Question

A 1级

public class A {

    private static final A instance = new A();

    public static A getInstance() {
        return new A();
    }

}

A级2

public class A {

    private static final A instance = new A();
    private A(){}
    public static A getInstance() {
        return instance;
    }

}

我刚开始学习单例，我看到了两个使用A 1类示例和A 2类示例的java示例。 A 1 getInstance()是单身吗？我也想知道这两个A getInstance()类方法之间有什么区别？谢谢

Answer 1

在A1中，A不是singleton .. getInstance()每次都会返回A的新实例

在A2中，A再次非单身，导致默认构造函数仍为public（隐式）。人们可以轻松地从外部创建更多实例

修改

由于您已在A2中编辑了班级A，现在它已变为单身。

此处A是热切创建的，默认情况下是线程安全的。查看lazy vs eager intialization

Answer 2

我也想知道这两个A类getInstance（）方法之间的区别是什么

A类1：

如果你看一下代码：

 public static A getInstance() {
    return new A();
}

每次调用A方法时，您都会返回getInstance()的新实例，因此它不是Singleton。此外，在这种情况下，您还没有使用默认构造函数private，并且类外的任何代码都可以轻松创建类的实例，从而破坏Singleton范例。

A类2：

查看此代码：

public class A {

  private static final A instance = new A();
  private A(){}
  public static A getInstance() {
     return instance;
  }
}

您为getInstance()的每次调用返回相同的实例。现在您的类的行为类似于Singleton，您实际上在这里对Singleton实例进行了急切的实例化，并且此Singleton实例应该是线程安全的。同时创建类final，以便没有人可以对它进行子类化并打破单例。

Answer 3

在第一种情况下

每次创建A的新实例时。

* 在第二种情况下*

按照单吨模式，它应该是

public class A {
   private static A instance = null;
   private  A() {

   }
   public static A getInstance() {
      if(instance == null) {
         instance = new A();
      }
      return instance;
   }
}

类A维护对单独单例实例的静态引用，并从静态getInstance（）方法返回该引用。

Answer 4

A 1类getInstance（）是单身吗？

不，因为每次调用此方法时，都会创建一个A的新实例。

我也想知道这两个A类getInstance（）方法之间有什么区别？

第一个getInstance()将始终创建A类的新实例，第二个getInstance()将始终返回由A类创建的相同实例。

Answer 5

        There are two ways of creating a singleton class
        1, Dynamic Singleton
        2, Static Singleton

        Static Singleton :

        public class A {
          //Create a object of class A and make it final so that nobody can modify it
          private static final A instance = new A();

          //make the constructor private so that new objects can not be created
          private A(){}

          //provide a method to access the object
          public static A getInstance() {
             return instance;
          }
        }

        Dynamic Singleton :

a, Single Check
        public class A {
    //Create a object reference of class A
    private static A instance = null;

    //make the constructor private so that new objects can not be created
    private  A() {}


    public static A getInstance() {
        //check if instance is null or not
        if(instance == null) {
            if(instance == null) {
                //if null then create an instance of class A and assign it to the final reference
                instance = new A();
            }

        }
        return instance;
    }
}

b, double check
public class A {
    //Create a object reference of class A
    private static A instance = null;

    //make the constructor private so that new objects can not be created
    private  A() {}


    public static A getInstance() {
        //check if instance is null or not
        if(instance == null) {
            synchronized(A.class){
                //Double Check
                if(instance == null) {
                    //if null then create an instance of class A and assign it to the final reference
                    instance = new A();
                }
            }
        }
        return instance;
    }
}

两个单例示例之间的差异

5 个答案: