Programmieren mit DELPHI

Delphi stellt den Programmentwicklern eine auf BORLAND Object Pascal aufbauende visuelle Entwicklungsumgebung zur Verfügung. Die Elemente der Delphi-Programmierumgebung wurden entwickelt, um Tools zum einfachen und intuitiven Entwickeln von leistungsfähigen Anwendungen zur Verfügung zu stellen.

Zunächst erkennen wir folgende Elemente:

Formular. Das Formular enthält alle für den Programmlauf wichtige Teile. Ein leeres Formular enthält bereitsdie Systemsteuerung ("Minuszeichen"), die Mini-mieren-Maximieren-Schaltflächen, die Titelleiste und die Ränder zum Ändern des Formulares.
Quelltexteditor. Er erstellt große Teile des Programmtextes (UNIT.PAS). Eigene Programmschritte werden wie in Object Pascal 7.0 eingefügt.
Symbolleiste. Enthält Steuerungselemente für die Bedienung der Delphi-Oberfläche (Projekt, Datei öffnen, Lauf/Stop, ...)

Komponentenpalette. Aus ihr werden die Komponenten für das Formular ausgewählt und im Formular plaziert. Wird der Mauszeiger über die Komponenten gezogen, werden jeweils zugehörige Informationen angezeigt. Zusätzliche Komponentenseiten stehen über die Register zur Verfügung (am unteren Rand der Palette sichtbar).

Objektinspektor. Stellt die Eigenschaften und die Ereignisse der auf dem Formular plazierten Komponenten dar. Anhand der Eigenschaften können die Komponenten individuell "angepaßt" werden. Mit der Ereignisseite wird der ausgewählten Komponente ein bestimmtes Verhalten zugeordnet.
Objektselektor. Ist ein Teil des Objektinspektors. Der Objektselektor ermöglicht die Auswahl der Komponenten des aktuellen Formulares - mit ihm kann leicht zwischen den einzelnen Komponenten hin- und hergeschaltet werden.

Durch Doppelklick auf eine Komponente wird der Quelltext in der zugehörigen Methode geöffnet... Die Programmierung hält sich an die Regeln von Object-Pascal!

1 Erste Programmierschritte

Um das Arbeiten mit der Entwicklungsoberfläche von Delphi kennenzulernen, erstellen wir ein einfaches Windows-Programm, das nichts anderes leistet, als auf Tastendruck den Text "Die Taste wurde gedrückt" auszugeben...

Als erstes ziehen wir die Komponenten für "Label" und "Button" auf unser Formularfeld. Durch Ziehen mit der Maus kann die Größe und Position dieser Komponenten veändert werden

Anschließend tragen wir die Programmierbefehle ein, die nach Auswählen einer Komponente ausgeführt werden sollen. Im vorliegenden Beispiel soll nach Druck auf den Button der Text des Labels verändert werden. Per Doppelklick auf das "Button"-Symbol gelangen wir in den Quelltexteditor:

Alle Programmschritte werden in sogenannte "Prozeduren" zusammengefasst. Im Quelltexteditor wird der Cursor automatisch in die Prozedur

procedure Tform1.Button1Click

gestellt (die Befehle sollen ja nach dem Klicken auf der Button ausgeführt werden). Alle Befehle einer Prozedur stehen zwischen den Befehlen begin und end:

Wir tragen den gewünschten Befehl ein:

label1.caption:='Taste wurde gedrückt';

Beachte, dass jede Befehlszeile mit einem Strichpunkt abgeschlossen wird.

Anschließend soll das Programm getestet werden. Dazu muss es zunächst compiliert werden. Dies wird durch Druck auf das "Ausführen"-Symbol (grüner Pfeil) in der Symbolleiste erreicht.

Dadurch wird ein lauffähiges Windowsprogramm erzeugt, das typische Elemente eines Windowsprogrammes zeigt. So kann es mit Hilfe der Maus bedient werden, es kann verschoben, verkleinert, vergrößert oder geschlossen werden...

Aufgabe: Führe das Programm aus und speichere das "Projekt" auf der lokalen Festplatte oder in deinem Arbeitsverzeichnis am FileServer!

2 Units und Projekte

Jedes Delphi-Programm wird von einem Hauptprogramm ("Projekt") gesteuert, das alle weiteren Programmeinheiten aufruft und zahlreiche Teilprogramme zusammenfassen kann. Der typische Aufbau des Hauptprogrammes wird in der folgenden Abbildung dargestellt:

Der Projekt-Quelltext hat den typischen Aufbau eines Pascal-Programmes:

Die erste Zeile besteht aus dem reservierten Wort programund dem Projekt-Namen.#

Der Befehl uses bindet die angegebenen Units in das Projekt ein.

Schließlich stehen die Programmbefehle zwischen den reservierten Wörtern begin und end.

Application.CreateForm

Das "Formular" (Programmoberfläche) wird erzeugt.

Application.Run

Das Programm wird gestartet

Delphi stellt zahlreiche Units zur Verfügung, die typische Programmaufgaben ausführen. Auch das selbst geschriebene Pascal-Programm wird als Unit in das Projekt eingefügt (der Quelltext wird dazu als Pascal-Datei mit der Endung *.PAS gespeichert).

Im obigen Beispiel enthält der Editor das Hauptprogramm ("Projekt1") und das Pascalprogramm ("Unit1"). Beide Programme können nach Klick auf die entsprechende "Karteikarte" editiert (verändert) werden.

Sowohl der Projektquelltext als auch der Quelltext des selbst geschriebenen Delphi-Programmes können mit Hilfe des Drucker-Symbols aus der Symbolleiste ausgedruckt werden. In den eigenen Quelltext sollten der Name, das Datum und eventuell ein Hinweis auf die Aufgabe des Programmes (zwischen geschwungene Klammern) eingefügt werden. Damit können die Ausdrucke auch nach längerer Zeit bestimmten Programm(teil)en zugeordnet werden!

Aufgabe: Füge Name und Datum in den Quelltext zwischen geschwungenen Klammern {Autor: N.N, Datum:26. September 1997, Programm: ...}ein und drucke ihn aus!

Eine Unit ist ähnlich aufgebaut wie ein Programm. Die erste Programmzeile bezieht sich auf den Namen der Unit. Nach dem reservierten Pascal-Befehl interface folgt unter Verwendung des Pascal-Befehles uses eine Liste der verwendeten Units, Typen und Variablen. Verwendet man eine bestimmte Komponente aus der Palette, so wird nach dem "uses"-Befehl automatisch der Aufruf der entsprechenden Unit eingefügt.

type

Anschließend werden alle Typen und Methode angegeben

procedure

Prozedur (Unterprogramm), hier eigentlich eine "Methode"

private

"Private" Deklaration von Typen & Methoden

public

"Öffentliche" Deklaration...

var

Anschließend werden alle globalen Variablen angegeben

implementation

Anschließend werden alle Prozeduren (eigentlich Methoden) mit allen Programmzeilen angegeben

Beachte, dass mit jeder Komponente, die in ein Formular "gezogen" wird, eine gleichlautende Prozedur (Methode) in den Quelltext eingefügt wird. Anschließend schreibt man den zugehörigen Programmtext zwischen die (bereits eingefügten) Pascalwörter beginund end. Dieser Programmcode wird ausgeführt, wenn die Kompontente (beispielsweise per MausClick) gestartet wird....

3 Variable - das Projekt "Rechner"

Im obigen Beispiel sollen zwei Zahlen z.B. addiert und das Ergebnis in einem weiteren Zahlenfeld angezeigt werden. Dazu verwenden wir sogenannte Variable, die Zahlenwerteund Zeichenketten während des Programmlaufes zwischenspeichern.

unit Unit1;
interface
uses
SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,
Forms, Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Label1: TLabel;
Label2: TLabel;
Edit1: TEdit;
Edit2: TEdit;
Button1: TButton;
Button2: TButton;
Button3: TButton;
Button4: TButton;
Button5: TButton;
Edit3: TEdit;
procedure Button1Click(Sender: TObject);
procedure Button5Click(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.Button1Click(Sender: TObject);
var
zahl1,zahl2,summe:integer;
ergebnis:string;
begin
zahl1:=StrToInt(edit1.text);
zahl2:=StrToInt(edit2.text);
summe:=zahl1+zahl2;
ergebnis:=IntToStr(summe);
edit3.text:=ergebnis;
end;
procedure TForm1.Button5Click(Sender: TObject);
begin
Form1.Close;
end;
end.

Wir erkennen:

Die Variablen werden nach dem reservierten Pascal-Wort var unter der Angabe eines bestimmten Typs vereinbart. Dadurch wird der Compiler beim Übersetzen des Programmes angewiesen, einen entsprechend großen Speicherplatz im Hauptspeicher des Computers unter einer bestimmten Adresse zu reservieren.
Wir müssen entsprechende Typen planen - für die Variablen, die eine ganze Zahl speichern sollen, verwenden wir den Typ integer, für eine Variable, die einen Text speichern soll, string.
Zahlen werden mit Hilfe der Zifferntasten eingegeben, Strings werden üblicherweise zwischen einfache Anführungszeichen gesetzt.
Variable haben nur in der Prozedur (Methode) Gültigkeit, in der sie vereinbart wurden.
Einer Variablen wird unter Verwendung von Strichpunkt und Gleichheitszeichen ein Wert zugewiesen. Dieser Wert kann eine Konstante, ein Rechenergebnis, der Inhalt einer anderen Variablen, das Ergebnis einer Funktion o.ä. sein - wichtig ist nur, dass der Typ der Variablen und der Typ der zugewiesenen Größe übereinstimmen!
Um Werte von einer Zeichenkettenvariablen in eine Integer-Variable übergeben zu können, muss eine Typenumwandlung vorgenommen werden. In Delphi werden dazu die Funktionen StrToInt(string)und IntToStr(zahl) verwendet.

1. Hinweis: Das "Formular" wird als globale Variable (Instanz) festgelegt. Damit kann von jeder Prozedur auf das Formular zugegriffen werden. Der Typ ist ziemlich kompliziert, da diese Variable alle Variablen und Prozeduren (Methoden) enthält, die in der Typenvereinbarung

TForm1 = class(TForm) angegeben wurden. Später werden wir diese Struktur bei der "Objektorientierten Pro-grammierung" genauer diskutieren.

2. Hinweis: Obwohl der Compiler nicht zwischen Groß-und Kleinbuchstaben unterscheidet, ist es sinnvoll den Quelltext mit Groß- und Kleinbuchstaben besser lesbar zu gestalten. Namen von Typen erhalten ein vorangestelltes großes T. Variablen sollten möglichst "sprechende Namen" aufweisen. Der auf eine spezielle Variable bezogene Typ soll gleichlautend heißen, ...

Aufgabe: Erweitere das Programm, indem du zu den Buttons der anderen Rechenarten die entsprechenden Quelltexte einfügst! Zusätzlich soll neben dem Ergebnis der Name der verwendeten Rechenoperation ausgegeben werden.