Java enums are essentially classes inherited from java.lang.Enum. Each enum value is a static final instance of the class and is initialized when the class is loaded. 1. Enumeration supports adding fields, constructor methods, ordinary methods and abstract methods to enable them to carry data and encapsulate behavior; 2. Each enum instance implies two fields, name and ordinal, representing the name and declaration order respectively. The ordinal value is determined by the declaration order and is not recommended for business judgment; 3. Enumerations rely on ordinal values ??in switch, changing the declaration order will affect logic; 4. Enumeration provides values() and valueOf() methods to obtain all instances and find instances based on names; 5. Enumeration can implement interfaces or define abstract methods, and different enumeration values ??can achieve different behaviors, which are suitable for policy patterns and other scenarios. Understanding these mechanisms can help write clearer and more efficient code.

Java's enum type (Enum) looks simple, but the internal implementation is actually very interesting. It is not a simple set of constants, but a complete class structure with a set of mechanisms behind it to ensure its security and ease of use.

Enumeration is essentially a class

When you write an enum, the Java compiler will automatically generate a class inherited from java.lang.Enum for you. For example, you wrote:

 enum Color { RED, GREEN, BLUE }

After compilation, it will actually become a class like this:

 final class Color extends Enum<Color> { ... }

Each enum value (such as RED , GREEN ) will be defined as a static final instance of this class and is initialized when the class is loaded. These instances are singletons and cannot be copied or modified, which is why we say that enums are thread-safe.

Also, because it is a class, you can add fields, constructors, normal methods, and even abstract methods to the enum. For example:

 enum Color {
    RED(255, 0, 0),
    GREEN(0, 255, 0);

    private final int r, g, b;

    Color(int r, int g, int b) {
        this.r = r;
        this.g = g;
        this.b = b;
    }

    public String toString() {
        return String.format("RGB(%d, %d, %d)", r, g, b);
    }
}

This way, the enumeration can carry more information and encapsulate behavior.

The underlying data structure of enumeration

In addition to saving the data you define yourself, each enum instance will have two implicit fields:

• name : The name of the enumeration constant, the string type.
• ordinal : The order of enumeration constants, incrementing from 0.

These two fields can be accessed through name() and ordinal() methods. They are defined in the parent class Enum and all enums are owned by default.

For example, in the above example:

• Color.RED.name() returns "RED"
• Color.RED.ordinal() returns 0

It should be noted that although ordinal() looks useful, in actual development, try to avoid relying on it directly for business judgment, because it is strongly related to the order of enum declarations. Once the order changes, the logic may be incorrect.

Enumeration compatibility with switch

Java supports the use of enum types in switch statements, which is actually syntactic sugar, and the underlying layer is still used to make judgments through ordinal() .

For example:

 Color c = Color.RED;
switch(c) {
    case RED: System.out.println("Red"); break;
    case GREEN: System.out.println("Green"); break;
}

Will be compiled to something like:

 switch(c.ordinal()) {
    case 0: ... 
    case 1: ...
}

So if you change the order of declaration of enums, it will affect the behavior of switch . This also means again, don't over-rely rely on ordinal() value.

Some additional features of enumeration

Java enumeration also has some hidden functions, such as:

• Automatically provide values() method: returns an array of all enum values. This method is generated by the compiler.
• Provide valueOf(String name) method: the corresponding enum value can be obtained according to the name.
• Interfaces can be implemented: allows different enum instances to have different behaviors (such as policy patterns).
• Enumerations can have abstract methods: each enum value must implement this method.

For example, the following code shows how to enable enumeration to implement interfaces:

 interface Animal {
    void speak();
}

enum Dog implements Animal {
    BARKER {
        public void speak() { System.out.println("Woof!"); }
    };
}

This flexibility makes enumerations more than just "constants" in Java, but more like a lightweight state machine or policy container.

Basically that's it. Understanding the internal mechanism of enumeration can help write clearer and more efficient code and avoid some common pitfalls.

The above is the detailed content of How does the Java Enum type work internally?. For more information, please follow other related articles on the PHP Chinese website!