Projekt mit
1 €
unterstützen?
So geht das *:


Step 03 - OOP Zusammenfassung


1. Das Prinzip


Klassen sind von zentraler Bedeutung in der Objektorientierten Programmierung. Sie sind Baupläne für ein genau definiertes Objekt. Diese Definitionen dienen dann zur Verallgemeinerung der Problemlösung. Dies bedeutet, dass wir ein großes Problem in (möglichst durchschaubare, einfachere) Teilprobleme zerlegen. Ein Chat z.B. stellt ein "großes Problem" dar, welches wir in mehere Kleine zerlegen könnten: Senden und Empfangen von irgendwelchen Daten, Benutzerverwaltung, Statusverwaltung, Ansicht des Clients .... Diese Teilprobleme können dann auf ein Maximum durch Teamarbeit optimiert werden und geben somit eine möglichst hohe Modularität und erhöhen sowohl Wartbarkeit als auch übersichtlichkeit.


2. Aufbau von Klassen


Standardmäßig sollte eine Klasse immer in einer eigenen Unit eingelagert sein. Wichtig hierbei ist, dass man sich schon zu Beginn an einen gewissen Programmierstil hält. Der Klassenname sollte mit "T" (für Type) eingeleitet werden. Eine Unit, die lediglich eine normale Klasse enthällt, fängt für gewöhnlich mit "u" gefolgt vom Klassennamen (ohne "T") an.

Hier einmal ein Beispiel für eine Solche Klasse mit einer privaten Variable und einem dazugehörigen Property welches durch Getter und Setter gelesen bzw. gesetzt wird:

unit uClerk;

interface

type
  TClerk = class(TObject)
  private                     // at first the fields
    fName : String;           // don't forget the leading "f"!
    fID   : Integer;
                              // now the Getter and Setter-Methods
    function getName:String;
    procedure setName(AName :String);
    function getID:Integer;
    procedure setID(AID :Integer);
  public                      // use the Getter and Setter for the properties
    property Name : String  read getName write setName;
    property ID   : Integer read getID   write setID;
  end;

implementation

  // now Implement the Getter- and Setter-Methods:


function TClerk.getName:String;
begin
  // here something can be done with fName before it will be returned
  result := fName;
end;

procedure TClerk.setName(AName :String);
begin
  // check here if AName consists of two words
  if pos(' ', AName) > 1 then
    fName := AName
  else
    // only forename or familyname is given
    fName := '412 - incorrect';
end;

 // uncommented

function TClerk.getID:Integer;
begin
  result := ID shl 1024;
end;

procedure TClerk.setID(AID :Integer);
begin
  if AID > 1024 then
    fID := AID shr 1024
  else
    fID := AID;
end;

end.


3. Der "Constructor" und "Destructor"


Um eine Klasse "benutzen" zu können, muss diese erst durch ein Objekt instantiiert werden. Beim Erstellen des Objektes bietet es sich manchmal an, Werte des Objektes bereits jetzt schon zu initialisieren. Dies geht indem man einen "Constructor Create" im public-Bereich (überladen) deklariert und implementiert. Dieser kann beispielsweise auch mit Parameter implementiert werden, sodass richtige Werte bereits hier dem Objekt übergeben werden können:

unit uClerk;

interface

type
  TClerk = class(TObject)
  private
     //... fields first, then Getter and Setter or other methods
  public
     //... properties first, then methods, then constructor and destructor

    constructor Create( AName : String = 'Harold Maier';
      AID : Integer = 24576); override; // override inherited Create-Method
                                        //                          from TObject
  end;

implementation

//... 

constructor TClerk.Create( AName : String = 'Harold Maier'; AID : Integer = 24576);
begin
  // important: Call the inhereted Constructor from the Parent-Class:
  inherited Create; // for description see later
  // use the Setter to set the fields
  setName( AName);
  setID( AID);
end;

end.

Der "destructor Destroy" muss hingegen überladen werde. Es handelt sich hierbei um eine Methode, welche kurz vor Freigabe des vom Objekt belegten Speichers durch Aufruf von MyObjekt.Free ausgeführt wird. Dies kann züB. N�tzlich sein, wenn wir in unserem Objekt selbst ein Objekt benutzen, sodass wir durch fMyOwnObject.Free dessen Speicherplatz freigeben können.


4. Vererbung (inherited)


Dies ist von der Theorie her sehr einfach: Wir haben eine Ursprungsklasse, welche bestimmte Methoden und Felder bereitstellt und genutzt werden können. Diese Klasse ist bereits fertig implementiert und läuft fehlerfrei. Nun Soll diese jedoch funktional erweitert werden, ohne sie selbst zu verändern. Also erstellen wir eine neue Klasse und Erben einfach die bestehenden Methoden und Eigenschaften.

In unserem Beispiel nehmen wir einen Abteilungsleiter (DepartmentChief), der insgesammt drei neue Attribute bekommt: fDepartmentName:String, fIsAtWork:Boolean, fSpecialEarnings:Real;

unit uDepartmentChief;

interface

uses
  uClerk;

type
  TDepartmentChief = class(TClerk) // inherite from TClerk
  private
    // the [new] fields
    fDepartmentName  : String;
    fIsAtWork        : Boolean;
    fSpecialEarnings : Real;

    // Getter and Setter
    function getSpecialEarnings : Real;
    procedure setSpecialEarnings( ASpecialEarnings: real);
  public
    // Property
    property SpecialEarnings : Real read getSpecialEarnings
                                       write setSpecialEarnings;

    // could be simple functions because no write-flag neccassary
    function getDepartmentName : String;
    function isAtWork : Boolean;

    constructor Create(AName : String = 'Michael Maier'; AID : Integer = 1;
      ADepartmentName : String = 'Informatik'; AIsAtWork: Boolean = false;
      ASpecialEarnings : Real = 0 );
  end;

implementation

// ... here the implementation of the other methods!

constructor TDepartmentChief.Create(AName : String = 'Michael Maier';
  AID : Integer = 1; ADepartmentName : String = 'Informatik';
  AIsAtWork: Boolean = false; ASpecialEarnings : Real = 0 );
begin
  // important: now with parameters!
  inherited Create(AName, AID);
  fDepartmentName  := ADepartmentName;
  fIsAtWork        := AIsAtWork;
  fSpecialEarnings := ASpecialEarnings;
end;

end.


5. Überladen von Methoden (overload)


Überladen von Methoden bedeutet im Grunde nur, dass eine gleichnamige Methode mit anderen Parametern nochmal deklariert und implementiert wird.

Bei unserem beispiel werden wir den Constructor überladen:

//...
uses
  uClerk, Classes;

type
  TDepartmentChief = class(TClerk)
//...
    constructor Create(AName : String = 'Michael Maier'; AID : Integer = 1;
      ADepartmentName : String = 'Informatik'; AIsAtWork: Boolean = false;
      ASpecialEarnings : Real = 0 ); overload;
    constructor Create(AFileName : String; ALine : Integer); overload;
    constructor Create(AStringList : TStringList; ALine : Integer);
  end;

implementation

// ...

constructor TDepartmentChief.Create(AFileName : String; ALine : Integer); overload;
begin
  // Load File and read Line ALine and split into needed parts
  // and don't forget:
  inherited create;
end;

constructor TDepartmentChief.Create(AStringList : TStringList; ALine : Integer);
begin
  // read Line ALine from AStringList and split into needed parts.
  // and don't forget:
  inherited create;
end;

end.


6. Überschreiben von Methoden (override)


überschreiben hat besonderst beim Vererben eine Wichtige Rolle: Wenn in der Elternklasse eine Methode etwas unsicher implementiert hat, so kann dies nun komplett überschrieben werden. D.h. die komplette Methode wird neu implemenitert.

Dies funktioniert allerdings nur bei Methoden, welche nur in der neuen Klasse verwendet werden. Wird die urspüngliche Methode X() der Elternklasse in einer anderen Methode Y() in der Elternklasse verwendet, welche nicht überschrieben wird, so wird in Y() die Methode X() und nicht die überschriebene Methode X()' verwendet. Üuuml;berladen ist hier folglich sinnlos.

// in Parent-Class:

  procedure myOverwrittenMethod(myParam : String);
// ...

procedure myOverwrittenMethod(myParam : String);
begin
  DoSomeThing;
end;

// in Child-Class:

  procedure myOverwrittenMethod(myParam : String); override;
//...

procedure myOverwrittenMethod(myParam : String);
begin
  DoSomeThingElse;
end;


7. Instantiieren der Klasse.


Um unsere Test-Objekte auch mal zu benutzen, verwenden wir ein neues Projekt. Benennen es "Example204" usw. . Setzen in den Uses unsere zwei Units ein. Deklarieren im privat-Abschnitt der TMainform-Klasse zwei Felder: fMyClerk: TClerk und fMyDepartmentChief : TDepartmentChief; Nun benötigen wir 4 Buttons. Der Erste erstellt den Clerk, der Zweite gibt den Speicher wieder frei, der Dritte und Vierte macht das gleiche mit fMyDepartmentChief.

procedure TMainForm.BtnCreateClerkClick(Sender: TObject);
begin
  fMyClerk := TClerk.Create; // Parameter optional
end;

procedure TMainForm.BtnFreeClerkClick(Sender: TObject);
begin
  fMyClerk.Free;
end;


8. Über die Sicherheit.


Wenn Ihr das ganze mal testet, dann bekommt ihr mit Sicherheit den folgenden Fehler präsentiert:
"Ungültige Zeigeroperation."
Dies beruht darauf, dass Ihr Speicher eines Objektes, welches garnicht existiert, (nochmals) freigeben wollt.

Abhilfe hierbei schafft folgendes Konzept:

  1. Wir setzen unsere nicht instanziieren Objekt-variablen auf "nil".
  2. Bevor wir es ordnungsgemäß instanziieren, prüfen wir, ob unsere Objektvariable gerade "nil" ist. Ist es "nil", so instanziieren wir.
  3. Bevor wir unser möglicherweise instanziiertes Objekt wieder freigeben prüfen wir das gleiche. Ist es nicht "nil", dann befreien wir den Speicher und setzen es auf "nil".

Hierdurch haben wir die maximale Fehlersicherheit in unserem Programm, ohne dass wir unbedingt einen try-except-Bereich einführen müssen.


Da das Kommentarmodul dieser Seite zur Zeit neu überarbeitet werden muss, sendet bitte alle Fragen, Anregungen oder Probleme mit Betreff zu welchem Thema es sich handelt an folgende Mailadresse:



www.marco-hetzel.de
www.delphi-lernen.de
www.lazarus-lernen.de

© 2006-2019 by Marco Hetzel , last modified 01.11.2018, 11:28

(* Unterstützung dient der Aufrechthaltung laufender Kosten für dieses Projekt.)