Gut, dann gebe ich mal eine kurze Einführung ins objektorientierte Programmieren (OOP)...
Herkömmlich
Ein althergebrachtes Programm besteht aus Variablen und Prozeduren, die diese Variablen manipulieren. Jede Prozedur ist dabei eine statische, wie auch im Beispiel aufgeführt.
Code:
type
Tkreis = record
X, Y, R : Integer;
end;
var
Kreise : array[0..9] of TKreis;
procedure ZeichneKreis (X, Y, R: Integer);
begin
Circle (X, Y, R);
end;
OOP
Bei der OOP werden die Variablen und Prozeduren nun zusammengefaßt, man bildet eine Klasse. Damit erreicht man 3 Punkte:
- Kapselung: Du greifst nicht mehr direkt auf die Variablen der Klasse zu, sondern nur noch über die zur Klasse gehörenden Prozeduren (Methoden). Damit kannst Du z.B. die Richtigkeit der Werte sichern, wenn einer was zuweisen will. Zusätzlich kannst Du damit die Sicherheit gewährleisten. Siehe unten.
- Vererbung: Es ist möglich, weitere Klassen von einer Elternklasse abzuleiten, diese erbt die Eigenschaften und kann andere einführen. Damit bekommst Du Ordnung in Deine Programmierung.
- Polymorphie: Hat die abgeleitete (abgelittene) Klasse eine Methode, die denselben Header wie die in der Elternklasse hat, und überschreibst Du diese, dann wird beim Aufruf der Methode über die Instanz der Klasse immer die klasseninterne Methode verwendet, nicht die der Elternklasse. Beispiel folgt.
Begriffe
Klasse: Kombination von Variablen und Prozeduren zu einer Einheit. Analog Typ bei Nicht-OOP.
Instanz: Repräsentation einer Klasse. Aktuelles Element im Speicher. Analog Variable (vom Typ x) bei Nicht-OOP.
OOP-Beispiel
Klassen-Deklaration und Feld, wo unsere Instanzen reinkommen:
Code:
type
TGrafikObjekt = class
X, Y : Integer;
constructor Create; virtual;
procedure Zeichnen; virtual;
end;
TKreis = class (TGrafikObjekt)
R : Integer;
constructor Create; override;
procedure Zeichnen; override;
end;
TRechteck = class (TGrafikObjekt)
B, H : Integer;
constructor Create; override;
procedure Zeichnen; override;
end;
var
Grafiken : array[0..9] of TGrafikObjekt;
Hier sind die Methoden:
Code:
constructor TGrafikObjekt.Create;
begin
X := 0; Y := 0;
end;
procedure TGrafikObjekt.Zeichnen;
begin
// Nichts weiter machen. Dient der Demonstation von Polymorphie.
MessageBeep (0);
end;
constructor TKreis.Create;
begin
inherited; // Pascal-spezifisch, ruft die Methode der Elternklasse auf.
R := 0;
end;
procedure TKreis.Zeichnen;
begin
inherited;
Circle (X, Y, R);
end;
constructor TRechteck.Create;
begin
inherited;
B := 0; H := 0;
end;
procedure TRechteck.Zeichnen;
begin
inherited;
Rectangle (X, Y, X + B, Y + H);
end;
So, jetzt geht's los. Es werden Instanzen der jeweiligen Klassen gebildet. Man beachte, daß die Kinder zu ihren Eltern kompatibel sind. Sie erben ja schließlich alle Eigenschaften. Umgekehrt gilt das aber nicht.
Code:
Grafiken[0] := TKreis.Create;
Grafiken[1] := TRechteck.Create;
...
Grafiken[9] := TKreis.Create;
Wir weisen jetzt mal ein paar Werte zu:
Code:
TKreis (Grafiken[0]).X := 100;
TKreis (Grafiken[0]).Y := 100;
TKreis (Grafiken[0]).R := 10;
Hier kommt jetzt die Polymorphie. Jede Instanz einer Klasse weiß intern, welche Methoden zu ihr gehören. Wenn ich jetzt die Zeichenroutine des Grafikobjekts aufrufe, wird immer die richtige Zeichenroutine der Instanz aufgerufen, sofern vorhanden. Da ich oben sowohl für Kreis als auch für Rechteck eine Zeichenroutine habe, wird die allgemeine Zeichenroutine mit dem MessageBeep nur via inherited aufgerufen, aber nie direkt.
Code:
for I := 0 to 9 do
Grafiken[I].Zeichnen;
Wenn ich fertig bin, muß ich die Instanzen der Klassen wieder zerstören, da diese ja (per constructor) dynamisch Speicher ausgefaßt haben. Das Schlüsselwort lautet dann destructor, dort kannst Du noch ein paar Sachen machen, z.B. weitere interne dynamische Sachen freigeben. Der Destructor Free ist übrigens in Delphi implizit vorhanden, weil Du das Schlüsselwort class verwendet hast.
Code:
for I := 0 to 9 do
Grafiken[I].Free;
Sicherheit + Gültigkeit in Klassen, Delphi-spezifisch
private: Diese Eigenschaften und Methoden sind nur innerhalb der Klasse bekannt.
protected: Diese Eigenschaften und Methoden sind auch in allen abgeleiteten Klassen bekannt (bei der Ausprogrammierung der Klassenmethoden), aber nicht nach außen (aus dem Hauptcode Deiner Anwendung).
public: Diese Sachen sind auch nach außen bekannt (sichtbar).
published: Diese Eigenschaften sind nicht nur aus der Anwendung heraus erreichbar, sondern Du siehst sie auch im Delphi-Objektinspektor, falls es sich bei der Klasse um eine Komponente handelt.
O Love
------------------
"I will not abide disobedience!"
)
. Ich glaube da ist der VB-Compiler etwas flexibler und "tolleranter".
