What are enums in Java?

In Java enumerations or enum are a special type of class that represents a group of constants (immutable values), that is, a fixed set of values ​​that do not change over time, so all possible values ​​are known at compile time, for example days of the week, months of the year, colors, etc.

Since an enum is a type of class you might think that we need to instantiate it to use it, however, this is not necessary, although it has the same capabilities as a normal class, such as attributes, methods, constructors and even implementing interfaces, the only consideration is that you cannot implement the concept of inheritance in an enum. Its main objective is to define our own data types (Enumerated Data Types). Some properties to highlight of an enum are:

• Each enum internally is implemented as a class using the class type.
• Each constant of an enum represents an object of type enum.
• All enums implicitly extend java.lang.Enum, as a class can only extend from a parent, an enum cannot extend from another class.
• Each constant in an enum is implicitly of type public static final.
• They can be used in control structures such as switches.
• A main() method can be declared inside an enum.
• The toString() method is overridden to return the name of the constant.

Declaration of an enum

We can declare an enum inside or outside a class, or in a separate file, but not inside a method. The syntax to declare an enum is as follows:

enum NombreEnum {
    CONSTANTE1, CONSTANTE2, CONSTANTE3, ...
}

By convention the constants of an enum are written in capital letters.
Typically the first line of an enum is the declaration of the constants, followed by the attributes, methods and constructors if necessary.

// Enum declarado fuera de una clase
enum Color {
    RED, GREEN, BLUE;
}

public class Main {
    public static void main(String[] args) {}
}

// Enum declarado dentro de una clase
public class Main {
    public static void main(String[] args) {}

    enum Color {
        RED, GREEN, BLUE;
    }
}

To access any of the constants of an enum we only need to use the name of the enum followed by a period and the name of the constant.

Color color = Color.RED;

It may not be so necessary, but if we need to obtain the name of a constant as it was declared, we can use the name() method, although sometimes it is omitted by the toString() method in case we need something more descriptive .

System.out.println(Color.RED.name()); // RED
System.out.println(Color.RED); // RED

Get constants from an enum

We can obtain all the constants of an enum using the values() method, which returns an array with all the constants.

enum NombreEnum {
    CONSTANTE1, CONSTANTE2, CONSTANTE3, ...
}

In case we need to obtain a constant based on its name, either because we receive it as input, we obtain it from a file or a database, we can use the valueOf() method, we just have to consider that this method is case sensitive, so if the name does not match any constant an IllegalArgumentException will be thrown.

// Enum declarado fuera de una clase
enum Color {
    RED, GREEN, BLUE;
}

public class Main {
    public static void main(String[] args) {}
}

Previously, we saw how we can get all the constants as an array, so you might be thinking if it is possible to get the index of a constant, the answer is yes, we can use the ordinal() method to get the index of a constant. constant, just like in an array the index starts at zero.

// Enum declarado dentro de una clase
public class Main {
    public static void main(String[] args) {}

    enum Color {
        RED, GREEN, BLUE;
    }
}

Use an enum on a switch

One of the advantages of using an enum is that we can use it in a switch control structure, which allows us to simplify the code and make it more readable.

Color color = Color.RED;

Attributes and constructors in an enum

Each of the constants of an enum can have custom attributes, just as in a normal class, it is only necessary to consider that there must be a constructor that initializes the attributes, in this way when loading the constants, it will be called to the corresponding constructor implicitly. Knowing that each constant is an object of type enum in the declaration we must pass the values ​​of the attributes according to the constructor.

System.out.println(Color.RED.name()); // RED
System.out.println(Color.RED); // RED

For this enum we have 3 constants, each with 3 attributes, name, level and description, in addition to a code attribute that is common for all constants, but it does not need to be initialized in the constructor, since it is a constant value. Each of the attributes can have different access modifiers, it all depends on our needs.

Methods in an enum

Considering the previous example, we can infer that since each attribute is of type private we need a way to access them, so we can declare getter methods for each of the attributes.

Color[] colors = Color.values();

for (Color color : colors) {
    System.out.println(color);
}

We can also declare utility methods in an enum, for example, a method that allows us to obtain a constant based on a level. You just have to consider that the method must be static, since we cannot instantiate an enum.

enum NombreEnum {
    CONSTANTE1, CONSTANTE2, CONSTANTE3, ...
}

Abstract methods in an enum

We have already seen how to implement methods in an enum, but if we need each constant to implement a method differently, we can declare an abstract method and each constant must implement it in its own way, considering that with this the syntax changes a little in the declaration of the constants. For example, let's declare an abstract method showPermissions() that prints the permissions of each constant through the console.

// Enum declarado fuera de una clase
enum Color {
    RED, GREEN, BLUE;
}

public class Main {
    public static void main(String[] args) {}
}

Interfaces in an enum

An enum can implement one or more interfaces, in the same way as a normal class, it is only necessary to separate the interfaces with a comma.

// Enum declarado dentro de una clase
public class Main {
    public static void main(String[] args) {}

    enum Color {
        RED, GREEN, BLUE;
    }
}

EnumSet and EnumMap

Java provides two classes to work with enum, EnumSet and EnumMap, which are more efficient than the HashSet and HashMap classes respectively, since they are designed to work with enum. EnumSet is a collection of unique elements of an enum, while EnumMap is an implementation of Map that uses an enum as a key.

Color color = Color.RED;

Complete example

We have already seen the different characteristics of an enum, now let's see an example where we make use of all of them.

System.out.println(Color.RED.name()); // RED
System.out.println(Color.RED); // RED

Conclusion

Enums are a very useful feature in Java, as they allow us to define our own data types, which helps us make our code more readable and maintainable, as well as allowing us to work with constants more efficiently. Although it is not a new feature, it is important to know about it and know how to use it, because in many cases it can help us simplify our code.

The above is the detailed content of What are enums in Java?. For more information, please follow other related articles on the PHP Chinese website!