Einführung in Delphi

Das Bild zeigt die Oberfläche von Delphi,
nachdem das Projekt Pkuerzen.dpr geöffnet wurde.

Hinweis:

Um ein Bild mit Kommentarfeldern zu sehen, muss man mit der Maus auf das Bild klicken !

Die Objekte

Links sieht man den so genannten Objektinspektor. Mit ihm kann man alle möglichen Eigenschaften der Objekte verändern.
Die Objekte, die man auf der Form anordnen will, werden oben in der Menüleiste angeklickt und mit der Maus platziert. Dazu drückt man auf die linke Maustaste und zieht diagonal das Objekt so groß wie man möchte. Lässt man nun die Maustaste los, erscheint das Objekt in der gewünschten Größe. Klickt man auf ein Objekt, wird dieses markiert. Die Lage und Größe eines Objektes können mit der Maus (im vorgegebenen Raster) verändert werden. Die Größe (width, height ) kann auch im Objektinspektor beliebig (ohne Raster) verändert werden.

Die wichtigsten Standardobjekte sind:

- das Textfeld (TEdit)
- die Schaltfläche (TButton)

evt noch die Überschrift ( TLabel) und Menüs (TMenu).

Bei den zusätzlichen Objekten findet man noch

- das Bild ( TImage)

Objektnamen

Sehr wichtig ist die richtige Wahl der Namen !

So wurde für die Form Fkuerzen ( F für Form und kuerzen für die Beschreibung ) gewählt.
Umlaute sind bei Namen nicht zulässig.
Das Textfeld ( EDIT ), in das der 1. Zähler geschrieben werden soll, wurde mit Ez1 bezeichnet. E für Edit und z1 für Zähler1.
Aus ökonomischen Gründen sollte man die Namen nicht zu lang, aber dennoch aussagekräftig wählen, eben so, dass man sich die Bezeichnungen gut merken kann. Dies gilt insbesondere für Objekte, auf die man häufig zugreifen muss.

Wird der Name eines Objektes im gesamten Programm überhaupt nicht benutzt, kann man darauf verzichten, das Objekt zu benennen. Delphi wählt ohnehin für jedes erzeugte Objekt einen Namen. Diese Namen sind natürlich überhaupt nicht aussagekräftig.

Die Objektliste

Alle Objekte der Unit ( hier heißt die Unit kuerzen) werden unter TFkuerzen aufgelistet.
Der Name wird von Delphi vorgegeben. Heißt die Form Fkuerzen, nennt Delphi den Typ TFkuerzen. Das vorangestellte T steht also für Typ.
Typen sind z.B. TEdit, TButton usw.
Typen sind vergleichbar mit den Arten der Variablen.

Vergleiche:
Var r : integer mit Ez1 : TEdit

Zu dem Typ TFkuerzen gehören alle Objekte der Form und sämtliche Prozeduren und Funktionen.
Die folgende Liste zeigt den Typ TFkuerzen.

type
TFkuerzen = class(TForm)
               Ez1: TEdit;
               En1: TEdit;   // Die Objekte der Form
               Edit3: TEdit;
               Ez2: TEdit;
               En2: TEdit;
               Edit6 : TEdit;
               Button1: TButton;
               Button2: TButton;
               Button3: TButton;
               Ek: TEdit

    function ggT(a,b : integer) : integer;
    procedure Eingabe;         // Eigene Prozeduren
    procedure kuerzen;         // und Funktionen
    procedure Ausgabe;

procedure Button3Click(Sender: TObject);
// Ereignis-Prozeduren

end;

Wie im kommentierten Bild bereits erwähnt, werden alle Objekte der Form automatisch eingefügt. Ändert man den Namen eines Objekts, veranlasst Delphi augenblicklich die Änderung des Namens in dieser Liste.
Die Ereignis-Prozeduren werden ebenfalls von Delphi hier eingetragen.

Ereignisprozeduren

Ein Ereignis ist zum Beispiel Click ( mit der linken Maustaste auf das Objekt klicken).
Diese Prozedur wird aufgerufen, wenn das entsprechende Ereignis (hier Mausklick) eintritt.
Um eine solche Prozedur zu erzeugen, muss man auf das entsprechende Objekt doppelklicken.
Man gelangt in das Quelltextfenster und stellt fest, dass der Rumpf der Prozedur bereits fertig ist.

z.B.

procedure TFkuerzen.Button3Click(Sender: TObject);
begin

end;

Der Name der Prozedur wird von Delphi erzeugt.
Bei jedem Prozedurnamen wird der Typ, also TFkuerzen, vorangestellt. Es folgt ein Punkt und dann der Objektname (hier Button3). Zum Schluss wird das Ereignis ( click) angefügt.
Der Parameter Sender ist erst einmal unwichtig.
Zwischen begin und end sollte nur wenig Quelltext stehen. Am besten beschränkt man sich darauf, hier nur bereits erklärte Prozeduren oder Funktionen aufzurufen.

Eigene Prozeduren und Funktionen

Die Hauptaufgabe beim Programmieren besteht wie bei Konsolenprogrammen darin, eigene Prozeduren und Funktionen zu schreiben. Diese müssen dann in die Objektliste eingetragen werden.

Alle Namen beginnen mit TFkuerzen. (Punkt nicht übersehen !), dann wird der selbsterdachte Namen angehängt.

Als Beispiel wird hier die vollständige Funktion ggT gezeigt:

function TFkuerzen.ggT(a,b : integer) : integer;
begin
    if (a>0) and (b>0) then
       begin
           repeat
              if a>b then a:=a-b;
              if b>a then b:=b-a;
           until a=b;
           ggT:=a;
       end else ggT:=1;
end;

Eine Beschreibung des zugrunde liegenden Euklidischen Algorithmus findet man hier !

Man erkennt, dass bis auf das Namenprefix ( TFkuerzen.) alles ganz genau wie im Konsolenmodus aussieht.
Der Quelltext ist nach wie vor ein Pascal-Quelltext.

Das Programm

Das eigentliche Programm, das alles zum Laufen bringt, wird von Delphi selbst erzeugt. Es sieht folgendermaßen aus:

program Pkuerzen;

uses
Forms,
kuerzen in 'kuerzen.pas' {Fkuerzen};

{$R *.RES}

begin
      Application.Initialize;
      Application.CreateForm(TFkuerzen, Fkuerzen);
      Application.Run;
end.

Es soll hier kurz beschrieben werden.

Wir vereinbaren dem Namen ein P voranzustellen ( P für Programm oder Projekt).
Unter uses wird dem Programm mitgeteilt, dass die Form der Anwendung (=Application) in der Datei kuerzen.pas zu finden ist.
In dieser Datei finden wir den Quelltext. Das Suffix pas steht immer noch für PASCAL.
Im Hauptprogramm wird die Form Fkuerzen erzeugt und die Anwendung gestartet.

Diese kurze Programm wird in der Datei Pkuerzen.dpr gespeichert. Das Suffix dpr steht für Delphiprojekt.
Enthält eine Anwendung mehrere Formen, werden hier alle nötigen Formen erzeugt.
Ansonsten sehen alle Delphi-Programme fast gleich aus.

Nötige Dateien:

Oben sind alle Dateien gezeigt, die zum Projekt Pkuerzen gehören. Die Hauptdatei, die das Programm enthält, ist markiert.
In kuerzen.pas befindet sich der Quelltext (das eigentliche Pascal-Programm).
In kuerzen.dfm sind die Daten über die Formobjekte, wie Größe, Farbe usw. gespeichert.
Die Dateien mit der Tilde (~) sind Sicherheitskopien.

Die drei Dateien:
Pkuerzen.dpr, kuerzen.pas und kuerzen.dfm sind die wichtigsten.
Fehlt eine dieser Dateien, kann das Programm nicht funktionieren !

Das vollständige Delphiprojekt Pkuerzen.dpr, inklusive EXE-File kann herunter geladen werden.
Außerdem steht das Projekt auch als Konsolenanwendung zur Verfügung.
Beide Dateien entpacken sich selbst. Man sollte aber in verschiedenen Ordnern entpacken, da einige Dateien den gleichen Namen haben.

Art	Dateiname	Größe
Delphiprojekt	delphi.EXE	193 KB
Konsolenanwendung	konsole.EXE	54 KB

Was gehört zum Projekt ?

Um sich einen Überblick zu verschaffen, was alles zum Projekt gehört wählt man den Menü-Punkt Ansicht.

Wählt man dann Units..., öffnet sich ein Fenster, in dem alle Units aufgelistet werden; dazu zählt auch die Projektdatei.

Angezeigt werden alle Dateien mit dem Suffix pas und dpr.
Wählt man Formulare..., werden alle Formen angezeigt (Dateien mit dem Suffix dfm).

Um bei großen Projekten den Überblick zu bewahren, ist eine sinnvolle Namengebung unbedingt erforderlich!
Die Form Fkuerzen gehört zum Quelltext kuerzen. Pkuerzen ist das Projekt.
Passt doch alles ganz gut zusammen, oder ?

Die Unit

Das gesamte Delphiprojekt besitzt nur ein einziges kleines Programm, welches von Delphi automatisch erzeugt wird.
Der Rest vom Quelltext wird in sogenannte Units geschrieben.
Eine Unit ist nicht alleine lauffähig. Eine Unit muss von einem Programm mit uses aktiviert werden.

Eine Unit besteht aus zwei Teilen. Wählt man z.B. Datei®neu®Unit bekommt man folgendes zu sehen:

unit Unit1;

interface
                < Was hier steht, wird nach außen weiter gereicht.
                < Das ist der öffentliche Teil.
implementation
                < Was hier steht bleibt verborgen. Das ist der
                < nichtöffentliche Teil.
end.

Bei Niki unter Delphi stand im Programmkopf immer uses Niki.
Damit wurde die Unit Niki aktiviert.
Die Unit stellte die Befehle vor, drehe_links, usw. zur Verfügung. Die Befehle sind nichts anderes als Prozedurnamen, die im interface aufgeführt sind. Sie wurden von der Unit nach außen weitergereicht.

Der Befehl vor bewirkte, dass Niki ein Feld weiterging. Wie das genau funktioniert war uns ziemlich gleichgültig, Hauptsache Niki ging ein Feld vor. Im implementation – Teil muss aber stehen, wie das genau vor sich gehen soll.
Hier müssen also die bereitgestellten Funktionen und Prozeduren erklärt werden.

Ähnliches gilt für den Gebrauch von Variablen. Variablen, die im interface erklärt werden sind sozusagen superglobal.
Sie gelten auch außerhalb der Unit !
Variablen unter implementation sind nur innerhalb der Unit bekannt.

Die einzige Variable im interface ist Fkuerzen, also die Form selbst.

Wie benutzt man Delphiobjekte ?

Das Textfeld Ez1 besitzt wie jedes Delphiobjekt zahlreiche Eigenschaften. Die meisten sind für uns unwichtig, nur wenige Eigenschaften sind von Bedeutung.

Die Eigenschaft TEXT (siehe Objektinspektor) ist wichtig. Dort steht nämlich der Text, den man in das Feld einträgt. Man kann das Feld bereits vor dem Programmstart füllen, man kann in dieses Feld aber auch schreiben, wenn das Programm läuft.

Will man auf eine Eigenschaft zugreifen, muss man zuerst den Namen angeben und dann die Eigenschaft anhängen:
z.B. Ez1.Text
Streng genommen handelt es sich eigentlich um das Objekt Fkuerzen.Ez1.Text , da ja Ez1 ein Element der Form Fkuerzen ist.
Hat man nur eine Form, kann man auf Fkuerzen verzichten, solange man sich in einer Prozedur des Projekts befindet.
Hätte man ggT ohne TFkuerzen erklärt, würde das Objekt Ez1 nicht erkannt !

Kompliziert ?

Also ! Solange man eine Form hat und alle Prozeduren oben in die Objektliste eingetragen hat, kann nichts schief gehen. Das Objekt Ez1 wird erkannt. Und Ez1.Text ist der Text, der im Textfeld drinsteht !

Wie kann ich diesen Text lesen, wenn das Programm läuft ?

Im Konsolenmodus war ein readln(z1) erforderlich, um die Variable z1 (1.Zähler) einzulesen.
Wir müssen den Text im Textfeld erst einmal in eine Zahl umwandeln (siehe mathematischer Hintergrund).

Dazu stehen folgende Funktionen zur Verfügung:

StrToInt,
StrToFoat,
StrToFloatF und
val.

StrToInt wandelt einen String in eine Integer-Zahl um. Z.B.:
z1:=StrToInt(Ez1.Text)

StrToFloat wandelt einen String in eine Real-Zahl um. Z.B.:
r:=StrToInt(Er.Text) mit r : real.

StrToFloatF erlaubt eine formatierte Umwandlung. Genauere Informationen findet man in der Hilfe von Delphi.

val ist keine Funktion sondern eine von Turbo Pascal her bekannte Prozedur.
Die Syntax lautet: val(s, w, f)
s ist ein String, also eine Zeichenkette
w ist eine Zahlvariable ( integer oder real)
f ist der sogenannte Fehlercode vom Typ integer.
f ist unwichtig, muss aber immer mit angegeben werden.

Beispiel: val(Ez1.Text,z1,f)

Für das Projekt Pkuerzen ist StrToInt die beste Lösung.

Das erste Problem wäre damit gelöst !

Statt readln(z1) heißt es jetzt:

z1:=StrToInt(Ez1.Text)

Anmerkung:
Bei fehlerhafter Eingabe reagiert Delphi unterschiedlich. Läuft das Programm unter Delhi wird abgebrochen.
Das fertige EXE-File gibt eine Fehlermeldung aus, bricht aber nicht ab !

Wie kann man ein Ergebnis einer Rechnung während der Laufzeit in ein Textfeld schreiben lassen ?

Natürlich will man auch bei Delphi-Programmen eine Ausgabe machen. In der Konsolenanwendung benutzen wir dazu die Prozeduren write(..) und writeln(..).
Wir müssen nun wieder die Eigenschaft Text verwenden, diesmal aber genau umgekehrt. Ein Rechenergebnis ist ja zunächst einmal eine Zahl. Diese Zahl muss nun in eine Zeichenkette verwandelt werden. Dazu kann man folgende Funktionen verwenden: IntToStr, FloatToStr und str.

IntToStr wandelt eine Integer-Zahl in einen String um.
Z.B. Ez2.Text:=IntToStr(z2)
Die Zahl z2 (also der neue Zähler) wird in das Textfeld Ez2 geschrieben.

Entsprechend verwendet man FloatToStr bei Real-Zahlen.

str ist keine Funktion sondern eine von Turbo Pascal her bekannte Prozedur.
Syntax: str(w, s)
w ist dabei eine Zahl (real oder integer), s eine Zeichenkette (string).
Für unser Projekt verwenden wir IntToStr.

Statt writeln(z2) heißt es jetzt:

Ez2.Text:=IntToStr(z2)

StrToInt, StrToFloat, IntToStr und FloatToStr sind die wichtigsten Befehle. Sie lösen readln und writeln ab.

Schlussbemerkung

Nunmehr können wir mit Delphi alles machen, was wir bisher in der Konsolenanwendung zustande gebracht haben, und vielleicht noch vieles mehr !

Außerdem sehen die Delphi-Anwendungen viel schöner aus, oder ?

Alles verstanden ?
Wenn nicht, es gibt ja auch noch Nachbarn.

Falls auch diese Informationsquelle versagt, kann man ja auch mal den Lehrer fragen !

Hoe , Lippe im Mai 2000

Hoe, Lippe im Mai 2003