Java中的枚举类初始化 [英] Enum class initialization in Java

问题描述

在 Java 中，我们可以通过以下方式初始化该类中的类和调用方法。

  public class MyClass {
 
 public String myClassMethod（）{
 returnMyClass; 
} 
} 
  

。

  public class Test {
 
 public static void main（String [] args）{
 MyClass myClass = new MyClass（）; //初始化MyClass 
 myClass.myClassMethod（）; //调用方法
} 
} 
  

如果我的课程是一个 Enum 类，实现将会如下。

  public enum MyEnumClass {
 INSTANCE; 
 public String myEnumClassMethod（）{
 returnMyEnumClass; 
} 
} 
  

。

  public class Test {
 
 public static void main（String [] args）{
 MyEnumClass myEnumClass = MyEnumClass.INSTANCE; 
 myEnumClass.myEnumClassMethod（）; 
} 
} 
  

这两种情况都是一样的。但据说是更好的方式是枚举实现。我的问题是为什么和如何发生？

解决方案

一个枚举本质上是一个单例模式。

JVM处理初始化和存储枚举实例。为了最清楚地看到，你可以写：

  public enum MyEnumClass {
 INSTANCE（ ）; 
 
 private final String someString; 
 
 private MyEnumClass（final String someString）{
 this.someString = someString; 
} 
 
 public String getSomeString（）{
 return someString; 
} 
} 
  

另一个类：

  public static void main（String [] args）{
 final MyEnumClass myEnumClass = MyEnumClass.INSTANCE; 
 system.out.println（myEnumClass.getSomeString（））; 
} 
  

这将打印出字符串的某些值。

这表明，在$ load code>实例在类加载时被初始化，就好像通过静态 initializer。

或者换句话说，如果不覆盖等于 code> MyClass 然后

  new MyClass（）== new MyClass（）; 
  

始终 false strong>，而：

  MyEnumClass.INSTANCE == MyEnumClass.INSTANCE; 
  

始终 true STRONG>。即 MyEnumClass.INSTANCE 是始终相同 MyEnumClass.INSTANCE 而新的 MyClass 是在每次通话时创建的 new MyClass（）。

这给我们很好的你的更好的问题。

一个枚举是一个具有各种漂亮方法的单例实例，用于将 String 枚举名称转换为对其表示的单例实例的引用。它还保证，如果您将枚举解除序列化，则不会有两个单独的实例，例如正常类。

因此，一个枚举比一个类更强大和线程安全的单例。 p>

但是我们不能有两个 INSTANCE 的实例，其中 someString 所以枚举是无用的一个类 ...

简而言之，枚举对于他们有好处是有好处的， class es对他们有好处是好的。它们不是替代品，因此无法以任何有意义的方式进行比较，当将其用作另一种时。

In Java we can do following way to initialize class and call method inside that class.

public class MyClass {

public String myClassMethod(){
        return "MyClass";
 }
}

.

public class Test {

public static void main(String[] args) {
    MyClass myClass = new MyClass(); // initialize MyClass
    myClass.myClassMethod();// call a method      
   }
}

If my class is an Enum class , implementation will be following.

public enum MyEnumClass {
 INSTANCE;
public String myEnumClassMethod(){
    return "MyEnumClass";
  }
}

.

public class Test {

public static void main(String[] args) {
    MyEnumClass myEnumClass = MyEnumClass.INSTANCE;
    myEnumClass.myEnumClassMethod();
  }
}

Both these cases works quite same way. But it is said to be better way is Enum implementation. My question is why and how it is happening?

解决方案

An enum is essentially a singleton pattern.

The JVM handles the initialization and storage of enum instances. To see this most clearly you can write:

public enum MyEnumClass {
    INSTANCE("some value for the string.");

    private final String someString;

    private MyEnumClass(final String someString) {
        this.someString = someString;
    }

    public String getSomeString(){
        return someString;
    }
}

And in another class:

public static void main(String[] args) {
    final MyEnumClass myEnumClass = MyEnumClass.INSTANCE;
    system.out.println(myEnumClass.getSomeString());
}

This would print out "some value for the string.".

This demonstrates that the enum instances are initialised at class load time, i.e. as if by the static initialiser.

Or put another way, if you do not overwrite equals in MyClass then

new MyClass() == new MyClass();

Is always false, whereas:

MyEnumClass.INSTANCE == MyEnumClass.INSTANCE;

Is always true. i.e. MyEnumClass.INSTANCE is always the same MyEnumClass.INSTANCE whereas a new MyClass is created every time your call new MyClass().

This brings us nicely to your question of "better".

An enum is a singleton instance with various nifty methods for converting String enum names into a reference to the singleton instance that it represents. It also guarantees that if you de-serialize an enum there won't be two separate instances like there would for a normal class.

So an enum is certainly much better as a robust and threadsafe singleton than a class.

But we cannot have two instances of INSTANCE with the different values for someString so the enum is useless as a class...

In short enums are good for what they're good for and classes are good for what they're good for. They are not substitutes and therefore cannot be compared in any meaningful way expect when one is used as the other.

这篇关于Java中的枚举类初始化的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！