IT-Systemkaufmann/-frau: Einführung in die visuelle, objektorientierte Entwicklungsumgebung mit Delphi

Sie sind hier: Startseite › IT-System-Kaufmann › Delphi

Delphi: Delphi (Allgemein) (Vorwort, IDE und RAD, Schreibregeln, Definitionen, Erstellen einer Anwendung in Delphi, Das Formular, Der Objektinspektor, Aufbau einer Unit, Variablendeklaration, Kommentare), Variablen und Datentypen (Variablen, Datentypen), Ausdrücke und Operatoren (Arithmetische Operatoren, Vergleichsoperatoren, Bit-Operatoren, Boolesche Operatoren, String-Operator, Mengen-Operatoren, Klassen-Operatoren, Zeiger-Operatoren, Adress-Operator), Ablaufsteuerung (Bedingte Verzweigung mit if und else, Bedingte Verzweigung mit case, for-Schleifen, while-Schleifen, repeat-Schleifen, Abbruchbefehle und -prozeduren), Prozeduren und Funktionen (Prozedurdeklarationen, Funktionsdeklarationen, Routinen und der Stack).

1. Delphi (Allgemein)
2. Variablen und Datentypen
3. Ausdrücke und Operatoren
4. Ablaufsteuerung
5. Prozeduren und Funktionen

Delphi (Allgemein)

Vorwort

Delphi ist ein auf die Programmiersprache Object Pascal aufbauendes Entwicklungssystem der Firma Borland.

Die "objektorientierte" Entwicklung erkennt man anhand von Objekten, Eigenschaften und Ereignissen.

Ein sich in der Entwicklung befindendes Programm unter Delphi besteht in der Regel aus mehreren Teilen, welche im Ganzen ein "Projekt" bilden.

Diese Seite soll keine vollständige Delphi-Beschreibung geben. Ich möchte ausschließlich die grundlegendsten Dinge erläutern und einige Beispiele geben. Alles in allem soll diese Seite dazu dienen, erste Einblicke in die Delphi-Programmierung zu erhalten und bestimmte Begriffe nachzulesen.

IDE und RAD

Integrated Development Environment (IDE):

In Delphi sind alle zur Programmerstellung erforderlichen Tools, wie z.B. Editor, Compiler, Linker, Debugger direkt aufrufbar. Compiler und Linker erstellen aus den Quelldateien eines Projektes ein Programm oder eine .dll (Zieldatei des Projektes). Der Compiler übersetzt die Quelltextdateien in Objektdateien. Der Linker erzeugt aus den Objektdateien die Zieldatei. Der Debugger dient zum Lokalisieren von Laufzeitfehlern (Fehler = Bug). Man spricht daher von "integrierter Entwicklungsumgebung".

Rapid Application Development (RAD):

Idee der komponentengestützten, grafischen Entwicklung von Windows-Anwendungen.

Schreibregeln

Mögliche Zeichen: Buchstaben von a bis z und A bis Z, Ziffern von 0 bis 9, Unterstrich.

Folgende Vorgaben müssen bei der Variablen-, Funktions-, Prozedur-, Klassen- und Typennamengebung eingehalten werden:

• Name muss mit einem Buchstaben oder dem Unterstrich beginnen
• Umlaute und Sonderzeichen dürfen nur in Kommentaren und Zeichenketten vorkommen

Pascal unterscheidet nicht zwischen Groß- und Kleinschreibung.

Hinweis: Beachte daher: Der Variablenname var1 entspricht Var1!

Definitionen

Bildbeschreibung "Delphi, Startbeispiel": Bildschirmphoto der beim Starten der Delphi-Anwendung sichtbaren Oberfläche.

Standardmäßig wird bei Start ein leeres Projekt geöffnet. Für jedes Projekt werden verschiedene Dateien angelegt:

• xxx.dpr: Projektdatei
• xxx.pas: Unit-Datei
• xxx.dfm: Formular-Datei
• xxx.dcu: Sicherungsdatei in kompilierter Form
• xxx.dof: Konfigurationsinformationen
• xxx.res: Windows-Ressourcen

Der neben dem Formular angezeigte Objektinspektor enthält die Eigenschaftswerte für die jeweiligen Komponenten. F9 kompiliert das Programm.

Die Komponentenleiste stellt, wie der Name schon sagt, die Komponenten bereit. Ein Klick auf die gewünschte Komponente, ein Klick auf die Form und die Komponente ist eingfügt.

So gestaltet man vorerst die graphische Oberfläche. Über den Objektinspektor werden grundlegende Eigenschaften der betreffenden Komponente festgelegt. Im Hintergrund erstellt Delphi in der .pas-Datei das Gerüst für den Programmcode. Diesen gilt es nun zu bearbeiten.

Erstellen einer Anwendung in Delphi

1. Anlegen eines neuen Projektes: Datei/Neu - Anwendung
2. Komponenten in Formular aufnehmen: Auswahl in der Komponentenpalette, Klick auf gewünschte Komponente, Ablegen der Komponente im Formular durch erneuten Klick
3. Komponenten und Formular konfigurieren: Komponente anklicken und Eigenschaften im Objektinspektor bearbeiten
4. Funktionellen Code hinzufügen: Doppelklicken in Ereigniseingabefelder im Objektinspektor oder direkt auf gewählte Komponente im Formular
5. Kompilieren: Projekt - Projektname
6. Testen: Start - Start

Um eine Anwendung auszutesten, ist es nicht erforderlich, das Projekt vorher zu kompilieren.

Bei Aufruf des Befehls Start prüft Delphi automatisch, ob der Quelltext des Projektes seit der letzten Kompilation geändert wurde und aktualisiert gegebenenfalls die .exe-Datei.

Das Formular

Das Formular dient der Bearbeitung der Anwendung. Es unterscheidet sich optisch vom eigentlichen ausführbaren Programm nur durch Bearbeitungshilfen, z.B. Gitter- und Markierungspunkte. F12 wechselt vom Formular zur Quelltext-Unit.

Der Objektinspektor

Bezieht sich immer auf die im Formular markierte Komponente (bzw. auf das Formular, wenn keine Komponente aktiv).

Über das Listenfeld im Objektinspektor kann jedoch auch ohne Markierung die entsprechende Komponente ausgewählt werden. Sind mehrere Komponenten gleichzeitig markiert, werden nur gemeinsame Eigenschaften angezeigt. So können gemeinsame Eigenschaften zentral festgelegt werden (spart Zeit!!!).

Sollte die eingefügte Komponente einen bestimmten Namen bekommen sollen, muss das gleich nach Einfügen in das Formular festgelegt werden, da Delphi im nachhinein keine Namen aktualisiert.

Aufbau einer Unit

Programmcode, der in der .pas-Datei gespeichert wird.

Beispiel 1 überspringen

unit <Name der Unit>; // Unit-Kopf: Schlüsselwort unit + frei wählbarer Name
interface // Interface-Teil: reine Deklarationen
uses <Liste der öffentlichen Units>;
...
implementation { Implementierungs-Teil: Anweisungsblöcke zu den im Interface-Teil
uses <Liste der privaten Units>; deklarierten Funktionen, Prozeduren und Methoden sowie
... Elemente, die nur innerhalb der Unit verwendet werden }
end.

Variablendeklaration

Um das Programm übersichtlich zu gestalten, sollten Variablen gemeinsam an einer Stelle deklariert werden. Dieser Abschnitt wird mit var eingeleitet.

Beispiel 2 überspringen

var
a : real;
b, c : integer;
d : boolean;


Deklarationen können jedoch auch an mehreren Stellen erfolgen. Der Ort der Deklaration legt fest, welche Bereiche der Unit diese Variablen nutzen können.

Wie im obigen Beispiel verdeutlicht, werden Anweisungen immer durch Semikolon voneinander getrennt!

Kommentare

Es gibt drei Möglichkeiten, Kommentare zu notieren:

1. {mehrzeiliger Kommentar}
2. (*mehrzeiliger Kommentar*)
3. //einzeiliger Kommentar

Um später immer einen Überblick über ein Programm zu behalten, sollten wichtige Passagen von Kommentaren begleitet werden. Das hilft Dir und auch programmfremden Personen, die Sachlage zu erkennen und zu verstehen.

|

Variablen und Datentypen

Variablen

Variablen sind vom Programmierer eingeführte Bezeichner, denen Werte zugewiesen werden können, die vom Datentyp der Variable abhängen. Der Compiler verbindet die Variable mit einem Speicherbereich, in dem der jeweils aktuelle Wert der Variable abgespeichert wird.

Die Art der Daten fordert verschiedene Datentypen:

• Integer (ganze Zahlen)
• Double (reelle Zahlen bzw. Gleitkommazahlen)
• Char (Zeichen wie Buchstaben, Ziffern oder Sonderzeichen)
• Boolean (Boolesche Variablen: Wahrheitswert true bzw. false)

Die Datentypen haben Auswirkung auf die interne Darstellung der Werte im Rechner, die Größe des Speicherbereichs, den Wertebereich und die Operation, die auf den Werten des Datentypes ausgeführt werden können.

Variablen sind also eine Art Zwischenspeicher. Daten werden abgelegt, bei Bedarf wieder hervorgeholt und können dann weiterverarbeitet werden.

Datentypen

Integer-Typen:

Gleitkomma-Typen:

Darstellung von Kommazahlen. Die gebräuchlichsten Datentypen sind Single (4 Bytes), Double (8 Bytes) und Extended (10 Bytes).

Boolesche Typen:

Zwei Werte möglich: true und false. Meistverwendeter Typ: Boolean.

Zeichen-Typen:

String-Typen:

Folge von Zeichen. Mögliche Varianten:

• ShortStrings,
• LongStrings,
• Null-terminierte Strings

|

Ausdrücke und Operatoren

Durch := können einer Variable Werte zugewiesen werden.

Arithmetische Operatoren

• + (Addition),
• - (Substraktion),
• * (Multiplikation),
• / (Division),
• div (Integerdivision),
• mod (Modulo (Rest)),
• + (unär) (Identität) und
• - (unär) (Negation).

Vergleichsoperatoren

Das Ergebnis solcher Operationen ist immer ein Boolescher Wert (true oder false).

Bit-Operatoren

• not: bitweise Negation
• and: bitweises "und"
• or: bitweises "oder"
• xor: Bitweises "entweder oder"
• shl: Schieben links
• shr: Schieben rechts

Sowohl der Operanden- als auch der Ergebnistyp sind immer Integer.

Boolesche Operatoren

• not: logische Negation
• and: logisches "und"
• or: logisches "oder"
• xor: logisches "entweder oder"

Sowohl der Operanden- als auch der Ergebnistyp sind immer Boolean.

logisches "und" (and):

Das Ergebnis hat nur dann den Wert true, wenn beide Operatoren den Wert true besitzen.

logisches "oder" (or):

Das Ergebnis hat dann den Wert true, wenn einer der beiden Operatoren den Wert true besitzt.

logisches exklusives "oder" (xor):

Das Ergebnis hat dann den Wert true, wenn genau einer der beiden Operatoren den Wert true besitzt.

String-Operator

Der Operator + verkettet zwei Operanden des Types String oder Char miteinander und liefert einen String als Ergebnistyp.

Mengen-Operatoren

Unter Zuhilfenahme des Datentypes set of und den folgenden Mengen-Operatoren kann man nach den Gesetzen der Mengenlehre Operationen ausführen.

• + (Vereinigung)
• - (Differenz)
• * (Schnitt)
• = (identisch)
• <> (nicht identisch)
• <= (Teilmenge von)
• >= (Obermenge von)
• in (Element von)

Klassen-Operatoren

• as (Typprüfung)
• is (Typumwandlung)
• = (Gleichheit)
• <> (Ungleichheit)

Zeiger-Operatoren

• + (Zeiger-Addition)
• - (Zeiger-Differenz)
• ^ (Dereferenzierung)
• = (Gleichheit)
• <> (Ungleichheit)
• <, <=, >, >= (Vergleiche)
• >= (Obermenge von)
• in (Element von)

Adress-Operator

Der Adress-Operator @ liefert Adressen von Variablen, Prozeduren, Funktionen oder Methoden zurück.

|

Ablaufsteuerung

Bedingte Verzweigung mit if und else

• Bedingungen werden in der notierten Reihenfolge ausgewertet.
• Wird eine Bedingung mit true beantwortet, erfolgt die Ausführung des Anweisungsteiles und die Beendung der Kette.
• Die zu else gehörenden Anweisungen werden erst dann ausgeführt, wenn alle vorangegangenen Bedingungen als false zurückgegeben wurden.

Wird eine Bedingung mit dem Wert true zurückgegeben, erfolgt die Ausführung des Anweisungsblockes.

if Bedingung erfüllt then tue dies;

Wird der Wert false zurückgegeben, wird der then-Teil übersprungen und das Programm wird bei der nächsten Anweisung fortgeführt.

In vielen Fällen möchte man aber für den zweiten Fall (false) eine Alternative angeben. In diesem Fall erweitert man das obige Beispiel wie folgt:

if Bedingung erfüllt then
begin
tue dies
end
else tue das;

Hinweis: Zu beachten ist, dass vor dem Schlüsselwort else kein Semikolon stehen darf!

Bedingte Verzweigung mit case

Gibt die Möglichkeit, zwischen mehreren Alternativen zu wählen. Während man mit einer if-then-else-Verzweigung aufgrund unterschiedlicher Bedingungen die Steuerung des Programmflusses übernimmt, wird bei der case-Kette aufgrund der unterschiedlichen Möglichkeiten der Werte eines Ausdrucks der Programmfluss verzweigt.

Ein sogenannter Selektor dient als Vergleichsansatzpunkt. Dieser Selektor wird mit den verschiedenen Konstanten verglichen. Tritt eine Gleichheit auf, so wird der entsprechende Anweisungsteil ausgeführt.

case <Selektor> of
Konstanten1: Anweisungsteil1;
Konstanten2: Anweisungsteil1;
Konstanten3: Anweisungsteil1;
...
else Standard-Verarbeitung;
end;

Der else-Teil ist nicht unbedingt notwendig, dient aber dem Abfang von Fehlern bei unvorhersehbaren Werten.

for-Schleifen

Feststehende Anzahl an Schleifendurchläufen. Eine Kontrollvariable übernimmt das Zählen der Durchläufe.

for <Kontrollvariable> := <Anfangswert> to Endwert do <Anweisungsteil>;

Mögliche Varianten: for-to-do und for-downto-do. Die Schleifenvariable wird pro Durchgang um genau Eins erhöht bzw. erniedrigt.

while-Schleifen

Wiederholen der Schleife, bis vorgegebene Schleifenbedingung erfüllt ist.

while <Bedingung> do
<Anweisungsteil>;

Ist die Bedingung also gleich erfüllt, so wird der Anweisungsteil gar nicht erst ausgeführt.

repeat-Schleifen

Auswertung der Schleifenbedingung nach Durchlaufen des Anweisungsteiles.

repeat
<Anweisungsteil>
until <Bedingung>;

Die Bedingung der repeat-Schleife wird somit zum Ende jedes Schleifendurchlaufes überprüft. Was zur Folge hat, dass der Anweisungsteil mindestens einmal durchlaufen wird!

Abbruchbefehle und -prozeduren

• continue: Abbruch des aktuellen Schleifendurchlaufes und Fortsetzen der Schleife mit dem nächsten Schleifendurchlauf.
• break: Verlassen der Schleife.
• exit: Programmabbruch.
• abort: Sofortige Programmbeendung.
• halt(exitcode: Integer): Sofortige Programmbeendung.
• runerror: Sofortige Programmbeendung mit Fehlercode-Angabe.

|

Prozeduren und Funktionen

Prozedurdeklarationen

Den einfachsten Fall zeigt der folgende Ausschnitt:

procedure <Name>;
begin
<Anweisungsteil>;
end

Prozeduren nutzt man zur Auslagerung von Code, der keinen konkreten Ergebniswert zurückgeben soll.

Funktionsdeklarationen

Ähnelt der Prozedurdeklaration, deklariert aber zusätzlich noch einen Ergebnistyp:

function <Name> : <Ergebnistyp>;
begin
<Anweisungsteil>;
end

Routinen und der Stack

• Routine: Prozedur und Funktion zusammen.
• Stack: Spezieller Teil des Arbeitsspeichers, der als Speicher für Parameter und lokale Variablen der Routine vom Compiler reserviert wird.

Der Stack muss nur solange aufrechterhalten werden, wie die Routine erhalten wird. Danach wird dieser Speicherplatz wieder freigegeben.

Der vom Compiler festgelegte Speicherbereich (Stack) wächst und schrumpft dynamisch mit den aufgerufenen und abgearbeiteten Routinen.