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 enum
s are good for what they're good for and class
es 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屋!