Zur Themenübersicht     

Syntax für Objektklassen

Als Grundregel gilt:

Grundregel 
Jede Objektklasse ist in einer eigenen Unit zu deklarieren !!

Als erstes hier der kommentierte Programmcode der Unit TTurtle:

Die Unit TTurtle 
UTurtle ist der Name der Unit.
Unter diesem Namen wird sie auch abespeichert.

unit UTurtle;

Hier beginnt die Schnittstellenbescheibung.
Es folgt die Angabe, worauf andere Units 
zugreifen können und worauf nicht. 

interface

In der uses Liste wird angegeben, auf welche 
andere Units diese Unit zugreift.

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

.
TTurtle ist NachfolgeKlasse der Klasse TObject

Grundsatz: Die inneren Zustände einer Klasse
   sind immer als private (oder als protected 
   - siehe Vererbung in Delphi)zu deklarieren.
   private bedeutet, dass auf diese Eigenschaf-
   ten von anderen Units aus nicht zugegriffen
   werden kann.

Unter public (öffentlich) werden diejenigen
   Prozeduren und Funktionen aufgeführt,
   welche andere Units benutzen können.

Für die Vererbung wichtig ist die Schutzeigen-
   schaft protected. Als protected deklarierte
   innere Zustände können von Nachfolgeklassen
   genutzt werden, sind anderen Units aber 
   nicht zugänglich 

'end' bedeutet: Ende des Interface-Teils

type
  TTurtle = class(TObject)

  private
    h_xpos,h_ypos:Real;
    h_winkel:Real;
    h_gesenkt:Boolean;
    k_Leinwand:TCanvas;
  
  public
    constructor createturtle(x_p,y_p,winkel_p : Real;
                             gesenkt_p : Boolean;
                             Leinwand_p : TCanvas);
    procedure links (winkel : Real);
    procedure rechts(winkel : Real);
    procedure hoch;
    procedure runter;
    procedure vorwaerts (length:Real);

  end; (* of Interface *)

Hier beginnt die Erklärung, wie die Objekte
  ihre Aufträge erfüllen bzw wie sie ihre
  Anfragen beantworten.
Man könnte auch sagen: Es folgen die 
  Deklarationen der Prozeduren und Funktionen

implementation

Beim Erzeugen werden die inneren Zustände
eines Turtleobjektes mit den in der Parameter-
liste angegebenen Werten belegt.

inherited (geerbt) bedeutet: Hier wird die
  create.Methode der Vorgängerklasse
  benutzt

constructor TTurtle.createturtle
                      (x_p,y_p,winkel_p : Real;
                       gesenkt_p : Boolean;
                       Leinwand_p : TCanvas);
begin
   inherited create;
   h_xpos := x_p;
   h_ypos := y_p;
   h_winkel := winkel_p;
   h_gesenkt := gesenkt_p;
   k_Leinwand := Leinwand_p
end;

Es folgen nun die anderen Methoden. 

Auf ihre Realisierung wird hier nicht 
   eingegangen, weil es hier nur um die
   Syntax (Schreibweise) und nicht um die
   konkrete Realisierung der Methoden geht.

procedure TTurtle.links (winkel : Real);
begin
   h_winkel := h_winkel + winkel
end;

procedure TTurtle.rechts(winkel : Real);
begin
   h_winkel := h_winkel - winkel
end;

procedure TTurtle.hoch;
begin
   h_gesenkt  := false
end;

procedure TTurtle.runter;
begin
   h_gesenkt := true
end;

procedure TTurtle.vorwaerts (length:Real);
begin
   // ....siehe Download ...
end;


    		
    
end. (* of implementation *)


    		
  





Nun der kommentierte Quellcode der Unit, welche das Formular verwaltet




  
    Die Unit für das Hauptformular
  
  

    
- klar -


    		
    
unit UBaum;

interface


    		
  

  

    
Wichtig: 
   In der Uses-Liste muss der Name der
   Unit, in welcher die Klasse TTurtle
   definiert wird, aufgeführt werden.


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


    		
  

  

    
.
.
.
.
.
.
.
.
.
Hier wird bekannt gegeben, dass das Formular
ein Objekt der Klasse TTurtle besitzt


    		
    
type
  TFBaum = class(TForm)
    BtZeichne: TButton;
    Label1: TLabel;
    Label2: TLabel;
    EdStamm: TEdit;
    EdEbene: TEdit;
    procedure BtZeichneClick(Sender: TObject);
  private
    h_turtle : TTurtle;
    procedure baum (length:Real; Ebene:Integer);
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  FBaum: TFBaum;

implementation

{$R *.DFM}


    		
  

  

    


Die Erteilung eines Auftrages erfolgt wie
auch sonst üblich in der Form:
  Objektname.Methodenname (Parameterliste)


    		
    
procedure TFBaum.baum(length:Real; Ebene:Integer);
begin
    if Ebene <= 1 then
       begin
          h_turtle.vorwaerts(length);
          h_turtle.vorwaerts(-length)
       end (* of then*)
    else
       //.... siehe Download ....
end; (* of proc*)

procedure TFBaum.BtZeichneClick(Sender: TObject);
begin


    		
  

  

    
Der Auftrag zum Erzeugen eines Objektes 
benötigt eine besondere Syntax:

neuesObjekt := 
   Klassename.Methodenname (Parameterliste) 


    		
    
   h_turtle := TTurtle.createturtle(width DIV 2,
                 height - 50, 90,true,self.Canvas);
                                  
   // TTurtle : Klassenname
   // createturtle : Name der Methode zum Erzeugen


    		
  

  

    
- klar -


    		
    
   self.canvas.rectangle(0,50,width,height);
   baum(StrToInt(EdStamm.text),
        StrToInt(EdEbene.text));
end;


end.


    		
  





  



  

    Zur
      Themenübersicht  
  

  

     Zum Seitenanfang 
    
  

  

      Zur vorigen Seite
            Zur
      nächsten Seite  
      
      
  





  



  

        © 2000 LK 12 If und G.
      Kubitz
     Hannah-Arendt-Gymnasium, Lengerich