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


Step 14 - Methoden und OOP

Mit Methoden meint man in Delphi Funktionen und Prozeduren. Diese Methoden haben die Aufgabe, den Quelltext kürzer und übersichtlicher zu gestalten. Wiederkehrender Code wird damit als Baustein zusammengefasst und der gesammte Code wird kürzer, was auch die Zeit bei Wartungsarbeiten verringern kann.
Man gibt diesen Methoden Namen und kann sie dann im späteren Verlauf immer wieder aufrufen.

Prozedur:

procedure [Name]([Parameter:Typ]);
{ Nach dem Schlüsselwort procedure muss man einen beliebigen
Namen angeben, danach kann man in der Klammer die Parameter 
angeben oder komplett weglassen (auch die klammern sind irrelevant)}

{hier deklariert man Variablen und Konstanten}
begin
  // Anweisungen
end;

Funktion:

function [Name]([Parameter: Typ]): [Rückgabewerttyp];
{ Das gleiche wie bei einer Prozedur, nur muss man noch den Rückgabewerttyp
bestimmen (String, Integer ...)}
{hier deklariert man Variablen und Konstanten}
begin
  // Anweisungen
  result:= // Rückgabewert
end;


Was passiert bei folgender Funktion?

function getBothVal(i:Integer):Integer;
begin
  i:=10;
  result:=20;
end;

// Aufruf irgendwo weiter unten im code:

var
  int1, int2 : Integer;
begin
  int2:=0;
  int1 :=getBothVal(int2);
  ShowMessage(IntToStr(int1));
  ShowMessage(IntToStr(int2));
end;
  // Wenn man getBothVal aufruft, so ist int1=20,
  // aber int2 bleibt unverändert

Der Grund hierfür ist, dass wir durch den einfachen Parameter
(i:Integer) keine Schreibrechte in der Funktion haben.
Daher müssen wir den Bezeichner var benutzen:
function getBothVal(var i:Integer):Integer;
begin
  i:=10;
  result:=20;
end;

Ein weiterer Bezeichner ist const. Dieser wird allerdings später in der Objektorientierten Programmierung genauer behandelt.

Ein weiterer Vorteil bei Delphi zu anderen Sprachen, wie z.B. C++, ist eine Art Verschachtelung von Prozeduren und Funktionen:
Das folgende Beispiel stammt aus einem erst kürzlich in Beta-Phase gelangtes Projekt eines HTML-Editors, bei dem die wichtigsten Tags alle oben zum click and drop bereitstehen.
Die folgende Procedure ist für das Einfärben der Tags verantwortlich:

procedure TMainForm.ColorTags(tagBeginSymbol, tagEndSymbol: Char; Col:TColor);
var    // hier die Definition der lokalen Variablen
  s               :String;
  start_position,
  end_position,
  last_position,
  lengthOfText    :Integer;

  // hier die Definition der lokalen Methoden

  procedure PaintIt(start,leng:Integer;Color:TColor);
  begin
    ReText.SelStart:=start;
    ReText.SelLength:=leng;
    ReText.SelAttributes.Color:=Color;
  end;
 
    // da PaintIt nur in dieser Procedure (und das 3 mal) aufgerufen wird, und da
    // man beim Programmieren immer so lokal wie möglich programmieren sollte,
    // sollte diese Procedure auch nur hier stehen.

    // Ein Grundsatz: So global wie nötig, so lokal wie möglich!

    // Der restliche Quellcode ist eigentlich egal, 
    // aber der Vollständigkeit wegen könnt ihr ihn ja mal durchlesen ;)
		
	
begin
  s:=ReText.Text;
  lengthOfText:=Length(s);
  last_position:=0;
  repeat
    start_position:=pos(tagBeginSymbol,s);
    end_position:=pos(tagEndSymbol,s);
    if (end_position<1) and (start_position>1) then
    begin
      PaintIt(start_position+last_position-1,lengthOfText,clRed);
      break;
    end;
    if (start_position>end_position) then
    begin
      PaintIt(end_position+last_position-1,start_position-end_position+1,clRed);
      break;
    end;
    if start_position>0 then
      PaintIt(start_position+last_position-1,end_position-start_position+1,Col);
    s:=copy(s,end_position+1,lengthOfText);
    last_position:=last_position+end_position;
    Application.ProcessMessages;  
  until (start_position<1) or (start_position=end_position);
end;



Deklaration und Implementierung von Methoden

Erster Einblick in OOP - das "Geheimnisprinzip".

Als Methoden bezeichnet man Prozeduren und Funktionen, welche zu einer Klasse gehören. Dies sind die Stellen bei denen die Funktionen implementiert werden dürfen:

type
  TMainForm = class(TForm)
    BtnDoSmth: TButton;
  private
    { Private-Deklarationen }
    // diese Procedure kann nur in dieser Unit per 
    //        MainForm.myPrivatProcedure1 aufgerufen werden.
    procedure myPrivatProcedure1;
  public
    { Public-Deklarationen }
    // diese Procedure kann auch in anderen Units per 
    //       MainForm.myPublicProcedure1 aufgerufen werden.
    procedure myPublicProcedure1;
  end;

var
  MainForm:TMainForm;
  // diese Procedure kann auch in anderen Units per 
  //     myPublicProcedure2 aufgerufen werden.
  procedure myPublicProcedure2;

implementation

{$R *.dfm}

// Diese Procedure kann nur von allen unten stehenden Methoden aufgerufen werden
procedure myProc(myParam:Integer);
begin
  MainForm.myPrivatProcedure1;
end;

// ganz wichtig bei Methoden, die in der TMainForm-Klasse deklariert wurden:

// Sie fangen mit TMainForm. an!
procedure TMainForm.myPrivatProcedure1;

  // diese Procedure ist nur innerhalb 
  //     der myPrivatProcedure1-Procedure gültig!
  Procedure myPrivatProcedure2;
  begin
    // diese kann auch auf Objekte der Klasse TMainForm zugreifen
    BtnDoSmth.Caption:='InnerProc';
  end;


begin
  myPrivatProcedure2;
end;


procedure TMainForm.myPublicProcedure1;
begin
  // Hier kann auf alle Objekte, Methoden und Attribute 
  //      der Klasse TMainForm zugegriffen werden.
  BtnDoSmth.Caption:='Public1';

end;


procedure myPublicProcedure2;
begin
  // hier kann nur auf die globalen Objekte der Klasse TMainForm zugegriffen werden.
  MainForm.BtnDoSmth.Caption:='Public2';
end;

end.


Weitere Beispiele:
function isInRange(nmb:Integer):Boolean
begin
  if (nmb>2) and (nmb<20) then
    result := true  
  else
    result := false;
end;

// oder:

function isInRange(nmb:Integer):Boolean
begin
  result := (nmb>2) and (nmb<20);
end;


  //... Aufruf:
  if isInRange(9) then
  // ...


  // MessageBox ist eine oft verwendete Meldung - unbedingt merken!
procedure ErrorMSG(msg:String);
begin
  Application.MessageBox(PChar(msg),'Error!',MB_OK+MB_ICONERROR);
end;
  
  //... Aufruf:
  ErrorMSG('Fehler bei der Kommunikation mit dem Drucker!');
  //...

Hier die Präsentation von meinem Besuch bei der Delphi-AG ;)

Hinweis:

Wenn man echte Projekte starten möchte, sollte man bei den Bezeichnungen aufpassen. Zum Beispiel sollte das Hauptformular nicht MainForm, sondern besser aussagend TMainForm bezeichnet werden. Genauso dann auch die Unit: MainUnit. Module, welche Methoden beinhalten, die in irgendeiner anderen Unit genutzt werden, fangen dann mit einem "m" an und es sollen sprechende Namen und bekannte Abkürzungen benutzt werden. Eine Funktion f(myParam1,myParam2:Integer):Integer; sagt zum Beispiel überhaupt nichts über seinen Nutzen aus, was bedeutet, dass man später bei einem Fehler womöglich die ganze Funktion nochmals überblicken muss, obwohl damit ein Sinn der Funktionen einsetzen sollte: Ein kleiner Baustein, der funktioniert, passen soll und nur noch durch den Namen und den Parametern in einer Haupt-Methode aufgerufen werden muss.

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:


Hinweis:

Dieses Kommentar-Modul teilt seinen Inhalt mit dem gleichnamigen Kapitel im Lazarus-Anfängerkurs. Daher kann es vorkommen, dass Fragen zu Lazarus im Anfängerkurs im Delphi-Anfängerkurs und umgekehrt stehen. Wenn ihr euch registriert, werdet ihr aber immer an die richtige Stelle weitergeleitet.
Zu dieser gemeinsamen Nutzung der Datenbank habe ich mich entschlossen, weil die Sprachelemente in Lazarus genauso wie in Delphi genutzt werden können.

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.)