OOP verschiedene Objekttypen ablegen

[joe_roemer]

Hallo,
ich habe folgendes Problem:
Ich habe drei Klassen, die von einer Superklasse erben.
Die drei Subklassen unterscheiden sich nur durch die implementierten Methoden.

Ich möchte also wenn ich eine der drei Subklassen instanziiere, nur deren Methoden aufrufen können und nicht die der anderen zwei.
Das funktioniert auch soweit.

Nun möchte ich aber Instanzen aller drei Subklassen in einem Array oder ähnlichem ablegen um leichter darauf zuzugreifen.
Dazu habe ich mir (zum Beispiel) ein Array vom Typ der Superklasse angelegt und die einzelnen Elemente des Arrays vom Typ der Subklassen deklariert.
Wenn ich nun auf die Arrayelemente zugreife, kann ich immer nur auf die Methoden der Superklasse zugreifen und nicht auf die speziellen Methoden der Subklassen.
Diese speziellen Methoden sind ja aber nicht in der Superklasse definiert.
Wo ist mein Denkfehler?

Gruß, Alex

 

[joe_roemer]

Noch als Nachtrag,
muss ich diese unterschiedlichen Methoden aus den Subklassen in der Superklasse "abstrakt" implementieren?
Es sind aber nicht alle Methoden in allen Subklassen enthalten.

Gruß, Alex

 

[Michael...]

Wenn Du ein Objekt vom Typ Superklasse hast, kannst Du nur auf die in der Superklasse definierten Methoden zugreifen, auch wenn das Objekt eigentlich vom Typ einer Subklasse ist.
Eine Möglichkeite wäre das Objekt auf die Subklasse zu casten, dabei sollte man aber wissen von welchen Typ Superklasse das Objekt ist.
Mach doch mal ein konkretes Bsp. das verdeutlicht was genau Du vorhast. Vielleicht kann man das Problem eleganter lösen.

 

[joe_roemer]

Hi Michael,
ok, ich stelle mal kurz dar worum es geht.
Ich bin dabei für meine digitale Modelleisenbahn eine Steuerung zu schreiben.
Diese soll auch die Signale steuern.
Also habe ich eine Klasse Signal geschrieben mit bestimmten Attributen und Methoden.
Jetzt gibt es aber im Schienenverkehr unterschiedliche Arten von Signalen.
Diese unterscheiden sich darin, daß sie nur bestimmte Zustände annehmen können: rot/grün, rot/gelb, rot/grün/gelb...usw.
Nun habe ich Subklassen geschrieben, die von der Klasse Signal erben.
Zum Beispiel die Sublasse Blocksignal.
Dieses kann alles was die Klasse Signal kann (vererbt), kann aber im Gegensatz zu anderen Signalarten (Subklassen) nur die Zustände rot und grün annehmen, also kein gelb.
Daher soll sie NUR die Methoden setzeAufRot und setzteAufGrün haben.

Eine weitere Subklasse von Signal wäre das Einfahrsignal.
Dieses kann ebenfalls alles was die Klasse Signal kann (vererbt), aber kann die Zustände rot, grün oder gelb annehmen.
Daher soll sie die Methoden setzeAufRot() und setzteAufGrün() und setzeAufGelb() haben.

So will ich erreichen, das bei jeder Art von Signal nur die zulässigen Methoden aufgerufen werden.

Soweit so gut.
Nun möchte ich alle Signale zusammen, also Block- und Einfahrsignale zusammen verwalten.
Daher habe ich ein Array erschaffen, als Beispiel nur mit 2 Elementen:

Signal [] signal = new Signal[2]

Dann habe ich folgendes gemacht:

signal[0] = new BlockSignal();
signal[1] = new EinfahrSignal();

Spreche ich nun signal[0] an, was ja ein Blocksignal sein soll, bekomme ich aber nur die Methoden der Superklasse Signal zu packen, signal[0].setzeAufRot() geht nicht, weil diese in der Subklasse definiert sind.
Ebenso mit signal[1].
Mit Casten bin ich nicht weitergekommen.

Was ich möchte, ist halt alle Signalarten relativ bequem ansprechen bzw. verwalten.
Es muss kein Array sein.

Gruß, Alex

 

[Gast2]

Das geht mit einem cast:

Signal[] signal = new Signal[2]

signal[0] = new BlockSignal();
signal[1] = new EinfahrSignal();
...

BlockSignal block = (BlockSignal) signal[0];
EinfahrSignal einfahr = (EinfahrSignal) signal[1];

block.methode1();
einfahr.methode1();

Kannst du auch gleich direkt machen:

((BlockSignal) signal[0]).methode1();
((EinfahrSignal) signal[1]).methode1();

Aber wirklich schön ist das nicht. Eigentlich musst du auch sicherstellen das der cast gültig ist, classCastExceptions abfangen etc. Ich würde das eher über Interfaces implementieren.

interface Signal{
  void methode1();
}

class BlockSignal implements Signal{
  public void methode1(){
  ...
}

class EinfahrSignal implements Signal{
  public void methode1(){
  ...
 }
}

Dann kannst du gleich mit dem Signal[] arbeiten:

Signal[] signal = new Signal[2]

signal[0] = new BlockSignal();
signal[1] = new EinfahrSignal();

signal[0].methode1(); // called methode1 in BlockSignal
signal[1].methode1(); // called methode1 in EinfahrSignal