Home

DELPHI - erste Programme

Grundlagen | Briefprogramm | Adressprogramm | Speichern | Brief 2 | Taschenrechner 1 | TR 2

1. Grundlagen

Unser erstes Delphi-Programm (hier kannst Du es herunterladen) dient dem Kennenlernen der drei wichtigsten Komponenten:

Eingabe z. B. über die Komponente Edit
  1. Hier kann während der Laufzeit des Programms Text hineingeschrieben werden.
  2. Dieser Text wird in die Eigenschaft "text" - also unter edit1.text - abgelegt.
Verarbeitung: z. B. über die Komponente Button
  1. z. B. über das Ereignis "Onclick" (im Objektinspektor)
  2. Hier wird angegeben was passieren soll, wenn der User mit der Maus auf den Button klickt.
  3. Der Programmierer führt einen Doppelklick auf dieses Ereignis aus und kommt so zum Quelltext
  4. Dort hat DELPHI automatisch schon den notwendigen Rahmen erstellt:
    Procedure Tform1.button1click(..);
    Begin
    End;
  5. Zwischen "Begin" und "End" programmieren wir jetzt den Quelltext.
  6. close; //Durch einen Klick wird das Programm beendet
  7. Oder wir ändern die Beschriftung des Button über die Eigenschaft "caption":
    button1.caption:='Danke!'; //Hochkommas! - Nach dem Klicken erscheint: Danke!
Ausgabe z. B. über die Komponente Label
  1. Die Ausgabe soll z. B. nach einem Klick auf einen Button erfolgen - wird also in die obengenannte Procedure hineingeschrieben (zwischen Begin und End).
  2. Beim Label kann Text ausgegeben werden über die Eigenschaft "caption":
    label1.caption:='Hallo'; // Beachte die Hochkommas!!
  3. weitere Eigenschaften wie font verändern die Schriftart, Farbe, ...
    label1.color:=clblack; label1.font.color:=clgreen; // cl für color - ohne Hochkommas
  4. Das was in die Edit-Komponente hineingeschrieben worden ist (Eingabe in edit1.text), kann im Label wieder ausgegeben (also in label1.caption) werden.
    label1.caption:=Edit1.text;
    label1.caption:='Hallo '+Edit1.text;// erscheint z. B. als: Hallo Christopher
  5. Es kann aber auch in der Edit-Komponente eine Ausgabe erfolgen
    Edit1.text:='Einen neuen Namen, bitte!' // Hochkommas
    Auch hier kann die Schriftart etc. eingestellt werden

 

Versuche nun, analog dem obigen Programm, mit diesen Eigenschaften der Komponenten zu arbeiten.
Du kannst dir auch den Quelltext herunterladen (er ist gezippt, du benötigst ein Programm wie WinZip zum entpacken).

Briefprogrann (Variant1 - ohne speichern)

Design
  1. Erstelle die für ein Adressprogramm notwendigen Eingabefelder
  2. Füge die entsprechenden Beschriftungen (über Label) hinzu
  3. Zwei Buttons werden benötigt
  4. Ein Ausgabefeld - Label - (Dort soll zuerst nur stehen: 'Hier wird die Adresse angezeigt')
  5. Ordne alles schön an und führe ansprechende Formatierungen (color ...) durch
  6. Führe das Programm aus und überprüfe die Benutzerfreundlichkeit
Programmieren
  1. Im Ausgabefeld erscheint die Adresse (einzeilig)
  2. Teste das Programm
Erweiterung der Programmierung
  1. Bitte stets in kleinen Schritten vorgehen und immer wieder testen
  2. Arbeite mit mehreren Ausgabe-Feldern und erstelle einen Briefkopf
  3. Füge die Komponente Memo hinzu (mit dem Klick auf F1 bekommst du Hilfe dazu).
    Du kannst diese für Ein- und Ausgabe benutzen.
    Die wichtigste Eigenschaft ist "Lines": memo1.lines
  4. Du kannst eine neue Zeile ausgeben über "Add()"
    memo1.Lines.Add('Ein Briefkopf'); //Hochkommas: "Ein Briefkopf" wird ausgegeben
    memo1.lines.Add(Edit1.text); //ohne Hochkommas: Inhalt von Edit1 wird ausgegeben
  5. Erstelle damit einen Briefkopf (Übernahme aus den Edit-Feldern auf Button-Klick)
  6. Erstelle den Briefschluss (auf Button-Klick)
  7. Nun kannst du dort einen Brief schreiben
  8. Über Markieren und Kopieren kannst du den Brief dann in einem Textverarbeitungsprogramm übernehmen und ausdrucke

Adressprogramm (Variante 1 - ohne speichern)

Design
  1. Erstelle die für ein Adressprogramm notwendigen Eingabefelder, Beschriftungen und Buttons
  2. Als Ausgabefeld benutzt du eine Memo-Komponente
  3. Ordne alles schön an und führe ansprechende Formatierungen (color ...) durch
  4. Führe das Programm aus und überprüfe die Benutzerfreundlichkeit
Programmieren
  1. Nach jedem Button-Klick wird im Ausgabefeld die Adresse (einzeilig - mit Leerzeichen getrennt) hinzugefügt.
  2. Teste das Programm

Speichern und Öffnen

  1. In Windowsanwendungen gibt es meist die Möglichkeit, Daten auf der Festplatte zu speichern. Häufig wird zuvor ein Dialog geöffnet, indem der Dateiname festgelegt werden kann. Diese Fähigkeit wollen wir auch in unsere Delphi-Programme implementieren.
  2. Wir benötigen die Dialog-Komponente Save-Dialog auf dem Formular, sowie einen Label, eine Memokomponente und einen Button.
    Führe das Programm einmal aus. Was fällt dir auf?
  3. Als Programmtext schreiben wir in die OnClick-Prozedur des Buttons
    savedialog1.execute //Zum Ausführen des Dialogs
    Führe das Programm einmal aus. Nun kannst du den Dateinamen festlegen.
  4. Der gewählte Dateiname ist als Savedialog1.filename benutzbar.
    Gib diesen Dateinamen auf dem Label aus.
  5. Um nun den Inhalt der Memokomponente abzuspeichern, müssen wir die Eigenschaft memo1.lines.savetofile() benutzen. In die Klammern kommt der Dateiname.
  6. Führe das Programm aus, schreibe einen Text in das Memo, wähle einen Dateiname (am besten mit der Endung "txt" und speichere im Home-Verzeichnis ab.
    Öffne den gespeicherten Text z. B. in Word oder im Notepad-Editor.
  7. Genauso kann das Öffnen einer Datei in eine Memokomponente programmiert werden.
    Lege auf das Formular die Dialog-Komponente Opendialog, einen weiteren Label und einen Button.
  8. Der Programmtext läuft analog: opendialog1.execute und opendialog1.filename von der Dialogkomponente und memo1.lines.loadfromfile() vom Memo werden benötigt:
    opendialog1.execute; //Öffnen-Dialog wird ausgeführt, Dateiname festgelegt
    memo1.Lines.loadfromfile(opendialog1.filename); //Diese Datei wird ins Memo geladen

Brief- und Adressprogramm (Variante 2 - mit speichern)

  1. Ergänze das Briefprogramm um die Fähigkeit zum Speichern des Briefes
  2. Ergänze das Adressprogramm um die Fähigkeit zum Speichern der Adressen und zum Öffnen schon gespeicherter Adresse

Taschenrechner (Variante 1)

Wir wollen die einfachsten Grundrechenarten benutzen können: +, -, * und /

Eingabe: Um Zahlen einzugeben, verwenden wir zwei Edit-Felder.
Verarbeitung: Um etwas zu berechnen, benutzen wir vier Buttons für die Grundrechenarten.
Rechnen können wir aber "nur" mit Zahlen, nicht aber mit Strings
Um rechnen zu können, müssen wir den Inhalt von Edit1.text (einen String) in eine Zahl umwandeln. Dazu stehen zwei Varianten zur Verfügung:
StrToFloat(Edit1.text): Umwandlung von String zu Real-Zahl
StrToInt(Edit1.text): Umwandlung von String zu Integer-Zahl
Dann können wir z. B. addieren: StrToFloat(Edit1.text) + StrToFloat(Edit2.text)
Ausgabe: Das Ergebnis wird in einem Label ausgegeben.
Dazu müssen wir die Zahlen wieder in einen String umwandeln mit:
FloatToStr(): Umwandlung von Real-Zahl zu String
IntToStr(): Umwandlung von Integer-Zahl zu String
Der vollständige Quelltext in der OnClick-Prozedur lautet dann:
label1.text:=FloatToStr(StrToFloat(edit1.text) + StrToFloat(edit2.text));
Analog werden die anderen Buttons programmiert.

Taschenrechner (Variante 2)

Wir wollen einen einfachen Taschenrechner programmieren, um die Syntax im Delphi-Quelltext einzuüben und um die neue Struktur "If ... then ..." einzuführen.

Schau Dir zuerst das Programm Taschenrechner 1.0 an und überlege, was jeweils beim Drücken der Buttons jeweils geschieht.
Erstelle dasselbe Formular und gib den Komponenten verständliche Bezeichnungen.
Versuche dich nun am Quelltext. Arbeite mit einer Hilfsvariablem vom Typ Integer, die den Wert 0 zugewiesen bekommt, wenn der +-Button gedrückt wird, den Wert 1 beim ...
Wenn Du auf Probleme der Art "Wenn der +-Button gedrückt wird, dann ..." stößt, dann entspricht das dem Pascal-Quelltext "if ... then ...".
Vergleiche deine Versuche mit dem Quelltext von Taschenrechner 1.0.

Taschenrechner (Variante 3)

Bedeutend schwieriger ist die nächste Version Taschenrechner 2.0. Beantworte bitte folgende Fragen ausführlich:

Was ändert sich?
Was geschieht beim Drücken von Zahlen?
Was geschieht beim Drücken der Rechenoperatoren?

Als kleine Herausforderung kannst du dich am Nachbau dieses Programms versuchen.
(Tipp: An eine bestehende String-Variable string1 kann man mit folgender Zuweisung noch etwas, z. B. die "5", anhängen: string1:=string1+'5';)