एनम

Question

के अंदर एनम यह मेरे मामले में फंसने का मामला नहीं है, बल्कि मैं अपना कोड लिखने के लिए एक साफ तरीका ढूंढ रहा हूं।

अनिवार्य रूप से, मैं एक ईवेंट संचालित आवेदन लिख रहा हूं। उपयोगकर्ता किसी ईवेंट को ट्रिगर करता है, ईवेंट उचित ऑब्जेक्ट्स पर भेजा जाता है, और ऑब्जेक्ट्स ईवेंट को संभालते हैं। अब मैं यहां तक ​​कि हैंडलर विधियों को लिखने पर भी काम कर रहा हूं, और मैं इस कार्यक्रम को संभालने का तरीका निर्धारित करने के लिए स्विच स्टेटमेंट का उपयोग करने की उम्मीद कर रहा था। अभी जबकि मैं सामान्य संरचना पर काम कर रहा हूँ, घटना वर्ग वास्तव में सरल है:,

public class Event { 

    public static enum Action { 
     MOVE, FOO, BAR 
    } 

    private Action action; 
    private int duration; 

    public Event(Action action, int duration) { 
     this.action = action; 
     this.duration = duration; 
    } 

    public Action getAction() { 
     return action; 
    } 

    public int getDuration() { 
     return duration; 
    } 

फिर एक और कक्षा में, मैं की तरह कुछ होगा:

public void handleEvent(Event evt) {  
    switch(Event.getAction()) { 
     case MOVE: doSomething(); break; 
     case FOO: doSomething(); break; 
     case BAR: doSomething(); break; 
     default: break; 
    } 
} 

क्या मैं करूंगा

public void handleEvent(Event evt) {  
    switch(Event.getAction()) { 
     case MOVE: switch(Event.getAction()) { 
         case UP: break; 
         case DOWN: break; 
         case LEFT: break; 
         case RIGHT: break; 
        } 
     case FOO: break; 
     case BAR: break; 
     default: break; 
    } 
} 

: करने के लिए की तरह कुछ इस तरह (हालांकि मैं निश्चित रूप से अपने स्वयं के कार्यों में स्विच बयान छड़ी होगा यह स्विच और मामलों की एक बुरा hairball में बदल से बचने के लिए) है

तो, मैं नेस्टेड enums बनाने के लिए ... इसलिए की तरह चाहते हैं:

public static enum Action { 
    public enum MOVE {UP, DOWN, LEFT, RIGHT}, FOO, BAR 
} 

यह पसंद मैं स्थिति से बचने नहीं कर सकते हैं नहीं है, यह सिर्फ होगा ... सुविधाजनक। तो जब उपर्युक्त वास्तव में काम नहीं करता है, तो क्या यह हासिल करने के लिए कुछ समान तरीका है? यह अच्छा होगा अगर मैं "MOVE.UP" कार्रवाई के साथ एक ईवेंट भेज सकता हूं, और विधि इसे पहले MOVE की क्रिया के रूप में पहचान लेगी, और फिर यह पहचान लें कि यह विशेष रूप से यूपी दिशा में है। यह सिर्फ एक साधारण उदाहरण है, अगर मैं लंबी श्रृंखला बना सकता हूं, तो "DELETE.PAGE1.PARAGRAPH2.SENTENCE2.WORD11.LETTER3" जैसी कुछ भी मुफ्त होगी। जिस तरह से मैं इसे देखता हूं, मुझे स्ट्रिंग्स और बहुत सारे/अन्य कथन का उपयोग करना होगा। उम्मीद है कि एक बेहतर तरीका है! (ओह, और मेरे मामले में प्रदर्शन मायने रखता है, अगर यह मदद करता है)

Answer 1

शायद घटनाओं के लिए विरासत पदानुक्रम का उपयोग करें?

तो तुम हो:

- abstract Event 
-- MoveEvent(Direction) 
-- FooEvent() 
-- BarEvent() 

यह अधिक फ़ायदेमंद साबित हो सकता है करने के लिए:

- abstract Event 
-- abstract MoveEvent 
--- MoveUpEvent 
--- MoveDownEvent 
--- MoveRightEvent 
--- MoveLeftEvent 
-- FooEvent 
-- BarEvent 

सब ले जाएँ घटनाओं एक दूरी है, तो यह है कि पारित MoveEvent निर्माता में (जो तरंग होगा नीचे)।

Answer 2

मेरा मानना ​​है कि जावा में, आप केवल घोंसला enums कर सकते हैं, जब तक कि आपके गैर-enum स्थिरांक पहले आते हैं।

enum Action 
{ 
    FOO, 
    BAR; 
    enum MOVE 
    { 
     UP, 
     DOWN, 
     LEFT, 
     RIGHT 
    } 
} 

यह मेरे लिए संकलित करता है और मुझे वह व्यवहार देता है जिसे आप ढूंढ रहे थे। इस तरह से उन्हें एक मनमाना क्रम में घोंसला

Answer 3

आप कर सकते हैं:

पैकेज नेस्टेड;

import java.util.*; 
import nested.Citrus.Orange; 
interface HasChildren { 
    Set<Enum<?>> children(); 
} 
enum Citrus implements HasChildren { 
    lemon, lime, orange; 
    Set<Enum<?>> children; 
    enum Orange implements HasChildren { 
     navel, valencia, blood; 
     Set<Enum<?>> children; 
     enum Navel implements HasChildren { 
      washinton, lateLane, caraCaraPink; 
      public Set<Enum<?>> children() { 
       return null; 
      } 
     } 
     static { 
      navel.children = new LinkedHashSet<Enum<?>>(); 
      navel.children.addAll(EnumSet.allOf(Navel.class)); 
     } 
     enum Blood implements HasChildren { 
      moro, taroco; 
      public Set<Enum<?>> children() { 
       return null; 
      } 
     } 
     static { 
      blood.children = new LinkedHashSet<Enum<?>>(); 
      blood.children.addAll(EnumSet.allOf(Blood.class)); 
     } 
     public Set<Enum<?>> children() { 
      return children != null ? Collections.unmodifiableSet(children) : null; 
     } 
    } 
    static { 
     orange.children = new LinkedHashSet<Enum<?>>(); 
     orange.children.addAll(EnumSet.allOf(Orange.class)); 
    } 
    public Set<Enum<?>> children() { 
     return children != null ? Collections.unmodifiableSet(children) : null; 
    } 
} 
public class EnumTreeNested { 
    static void visit(Class<?> clazz) { 
     Object[] enumConstants = clazz.getEnumConstants(); 
     if (enumConstants[0] instanceof HasChildren) for (Object o : enumConstants) 
      visit((HasChildren) o, clazz.getName()); 
    } 
    static void visit(HasChildren hasChildren, String prefix) { 
     if (hasChildren instanceof Enum) { 
      System.out.println(prefix + ' ' + hasChildren); 
      if (hasChildren.children() != null) for (Object o : hasChildren.children()) 
       visit((HasChildren) o, prefix + ' ' + hasChildren); 
     } else 
      System.out.println("other " + hasChildren.getClass()); 
    } 
    static <E extends Enum<E> & HasChildren> Set<E> foo() { 
     return null; 
    } 
    public static void main(String[] args) { 
     System.out.println(Citrus.Orange.Navel.washinton); 
     visit(Citrus.lemon, ""); 
     System.out.println("----------------------"); 
     visit(Citrus.orange, ""); 
     System.out.println("----------------------"); 
     visit(Citrus.class); 
     System.out.println("----------------------"); 
    } 
}