# Enums subclassen / erweitern?



## Daishy (18. Jun 2010)

Hi zusammen,

Ich fuerchte der Titel ist nicht ganz getroffen, aber ich hoffe es kommt nah genug dran . 
Ich sitze momentan an einem Problem und kann mir nicht vorstellen, dass es dafuer keine schoene Loesung gibt. Ich habe mehrere Messages, die alle von der Klasse Message erben. Diese werden, wie der Name schon vermuten laesst, in meinem Programm durch die Gegend geschickt. Soweit auch kein Problem.
Jetzt verwaltet jede Message eine Liste von Fehlern, die bei der Verarbeitung auftreten koennen in Form von Enums. Also z.B.


```
public class MessageA extends Message {
    public enum Error {
        error_a, error_b, error_C
    }

    ...weitere Transportdaten...
}
```

Jetzt soll es in jeder Message 3 Methoden geben (setError, getError, hasError), die exakt das tun, was die Namen verraten. Sie sollen sich jeweils auf das Error-Enum beziehen, dass die jeweilige Nachricht definiert. Nun wuerde ich ungern die drei Methoden jeweils wieder in jeder Message-Subklasse implementieren, sondern sie in die Hauptklasse auslagern. Um das zu machen muesste jedoch die Hauptklasse eine Error-Enum haben, dass in den Kind-Nachrichten jeweils erweitert bzw. ueberschrieben wird, damit ich eben expliziten Fehler setzen kann. Also z.B.:


```
MessageA m = new MessageA(objekt_fuer_den_transport);
...
m.setError(MessageA.Error.error_a);
...
if(m.getError() == MessageA.Error.error_a) ...
```

Ist sowas auch mit Enums moeglich, oder muesste ich da den Umweg ueber interne Static-Final-Klassen gehen? (Quasi so wie es vor den Enums gemacht wurde)

Vielen Dank schonmal jetzt fuer die Hilfen 

Gruesse,
Daishy


----------



## thE_29 (23. Jun 2010)

Nur so ne Frage, du hast ja die Idee wie es gehen sollte. Wieso probierst du diese nicht einfach aus?


----------



## slawaweis (23. Jun 2010)

das ist ein Fall für die Generics, Beispiel:


```
public abstract class AbstractMessage<T extends Enum>
 {
  protected T error_type = null;

  public T getError()
   {
   return error_type;
   }
 }

 public class MessageA extends AbstractMessage<MessageA.Error>
 {
  public enum Error { ERROR_A, ERROR_B, ERROR_C };
 }
```

Aber noch ein paar Sachen zum Design. Solche Klassen wie "Message" sollten immutable sein, um Fehler im Design von Anfang an zu vermeiden. D.h. der Fehler-Wert sollte nur einmal gesetzt werden, z.B. im Konstruktor, und dann nicht veränderbar sein. Also setError entweder weglassen oder protected machen.

Weiterhin ist meine Erfahrung in solchen Sachen, man sollte mit OOP und Klassen nicht übertreiben. Früher habe ich z.B. für jeden Fehler im System eine eigene Exception-Klasse erstellt, bis mir die instanceof und die Typumwandlungen zu viel wurden. Heute erstelle ich, wenn überhaupt, nur eine einzige eigene Exception-Klasse für ein ganzes System. So wäre es vielleicht von Vorteil sich nur eine universelle Klasse Message anzulegen und eine Enum Klasse für alle Fehlerarten. Erspart später viel Schreibarbeit und die Wartung wird auch einfacher.

Slawa


----------

