OOP-Grundlagen

Objekt

0. Motivation

Modularisierung ist ein wichtiges Prinzip der Software-Technik. Objekte kapseln nicht nur Daten, sondern auch Methoden. Objekte bilden "Zuständigkeiten"

1. Typvereinbarung, der "Bauplan"

Nach einer ersten Idee wird die grafische Beschreibung des Objekts am Anfang stehen.

Die Grafik wurde mit violet erzeugt, das nicht auf der Eingabe von Datentypen besteht.

Diese Beschreibung wird im Laufe des Software-Entwicklungs-Prozesses so weit verfeinert, dass schließlich eine Implementierung in der gewählten Programmiersprache möglich ist.

Die Grafik wurde mit UmlEd erzeugt, das aus der grafischen Repräsentation wie folgt das Gerüst einer zugeordneten Delphi-Unit erzeugen kann.

interface

uses
// Uses-Klausel ggf. anpassen

type
   TString = CLASS

     // Attribute
     private
        FString : string;

     // Methoden
     public
        procedure SetString(s : string);
        function GetString : string;

   end;

implementation

//+---------------------------------------------------------------------
//|         TString: Methodendefinition
//+---------------------------------------------------------------------

//-------- SetString (public) ------------------------------------------
procedure TString.SetString(s : string);
begin
  //Hier Code einfügen.
end;

//-------- GetString (public) ------------------------------------------
function TString.GetString : string;
begin
  //Hier Code einfügen.
end;

Es sollen nun die (hier selbst geschriebenen) Code-Fragmente für die Typvereinbarung angegeben werden:

TString = class(TObject)                   { 1. Typvereinbarung                       }
  private
    FString : string;
  public
    procedure SetString(s : string);
    function GetString : string;
  end;

Dieser Teil steht im interface-Teil hinter type.

Im Implementation-Teil folgt die Implementierung der Methoden:

procedure TString.SetString(s : string);    { Implementierung zu 1.           }
begin
  FString := s;
end;

function TSTring.GetString : string;        { Implementierung zu 1.           }
begin
  result := FString;
end;

2. Erzeugung eines Objekts

Zur Erzeugung eines Objekts ist die Deklaration einer Referenzvariablen

  s     : TString;                 { 2. Deklaration der Referenzvariablen     }

und der Aufruf des Konstruktors nötig.

  s := TString.Create;             { 3. Erzeugung des Objekts                 }

3. Benutzung eines Objekts

Man benutzt ein Objekt, indem man ihm Botschaften schickt, Aufträge

  s.SetString(eEingabe.text);      { 4. Beschreiben des Objekts               }

oder Anfragen

  lAusgabe.caption := s.GetString; { 5. Auslesen des Objekts                  }

4. Freigabe des Speichers

Schließlich muss am Ende der Lebensdauer des Objekts der belegte Speicher wieder freigegeben werden. Dazu ruft man den Destruktor auf:

  s.free;                          { 6. Vernichtung des Objekts               }

Testprogramm

Ein Objekt sollte für sich in einem kleinen Programm getestet werden. Das folgende Programm verzichtet auf eine MVC-Trennung:

unit uGUI;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,StdCtrls;

type
  TString = class(TObject)         { 1. Typvereinbarung                       }
  private
    FString : string;
  public
    procedure SetString(s : string);
    function GetString : string;
  end;

  TForm1 = class(TForm)
    eEingabe: TEdit;
    bSetze: TButton;
    nAusgabe: TButton;
    lAusgabe: TLabel;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure bSetzeClick(Sender: TObject);
    procedure nAusgabeClick(Sender: TObject);
  private
    s : TString;                  { 2. Deklaration der Referenzvariablen     }
  public
    { Public-Deklarationen }
  end;

var
  Form1 : TForm1;

implementation

{$R *.DFM}

procedure TString.SetString(s : string);    { Implementierung zu 1.           }
begin
  FString := s;
end;

function TSTring.GetString : string;        { Implementierung zu 1.           }
begin
  result := FString;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  s := TString.Create;             { 3. Erzeugung des Objekts                 }
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  s.free;                          { 6. Vernichtung des Objekts               }
end;

procedure TForm1.bSetzeClick(Sender: TObject);
begin
  s.SetString(eEingabe.text);      { 4. Beschreiben des Objekts               }
end;

procedure TForm1.nAusgabeClick(Sender: TObject);
begin
  lAusgabe.caption := s.GetString; { 5. Auslesen des Objekts                  }
end;

end.