Vererbung

[ozz]

Hallo zusammen,
ich habe eine Frage zur Vererbung.
Ich habe eine Parent-Klasse, die mit SQL Datenbank umgehen kann.

Delphi-Quellcode:

type TMasterClass = class (Tcomponent)
private
 FConnection: TZConnection;
 function checksqlconnect:boolean;
 procedure ConnectionWrite(value:TZconnection);virtual;
Published
   property Connection : TZConnection read FConnection write ConnectionWrite;
end;

Diese Funktionalität vererbe ich an einen Nachfahren, der noch etwas mehr kann.

Delphi-Quellcode:

type TURL = class (TMasterClass)
private
  // Lokale Variablen
  TProtokolltypes: array of string;
  procedure ConnectionWrite(value:TZconnection);override;

......

Dieser Nachfahre kann jetzt zwar mit den SQL-Datenbank umgehen, jedoch sind im die Verbindungsdaten unbekannt (Servername, Datenbankname, DB-Typ etc.). Weiterhin erzeuge ich noch andere Nachfahren (hier nicht augelistet). Von allen Arten von Nachfahren gibt es mehrere Instanzen.
Nun zu meiner Frage.
Wie kann ich es machen, das alle Instanzen (aller Arten von Nachfahren) die gleichen Verbindungsdaten verwenden, OHNE das ich es jedesmal an alle übergeben muß. Prinzipell kann ich sie nicht als Konstanten festlegen.Hat jemand eine Idee?

Danke!

[sh17]

Nur mal den Text aus der Delphi-Hilfe:

Auf ein private-Element kann nur innerhalb des Moduls (Unit oder Programm) zugegriffen werden, in dem die Klasse deklariert ist. Mit anderen Worten: eine private- Methode kann nicht von anderen Modulen aufgerufen werden, und als private deklarierte Felder oder Eigenschaften können nicht von anderen Modulen gelesen oder geschrieben werden. Indem Sie verwandte Klassendeklarationen im selben Modul zusammenfassen, können Sie diesen Klassen also den Zugriff auf alle private
-Elemente ermöglichen, ohne die Elemente anderen Modulen bekanntzumachen.

Ein protected-Element ist innerhalb des Moduls mit der Klassendeklaration und in allen abgeleiteten Klassen (unabhängig davon, in welchem Modul sie deklariert sind) sichtbar. Mit anderen Worten: auf ein protected-Element können alle Methoden einer Klasse zugreifen, die von der Klasse mit der Elementdeklaration abgeleitet ist. Mit diesem Sichtbarkeitsattribut werden also Elemente deklariert, die nur in den Implementierungen abgeleiteter Klassen verwendet werden sollen.

Ein public-Element unterliegt keinerlei Zugriffsbeschränkungen. Es ist überall dort sichtbar, wo auf seine Klasse verwiesen werden kann.

[r2c2]

Hallo
Normalerweise hat jede Instanz ihre eigenen Daten. Die sind so einfach nicht zu verbinden.
Mach doch einfach ne property, die ne Instanz zu deine Master-Klasse verlangt. Darüber kannst du dann auf die Daten zentral zugreifen...

mfg

Christian

[ozz]

Hallo r2c2,
kannst du dies

Zitat:

Mach doch einfach ne property, die ne Instanz zu deine Master-Klasse verlangt. Darüber kannst du dann auf die Daten zentral zugreifen...

vielleicht kurz an einem Code Beispiel erklären, ich verstehe es nicht ganz.

Danke!

[Der_Unwissende]

Hi,
ich würde dir empfehlen lieber auf sh17 zu hören. Grundsätzlich bringt es nicht viel über ein künstliches Property auf die Eltern-Klasse zuzugreifen.
Für's vererben (und damit implizit für die OOP) gilt, dass die Sichtbarkeiten schon verstanden sein sollten und auch benutzt werden müssen.
Also setzt einfach deine Methode die du überschreiben möchtest in den Protected-Teil und du kannst überladen (und das recht sauber) und die nicht öffentliche Sichtbarkeit bleibt auch erhalten.

Gruß Der Unwissende

[ozz]

Danke für die Hinweise. Ich werde mir die Unterschiede mit dem Protected-Teil nochmal genau anschauen. Eine Sache ist mir allerdings noch unverständlich. Normalerweise überlade ich doch nur Funktionen, wenn ich den gleichen Namen verwenden möchte, diese aber unterschieliche Parameter(sätze) verwenden. In meinem Fall sind diese jedoch immer gleich. Jede Instanz benötigt den Namen der Datenbank, Servername, login, pwd etc. Bitte helft mir kurz auf die Sprünge.
Danke.

[sh17]

Es gibt ein Unterschied zwischen überschreiben und überladen

[Der_Unwissende]

Ja
überladen = gleicher Methodenname, unterschiedliche Parameter
überschreiben = "ersetzen" bzw. "verdecken" der geerbten Methode

Wenn du etwas mit overload markierst, dann wird je nach Parameter immer eine Funktion aufgerufen, die genau diese Parameter erwartet.
Beim Überschreiben hättest du eher sowas :

Delphi-Quellcode:

type
  TFirstClass = class(TObject)
    protected
      procedure sayHello;
  end;

  TSecondClass = class(TFirstClass)
    protected
      procedure sayHello; override;
  end;

procedure TFirstClass.sayHello;
begin
  ShowMessage('FirstClass sagt Hallo');
end;

procedure TSecondClass.sayHello;
begin
  ShowMessage('SecondClass sagt Hallo');
end;

Und wenn du dann Istanzen der verschiedenen Klassen hast, siehst du den Unterschied :

Delphi-Quellcode:

var First : TFirstClass;
    Second : TSecondClass;
begin
  First := TFirstClass.Create;
  Second := TSecondClass.Create;
  First.sayHello; // Ausgabe : FirstClass sagt Hallo
  Second.sayHello; // Ausgabe : SecondClass sagt Hallo
  First.Free;
  Second.Free;
end;

Wie du siehst, haben die Methoden beide keine Parameter, aber machen doch was unterschiedliches. In dem Zusammenhang sei auch auf inherited verwiesen. Mit diesem Schlüsselwort kannst du in einer erbenden Klasse eine Methode der Vorgängerklasse aufrufen, die du überschreibst.

[sh17]

Zitat von Der_Unwissende:

In dem Zusammenhang sei auch auf inherited verwiesen. Mit diesem Schlüsselwort kannst du in einer erbenden Klasse eine Methode der Vorgängerklasse aufrufen, die du überschreibst.

Ein gutes Beispiel dafür ist die Methode Destroy - die muss überschrieben werden und sollte Destroy der Vorgängerklasse aufrufen

[r2c2]

Zitat:

ich würde dir empfehlen lieber auf sh17 zu hören. Grundsätzlich bringt es nicht viel über ein künstliches Property auf die Eltern-Klasse zuzugreifen.

Sollte gar nicht auf die Elternklasse sein:

Delphi-Quellcode:

type TMasterClass = class (Tcomponent)
...

type TURL = class (TObject) // eingenständige Klasse
private 
  FDBConnection: TMasterClass; // nur für den Datenaustausch
public
  property DBConnection read FDBConnection write FDBConnection;
  constructor Create(ADBConnection: TDBConnection);
...

constructor TURL.Create(ADBConnection: TDBConnection);
begin
  inherited Create;
  FDBConnection := ADBConnection;
end;

ich habe nämlich folgenden Satz etwas anders anders interprätiert, als sh17:

Zitat von ozz:

Wie kann ich es machen, das alle Instanzen (aller Arten von Nachfahren) die gleichen Verbindungsdaten verwenden, OHNE das ich es jedesmal an alle übergeben muß.

Das heißt doch, dass alle Nachfahren die selben Daten verwenden sollen. Und die sollen nicht immer einzeln festgelegt werden müssen. Dann ist es doch am einfachsten man hat eine Klasse, der man die Daten übergibt und die verwaltet die Verbindung zur Datenbank. Die anderen müssen sich darum also gar nicht mehr kümmern...

mfg

Christian