Home » Programmiersprachen » Delphi » Einführung in Delphi 4      
 

 

Einführung in Delphi 4

 

 

INDEX

Was ist Delphi?
Die Entwicklungsumgebung
Ein erstes Programm
Komponenten und Eingenschaften
Ereignise
Typen, Variablen und Konstanten
Schleifen
Verzweigungen
Objekte
Das zweite Programm
Arbeiten mit Dateien
Mehrere Units



1. Was ist Delphi?


Delphi ist die Nachfolgersprache von Pascal, die Befehle sind deshalb sehr ähnlich zu denen von Pascal.
Delphi gehört zu den sogenannten Objektorientierten Programmiersprachen, was das ist erklär ich später noch.
Delphi wurde von Borland entwickelt und ist jezt schon in der Version 5 erhältlich.
Mitgeliefert werden die IDE, das ist die integrierte Entwicklungsumgebung, mit Edior und Debugger, eine Menge
Komponenten, eine hervorragende Online Hilfe mit kompletter Befehlsreferenz und 'n
paar Bilder und Icons.
Aber kommen wir zu den wichtigeren Sachen ...







2. Die Entwicklungsumgebung

Die Delphi Enwicklungsumgebung

Dies ist die Entwicklungsumgebung unter Delphi. Man kann sehen, dass sie aus
4 Teilen besteht:Dem Objektinspektor, das Formblatt, der Code Editor und die
Werkzeugleiste.

Der Objektinspekor:



Mit ihm kann man den Objekten (z.B Button, Textfelder etc.)
ihre Eigenschaften (Grösse, Beschriftung etc.) festlegen
oder bestimmen wie sie auf bestimmte Ereignisse reagieren
(Knopfdruck, Änderung des Textinhaltes).
Das Formblatt:



Damit legen sie das Aussehen ihres Programmes fest. Wie in
einem Malprogramm werden Buttons, Beschriftungen usw. einfach
plaziert. Den benötigte Code für diese Komponenten erzeugt Delpi
von ganz allein.
Der Code Editor:


Das Herzstück eures Programmes, damit haucht ihr eurem Programm
Leben ein. Doch der Editor hält viele Hilfen bereit: Automatische
Ergänzungen und eine Menge mehr.
Die Werkzeugleiste:


Das wichtigste ist wahrscheinlich die Komponentenleiste, denn dort
findet man diese ganzen Sachen die ein Windows Programm ausmachen:
Buttons, Labels, Textfelder, Memos und anderes.



3.Erstes Programm



Im folgendem Beispiel erstellen wir ein Programm, das "Hallo Welt" ausgibt:
Dazu erstellen wir erstmal eine neue Anwendung (Datei -> Neu -> Anwendung). Dann klickt ihr in der Komponentenleiste,
in der Registrierkarte Standard den Button an und platziert ihn durch Klicken auf dem Formblatt auf demselben.
Dann auf den Button doppelklicken. Delphi erstellt automatisch ein paar Codezeilen:


prodedure TForm1.Button1Click(Sender: TObject)
begin

end;

Natürlich hat Delphi schon davor 'ne Menge Code selbstgschrieben, wenn man mal hochscrollt. Die Bedeutung
schauen wir uns nachher noch an.
Erstmal zu diesen 3 Zeilen:
Eine Prozedur ist ein Block von Befehlen an Delphi, die dann ausgeführt werden wenn die entsprechene Prozedur
aufgerufen wird. Alle Befehle befinden sich innerhalb von "begin" und "end". Die Prozedur TForm1.Button1Click wird
genau dann aufgerufen wenn der Button angeklickt wird.
Zwischen begin und end schreiben wir jezt folgende Zeilen:

Canvas.Textout(Form1.Width div 2,Form1.height div 2,'Hallo Welt');

Dieser Befehl bewirkt, dass der Text "Hallo Welt" in der Mitte des Formblattes ausgegeben wird, wenn der Button
angeklickt wird.
"Form1" ist der Name des Formblattes, dieses hat die Eigenschaften Width und Height, die die Breite und die Höhe
des Blattes angeben (steht auch im Objektinspektor). "div 2" heisst einfach durch 2 dividieren und danach runden.
Der Canvas ist die Zeichenfläche auf dem Formblatt. Er "besitzt" eine Prozedur namens Textout, bei der man 3 Para-
meter angeben muss: Die x- und y-Koordinaten in einem Koordinatensystem mit Ursprung in der linken oberen Ecke
des Bildschirmes, (nach unten bzw. rechts hin werden die Werte grösser) und den Text der ausgegeben werden soll
in Hochkomma.
Der formale Befehl lautet also: Canvas.Textout(x-Koordinate,y-Koordinate,textinhochkomma);
Dieses Programm jetzt mal durch einen Klick auf den grünen Pfeil laufen lassen. Wenn alles richtig war müsste der Delphi-Compiler es anstandslos übersetzt haben und ein Fennster mit Button anzeigen.
Klick man diesen an, erscheint "Hallo Welt" auf dem Fenster.






4. Die wichtigsten Komponenten


Mit Delphi werden schon eine Menge Komponenten mitgeliefert, doch es gibt immer wieder Neue zum Dowloaden
im Internet, man kann auch eigene Komponenten programmieren oder vorhandene abändern oder erweitern.
Sie sind in den Sparten Standard, Zusätzlich, Win32, System, Datenzugriff, Datensteuerung, QReport, Dialoge,
Win3.1, Beispiele und ActiveX untergebracht. Für den Anfang wird man sich wahrscheinlich hauptsächlich mit
den Komponenten im Standard-, Zusätzlich-, Win32-, System-, und Win3.1-Ordnern beschäftigen.
Sie können durch einfaches Anklicken ausewählt werden und dann auf dem Formblatt plaziert werden.
Die Eigenschaften kann man sich dann im Objektinspektor anschauen.
Einige wichtige Eigenschaften sind:


Eigenschaft Erklärung Beispiele
Caption Beschriftung Button, Lable, GroupBox, RadioGroup, Panel
Color Farbe bei den meisten Standardkomponenten
Cursor Cusorform beim
Überfahren mit
der Maus
praktisch alle sichtbaren Komonenten
Enabled Aktiviert auch fast überall
Font Schrifteinstellungen Überall wo die Eigenschaften Text oder
Caption vorhanden sind
Heigth Bestimmt die
Höhe der Kom-
ponente
bei allen sichtbaren Komponenten
Hint Hilfe, die beim Über-
fahren mit der Maus
angezeigt wird, wenn
die Eigenschaft Show
Hint true ist
Wiederum alle sichtbaren Komponenten
Left Abstand vom linken Rand
des Formulars
Alle sichtbaren Komponenten
Items Beinhaltete Einträge Alle Arten von Listen oder Baumstrukturen
Left Abstand vom linken Rand bei allen sichtbaren Komponenten
Lines Eingetragener Textzeilen Memofeld, RichEdit
Name Interner Name Überall
Taborder Tabulator-Reihenfolge Bei allen Interaktiven Komponenten
Top Abstand vom oberen Rand Bei allen sichtbaren
Visible Einstellung ob Komponenete sichtbar Bei allen (normalerweise)sichtbaren

Dies soll nur eine ganz kurze Übersicht über die häfigst gebrauchten Eigenschaften sein, um vielleicht mal
ein Gefühl zu bekommen was Eigenschaften von Komponenten überhaupt sind. Es ist in keinster Weise auch nur
annähernd eine Liste aller vorhandenen Eigenschaften von Komponenten.




5. Ereignise


Ein Ereignis, oder ein "Event" was ist das in Delphi??
Wenn ich z.B. in irgendeinem Windows Programm einen Button drücke oder ein Textfeld ändere, dann ist das
schon ein Ereignis. Der Job eines Programmierers ist es auf diese Ereignise zu reagieren, bzw. das Programm
darauf reagieren zu lassen. D.h. man muss Delphi sagen was es bei demUnddem Ereignis machen soll.
Im Programm oben haben wir genau das schon gemacht. Wir haben Delphi gesagt, was es machen soll, wenn der
Benutzer den Knopf drückt. Klick auf den Button hat dann das Ereignis "OnClick" ausgelöst, daraufhin startet Delphi
die Prozedur "Button1Click". Das"TForm1." davor heisst, dass die Prozedur zur Klasse TForm1 gehört, das ist im
Moment aber unwichtig. Die Prozedur, die bei einem Klick auf den Knopf gestartet wird könnte auch "KlickaufKnopf"
oder "sldkjgkl" heißen, man muss Delphi nur sagen, wiesie heißt, damit es weiß was es machen soll wenn der
Knopf gedrückt wird. Dieses "sagen" geschieht ganz einfach dadurch, dass man den Knopf markiert, im Objektinspektor
die Sparte Ereignise wählt und dann im Feld "OnClick" den Namen der zu startenden Prozdedur einträgt, welche
natürlich existieren muss. Wie ihr jetzt auch gesehn haben müsstet gibt es noch viel mehr Ereignisse, auf die
Delphi reagieren kann: OnDrag, onMouseMove usw.


Aufgabe:
Schreibt doch mal ein Programm, dass beim Überfahren mit der Maus, "Es klappt" auf dem Bildschirm ausgibt.

Tipp: Das Ereignis "Überfahren mit der Maus" heisst "OnMouseMove". Beim Doppelklicken auf das Textfeld
daneben schreibt Delphi automatisch den Prozedurrumpf, und die Prozedur Button1Move wird als Ereignis
eingetragen.



6. Typen, Variablen und Konstanten


Wir kommen jetzt zu einem der wichtigsten Kapiteln der Programmierung: zu den Variablen. Eine Variable ist
eigentlich ein Abschnitt im Speicher, dem man einen Namen geben kann, irgendwas hineinspeichern kann
und später wieder darauf zugreifen kann. Man muss dem Computer nur sagen, was man hineinspeichern will,damit
er entsprechend viel oder wenig Speicher vorbelegen kann (Zahl, Buchstaben etc.). D.h. man muss Delphi sagen,
welchen Typ die Variable hat. Um das zu verdeutlichen ein kleines Beispiel: Wenn ich den Benutzer irgendetwas
frage, also eine Antwort erwarte, kann ich diese in eine Variable des Types "String" speichern. Ein String ist
Zeichenkette. Delphi muss also genug Speicher für eine Zeichenkette vorbelegen. Wenn ich aber etwas in eine
Variable speichern will, dass nur zwei Zustände haben kann, z.b. männlich oder weiblich, dann benutzte ich
eine Variable des Types Boolean. Eine solche Variable kann nur zwei Zustände annehmen, nämlich "true" oder
"false" (1 oder 0). Eine solche Variable benötigt natürlich viel weniger Speicher. Ich hoffe man erkennt daraus
die Notwendigkeit, dem Computer mitzuteilen was man in der Variable zu speichern gedenkt. Dies teilt man Delphi
folgendermaßen mit:

var
alter :integer;
name,vorname:string;
geschlecht :boolean;

Im obigen Beispiel haben wir 4 Variablen "deklariert" (so nennt man das), eine Integer- (ganze Zahlen), zwei
String-, und eine boolsche Variable. Diesen Variablen kann man dann einen ihrem Typ entsprechendem Wert
zuweisen. Eine Liste aller Typen in Delphi findet sich in der Online-Hilfe.
Die Zuweisung erfolgt folgendermaßen:

alter:=1;
name:='Junker';
vorname:='Max'; gEsChlecHT:=true;

Erkenntnisse:

  • Eine Zuweisung erfolgt durch ":="
  • Eine Zeichenkette wird von ' und ' eingeschlossen
  • Ein Befehl wird immer mit ";" beendet
  • Nach einem Befehl muss kein Zeilenumbruch erfolgen. Es ist allerdings übersichtlicher.
  • Die Groß- Kleinschreibung ist wurscht


7. Schleifen


Nehmen wir einmal an irgend jemand will ein Programm 100 Mal "Hallo" schreiben lassen. Jetzt kann er natürlich 100 Mal
Canvas.Textout(12,30,"Hallo") schreiben, wobei er die Koordinaten natürlich jedesmal ändern müsste. Dies ist natür-
lich sehr umständlich und ausserdem Zeitaufwendig. Deswegen gibt es in allen Programmiersprachen sog. Schleifen.
Wie der Name schon sagt, "schleifen" sie einen Teil des Programmes mehrmals durch. Je nach Situation kommen verschie-
dene Schleifen zu Anwendung: Zuerst will ich mal die "For-Schleife" zeigen:
Dazu ein kleines Beispielprogramm. Wir öffnen jezt mal ein neues Programm (ich auch weil ich die genauen Namen immer
vergess) und setzen 'nen Button auf das Formular. Dann erstellen sie die Button1Click Procedure durch einen Doppelklick
auf den Button, wie wir's oben auch schon gemacht haben und vervollständigen es folgendermaßen:

Procedure TForm1.Button1Click(Sender: TObject)

var i: Integer; //Eine einfache Variable die ganze Zahlen enthalten kann

begin
FOR i:=1 TO 10 DO
  Canvas.TextOut(50,i*20,'Hallo');
end;


Also, die ersten 3 Zeilen sind ja nix neues, interessant wirds in der nächsten Zeile: FOR i:=1 TO 10 DO. Dies heist ganz
einfach, dass der Befehl der nach dem "DO" kommt 10 mal hintereinander ausgeführt wird, und i jedesmal um 1 erhöht wird.
"Hallo" wird also jedesmal an der gleichen X-Koordinate, aber mit erhöhter Y-Koordinate ausgegeben, i muss noch mit 20
multipliziert werden, da sonst der Y-Wert immer um 1 mehr wäre als der vorhergegangene, so aber um 20. i behält dabei
seinen Wert bei. Wenn man mehr als einen Befehl wiederholen will, muss man vor den Befehlsblock "begin" und danach "end"
schreiben. Jezt mal die allgemeine Form:


for i:= X TO Y DO
   begin
    { auszuführende Befehle }
   end;

wobei x der Startwert und Y der Endwert ist.

Ich will jezt mal kurz den Begriff "Bedingung" erklären, da er für die nächsten Schleifen wichtig ist. Also, wenn ich zum Bei-
spiel sag 1=1, dann ist das eine Bedingung, und diese ist erfüllt, denn 1 ist ja gleich 1. Man sagt, die Bedingung hat den Wert
true. Also hätte 1=2 den Wert false. 1 < 2 wäre dann wieder true usw. Dies als kurze Vorbemerkung zur nächsten Schleife. Die zweite Schleife ist die "Repeat...Until" Schleife. Diese ist absolut simpel aufgebaut, man benötigt eigentlich keine grosse
Erklärung mehr:

REPEAT
begin
{auszuführende Befehle}
end
UNTIL [bedingung]


können, wenn nur ein Befehl wiederholt werden soll.
Beispiel:

Procedure TForm1.Button1Click(Sender: TObject)

var i: Integer; //Eine einfache Variable die ganze Zahlen enthalten kann

begin
i:=0;
REPEAT
begin   i++; // i wird um 1 erhöht, gleichwertig mit i:=i+1;
  Canvas.TextOut(50,i*20,'Hallo');
end; UNTIL i=4
end;

Es gibt noch eine Schleifenart, die sehr häufig genutzt wird, die while...do.. Schleife. Sie funktionniert im Prinzip wie die
Repeat Schleife, jedoch wird die Bedingung gleich am Schleifenanfanf überprüft. D.h. wenn das Ergebnis der Bedingung schon beim
ersten Schleifendurchgang false ergibt, wird die Schleife nicht angefangen. Bei Repeat, wo die Bedingung erst am Schluss überprüft
wird würde die schleife mindestends einmal durchlaufen. Ausserdem wird die while schleife durchgeführt wenn die Be-
dingung true ist. Bei Repeat endet die Schleife ja wenn die Bedingunng erfüllt ist.
Soviel zur Theorie, jezt mal wieder ein kleinen Beispiel analog zu den Aufgaben der oberen Schleifen:

Procedure TForm1.Button1Click(Sender: TObject)

var i: Integer; //Eine einfache Variable die ganze Zahlen enthalten kann

begin
i:=0;
while i<=4 DO
  begin
   i++; // i wird um 1 erhöht, gleichwertig mit i=i+1;
   Canvas.TextOut(50,i*20,'Hallo');
  end;
end;

Die allgemeine Form ist also:

while[Bedingung] do
  begin
   {auszuführender Code}
  end;

8. Verzweigungen


So, nachdem wir jezt schon wunderbare Schleifen fabrizieren können, gehen wir einen Schritt. Was ist denn z.B. wenn man den Benutzer
etwas frägt, und je nachdem wie die Antwort ausfällt, den Verlauf des Programmes beeinflussen will. Ich würde natürlich nicht ewig
rumreden wenn das nicht gehen würde, die Frage ist nur wie. In Delphi gibt es verschiedene Möglichkeiten im einem Programm zu Ver-
zweigen. Die einfachste ist die "if..then..else" Anweisung. Dazu ein kleines Beispielprogramm:
Aus dem Register "Standard" wird die Edit-Komponente ausgewählt (5. Symbol von links) und auf dem Formular platziert.
Als nächstes legen wir noch ein Label (Standard 4.Symbol von links) vor das Textfeld und einen Button dahinter.
Nun wird das soeben erstellte Textfeld markiert oder im Objektinspektor ausgewählt und folgende Eigenschaften verändert:
Eigenschaft alter Wert neuer Wert
Name Edit1 Vorname
Text Edit1 (gar nix)


Beim Label ändern wir folgendes:
Eigenschaft alter Wert neuer Wert
Caption Label1 Vorname eingeben:


Und beim Button:
Eigenschaft alter Wert neuer Wert
Caption Button1 OK


Nun wird durch Doppelklick auf den Button die Methode TForm1.Button1Click erstellt und in dei Ereignisliste des Buttons eingetragen.
Der Editor erhält den Fokus. Jetzt müssen wir auf den Klick reagieren. Dies machen wir auf folgende Art und Weise:

procedure TForm1.Button1Click(Sender: TObject);
var eingabe:String; begin

eingabe:=Vorname.text;
if length(eingabe)=0 then
  showmessage('Sie haben nichts eingegeben')
else showmessage('Sie haben eingegeben: '+eingabe);
end;

So, nun zu einer Erklärung: Zuerst haben wir dem Textfeld einen neuen Namen gegeben, dieser steht in der Eigenschaft "Name". Es ist die
interne Bezeichnung des Textfeldes mit der es aus dem Quellcode aus angesprochen werden kann. So wird dann der Stringvariablen "eingabe"
der Text zugewiesen, der im Textfeld steht wenn der Button gedrückt wird.
Nun zur if anweisung. Wir prüfen nach ob die Laenge der Eingabe 0 ist. Dies geschieht mit der Funktion length(text: String). Eine Funktion
ist etwas ähnliches wie eine Procedure, nur hat sie einen Rückgabewert. Bei der Funktion length ist dieser vom typ integer. D.h. man
könnte auch schreiben:

var i:integer;
var s:String;
begin
 i:=length(s);
end;

Damit hätte man der Variablen i die Länge des Strings s zugewiesen.
Nun aber weiter mit der if anweisung: Wenn jetzt also die länge 0 ist, also nichts in das Textfeld geschrieben wurde, dann lassen wir ein
Fenster öffnen in dem Kund getan wird, dass nichts eingeben wurde: showmessage(s:String). In allen anderen Fällen (laenge=1,laenge=2 usw.)
wird der Teil ausgeführt der nach else steht. Wenn mehrere Befehle ausgeführt werden sollen,
müssen sie in einem begin...end; Block stehen. Das gilt auch für die oberen Befehle.
Wichtig: vor "else" darf kein ";" stehen.
Der Else-Teil ist nur optional, er kann auch weggelassen werden.
Die allgemeine Form der if anweisung ist also:

if [Bedingung] then
  begin
   [Anweisungen]
  end{;} //Wenn else, dann kein Strichpunkt
else
begin
  [Anweisungen]
end;

 

 

© 2001 - 2003: tutorial-project.de | webmaster@tutorial-project.de | Haftungsausschluss