Deep mastery of Enum in Java

For something that you want to represent a finite kind of thing in a program, generally we can do it in two ways: public static final String constant, and second, using Enum to represent. In general, the former is simple, but not very good to provide more information, and in Java, the enum is very strong, but also more professional.

1. most C-style enum:

/***/publicenum  datasources {    MASTER0, MASTER1, SLAVE0, SLAVE1, SLAVE2,  SLAVE2}

This is the simplest enum, almost the same as in the C language. Simple and concise But the function is also very weak.

2. Nature of the enum

The essence of enum in Java is a class that inherits Java.lang.Enum . So he's more powerful than the C-style enum. It can have properties, methods, constructors, and so on, and here's an example:

Importorg.apache.commons.lang.StringUtils;/*** Error Code enumeration*/ Public enumErrorcodeenum {/**System Exceptions*/System_error ("System_error", "System exception"),    /**Invalid parameter*/Illegal_argument ("Illegal_argument", "argument illegal"),    /**Illegal Signature*/Illegal_sign ("Illegal_sign", "illegal signature"),    // ... ...    /**Illegal registration Code*/Illegal_reg_code ("Illegal_reg_code", "Illegal registration code"); /**Enumeration Code*/    PrivateString Code; /**Enumeration Description*/    PrivateString desc; PrivateErrorcodeenum (string code, String desc) { This. Code =Code;  This. desc =desc; }     PublicString GetCode () {returnCode; }     PublicString GetDesc () {returndesc; }        /*** Get an enumeration based on an enumerator *@paramCode Enumeration Code *@returnEnumeration*/     Public Static Finalerrorcodeenum Getbycode (String code) {if(Stringutils.isblank (code)) {return NULL; }         for(Errorcodeenum item:ErrorCodeEnum.values ()) {if(Stringutils.equals (Item.getcode (), code)) {returnitem; }        }        return NULL; }}

We see that Errorcodeenum has the attribute string code and string desc, and has a private constructor. The reason is that our enumeration constants need to use the definition of this private constructor: System_error ("System_error", "System Exception") is the private constructor of the invoked enumeration: Private Errorcodeenum (String code, String desc); So in fact, the enumeration constants defined in Errorcodeenum System_error, illegal_argument, etc. are actually equivalent to an instance of Errorcodeenum. Because they are generated by calling the private constructor of Errorcodeenum. The Errorcodeenum attribute, string code and string desc, is defined to better provide more detailed error information. It is also possible to define a variety of other helper methods in the enumeration errorcodeenum.

so the essence of an enumeration is a class that inherits and Java.lang.Enum, and enumeration constants are instances of enumerations . Enumerations can have properties and methods to harden the functionality of enumerations. Enumerations are generally not well understood in Java and generally grasp the nature behind enumerations, so it is no more difficult to understand them.

3. Common methods of enumeration

 Public Static void Main (string[] args) {        System.out.println (System_error.name ());        System.out.println (System_error.ordinal ());        System.out.println (System_error.tostring ());          for (Errorcodeenum e:errorcodeenum.values ()) {            System.out.println (e.name ());            System.out.println (E.getdesc ());        }                System.out.println (ErrorCodeEnum.SYSTEM_ERROR.name ());        System.out.println (Errorcodeenum.valueof (errorcodeenum. class, "Illegal_argument"));    }

String name (): Returns The name of this enum constant, exactly as declared in its enum declaration. Returns the string when the enumeration constant is declared.

int ordinal (): Returns the ordinal position of the declaration of an enumeration constant, like an array's index, starting at 0.

ValueOf (class<t> enumtype, string name): is actually a conversion from a string of enumerated constants to an enumeration constant, equivalent to a factory method.

The name () method is a conversion from an enumeration constant to a string, and ValueOf is a string-to-enumeration constant.

VALUES (): The method is an implicit method, all the constants of a enum type can be obtained by calling the implicit method of this public static T[] values() type . Used to iterate through all the enumeration constants in the enumeration.

4. Enumeration of thread-safe singleton patterns

enum singletondemo{    INSTANCE;      Public void Othermethods () {        System.out.println ("Something");}    }

A simple piece of code to implement a thread-safe singleton, rather than the way it is written, rather than the appropriate application of the nature of the enum.

Deep mastery of Enum in Java