Klassen und Objekte

[kehj]

Moin,
ich fürchte, daß meine Frage nicht ganz dem Niveau des Forums entspricht, aber eigentlich sollte es (glaube ich) 'n Anfänger-Forum sein...

Also: ich hab 'n Array einer Klasse, in dem ich Nachfahren dieser Klasse speichere. (z. B. array of Baum - array[1]=Eiche und so)
Wie kann ich jetzt, wenn ich auf einen bestimmten Platz im Array zugreife, feststellen, welches Objekt welcher Nachfahren-Klasse darin gespeichert ist? (also ob Eiche oder Buche...)

P.S.: Sorry, wenn die Begriffe nicht so 100% stimmen, ich denke mal, ihr wißt, was ich wissen will!

[Hagen Reddmann]

Hi

also vom Baum abgeleitet wurden eine Eiche und Linde, von Eiche abgeleitet wurde RotEiche

<pre>

if Array[I] is TBaum then .. // ein Baum oder Eiche oder Linde oder RotEiche
if Array[I] is TEiche then .. // eine Eiche oder RotEiche aber keine Linde oder Baum
if Array[I].ClassType = TEiche then ..// eine Eiche aber keine Linde oder RotEiche oder Baum

if Array[I].ClassType = TBaum then ..// ein Baum aber keine Eiche, Linde oder RotEiche

</pre>

Gruß Hage

[Mickajel]

Also, ich würde an deiner Stelle einfach ein neuen Typen Programmieren und anschließend in dem Typ alle Baum Typen Arten Unterbringen und die dan im Create der Klassen einfügen, so kannst du später ganz genau sagen ob es den eine Eiche ist oder eine Linde oder eine Fichte ....

Hier kurzes Beispiel kann nur delphi aber vielleicht hilft es>>

//Eigener Typ wo die Typen definiert sind
TtypOfBaum = (tb_None, tb_Fichte, tb_Tanne, tb_Eiche);

//-------------------------------------------------------------
//------------Eigene Basis Klasse TBaum---------------
//------------------------------------------------------------
TBaum = class(Tobject)
private
..........
FBaumTyp: TtypOfBaum;
..........
public
......
constructor Create;
property BaumTyp: TtypOfBaum read FBaumTyp write FBaumTyp;
.......
........
end;

-------------------------------------------------------------------------
------------Klasse TFichte Abgeleitet von TBaum---------------
-------------------------------------------------------------------------
TFichte = class(TBaum)
private
..........
..........
public
......
constructor Create;
........
end;


//*************************************************
//*******Implementation des Creates der Klasse Baum******
//*************************************************
constructor TBaum.Create;
begin
inherited Create;
fBaumTyp := tb_None;
end;


//*************************************************
//*******Implementation des Creates der Klasse Baum******
//*************************************************
constructor TFichte.Create;
begin
inherited Create;
fBaumTyp := tb_Fichte;
end;


<< Nun kannst du, so wie ich es Verstanden habe wo du auch
drauf hinaus wolltest, folgendes tun also du kannst jetzt dein Array
nehemen und auf eines der Felder zugreifen und das Feld Fragen von
welchem Typ Baum es überhaupt ist

bspl.
if MyArrayOfBaume[3].BaumTyp = tb_Fichte then
begin
...............................
end;


Ich hoffe doch ich konnte dir Helfen, es ist zwar vielleicht eine Programmier Sprache die dir nicht liegt aber ich hoffe es hat dir geholfen.
Falls du Fragen zu dem Code oben hast frag ruhig bin gerne bereit es dir zu erklären.

LG

[X-odus]

Ich finde die Lösung con Mickajel nicht besonders gut. Wenn nun eine Tanne andes austreibt als eine Eiche (also die Methode Austreiben() anders zu implementieren ist) führt eine solche Vorgehensweise zu Coderedundanzen oder Unlesbarkeit.

Ich würde schon bei der Vererbung bleiben.

type
  TBaum = class(TObject);

  TLaubBaum = class(TBaum);
  TNadelBaum = class(TBaum);
  
  TEiche = class(TLaubBaum);
  TBuche = class(TLaubBaum);

  TTanne = class(TNadelBaum);
  TFichte = class(TNadelBaum);

  TBaeume = array of TBaum;

Mit dem is-Operator kann man abfragen, ob die Variable vom angegebenen Typ (oder eine Ableitung davon) ist oder nicht.

var
  Baeume : TBaeume;
  MyBaum : TEiche;

...
  SetLength(Baeume, BaeumeCount); //wie viele auch immer
  Baeume[0] := MyBaum;

  if Baeume[0] is TEiche then ; //True
  if Baeume[0] is TLaubBaum then ; //True
  if Baeume[0] is TBaum then ; //True
  if Baeume[0] is TObject then ; //True

  if Baeume[0] is TTanne then ; //False
  if Baeume[0] is TNadelBaum then ; //False

Allerdings sollte die Polymorphie so genutzt werden, dass es für dich i.d.R. egal ist, welcher Nachfahre sich darunter verbirgt. Solange der Nachfahre weiß was er ist!

type
  TBaum = class(TObject)
  public
     procedure Austreiben; virtual; abstract;
  end;

  TLaubBaum = class(TBaum);
  public
     procedure Austreiben; override;
  end;

  TNadelBaum = class(TBaum);
  public
     procedure Austreiben; override;
  end;

  //usw.

Ein Programmierer hat keine Ahnung, wie er einen Elefanten fangen kann. Der Elefant soll seine Fangmethode gefälligst selbst mitbringen!