Umsetzung von verschiedenen Anweisungen

[Skull]

Ich habe mal ne Frage wie ich eurer Meinung nach das folgende Problem umsetzen sollte:
Angenommen es gibt drei verschiedene Anweisungen für Teilnehmer.

Einmal eine Abbruch-Anweisung eine Auftrags-Anweisung und eine Statusanweisung.

Die Abbruchanweisung enthält nur eine laufende Nummer und den Identifikator der Person die die Anweisung ausgestellt hat. Auftragsanweisungen haben zusätzlich zu den beiden genannten Feldern einen String der den Auftrag beschreibt und Statusanweisungen haben ebenfalls zusätzlich einen String Auftragsanweisung + ein weiteren beliebigen String.

Meine Frage ist, wie ich das hierarchisch am besten implementiere (Über-Interface Anweisung und dann jeweils Sub-Interfaces?!), so dass auch später möglichst weitere Anweisungen hinzugefügt werden können, ohne dass viel geändert werden muss und Gemeinsamkeiten sinnvoll ausgelagert werden.

 

[mr-gurke]

Definiere dir drei verschiedene Interfaces, die jeweils die Funktionalität, enthalten, die die einzelnen Tickets brauchen. Dann kannst du eine Klasse schreiben, die alle drei Interfaces implementiert und hast keinen doppelten Code. Bei der Verwendung musst du dann ein Objekt der Klasse anlegen und es gleich auf das entsprechende Interface casten.

 

[Skull]

Ich hatte vor ein Interface Anweisung zu machen (hier lagere ich dann Gemeinsamkeiten aus), und für jede Unter-Art per extends ein Sub-Interface. Für jedes Sub-Interface hätte ich dann eine eigene Klasse geschrieben. Deine Variante klingt aber auch gut, verstehe das aber leider nicht ganz, fürchte ich. Kannst du mir ein Minimal-Beispiel zeigen wie ich das ganze in der Praxis verwende?

Jeder Unter-Art hat ja unterschiedliche Parameter, d.h. ich mache dann für jede Unter-Art einen eigenen Konstruktor, ja? Aber woher weiss derjenige der die klasse verwendet denn welchen Konstruktor er für welche Anweisung nehmen soll in deinem Beispiel?

 

[mr-gurke]

Die Interfaces:
[highlight=Java]
public interface IAbbruchAnweisung {
public int getNummer();
public String getPerson();
}

public interface IAuftragsAnweisung extends IAbbruchAnweisung{
public String getAuftrag();
}

public interface IStatusAnweisung extends IAuftragsAnweisung {
public String getStatus();
}
[/highlight]

Die Klasse:
[highlight=Java]
public class Anweisung implements IAbbruchAnweisung, IAuftragsAnweisung, IStatusAnweisung {
// Klassenattribute

// jetzt alle Methoden implementieren, die in den Interfaces stehen
}
[/highlight]
Verwendung der Klasse:
[highlight=Java]
...
Anweisung anweisung1 = new Anweisung();
IAbbruchAnweisung abbrAnweisung1 = (IAbbruchAnweisung) anweisung1;
// jetzt kann abbrAnweisung1 nur noch getNummer und Person. anweisung1 kann aber immer noch alle Methoden ausführen
[/highlight]


Edit: Wichtig ist bei der Sache, dass du nicht folgendest tust:
[highlight=Java]
...
IAbbruchAnweisung abbrAnweisung = (IAbbruchAnweisung) new Anweisung();
IAuftragsAnweisung auftrAnweisung = (IAuftragsAnweisung) new Anweisung();...
[/highlight]
Dann hast du nämlich zwei verschiedene Objekte und kannst die AbbrAnweisung sooft "abbrechen" wie du willst, der Auftrag würde immer noch bestehen.

 

[Skull]

Ok, Danke .

 

[Skull]

Habe es wie oben von dir beschrieben umgesetzt. Ich habe jetzt jeweils einen Konstruktor für jede Anweisungsart. Das Problem ist, dass der Test mit instanceof jetzt immer (also für jede implements Art) true ergibt....lässt sich das irgendwie ändern? Ich würde instanceof ggf. später gerne noch verwenden um rauszubekommen welches Object hier tatsächlich vorliegt.

 

[mr-gurke]

Ich denke du willst die selbe Anweisung von verschiedenen Rollen aus sehen und steuern?
Dann darfst du sie nur einmal anlegen, sonst arbeitet jeder mit einem anderen Objekt.

this instanceof IAbbruchAnweisung

sollte aber gehen.

 

[Skull]

Es kann beliebig viele Anweisungen geben. Ich habe ein Interface IAnweiszung gemacht in dem alle Gemeinsamkeiten sind und jedes Sub-Interface erweitert IAnweisung um die zugehörigen Parameter. Jetzt möchte ich einer Methode nach Möglichkeit einfach ein IAnweisung Object übergeben und es soll selbst gucken, welche Art Anweisung es jetzt genau ist. Da ich aber alles in einer Klasse habe (wie von dir beschrieben), die alle Interfaces implementiert kriege ich jetzt logischerweise für jeden instanceof-Test auf eines der Sub-Interfaces true....das lässt sich wohl nur lösen indem ich für jedes Sub-Interface ne eigene Implementierung mache oder?

 

[Skull]

Ich habs jetzt so gelöst, dass das Interface Anweisung von einer abstrakten Klasse implementiert wird. Alle anderen Sub-Interfaces haben jetzt wiederum eine eigene Klasse ,wobei jeder der Klassen zusätzlich von der abstrakten Klasse erbt...auf diese Art habe ich etwas mehr Klassen, aber wenigstens auch keine Code-Duplikation + instanceof funktioniert (hoffe ich jedenfalls).