Können Java-Methoden den Typ Enum zurückgeben?

Question

Ich könnte mich irren, aber ich vermute aus Warum können Aufzählungen nicht lokal in einer Methode deklariert werden?dass es für eine Methode problematisch ist, den Typ Enum zurückzugeben, da eine Aufzählung in Java nicht lokal deklariert werden kann?Ich kann erklären, dass eine Methode eine Aufzählung zurückgeben soll (siehe unten), aber wie würde man dann eine solche Methode implementieren, um etwas anderes als Null oder einen Verweis auf eine außerhalb der Methode deklarierte Aufzählung zurückzugeben?Mein erster Gedanke wäre es, den Einsatz von Generika für dieses Problem zu untersuchen, aber ich möchte jegliche Sackgassen vermeiden, wenn mir die SO-Community dabei helfen kann, sie zu vermeiden.

private Enum resources() {
    return null;
}

Answer 1

Ich denke, Sie haben Recht, es wird nur möglich sein, entweder zurückzukehren null oder ein Enum woanders deklariert.Aber Sie müssen beim Kompilieren nicht unbedingt „etwas anderes“ angeben.

  class EnumEnumerator<T extends Enum<T>> implements Iterable<T> {
    private final Class<T> enumClass;

    public EnumEnumerator(Class<T> enumClass) {
      this.enumClass = enumClass;
    }

    public Iterator<T> iterator() {
      T[] values = enumClass.getEnumConstants();
      return Arrays.asList(values).iterator();
    }
  }

Später rufen Sie es auf, indem Sie den generischen Konstruktor spezialisieren und die Enum-Klasse übergeben, an der Sie interessiert sind:

class EnumEnumeratorDemo {
    enum Foo {
        BAR, BAZ, QUX;
        @Override public String toString() {
            return name().toLowerCase();
        }
    }

    public static void main(String[] args) {
        for (Foo f : new EnumEnumerator<Foo>(Foo.class)) {
            System.out.println(f);
        }
    }
}

(Natürlich ist dies ein erfundenes Beispiel und im wirklichen Leben sollten Sie einfach Foo.values() aufrufen, aber Sie verstehen, worauf es ankommt.)

Answer 2

Der gesamte Punkt der Art und Weise Java Aufzählungen tut, ist, dass sie typsicher sind - so würden Sie eine Enum nicht zurück (das wäre doppelt-plus ungood) Sie stattdessen den tatsächlichen Typ zurückgeben Sie definieren (wie „Anzug“) die genau wie eine Klasse wirkt. Anzug hat 4 "Aufzählungs" Instanzen.

Wenn Sie einen „Anzug“ erwartet haben, was würde es einen „Rang“ von 7 zurückkehren? Es wäre alles brechen!

Auch wenn Sie eine „Enum“ bestanden oder einen generischen Wert, man konnte nicht Methoden aufrufen darauf. Das Beste an typsichere Aufzählungen ist, dass Sie nur einen „Anzug“ erhalten und rufen „Suit.getColor ()“ und erwarte die Farbe dieser Farbe zu erhalten. Sie könnten auch einen ranksHigherThan (Anzug s) haben, die erfüllen könnten:

assertTrue(SPADES.ranksHigherThan(HEARTS));

Oder was noch wichtiger ist:

suit1.ranksHigherThan(suit2);

(vorausgesetzt, sie waren beide übergeben und Sie nicht wissen, was sie sind)

Typ Sicherheit ist wirklich erstaunlich, (auch wenn es ein wenig unangenehm anfangs fühlt), umarmen sie.

Answer 3

Alle Aufzählungen implementieren die Schnittstelle Enum, so können Sie sicher eine Methode schreiben, die eine ENUM auf diese Weise zurückgibt. Aber diese Methode einen einzigen ENUM-Wert zurück. Es gibt keinen Weg, um einen generischen Wert zurückgeben, die die gesamte Enumeration umfasst (abgesehen von der Klasse zurückkehren und tun Reflexion). Sie können jedoch alle Enum-Werte zurück, die mehr oder weniger ist, was Sie wollen, denke ich.

enum Resources { ONE, TWO, THREE }
private Enum<?>[] resources() {
    return Resources.values();
}

Ein Vorteil dieses Ansatzes ist, dass Sie mehr oder weniger Werte beispielsweise zurückgeben kann:

enum Resources { ONE, TWO, THREE }
enum MoreResources { UN, DEUX, TROIS }
private Enum<?>[] resources() {
    List<Enum<?>> resources = new ArrayList<Enum<?>>();
    resources.addAll(Arrays.asList(Resources.values());
    resources.addAll(Arrays.asList(MoreResources.values());
    return resources.toList(new Enum<?>[] {});
}

Ein noch besserer Ansatz, der mehr ist typsicher ist die Aufzählungen von Interesse hat implementieren eine gemeinsame Schnittstelle z.

public interface Resources {}
enum SomeResources implements Resources { ONE, TWO, THREE }
enum MoreResources implements Resources { UN, DEUX, TROIS }
private Resources[] resources() {
    List<Resources> resources = new ArrayList<Resources>();
    resources.addAll(Arrays.asList(Resources.values());
    resources.addAll(Arrays.asList(MoreResources.values());
    return resources.toList(new Resources[] {});
}

können Sie fügen zusätzliche Methoden zur Schnittstelle mehr Funktionalität zur Verfügung zu stellen.

Answer 4

Was wollen Sie erreichen? Dies ist ein Weg, um eine Enum zurückzukehren:

public class Test
{
    public static void main(String args[])
    {
        System.out.println(doit());
    }

    public enum Foo {
        BAR,
        BAZ;
    }
    public static Enum doit() {
        return Enum.valueOf(Foo.class,"BAR");
    }
}

Aber ich vermute, das ist nicht das, was Sie für sich?

Answer 5

Ja, es ist definitiv möglich.

private Enum getRetentionPolicy() {
    return java.lang.annotation.RetentionPolicy.SOURCE;
}

Wenn Sie Ihre Frage ist erklärt Aufzählungen, Sie können sie erklären:

• in ihrer eigenen Java-Datei, ähnlich einem Top-Level-class;
• innerhalb einer Java-Datei zu einer anderen Klasse gehören, ähnlich einer statischen inneren class;

Answer 6

Nicht ganz sicher, was Ihr Ziel ist es, aber wenn man will eine generified Methode (das heißt eine, die außer Kraft gesetzt werden würde) zurückzukehren, die Sie vielleicht so etwas wie die folgende haben:

public class MyEnumClass<T extends Enum<T>> {
    public T resources() {
        //do stuff here
    }
}

Nicht ganz sicher, was Sie dort gewinnen würde, obwohl es von Vorteil sein kann, wenn man über verschiedene Sätze von Aufzählungen und ihre Elemente zu sprechen sind.

Wenn Sie sprechen über die Enum-Klasse (das heißt die percursor zu Iterator) soweit ich weiß, es ist nicht generified, also bin ich nicht sicher, ob Generika hier viel helfen würde.

Answer 7

Sie können ihren Namen auf einen Wert eines Aufzählungs beziehen, z.B. Suit.SPADES.

Sie können alle Werte durchlaufen, indem die Werte () Methode verwendet wird und einer der Werte auswählen.