Java Enumeration Common operations

Before JDK1.5, we defined constants: public static fianl ..... Now, with enumerations, you can group related constants into an enumeration type, and enumerations provide more methods than constants.

Java code

1. Public enum Color {
2. }

The switch statement before JDK1.6 only supports int,char,enum types, and using enumerations can make our code more readable.

Java code

1. Enum Signal {
2. }
3. Public class TrafficLight {
4. public Void Change () {
5. switch (color) {
6. Case RED:
7. Break ;
8. Case YELLOW:
9. Break ;
10. Case GREEN:
11. Break ;
12. }
13. }

If you intend to customize your own method, you must add a semicolon at the end of the enum instance sequence. And Java requires that an enum instance be defined first.

Java code

2. Public enum Color {
4. "Red", 1), Green ("green", 2), BLANK ("White", 3), Yello ("Yellow", 4);
6. Member variables
8. private String name;
10. private int index;
12. Construction method
14. Private Color (String name, int index) {
16. THIS.name = name;
18. This.index = index;
20. //Common method
22. Public static String getName (int index) {
24. For (Color c:color.values ()) {
26. if (c.getindex () = = index) {
28. return c.name;
30. }
32. return null;
34. //Get Set Method
36. Public String GetName () {
38. return name;
40. public void SetName (String name) {
42. THIS.name = name;
44. public int GetIndex () {
46. return index;
48. public void Setindex (int index) {
50. This.index = index;
52. }

An example of the ToString () method overlay is given below.

Java code

2. Public enum Color {
4. "Red", 1), Green ("green", 2), BLANK ("White", 3), Yello ("Yellow", 4);
6. Member variables
8. private String name;
10. private int index;
12. Construction method
14. Private Color (String name, int index) {
16. THIS.name = name;
18. This.index = index;
20. //Coverage Method
22. @Override
24. Public String toString () {
26. return this.index+"_" +this.name;
28. }

All enumerations are inherited from the Java.lang.Enum class. Because Java does not support multiple inheritance, enumeration objects can no longer inherit from other classes.

Java code

2. Public interface Behaviour {
4. void print ();
6. }
8. Public enum Color implements behaviour{
10. "Red", 1), Green ("green", 2), BLANK ("White", 3), Yello ("Yellow", 4);
12. Member variables
14. private String name;
16. private int index;
18. Construction method
20. Private Color (String name, int index) {
22. THIS.name = name;
24. This.index = index;
26. Interface method
28. @Override
30. Public String GetInfo () {
32. return this.name;
34. //interface method
36. @Override
38. Public void Print () {
40. this.index+":" +this.name);
42. }

Java Code

• Public interface Food {
• Enum Coffee implements food{
• }
• Enum Dessert implements food{
• }
• }

Java.util.EnumSet and Java.util.EnumMap are two enumeration collections. Enumset guarantees that the elements in the collection are not duplicated; The key in Enummap is the enum type, and value can be any type. The use of this two collection is not mentioned here, you can refer to the JDK documentation.

For the implementation details and principles of enumerations, please refer to:

Reference: "Thinkinginjava" fourth edition

http://softbeta.iteye.com/blog/1185573

My article, because it is reproduced, may be basically no change, resulting in someone stepping on a foot. I don't think it fits my big bro character. Below I understand the use of oneself to tidy up a bit.

Because it was just beginning to learn. The usual self-understanding of things are only about to understand a bit, in the final analysis, or self-thought to understand, in fact, in the blink of an eye do not know what is.
Come out to study, not accustomed to see the code how can do?
Here is my own test code.

[Java]View PlainCopy

2. Package com.lxk.enumTest;
6. /**
8. * Java Enumeration Usage test
10. * <p>
12. * Created by Lxk on 2016/12/15
14. */
16. Public class Enumtest {
18. public static void Main (string[] args) {
20. Forenum ();
22. Useenuminjava ();
24. }
28. /** 
30. * Loop enumeration, output ordinal property, or output if the enumeration has internal properties. (I'm talking about the TypeName property of the enumeration of type types I've defined)
32. */
34. private static void Forenum () {
36. For (Simpleenum simpleEnum:SimpleEnum.values ()) {
38. System.out.println (Simpleenum + "ordinal" + simpleenum.ordinal ());
40. }
42. System.out.println ("------------------");
44. For (TYPE type:TYPE.values ()) {
46. System.out.println ("type =" + Type + "Type.Name =" + type.name () + "TypeName =" + Type.gettypename ()  + "ordinal =" + type.ordinal ());
48. }
50. }
54. /** 
56. * Use enumerations in Java code
58. */
60. private static void Useenuminjava () {
62. String typeName = "F5";
64. Type type = Type.fromtypename (typeName);
66. if (TYPE. Balance.equals (type)) {
68. System.out.println ("Instances of enumerated types obtained from strings are consistent with enumeration constants");
70. } Else {
72. System.out.println ("Big bro Code Error");
74. }
78. }
82. /** 
84. * Season enumeration (enumeration constants without parameters) This is the simplest example of enumerating usages
86. * The Ordinal attribute, which corresponds to the order of arrangement, starts from 0.
88. */
90. private enum Simpleenum {
92. SPRING,
94. SUMMER,
96. AUTUMN,
98. WINTER
100. }
106. /** 
108. * Common types (enumeration constants with parameters, this is only in the book is not common, the actual use of a lot of, to understand this, use is not a problem.) )
110. */
112. private enum TYPE {
114. FIREWALL ("FIREWALL"),
116. SECRET ("Secretmac"),
118. BALANCE ("F5");
122. private String TypeName;
126. TYPE (String typeName) {
128. this.typename = typeName;
130. }
134. /** 
136. * Returns an enumeration instance of the type, based on the name of the type.
138. *
140. * @param typeName type name
142. */
144. public static TYPE fromtypename (String typeName) {
146. For (TYPE type:TYPE.values ()) {
148. if (Type.gettypename (). Equals (TypeName)) {
150. return type;
152. }
154. }
156. return null;
158. }
162. Public String Gettypename () {
164. return This.typename;
166. }
168. }
170. }

Then the result diagram of the test:

Simple example, we have basically used, can not understand the basic is the second example. As you can see, in the second example, with parameters, you can actually understand this.

The keyword enum is understood to be similar to class, and this is a separate class. As you can see, there are properties in the above example, there are construction methods, there are getter, can also have setter, but the general is the construction of parameters. There are additional custom methods. So in front of these things, separated by commas, and finally with a semicolon, this part is called the instance of this enumeration. It can also be understood as the instance object of class new. This is a good understanding. Just, Class,new object, can own casually new, think a few on a few, and this enum keyword, he does not, his instance object, can only be embodied in this enum. In other words, his corresponding instance is limited. This is the benefit of enumeration, limiting the scope of certain things, for a chestnut: all year round, there can only be four seasons, if you are a string representation, then the sea went, but, to use the enumeration type, you put all the options in the parentheses of the enum, all the columns out, then this season's properties, corresponding values, It can only be picked up inside. There's no other.

My example above is that according to TypeName, you can pick from those examples the only type of enumeration instance--type.balance. Note Method

Type type = Type.fromtypename (typeName);
The return type of this method is the type enumerated.
This is a good idea, how does this enumeration work?

Add:

There are actually three attributes in the instance of the enumerated type with the parameter above, and in addition to my custom TypeName, 2 are the system's own. Look at the following source map:

After seeing this, I don't know if you can understand the following picture: The following image mainly describes the specifications and standards when using enumerations. I hope we can use it in the actual development time.

Finally, add one point:

Maybe you know, but maybe you don't know? I really do not know, after the test did not know!!!

The comparison of values between enumerated type objects is that you can use = = to compare values directly, whether they are equal, not the one that must use the Equals method.

Java Enumeration Common operations