2016-04-27 3 views
0

Ich habe eine Schnittstelle ServiceArgument, die eine size() Versprechen definiert.Generic Enum Element oder Methode anwenden

public interface ServiceArgument { 
    public int size(); 
} 

implementieren Einige meiner enum Typen diese Schnittstelle

public enum StringCode implements ServiceArgument { 
    FOO, 
    BAR, 
    BACON, 

    public int size() { 
     return values().length; 
    } 
} 

Einige meiner Klasse eine EnumService abstrakte Klasse folgen.

public abstract class EnumService { 
    abstract void query (Enum<? extends ServiceArgument> e); 
} 

Und es einpacken, erstreckt sich einige Klassen diese abstrakte Klasse:

public class ServiceTranslation extends EnumService implements Serializable { 
/**some code and ctors and transient stuff etc **/ 

    @Override 
    void query (Enum<? extends ServiceArgument> e) { 
//line that matters : 
     if (e.ordinal() >= e.size()) { 
      throw InvalidStringCodeAsked(); 
    } 
} 

Mein Problem ist, kann ich e.size() in der letzten Zeile nicht, weil ich wouldn‘ t verwende FOO.size() in meiner Beispielaufzählung. Gibt es eine Möglichkeit zu sein, entweder:

1) spezialisiert, was die query Methode als Parameter in den konkreten Implementierungen von EnumService

2) erhält die konkrete Art der Enum in ServiceTranslation.query(MYSTERIOUS.ENUM), aufgerufen, um akzeptiert zu in der Lage sein, ConcreteENUM.size() anzurufen. oder sogar ConcreteEnum.values ​​(). length, es ist das gleiche.

3) sogar Filter alles, was nicht vom richtigen Aufzählungstyp ist, um direkt eine InvalidEnumeratedTypeException durch Methodenüberschreibung zu werfen, aber ich bin nicht vertraut mit mehreren überschreiben.

4) etwas, was ich nicht glaube, von

Edit: @shmosel im Kommentar ist richtig, auch wenn ich die falsche Aufzählung als Argument bekommen, wird es nie als seine Größe größer sein. Kein Vergleich mit seiner Größe.

+0

Wie wäre 'e.ordinal()> = e.size()' jemals möglich? Ich sehe auch nicht, warum Sie jede Konstante benötigen, um die Enum-Größe zurückzugeben, wenn Sie sie von 'e.getClass(). GetEnumConstants(). Length 'abrufen konnten. – shmosel

+0

Falls jemand den falschen aufgezählten Typ als Argument angibt:/Und danke, das ist ein Teil von dem, was ich brauche. –

+0

Nicht sicher, was Sie mit "falscher Aufzählungstyp" meinen. Sie vergleichen den Typ, der übergeben wurde, mit * seiner eigenen Enumerationsgröße. Es wird niemals fehlschlagen. – shmosel

Antwort

2

Wie wäre es mit diesem?

public abstract class EnumService { 
    abstract <T extends Enum<T> & ServiceArgument> void query (T e); 
} 

public class ServiceTranslation extends EnumService implements Serializable { 
    @Override 
    <T extends Enum<T> & ServiceArgument> void query (T e) { 
     if (e.ordinal() >= e.size()) { 
      throw InvalidStringCodeAsked(); 
     } 
    } 
} 
+0

Wenn ich es richtig verstehe, sagt Abfrage, dass ein T-Parameter, mit T extends Enum und ServiceArguments? Aber warum Enum ? –

+1

@PierreAntoineGuillaume - Siehe [hier] (http://Stackoverflow.com/q/3061759/823393) für eine Diskussion darüber. – OldCurmudgeon