What are enums and why are they useful?

后端 未结 27 1305
一整个雨季
一整个雨季 2020-11-22 07:06

Today I was browsing through some questions on this site and I found a mention of an enum being used in singleton pattern about purported thread safety benefits

相关标签:
27条回答
  • 2020-11-22 07:16

    I would use enums as a useful mapping instrument, avoiding multiple if-else provided that some methods are implemented.

    public enum Mapping {
    
        ONE("1"),
        TWO("2");
    
        private String label;
    
        private Mapping(String label){
            this.label = label;
        }
    
        public static Mapping by(String label) {
    
            for(Mapping m: values() {
                if(m.label.equals(label)) return m;
            }
    
            return null;
        }
    
    }
    

    So the method by(String label) allows you to get the Enumerated value by non-enumerated. Further, one can invent mapping between 2 enums. Could also try '1 to many' or 'many to many' in addition to 'one to one' default relation

    In the end, enum is a Java class. So you can have main method inside it, which might be useful when needing to do some mapping operations on args right away.

    0 讨论(0)
  • 2020-11-22 07:17

    Enum inherits all the methods of Object class and abstract class Enum. So you can use it's methods for reflection, multithreading, serilization, comparable, etc. If you just declare a static constant instead of Enum, you can't. Besides that, the value of Enum can be passed to DAO layer as well.

    Here's an example program to demonstrate.

    public enum State {
    
        Start("1"),
        Wait("1"),
        Notify("2"),
        NotifyAll("3"),
        Run("4"),
        SystemInatilize("5"),
        VendorInatilize("6"),
        test,
        FrameworkInatilize("7");
    
        public static State getState(String value) {
            return State.Wait;
        }
    
        private String value;
        State test;
    
        private State(String value) {
            this.value = value;
        }
    
        private State() {
        }
    
        public String getValue() {
            return value;
        }
    
        public void setCurrentState(State currentState) {
            test = currentState;
        }
    
        public boolean isNotify() {
            return this.equals(Notify);
        }
    }
    
    public class EnumTest {
    
        State test;
    
        public void setCurrentState(State currentState) {
            test = currentState;
        }
    
        public State getCurrentState() {
            return test;
        }
    
        public static void main(String[] args) {
            System.out.println(State.test);
            System.out.println(State.FrameworkInatilize);
            EnumTest test=new EnumTest();
            test.setCurrentState(State.Notify);
            test. stateSwitch();
        }
    
        public void stateSwitch() {
            switch (getCurrentState()) {
            case Notify:
                System.out.println("Notify");
                System.out.println(test.isNotify());
                break;
            default:
                break;
            }
        }
    }
    
    0 讨论(0)
  • 2020-11-22 07:18

    So far, I have never needed to use enums. I have been reading about them since they were introduced in 1.5 or version tiger as it was called back in the day. They never really solved a 'problem' for me. For those who use it (and I see a lot of them do), am sure it definitely serves some purpose. Just my 2 quid.

    0 讨论(0)
  • 2020-11-22 07:20

    As for me to make the code readable in future the most useful aplyable case of enumeration is represented in next snippet:

    public enum Items {
        MESSAGES, CHATS, CITY_ONLINE, FRIENDS, PROFILE, SETTINGS, PEOPLE_SEARCH, CREATE_CHAT
    }
    
    @Override
    public boolean onCreateOptionsMenu(Menu menuPrm) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menuPrm);
        View itemChooserLcl;
        for (int i = 0; i < menuPrm.size(); i++) {
            MenuItem itemLcl  = menuPrm.getItem(i);
                itemChooserLcl = itemLcl.getActionView();
                if (itemChooserLcl != null) {
                     //here Im marking each View' tag by enume values:
                    itemChooserLcl.setTag(Items.values()[i]);
                    itemChooserLcl.setOnClickListener(drawerMenuListener);
                }
            }
        return true;
    }
    private View.OnClickListener drawerMenuListener=new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            Items tagLcl= (Items) v.getTag();
            switch (tagLcl){
                case MESSAGES: ;
                break;
                case CHATS : ;
                break;
                case CITY_ONLINE : ;
                break;
                case FRIENDS : ;
                break;
                case  PROFILE: ;
                break;
                case  SETTINGS: ;
                break;
                case  PEOPLE_SEARCH: ;
                break;
                case  CREATE_CHAT: ;
                break;
            }
        }
    };
    
    0 讨论(0)
  • 2020-11-22 07:21

    You should always use enums when a variable (especially a method parameter) can only take one out of a small set of possible values. Examples would be things like type constants (contract status: "permanent", "temp", "apprentice"), or flags ("execute now", "defer execution").

    If you use enums instead of integers (or String codes), you increase compile-time checking and avoid errors from passing in invalid constants, and you document which values are legal to use.

    BTW, overuse of enums might mean that your methods do too much (it's often better to have several separate methods, rather than one method that takes several flags which modify what it does), but if you have to use flags or type codes, enums are the way to go.

    As an example, which is better?

    /** Counts number of foobangs.
     * @param type Type of foobangs to count. Can be 1=green foobangs,
     * 2=wrinkled foobangs, 3=sweet foobangs, 0=all types.
     * @return number of foobangs of type
     */
    public int countFoobangs(int type)
    

    versus

    /** Types of foobangs. */
    public enum FB_TYPE {
     GREEN, WRINKLED, SWEET, 
     /** special type for all types combined */
     ALL;
    }
    
    /** Counts number of foobangs.
     * @param type Type of foobangs to count
     * @return number of foobangs of type
     */
    public int countFoobangs(FB_TYPE type)
    

    A method call like:

    int sweetFoobangCount = countFoobangs(3);
    

    then becomes:

    int sweetFoobangCount = countFoobangs(FB_TYPE.SWEET);
    

    In the second example, it's immediately clear which types are allowed, docs and implementation cannot go out of sync, and the compiler can enforce this. Also, an invalid call like

    int sweetFoobangCount = countFoobangs(99);
    

    is no longer possible.

    0 讨论(0)
  • 2020-11-22 07:21

    Enums enumerate a fixed set of values, in a self-documenting way.
    They make your code more explicit, and also less error-prone.

    Why not using String, or int, instead of Enum, for constants?

    1. The compiler won't allow typos, neither values out of the fixed set, as enums are types by themselves. Consequences:
      • You won't have to write a pre-condition (or a manual if) to assure your argument is in the valid range.
      • The type invariant comes for free.
    2. Enums can have behaviour, just as any other class.
    3. You would probably need a similar amount of memory to use Strings, anyway (this depends on the complexity of the Enum).

    Moreover, each of the Enum's instances is a class, for which you can define its individual behaviour.

    Plus, they assure thread safety upon creation of the instances (when the enum is loaded), which has seen great application in simplifying the Singleton Pattern.

    This blog illustrates some of its applications, such as a State Machine for a parser.

    0 讨论(0)
提交回复
热议问题