Best Practice Generics mit Enum

[Jesterhead]

Hallo zusammen,
ich habe mehrere Datensätze im Zugriff und kann diese über eine vorhandene Enum unterscheiden. Beispiel:

public enum Automarken {
    Audi, Mercedes, Ford
}

Dazu getter Methoden:

public Audi getAudi(String marke){
 return execute.load(Audi.class, marke);
}

public Mercedes getMercedes(String marke){
 return execute.load(Mercedes.class, marke);
}

public Ford getFord(String marke){
 return execute.load(Ford.class, marke);
}

Ich stelle mir aber eher eine solche Lösung vor:

public T getAuto(Automarken<T> automarke, String marke){
 //return execute.load(automarke, marke);
}

Ich habe noch nicht so viel mit generics gemacht und hoffe auf etwas Hilfe von euch.

 

[Robert Zenz]

Naja, du kannst natuerlich jederzeit die Klassen dynamisch anhand des Namens des Enum-Werts laden. Grob:

Automarken automarke = Autormarken.Mercedes;

Class<?> automarkenKlasse = Class.forName(automarke.name());
return execute.load(automarkenKlasse);

Wobei du dich in deinem Code relativ oft wiederholst (wieso wird Marke nochmal als String uebergeben?).

 

[Jesterhead]

public T getAuto(Automarken<T> automarke, String seriennummer){
 //return execute.load(automarke, marke);
}

Marke als String war evtl. nicht gut als Beispiel. So wäre es korrekt. Ich habe ein identifier der innerhalb einer Klasse (Automarke) eindeutig ist. Deshalb kommt das als String.
Wichtig wäre halt noch, dass der Returntype anhand der Enum erkannt wird. Gebe ich als Enum Mercedes, erwarte ich als return type ein Objekt vom typ Mercedes.class

 

[kneitzel]

Ich finde das noch alles etwas verwirrend. Du hast zum einen Klassen wie Mercedes, Ford, ... Das sind Automarken und bei dir taucht Automarken auch auf (Wobei Klassenname wäre dann eher Automarke - also Singular).

Was soll das mit dem Enum dann noch werden? Was bezweckst Du mit dem Enum?

Wenn du eine Methode hast, die mit der Klasse als Parameter etwas anfangen kann, dann kann man natürlich da etwas machen wie:

public <T> Automarke getAuto(Class<T extends Automarke> clazz, String seriennummer){
   return execute.load(clazz, marke);
}

Da hast Du dann kein Enum und du kannst dies dann unabhängig von jedem Enum für jede Klasse aufrufen, die von Automarke erbt.

Andererseits kannst Du eine Enum auch erweitern. Die Elemente können halt alle alles noch ein Element bekommen, dass eine Function oder BiFunction ist (oder was Du auch immer brauchst). Und die setzt Du dann im Konstruktor so dass du dann eine enum hast a.la.

public enum Automarken {
    AUDI(s -> whatever(Audi.class, s)),
    MERCEDES(s -> whatever(Audi.class, s)),
    FORD(s -> whatever(Audi.class, s));
    
    // Hier dann noch das Feld das das übergebene Lambda aufnehmen kann,
    // den Konstruktor und natürlich auch
    // eine public Methode, die dies dann aufruft und das Ergebnis zurück gibt.
}

Aber so ein usecase sieht erst einmal ungewöhnlich aus. Und ein enum Member Audi und eine Klasse Audi... Daher: es werden in der Regel nur Grossbuchstaben und _ verwendet!

Der Ansatz geht aber natürlich auch ganz ohne Enum. Du kannst eine zentrale Stelle haben, bei denen man Klassen registrieren kann. Da kann dann auch z.B. eine Methode für eine Factory hinterlegt werden. Unter dem Strich hat man dann halt eine Map vom Namen hin zu dem, was da auch im Enum gelandet ist. Bei einem Aufruf über den Namen kann dann aus der Map geholt werden, was dann ausgeführt werden soll.