Klassen in versch Units vererben

[IFlyA380]

Hallo zusammen,

ich habe ein kleiner Problem: Ich soll in der 1. Unit eine Klasse erstellen. Dann soll ich eine neue Unit erstellen (Unit2) und die weitere Klasse soll nun aus der der Unit1 erben.

Code:

unit u_Bank;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
  u_Konto;

type

  { TForm1 }

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Edit1: TEdit;
    Edit2: TEdit;
    Label1: TLabel;
    Label2: TLabel;
    procedure FormCreate(Sender: TObject);
  private
    { private declarations }
  public
    { public declarations }
    end;
 type
  { TBank }
    TBank = class(TObject)
      public
    Name: String;
    Standort: String;
    Geld: real;
   // procedure einzahlen(Betrag:real);
   //procedure auszahlen(Betarg:real);
   //procedure ueberweisen;
   //function gibtKontostand:String;
   constructor create(FName, FStandort: String);
   destructor destroy;

  end;

   // type
 { TKonto = class(TBank)
    public
       Kontostand: real;
       Besitzer: String;

  end;               }

var
  Form1: TForm1;
  HBank : TBank;
  Konto1: TKonto;
implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.FormCreate(Sender: TObject);
begin
   HBank := TBank.Create('Hansa Bank HH', 'Hamburg');
   Label2.Caption:= HBank.Name;
   Konto1 := TKonto.Create(1234, 1000, 'Niklas', 'Osbahr');
end;

constructor TBank.Create(FName, FStandort: String);
begin
   inherited create;
   Name := FName;
   Standort := FStandort;
end;

destructor TBank.destroy;
begin
   inherited destroy;
end;

end.

Code:

unit u_Konto;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils;

type
  TKonto = class(TBank)
    public
       Kontostand: real;
       Besitzer: String;
       Kontonummer: integer;
       Constructor create(FKontonummer:integer; FKontostand:real; FBesitzer :string);
  end;
var
  Konto1: TKonto;

implementation

Constructor create(FKontonummer:integer; FKontostand:real; FBesitzer :string);
begin
  inherited create;
  Kontonummer := FKontonummer;
  Kontostand := FKontostand;
  Besitzer := FBesitzer;
end;

end.

Soweit so gut.
Lazarus gibt dann den Fehler raus, dass TBank an der Stelle TKonto = class(TBank) nicht bekannt sei.
Was mache ich falsch?

LG

[TBx]

Nimm u_bank in die uses von u_konto auf. Das sollte es dann gewesen sein.

[bra]

Zusätzlich muss das uses u_Konto aus der unit u_Bank aber entfernt werden, sonst bekommst du wohl eine zirkuläre Referenz.

[Blup]

Eigentlich müsste TForm1 in eine eigene Unit ausgelagert werden.

Delphi-Quellcode:

unit u_Bank;

type
  TBank = class(TObject)
  public
    Name: String;
    Standort: String;
    Geld: real;
    constructor create(FName, FStandort: String);
    destructor destroy;
  end;

Die Variablen HBank und Konto1 gehören eindeutig zu TForm1 und sollten deshalb dort deklariert werden.

Delphi-Quellcode:

unit u_Form1;

uses
  uBank, uKonto;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Edit1: TEdit;
    Edit2: TEdit;
    Label1: TLabel;
    Label2: TLabel;
    procedure FormCreate(Sender: TObject);
  private
    { private declarations }
    HBank : TBank;
    Konto1: TKonto;
  public
    { public declarations }
  end;

Die Klasse TKonto von TBank abzuleiten ist fachlich falsch. Das Konto gehört zu einer Bank, eine Bank verwaltet mehrere Konten.
Das könnte man z.B. so abbilden:

Delphi-Quellcode:

TBank = class;

TKonto = class(TObject)
private
  FBank: TBank; {im Konstruktor als Parameter übergeben und in die Liste der Bank eintragen}
public
  property Bank: TBank read FBank;
end;

TKontoList = class(TObjectList)
end;

TBank = class(TObject)
private
  FKonten: TKontoList; {im Konstruktor erzeugen, im Destruktor freigeben}
public
  property Konten: TKontoList read FKonten;
end;

[IFlyA380]

Danke für die Antworten.

Das mit dem Tauschen der uses funktioniert leider nicht. Jetzt erkennt TForm1 TBank nicht.

Die Idee des Vererbens war, dass u_Konto auf die Methoden von u_Bank zugreifen kann.
Somit eine Erweiterung der Bank ist.

[Neutral General]

Dein Ansatz ist schon falsch.
Man würde Konto nie von Bank ableiten. Eine Ableitung ist quasi eine Spezialisierung.

Delphi-Quellcode:

TFahrzeug = class
TAuto = class(TFahrzeug)
TLKW = class(TFahrzeug)
TMotorrad = class(TFahrzeug)

Autos, LKWs und Motorräder sind spezielle Arten von Fahrzeugen.
Sie unterscheiden sich zwar, aber es sind im Grunde alles Fahrzeuge (daher die Ableitung von TFahrzeug).

Bei Bank und Konto funktioniert das nicht. Ein Konto ist etwas anderes als eine Bank.
Ein Konto ist keine spezielle Art von Bank sondern etwas anderes (wenn auch TEIL einer Bank).

Was du tun würdest wäre eine Klasse TBank und eine Klasse TKonto (NICHT von TBank ableiten).
TBank fügst du eine Liste von TKonto hinzu und Methoden zum Verwalten dieser Liste - z.B. "procedure KontoHinzufuegen(AKontoNr: Integer; ABesitzer: TPerson)"

Delphi-Quellcode:

TKonto = class
private
  FKontoNr: Integer;
  FKontostand: Currency;
  FBesitzer: String;
public
  property Besitzer: String read FBesitzer write FBesitzer;
  property KontoNr: Integer read FKontoNr write FKontoNr;
  property Kontostand: Currency read FKontostand write FKontostand;
end;

TBank = class
private
  FKonten: TObjectList<TKonto>; // Im constructor erstellen.
public 
  property Konten[Index: Integer]: TKonto read GetKonto; // Result := FKonten[Index];
  property KontoCount: Integer read GetKontoCount; // Result := FKonten.Count;
  procedure AddKonto(AKontoNr: Integer; ABesitzer: String); // Konto-Objekt erstellen, Eigenschaften zuweisen und der Liste hinzufügen.
end;

[TiGü]

Zitat von IFlyA380:

Das mit dem Tauschen der uses funktioniert leider nicht. Jetzt erkennt TForm1 TBank nicht.

Steht die Unit uBank.pas in den uses von u_Form1.pas wie von Blup gezeigt?

Zitat von IFlyA380:

Die Idee des Vererbens war, dass u_Konto auf die Methoden von u_Bank zugreifen kann.
Somit eine Erweiterung der Bank ist.

Falscher Ansatz! Mach alles weitere über eine dritte Klasse (TÜberweisungsManager, TÜbertragManager, usw.)

[sakura]

Trenne TForm1 und TBank (TBank in eine eigene Unit) und binde diese Unit in u_konto ein. Dann u_konto in die Unit von TForm1

Ansonsten bleibt zu sagen, dass, zumindest logisch gesehen, TKonto nicht von TBank abgeleitet sein sollte.

......

[Luckie]

Eigentlich müsste man den Kunden noch dazwischen packen. Eine Bank hat Kunden und diese Kunden haben Konten. Dabei würde ich aber gar nichts ableiten, denn welche Methoden oder Attributen soll denn eien Konto mit einer Bank gemeinsam haben? Eher ist es so, dass die Bank als Container für die Kunden dient (Objektliste) und die Kunden wiederum als Container (Objektlist) für die Konten dienen.

Wenn es allerdings eine Übung sein soll, ist sie etwas sehr konstruiert und doof .

[IFlyA380]

Demnach könnte ich aber ein Sparkonto von der Klasse TKonto ableiten oder?