"Go" Mastering the Java Enumeration type (enum type)

Original URL: http://iaiai.iteye.com/blog/1843553

1 background

Before an enumeration type is introduced in the Java language, a common pattern that represents an enumeration type is to declare a set with an int constant. Before we usually use the public final static method to define the code as follows, with 1 for the spring, 2 for summer, 3 for autumn, 4 for winter.

Java code

2. Public class Season {
4. public static final int SPRING = 1;
6. public static final int SUMMER = 2;
8. public static final int AUTUMN = 3;
10. public static final int WINTER = 4;
12. }

This method is called an int enumeration pattern. But what's wrong with this model, we've been using it for so long, it should be okay. Often the code we write will consider its security, ease of use, and readability.

First, let's consider its type safety. Of course, this pattern is not type-safe. Let's say we design a function that asks for a value to pass through the spring and autumn. However, with the int type, we cannot guarantee that the value passed in is legal. The code looks like this:

Java code

2. Public class Season {
4. public static final int SPRING = 1;
6. public static final int SUMMER = 2;
8. public static final int AUTUMN = 3;
10. public static final int WINTER = 4;
14. private String Getchineseseason (int season) {
16. StringBuffer result = new StringBuffer ();
18. switch (season) {
20. Case season.spring:
22. Result.append ("Spring");
24. Break ;
26. Case Season.summer:
28. Result.append ("Summer");
30. Break ;
32. Case Season.autumn:
34. Result.append ("Autumn");
36. Break ;
38. Case Season.winter:
40. Result.append ("Winter");
42. Break ;
44. Default:
46. Result.append ("The earth does not have the season");
48. Break ;
50. }
52. return result.tostring ();
54. }
58. public void DoSomething () {
60. System.out.println (This.getchineseseason (season.spring)); This is a normal scene.
64. System.out.println (This.getchineseseason (5)); This is not a normal scenario, which leads to type insecurity .
66. }
70. public static void Main (string[] arg) {
72. Season Season = new Season ();
74. Season.dosomething ();
76. }
78. }

Program Getchineseseason (season.spring) is the method we expect to use. The Getchineseseason (5) is obviously not, and the compilation is passed, and what happens at runtime is unknown to us. This obviously does not conform to the type safety of Java programs.

Next, let's consider the readability of this pattern. In most cases where enumerations are used, I need to be convenient to get string expressions of enumerated types. If you print an int enumeration constant, what we see is a set of numbers, which is of little use. We might think of using string constants instead of int constants. Although it provides a printable string for these constants, it can cause performance problems because it relies on string comparison operations, so this pattern is something we don't expect.

In terms of type safety and program readability, the disadvantages of the int and string enumeration patterns are revealed. Fortunately, starting with the Java1.5 release, there is another alternative solution that avoids the drawbacks of the int and string enumeration patterns and provides many additional benefits. That is the enumeration type (enum type). The following chapters describe the definitions, characteristics, scenarios, and pros and cons of enumeration types.

2 Definitions

An enumerated type (enum type) refers to a fixed set of constants that make up a valid type. In Java, the keyword enum defines an enumeration type. The following is the definition of the Java enumeration type.

Java code

1. Public enum Season {
2. SPRING, SUMMER, AUTUMN, WINTER;
3. }

3 Features

The statements for Java-defined enumeration types are simple. It has the following characteristics:
1) using the keyword enum
2) Type names, such as the season here
3) A list of allowable values, such as the Four Seasons defined above
4) Enumerations can be individually defined in one file or embedded in other Java classes
In addition to this basic requirement, the user has some other options
5) enumeration can implement one or more interfaces (Interface)
6) You can define a new variable
7) You can define a new method
8) You can define classes that differ based on specific enumeration values
4 Application Scenarios

As an example of type safety mentioned in the background, rewrite that code with an enumeration type. The code is as follows:

Java code

2. Public enum Season {
4. SPRING (1), SUMMER (2), AUTUMN (3), WINTER (4);
8. private int code;
10. private Season (int code) {
12. This.code = code;
14. }
18. public int GetCode () {
20. return code;
22. }
24. }

Java code

2. Public class Useseason {
4. /**  
6. * Convert the English season to the Chinese season
8. * @param season
10. * @return
12. */
14. Public String Getchineseseason (Season Season) {
16. StringBuffer result = new StringBuffer ();
18. switch (season) {
20. Case SPRING:
22. Result.append ("[Chinese: Spring, Enumeration constant:" + season.name () + ", data:" + season.getcode () + "]");
24. Break ;
26. Case AUTUMN:
28. Result.append ("[English: Autumn, Enumeration constants:" + season.name () + ", data:" + season.getcode () + "]");
30. Break ;
32. Case SUMMER:
34. Result.append ("[English: Summer, Enumeration constant:" + season.name () + ", data:" + season.getcode () + "]");
36. Break ;
38. Case WINTER:
40. Result.append ("[English: Winter, Enumeration constant:" + season.name () + ", data:" + season.getcode () + "]");
42. Break ;
44. Default:
46. Result.append ("The earth does not have the season" + Season.name ());
48. Break ;
50. }
52. return result.tostring ();
54. }
58. public void DoSomething () {
60. For (Season s:season.values ()) {
62. System.out.println (Getchineseseason (s)); //This is the normal scene
64. }
66. //system.out.println (Getchineseseason (5));
68. //The compilation is not passed here, which guarantees type safety
70. }
74. public static void Main (string[] arg) {
76. Useseason Useseason = new Useseason ();
78. Useseason.dosomething ();
80. }
82. }

References [Chinese: Spring, Enumeration constants: Spring, Data: 1]
[English: Summer, Enumeration constants: SUMMER, Data: 2]
[English: Autumn, Enumeration constants: AUTUMN, Data: 3]
[English: Winter, Enumeration constants: WINTER, Data: 4]

Here's a question, why do I add a domain to an enumeration type? The goal is to associate the data with its constants. As 1 stands for Spring, 2 for summer.

5 Summary

So when should I use enumerations? Whenever you need a fixed set of constants, such as days of the week, year-round, etc. Or we know the collection of all the values it contains before we compile. The advantage is: enumeration can meet the requirements of most programmers, its concise, easy-to-use features are very prominent. Cons: Enumerations have a small performance disadvantage when compared to int constants, where there is a cost of space and time to load and initialize enumerations. such as resource-constrained devices: mobile phones and so on.

"Go" Mastering the Java Enumeration type (enum type)