Vererbung und Polymorphie

[DeddyH]

Wenn man der Oberklasse eine Handvoll (ggf. abstrakter) Methoden spendiert, könnte man sich außer bei der Filterung doch die ganzen "is"-Abfragen sparen.

Delphi-Quellcode:

type
  TOberdings = class
  public
    procedure SetValues; virtual; abstract;
    procedure DisplayValues; virtual; abstract;
  end;

  TErstesUnterdings = class(TOberdings)
  public
    procedure SetValues; override;
    procedure DisplayValues; override;
  end;  
  
  TZweitesUnterdings = class(TOberdings)
  public
    procedure SetValues; override;
    procedure DisplayValues; override;
  end;

Wenn man nun eine Liste von TOberdings hat, kann man die Methoden SetValues und DisplayValues für jedes einzelne Element aufrufen, ohne sich um dessen konkreten Unterklassentyp scheren zu müssen. Weiterhin wäre auch der Ansatz über Interfaces denkbar, das ist dann noch einen Tacken abstrakter, da man noch nicht einmal eine bestimmte Klassenhierarchie einhalten müsste.

[stahli]

Ich will auch mal zur Verwirrung beitragen...

Wenn Du Menschen in eine Liste speicherst steht dort drin nur
-> Zeiger auf Objekt
-> Zeiger auf Objekt
-> Zeiger auf Objekt
-> Zeiger auf Objekt

Du kannst Dir dann auch nur Objekte dort heraus holen.

Wenn Du dort nur Menschen gespeicherst hast kannst Du einfach die Objekte in Menschen casten -> Mensch := TMensch(List[0]); Falls der erste Mensch tatsächlich ein Schüler war kannst Du an die Schülereigenschaften nicht heran.
Wenn der erste Eintrag ein Auto war, dann knallt es (bestenfalls sofort oder mit unvorhersehbaren Folgen später), da u.U. Speicherplätze beschrieben werden, die gar nicht zu dem eigentlichen Objekt gehören.


Wenn Du Menschen, Schüler und Arbeiter in der Liste hast musst Du prüfen, was Du gerade vorliegen hast:

Delphi-Quellcode:

O := List[0];
if (O is TSchueler) then
  Schueler := (O as TSchueler)
else
if (O is TArbeiter) then
  Arbeiter := (O as TArbeiter)
else
if (O is TMensch) then
  Mensch := (O as TMensch);

Generische Listen akzeptieren nur bestimmte Objekte und geben die entsprechend wieder zurück. Bei einer generischen Menschenliste würdest Du also immer einen TMensch zurück erhalten.
Solche Listen sind u.a. nützlich, wenn man eine bestimmte Klasse speichern und sich das ständige Casten ersparen will.


Ein kurzer Ausflug, weil Du "Polymorphie" geschrieben hast:
Letztlich kannst Du Dich auch mal zu Schnittstellen (Interfaces) einlesen.
Da kann man völlig unterschiedliche Objekte speichern und weiter verarbeiten, die aber einheitliche Eigenschaften haben. Z.B. hätte ein Auto und ein Motorrad jeweils eine Schnittstelle IVerbrennungsmotor.
Der Verbrennungsmotor kann dann gestartet werden (Verbrennungsmotor.Start), ohne dass der Zündschlüssel wissen muss, ob am Motor ein Auto hängt oder ein Motorrad.
Dadurch kann man Klassen voneinander entkoppeln und flexibel mit ihnen umgehen.

[StepByStep]

Mahlzeit ,

danke für die Antworten. Die Lösung für mein erstes Problem, was DeddyH geschrieben hat, wende ich jetzt auch an, nur habe ich kleine Schwierigkeiten.
Ich habe das ganze mal an einem Beispiel ausprobiert.

Delphi-Quellcode:

unit Schach;

interface

uses
  system.generics.collections,
  Dialogs,
  system.sysutils;

type
  TSchachfigur = class
    Reichweite: integer;
    procedure setreichweite();
    function InString(): string; virtual;
  end;

type
  TSchachBauer = class(TSchachfigur)
    Form: string;
    procedure setform();
    function InString(): string; override;
  end;

type
  TSchachSpringer = class(TSchachfigur)
    Position: integer;
    procedure setposition();
    function InString(): string; override;
  end;

type
  Tschachspiel = class
    fschachfiguren: Tobjectlist<TSchachfigur>;
    constructor create;
  end;

implementation

function TSchachbauer.InString: string;
begin
  result := Form;
end;

procedure TSchachBauer.setform;
begin
  Form := 'kantig';
end;

constructor Tschachspiel.create;
var
  I:    integer;
  temp: TSchachfigur;
begin
  fschachfiguren := Tobjectlist<TSchachfigur>.create;

  temp := TSchachBauer.create;
  fschachfiguren.add(temp);

  temp := TSchachSpringer.create;
  fschachfiguren.add(temp);

  for I := 0 to fschachfiguren.Count - 1 do
  begin
    showmessage(fschachfiguren[I].InString);
  end;

end;

function TSchachSpringer.InString: string;
begin
  result := IntToStr(Position);
end;

procedure TSchachSpringer.setposition;
begin
  Position := 1;
end;

function TSchachfigur.InString: string;
begin
  result := IntToStr(Reichweite);
end;

procedure TSchachfigur.setreichweite;
begin
  Reichweite := 7;
end;

end.

Ich habe versucht das ganze anhand eines Schachspieles zu probieren, bevor ich mir mein eigentliches Programm ganz zerlege.
Aber ich bekomme in der Messagebox einmal nichts und dann einmal "0". Woran liegt das?
So wie das Programm aufgebaut ist, ist auch mein eigentliches Programm.

Gruß
Jan

Edit: Ich konnte das Problem gerade eben selber lösen, indem ich nicht den Umweg über die Set-Procedure gemacht habe. Aber wie geht das mit dieser?
UND bei der Ausgabe wird nicht der Wert von Schachfigur ausgegeben. Wie bekomme ich es hin, dass dieser dann auch ausgegeben wird?

[Bjoerk]

Ich würde vorschlagen, du verlegst die Adds und Castings weitegehend in die Liste, dann tust du dir anschließend leichter. Mit Generics geht das wahrscheinlich noch einfacher (keine Ahnung, hab D2007).

Delphi-Quellcode:

procedure TMenschTestForm.SomeButtonClick(Sender: TObject);
var
  Menschen: TMenschen;
  Index: integer;
begin
  Menschen := TMenschen.Create;
  try
    Index := Menschen.AddSportler;
    Menschen.Sportler[Index].SomeProp := 'Fußball';
    ShowMessage(IntToStr(Menschen.SportlerCount));
  finally
    Menschen.Free;
  end;
end;

Delphi-Quellcode:

  TMenschen = class(TObjectList)
  private
    function GetArbeiter(Index: integer): TArbeiter;
    function GetAzubi(Index: integer): TAzubi;
    function GetJob(Index: integer): TJob;
    function GetMensch(Index: integer): TMensch;
    function GetSchueler(Index: integer): TSchueler;
    function GetSchule(Index: integer): TSchule;
    function GetSportler(Index: integer): TSportler;
    function GetArbeiterCount: integer;
    function GetAzubiCount: integer;
    function GetJobCount: integer;
    function GetMenschCount: integer;
    function GetSchuelerCount: integer;
    function GetSchuleCount: integer;
    function GetSportlerCount: integer;
    function GetIsArbeiter(Index: integer): boolean;
    function GetIsAzubi(Index: integer): boolean;
    function GetIsJob(Index: integer): boolean;
    function GetIsMensch(Index: integer): boolean;
    function GetIsSchueler(Index: integer): boolean;
    function GetIsSchule(Index: integer): boolean;
    function GetIsSportler(Index: integer): boolean;
  public
    function AddMensch: integer;
    function AddJob: integer;
    function AddSchule: integer;
    function AddArbeiter: integer;
    function AddSportler: integer;
    function AddAzubi: integer;
    function AddSchueler: integer;

    property MenschCount: integer read GetMenschCount;
    property JobCount: integer read GetJobCount;
    property SchuleCount: integer read GetSchuleCount;
    property ArbeiterCount: integer read GetArbeiterCount;
    property SportlerCount: integer read GetSportlerCount;
    property AzubiCount: integer read GetAzubiCount;
    property SchuelerCount: integer read GetSchuelerCount;

    property Mensch[Index: integer]: TMensch read GetMensch;
    property Job[Index: integer]: TJob read GetJob;
    property Schule[Index: integer]: TSchule read GetSchule;
    property Arbeiter[Index: integer]: TArbeiter read GetArbeiter;
    property Sportler[Index: integer]: TSportler read GetSportler;
    property Azubi[Index: integer]: TAzubi read GetAzubi;
    property Schueler[Index: integer]: TSchueler read GetSchueler;

    property IsMensch[Index: integer]: boolean read GetIsMensch;
    property IsJob[Index: integer]: boolean read GetIsJob;
    property IsSchule[Index: integer]: boolean read GetIsSchule;
    property IsArbeiter[Index: integer]: boolean read GetIsArbeiter;
    property IsSportler[Index: integer]: boolean read GetIsSportler;
    property IsAzubi[Index: integer]: boolean read GetIsAzubi;
    property IsSchueler[Index: integer]: boolean read GetIsSchueler;
  end;

implementation

{ TMenschen }

function TMenschen.AddArbeiter: integer;
begin
  Result := Add(TArbeiter.Create);
end;
function TMenschen.AddAzubi: integer;
begin
  Result := Add(TAzubi.Create);
end;
function TMenschen.AddJob: integer;
begin
  Result := Add(TJob.Create);
end;
function TMenschen.AddMensch: integer;
begin
  Result := Add(TMensch.Create);
end;
function TMenschen.AddSchule: integer;
begin
  Result := Add(TSchule.Create);
end;
function TMenschen.AddSchueler: integer;
begin
  Result := Add(TSchueler.Create);
end;
function TMenschen.AddSportler: integer;
begin
  Result := Add(TSportler.Create);
end;

function TMenschen.GetArbeiter(Index: integer): TArbeiter;
begin
  if IsArbeiter[Index] then
    Result := TArbeiter(Items[Index])
  else
    raise Exception.Create('GetArbeiter');
end;
function TMenschen.GetAzubi(Index: integer): TAzubi;
begin
  if IsAzubi[Index] then
    Result := TAzubi(Items[Index])
  else
    raise Exception.Create('GetAzubi');
end;
function TMenschen.GetSchueler(Index: integer): TSchueler;
begin
  if IsSchueler[Index] then
    Result := TSchueler(Items[Index])
  else
    raise Exception.Create('GetSchueler');
end;
function TMenschen.GetJob(Index: integer): TJob;
begin
  if IsJob[Index] then
    Result := TJob(Items[Index])
  else
    raise Exception.Create('GetJob');
end;
function TMenschen.GetMensch(Index: integer): TMensch;
begin
  if IsMensch[Index] then
    Result := TMensch(Items[Index])
  else
    raise Exception.Create('GetMensch');
end;
function TMenschen.GetSchule(Index: integer): TSchule;
begin
  if IsSchule[Index] then
    Result := TSchule(Items[Index])
  else
    raise Exception.Create('GetSchule');
end;
function TMenschen.GetSportler(Index: integer): TSportler;
begin
  if IsSportler[Index] then
    Result := TSportler(Items[Index])
  else
    raise Exception.Create('GetSportler');
end;

function TMenschen.GetArbeiterCount: integer;
var
  I: integer;
begin
  Result := 0;
  for I := 0 to Count - 1 do
    if IsArbeiter[I] then
      Inc(Result);
end;
function TMenschen.GetAzubiCount: integer;
var
  I: integer;
begin
  Result := 0;
  for I := 0 to Count - 1 do
    if IsAzubi[I] then
      Inc(Result);
end;
function TMenschen.GetJobCount: integer;
var
  I: integer;
begin
  Result := 0;
  for I := 0 to Count - 1 do
    if IsJob[I] then
      Inc(Result);
end;
function TMenschen.GetMenschCount: integer;
var
  I: integer;
begin
  Result := 0;
  for I := 0 to Count - 1 do
    if IsMensch[I] then
      Inc(Result);
end;
function TMenschen.GetSchuleCount: integer;
var
  I: integer;
begin
  Result := 0;
  for I := 0 to Count - 1 do
    if IsSchule[I] then
      Inc(Result);
end;
function TMenschen.GetSchuelerCount: integer;
var
  I: integer;
begin
  Result := 0;
  for I := 0 to Count - 1 do
    if IsSchueler[I] then
      Inc(Result);
end;
function TMenschen.GetSportlerCount: integer;
var
  I: integer;
begin
  Result := 0;
  for I := 0 to Count - 1 do
    if IsSportler[I] then
      Inc(Result);
end;

function TMenschen.GetIsArbeiter(Index: integer): boolean;
begin
  Result := Items[Index] is TArbeiter;
end;
function TMenschen.GetIsAzubi(Index: integer): boolean;
begin
  Result := Items[Index] is TAzubi;
end;
function TMenschen.GetIsJob(Index: integer): boolean;
begin
  Result := Items[Index] is TJob;
end;
function TMenschen.GetIsMensch(Index: integer): boolean;
begin
  Result := Items[Index] is TMensch;
end;
function TMenschen.GetIsSchule(Index: integer): boolean;
begin
  Result := Items[Index] is TSchule;
end;
function TMenschen.GetIsSchueler(Index: integer): boolean;
begin
  Result := Items[Index] is TSchueler;
end;
function TMenschen.GetIsSportler(Index: integer): boolean;
begin
  Result := Items[Index] is TSportler;
end;

[Jumpy]

Zitat von StepByStep:

Edit: Ich konnte das Problem gerade eben selber lösen, indem ich nicht den Umweg über die Set-Procedure gemacht habe. Aber wie geht das mit dieser?
UND bei der Ausgabe wird nicht der Wert von Schachfigur ausgegeben. Wie bekomme ich es hin, dass dieser dann auch ausgegeben wird?

Das Beispiel ist blöd. Man muss schauen, was alle Teile gemeinsam haben (Position,Form,Reichweite) und was anders ist (vllt. erlaubte Bewegungsart oder so) dann wird auch klarer was warum nicht geht. Aber sei es drum, nehmen wir das Beispiel wie es ist.

Du könntest den Figuren jeweile einen eigenen Konstruktor spendieren, der (um im Beispiel zu bleiben) mal die Form, mal die Position setzt. Oder, um mal Polymorphie auszunutzen: Die Basisklasse bekommt eine virtuelle abstakte Prozedur "Initialisieren" oder so. Die Prozedur wird in jeder Klasse anders überschrieben und setzt halt einmal die Form, ein anderes mal die Position, was weiß ich.

Dann kannst du folgendes schreiben:

Code:

var
  I: integer;
  temp: TSchachfigur;
begin
  fschachfiguren := Tobjectlist<TSchachfigur>.create;

  temp := TSchachBauer.create;
  temp.Initialisieren;
  fschachfiguren.add(temp);

[...]

Und schon haben deine Figuren auch was, das sie beim ToString ausgeben können.

------------------------------------

Du solltest aber besser auf dein ursprüngliches Problem zurückkommen: Was brauchst du wirklich für Klassen und wofür. Dann kann man vllt. besser helfen. Worin sollen sich die einzelnen Menschen unterscheiden?

[StepByStep]

Hallo Jumpy,

ich komme auf deinen Ratschlag mal zurück.

Ich habe eine Klasse TMensch:

Delphi-Quellcode:

    FHerkunft:      string;
    FName:          string;
    FGeburtsdatum:  Tdate;
    FGroeße:        extended;
    FGeschlecht:    boolean;
    FFamilienstand: string;

Dann eine Klasse TJob:

Delphi-Quellcode:

    FGehalt:      extended;
    FArbeitszeit: integer;
    FBeruf:       string;

Dann eine Klasse TSchule:

Delphi-Quellcode:

    FSchulfaecher:      string;
    FNotendurchschnitt: extended;
    FSchulform:         string;

Dann eine Klasse TArbeiter:

    FChef: boolean;

Dann eine Klasse TSportler:

Delphi-Quellcode:

    FSportart:         string;
    FErrungenschaften: string;

Dann eine Klasse TAzubi:

Delphi-Quellcode:

    FNotendurchschnitt: extended;
    FSchulfaecher:      string;
    FSchulform:         string;

Dann eine Klasse TSchueler:

Delphi-Quellcode:

    FKlassenfahrt:    boolean;
    FKlassensprecher: boolean;

Das sind alle meine Klassen mit den Variablen. Ein einem extra Formular lese ich Editfelder aus und möchte die gerne in eine Variable von TMensch schreiben, was aber nicht geht, da TMensch die Klassenvariablen aber nicht kennt. Ich hoffe das ist jetzt verständlich.

Gruß
Jan

[stahli]

Also mir ist nicht klar, was Du genau willst...

Den Inhalt von EditBeruf kannst Du nicht ein ein TMensch-Objekt schreiben.
Du musst dafür ein TJob-Objekt (TAngestellter wäre sicher passender) vorliegen haben.

Andersrum kannst Du in ein TJob-Objekt auch alles schreiben, was in TMensch deklariert ist.

Oder geht es Dir eher darum, wie Du die Eingabeformulare organisieren sollst?

[StepByStep]

Also ich soll mit einer Liste arbeiten, nämlich: Menschlist: TObjectList<TMensch>
Diese möchte ich befüllen, mit den Inhalten, die aus den Editfelder in einem anderen Formular ausgelesen werden.
Ich möchte diese ausgefüllten Sachen in eine Variable von TMensch schreiben, was aber nicht geht, da ich ja zum Beispiel nicht "Mensch.FSchulform" abfragen kann,
weil TMensch diese Variable nicht kennt. Dies soll nach dem Schema gehen, welches ich versucht habe mit den Schachfiguren zu verdeutlichen, aber ich schaffe es nicht.

Sobald das funktioniert, brauche ich eine ToString-Methode die mir die verschiedenen Werte in Strings umwandelt, damit ich das in einem Memofeld ausgeben kann.
Das bekomme ich ja mit "override" hin.

[Jumpy]

Wenn wir zunächst bei deiner Vererbungstruktur aus #1 bleiben sind zumindest die Namen TJob und TSchule unglücklich gewählt (als Kinder von TMensch). Besser wäre TMenschMitJob und TMenschInDerSchule.

Schaust du dir den Azubi-Berufsschüler an, beruht der bei dir auf TJob, braucht aber auch eigenschaften als Schüler und bekommt die wieder extra. Das ist doch irgendwie blöd. Mehrfachvererbung gibt es ja (in Delphi) nicht, sonst wäre das vllt. gegangen.

Somit ist doch irgendwie der ganze Ansatz schon nicht gut. Mal als Verbesserungsvorschlag. Definiere eine Klasse TJob und TSchulinfo oder so. Als separate Klassen, die nicht von TMensch erben! Stattdessen bekommt TMensch nun variablen für Objekte des Typs TJob und TSchulinfo. Vererbung ist bei der OOP nicht alles (und wird glaub ich immer weniger (wg. Testbarkeit???) genutzt. Stattdessen werden Klassen verknüpft (Aggregation/Assoziation) (wg. Testbarkeit meist über Interfaces).

Du kannst dem TMensch ja dann noch Boolean-Funktionen ala "IstSchüler" "HatJob" mitgeben.
Jetzt soll Mensch 12 aus der Liste angeschaut/editiert werden:

Code:

//Edit-Felder des Formulars mit Werten aus TMensch verknüpfen oder füllen.
if TMensch(Menschliste[12]).HasJob then
  begin
  //Zusätzlich einen Frame (Unterform) laden, mit EditFeldern für Job
  //Edit-Felder mit Werten versorgen
  end
//Analog für Schulinfo

[Dejan Vu]

Zitat von StepByStep:

Das sind alle meine Klassen mit den Variablen. Ein einem extra Formular lese ich Editfelder aus und möchte die gerne in eine Variable von TMensch schreiben, was aber nicht geht, da TMensch die Klassenvariablen aber nicht kennt. Ich hoffe das ist jetzt verständlich.

Na du musst schon den konkreten Menschtypen instanziieren (Job, Schüler etc.) ist doch klar.

Das ist doch wie im richtigen Leben. Einen Deutschen sprichst Du deutsch an, einen Engländer englisch. Und einen 'Menschen'? Mit dem kannst Du nur in einer allen Menschen gemeinen Sprache sprechen (Mimik, Musik z.B.)

Na ja, hinkt vielleicht ein wenig.