Einführung in die Programmiersprache DELPHI - g · PDF fileI Einstieg in Delphi I.1...

G. KAMLEITERG. KAMLEITER

INFORMATIKINFORMATIKKurs 11Kurs 11

Einführung in DELPHIEinführung in DELPHI

SJ 2004/05SJ 2004/05

LGG * DARMSTADTLGG * DARMSTADT

Einführung in die Programmiersprache Delphi - 1 - 2. Dezember 2004 / 20:12:30

InhaltsverzeichnisInhaltsverzeichnis

I EINSTIEG IN DELPHI.................................................................................................................................................4

I.1 Struktur von Delphi Programmen...............................................................................................................................4

I.2Die Delphi-Oberfläche................................................................................................................................................... 4

I.3Das Einmaleins der Delphi Programmierung..............................................................................................................5

I.3.1Einstiegsbeispiel 1: Farbige Fenster............................................................................................................5

I.3.2Einstiegsbeispiel 2: Ein Button steuert die Farben......................................................................................5

I.3.3 Einstiegsbeispiel 3: Die Ampel.................................................................................................................. 6

I.3.4Einstiegsbeispiel 5: Der Währungsrechner................................................................................................. 8

I.4 Objektorientierte Programmierung........................................................................................................................... 9

II DATEIEN...................................................................................................................................................................... 10


AbbildungsverzeichnisAbbildungsverzeichnis


I I Einstieg in DelphiEinstieg in Delphi

I.1I.1 Struktur von Delphi ProgrammenStruktur von Delphi Programmen

Jedes Delphi Programm besteht aus • einem automatisch erzeugten Hauptprogramm• den genutzten System-Units• den eigenen Units• den angelegten Formularen• und Ressourcen

• Unter dem Programmnamen und der Dateierweiterung .DPR (=Delphi Projekt) wird der Programmquelltext gespeichert.

• Formulare werden in codierter Form in DFM (=Delphi ForMular) Dateien gespeichert. {$R *.DFM} sorgt für dasLaden des Formulars.

• Delphi erzeugt automatisch eine Ressourcendatei (*.RES), die das Symbol der Anwendung enthält.• Projektoptionendatei .DOF (Delphi Options File) Compiler und Linker Einstellungen• Desktop-Einstallungen: .DSK (DeSkTop), Arbeitseinstellungen, Fenster,...

Beim Speichern eines neuen Projekts oder beim Kopieren auf Diskette muss man sowohl die Unit- als auch dieProjekt-Datei speichern!!!

I.2I.2Die Delphi-OberflächeDie Delphi-Oberfläche

Die Arbeitsumgebung in Delphi wird als integrierte Entwicklungsumgebung (auch IDE) bezeichnet. In dieserUmgebung sind alle Werkzeuge zusammengefasst, die zur Programmentwicklung benötigt werden. Nach dem Startbefinden sich 4 Fenster auf dem Bildschirm:

• das Hauptfenster (1) zum Steuern von Delphi• der Objektinspektor (2) Gestaltung der Komponenten (Farbe, Größe,...)• das Formularfenster Form1 (3) Hauptfenster der Anwendung• das Unitfenster Unit1 (4) Es beinhaltet den Quelltext

Im allgemeinen besteht das Erstellen einer Delphi Anwendung aus fünf Schritten:1. Erstellen eines Formulars2. Platzieren der Komponenten auf dem Formularfenster3. Anpassen der Komponenten (Farbe, Größe,...)4. Schreiben des Programmtextes 5. Testen der Anwendung und Fehlerkorrektur


Starten des Programms:Starten des Programms:

Starten eines Programms mit Hilfe der Schaltfläche mit dem grünen Pfeil:

Löschen einer Komponente:Löschen einer Komponente:

1. Markiere die Komponente durch einen Klick2. Drücke die Taste EntfLöschen mehrerer Komponenten:

1. drücken und nacheinander auf alle Komponenten klicken. Es werden alle Komponenten markiert.2. Die Taste Entf drücken

I.3I.3Das Einmaleins der Delphi ProgrammierungDas Einmaleins der Delphi Programmierung

I.3.1I.3.1Einstiegsbeispiel 1: Farbige FensterEinstiegsbeispiel 1: Farbige Fenster

Farbhintergrund des Fensters ändern:Durch Anklicken mit der linken Maustaste machen wir das Fenster Form1 zum aktiven Fenster. Im Objektinspektorwählen wir das Feld Color aus und überschreiben den dortigen Eintrag z.B. mit clblue oder wählen eine der möglichenFarben aus.

Änderung der Beschriftung bzw. Überschrift des Fensters:Änderung der Beschriftung bzw. Überschrift des Fensters:Durch Anklicken mit der linken Maustaste machen wir das Fenster Form1 zum aktiven Fenster. Im Objektinspektorwählen wir das Feld Caption aus und überschreiben den dortigen Eintrag z.B. mit Fenster1

Schriftart ändern:Schriftart ändern:Durch Anklicken mit der linken Maustaste machen wir das Fenster Form1 zum aktiven Fenster. Im Objektinspektorwählen wir das Feld Font aus und wählen im anfgebotenen Fenster eine Schrift mit ihren Eigenschaften. ( Beispiel 1)

Änderung des Icons in der linken oberen Ecke des Formulars:Änderung des Icons in der linken oberen Ecke des Formulars:Durch Anklicken mit der linken Maustaste machen wir das Fenster Form1 zum aktiven Fenster. Im Objektinspektorwählen wir das Feld Icon aus und Doppelklicken auf die leere Spalte liefert einen Dialog zum Laden der Bilder, diegespeichert sind in

C:\Programme\Gemeinsame Dateien\Borland shared\Images\icons

I.3.2I.3.2Einstiegsbeispiel 2: Ein Button steuert die FarbenEinstiegsbeispiel 2: Ein Button steuert die Farben

Im folgenden Beispiel soll die Farbe des Fensters durch Betätigung einer Schaltfläche (Button) jeweils gewechseltwerden.Dazu ziehen wir einen Button von der Ikonleiste auf unser Formular1 durch Doppelklicken auf das Ikon Button. Wirmachen den Button auf dem Formular1 aktiv und klicken ihn doppelt an. Sofort wird in der Unit eine „Leer-Prozedur“zur Behandlung des Anklickens eingefügt:

procedure TForm1.Button1Click(Sender: TObject);begin

end;An der Position des Cursors nach begin fügen wir folgende Pascal-Anweisung ein:

procedure TForm1.Button1Click(Sender: TObject);beginForm1.color:=clRed;end;

Während der Programmausführung wird die Fensterfarbe bei jeder Betätigung des Buttons auf rot gesetzt.


Erweiterung:1. Erweitere das Programm so, dass mit Hilfe von 3 Buttons jeweils das Fenster auf eine von 3 verschiedenen

Farben gesetzt werden kann. ( Beispiel 2 )2. Ändere nach der gleichen Methode die Hintergrundfarbe eines Label-Feldes. ( B eispiel 2 )

I.3.3I.3.3 Einstiegsbeispiel 3: Die AmpelEinstiegsbeispiel 3: Die Ampel

Aufgabe: 1.Schreibe ein Delphi-Programm, das die Funktionsweise einer Ampel

durch manuelle Schaltung simuliert. Zum manuellen Schalten benutztman eine Button-Komponente, die auf das OnClick-Ereignis reagiert.Die zugehörige Ereignisprozedur enthält den Algorithmus zumUmschalten zwischen den Ampelphasen. ( Beispiel 3 )

(Hilfen: Zur Festlegung von Anfangswerten dient eine Prozedur .FormCreate() , die durch Doppelklicken auf das Hauptformular erstelltwerden kann.

2.Erstelle eine Prozedur, die über einen Ende Button das Programm zumLaufzeitmodus korrekt mit close schließt

Beispielprogramm:unit UAmpel;interfaceuses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, ExtCtrls, StdCtrls;type TForm1 = class(TForm) Label1: TLabel; Panel1: TPanel; Shape1: TShape; Shape2: TShape; Shape3: TShape; Schalten: TButton; Ende: TButton; procedure SchaltenClick(Sender: TObject); procedure EndeClick(Sender: TObject); procedure FormCreate(Sender: TObject); private { Private declarations } public { Public declarations } end;var Form1: TForm1; Zustand:Integer;implementation{$R *.DFM}procedure TForm1.SchaltenClick(Sender: TObject);beginCase Zustand of 0: Begin shape1.brush.color:=clred; shape2.brush.color:=clblack; shape3.brush.color:=clblack; Zustand:=Zustand+1; end; 1: begin shape1.brush.color:=clblack;


shape2.brush.color:=clyellow; shape3.brush.color:=clblack; Zustand:=Zustand+1; end; 2: begin shape1.brush.color:=clblack; shape2.brush.color:=clblack; shape3.brush.color:=cllime; Zustand:=0; end;end; {endCase}end;

procedure TForm1.EndeClick(Sender: TObject);beginClose;end;

procedure TForm1.FormCreate(Sender: TObject);beginshape1.brush.color:=clred;shape2.brush.color:=clblack;shape3.brush.color:=clblack;Zustand:=1;end;end.

Mögliche Erweiterungen:1. Schreibe das Programm so um, dass nicht dreimal fast dieselbe Prozedur geschrieben werden muss. ( Case-Anweisung )2. Mit Hilfe einer Timer-Komponente kann die Umschaltung automatisiert werden.

procedure TForm1.Timer1Timer(Sender: TObject);beginZeit:=Zeit+1;case Zeit of 1..5:Zustand:=0; 6 :Zustand:=1; 7..11:Zustand:=2; 12:begin Zustand:=0; Zeit:=0; end;end;SchaltenClick(Sender);end;

Eine weiteres Problem, was in einer Zusatzaufgabe gelöst werden kann, ist die Behandlung der unterschiedlichlangen Phasenlagen bei der Ampel.

3. Simulation einer AmpelkreuzungEine interessante Erweiterung des vorherigen Programms ist das Erstellen eines Programms zur Simulation desVerkehrs an einer Ampelkreuzung.


( Beispiel 4 )(Hintergrund ist das Hauptformular Form1, das die Strasse bildet und graueingefärbt wird; 4 Panels bilden die begrenzenden Wiesen; der CaptionEintrag wird gelöscht, sodass der Panelname verschwindet. Die Mittel-und Querstreifen bilden die shapes auf der Registerkarte additional. Die 4Rennwagen werden als Image von der Registerkarte additional auf dasHauptformular gesetzt und als transparent markiert. Zum Kopieren einerAmpel wird das Panel der bereits erstellten Ampelroutine markiert und mitstrg-C und strg-V in die Zwischenablage kopiert und dann eingefügt. Dererste Timer steuert die verschiedenen Ampelphasen, während der 2. Timersich um die Bewegung der verschiedenen Autos kümmert. Bezugspunktjeweils ist Image.left bzw. Image.top. (Der Ursprung des Koordinatensystems ist immer links oben. ) ( Beispiel 4 verschiedene Versionen )

I.3.4I.3.4Einstiegsbeispiel 5: Der WährungsrechnerEinstiegsbeispiel 5: Der Währungsrechner

Das Formular zur Währungsumrechnung besteht aus zwei Label- und Edit – Komponenten , sowie zwei Button-Komponenten. Die Label weden mit LDM und LEuro bezeichnet, die Edit-Komponenten mit EDM und EEuro. Wiebeim Ampelprogramm gibt es keine Probleme mit der Zuordnung der Variablen zu den Labels und den Edit-Feldern,wenn man den Anfangsbuchstaben L bzw. E zur Unterscheidung hinzufügt.Bei einem Programm in Turbo-Pascal würde man die Zahlen mit Readln einlesen. Beachtet man bei der Eingabe nichtgenau die korrekte Schreibung von Zahlen, so tritt ein Laufzeitfehler auf. In Delphi passiert dies nicht, weil in EDIT-Komponenten grundsätzlich nur Text eingegeben werden kann !!!Die Umwandlung in Zahlen nimmt die Ereignisprozedur vor, welche auf das OnClick-Ereignis des Buttons reagiert. Siebedient sich dabei der Standardprozedur Val.

procedure TUmrechnung.BBeendenClick(Sender: TObject);beginClose;end;

procedure TUmrechnung.BBerechnenClick(Sender: TObject);var DMWert,Eurowert:Real; code:Integer; s:String;

beginVal(EDM.Text,DMWert,code);If code=0 then Eurowert:=DMWert/1.95583;Str(Eurowert:0:2,s);EEuro.Text:=s;end;

procedure TUmrechnung.FormCreate(Sender: TObject);beginEDM.Text:='0';EEuro.text:='0';end;

mögliche Erweiterungen:

1. Die Ereignisprozedur kann so erweitert werden, dass anstelle des Dezimalpunktes auch ein Komma akzeptiert wird.Vor der Umwandlung mit Val muss dazu das Komma im String durch einen Dezimalpunkt ersetzt werden. (Mit derStandard-Funktion Pos lässt sich die Position eines Kommas finden.)

2. Der Währungsumrechner kann auch auf Tastendrücke statt Mauseingaben reagieren. Wird in der Editkomponente


die Eingabetaste gedrückt, so soll umgerechnet werden. Man ordnet dazu bei der EDM-Komponente dem EreignisOnKeyUp eine Ereignisprozedur zu ( hier: GeheWeiter ). ( Beispiel 5 : Pwaehrung3).

procedure TUmrechnung.GeheWeiter(Sender: TObject; var Key: Word; Shift: TShiftState);begin If Key=VK_Return then BBerechnenClick(Sender);end;

3. Projekt TaschenrechenerDas bisher Gelernte lässt sich bei der Erstellung eines kleinen Taschenrecheners überprüfen und festigen. ( Beispiel 6 )

I.4 I.4 Objektorientierte ProgrammierungObjektorientierte Programmierung

Am Beispiel eines kleinen Programms soll der Unterschied in der Programmierungstechnik bei herkömmlichen,imperativen Programmiersprachen, wie Basic, Pascal, Fortran, usw. gegenüber einer konsequent objektorientiertenProgrammiersprache, wie Delphi, Java herausgearbeitet werden.

Aufgabe: Gesucht sind die Lösungen einer quadratischen Gleichung der Form ax²+bx+c=0.

Imperatives Programmieren:Imperatives Programmieren:Um die Aufgabe zu lösen, zerlegt man das gegebene Problem nach dem E-V-A-Prinzip (E-Eingabe-V-Verarbeitung undA-Ausgabe) in 3 Hauptblöcke. Eine weitere Unterteilung zerlegt jeden Block noch einmal in weitere feinere Schritte, dienacheinander abgearbeitet werden können. Am Ende wird das Programm dann zeilenweise abgearbeitet.

Stellt man ein Flussdiagramm des Programms auf, so sieht man deutlich die statische, lineare Programmiertechnik.

Flussdiagramm Struktogramm

Objektorientiertes Programmieren:Objektorientiertes Programmieren:Beim objekorientiertem Programmieren verwendet man die von Booch, Jacobson und Rumbaugh entwickelte sog. UML(=Unified Modeling Language), um Beziehungen zwischen Klassen darzustellen. Rechtecke mit evtl. weiterenUnterteilungen für Methoden tragen die Namen der Klassen. Pfeile repräsentieren die Beziehungen zwischen ihnen.Dabei gliedert sich die moderne Software-Entwicklung grundsätzlich in 5 Phasen:

1.Anforderungsspezifikation - Hier wird festgelegt, welchem Zweck das Programm dienen soll und welcheAufgaben es erfüllen soll.

2.Analyse - In dieser Phase werden Bedienung und Arbeitsweise des Programms ausgearbeitet.

3.Design - Hier werden die Ergebnisse der Analyse ausgewertet und in Klassenspezifikationen umgesetzt. Dabei


ist zu erfassen, welche Klassen (Objekte) benötigt werden, welches die wichtigsten Elemente der Klassen sindund in welchen Beziehungen die Klassen zueinander stehen.

4.Implementation - Das Klassen-design wird in Code umgesetzt

5.Test - Das Programm wird kompiöiert und auf syntaktische und Laufzeitfehler getestet.

Analyse eines kleinen Beispiels ist zu finden in Dirk Louis Peter Müller „Java 2“ S. 320 ff.

Gute UML-basierte CASE-Tools sind:

Rational Rose (http://www.rational.com)

ObjectiF (http://www.microtool.de)

ArgoUML (http://argouml.tigris.org)


II II Grafik Grafik

II.1 II.1 Einführung Einführung

Windows ist Grafik pur. Einen Unterschied zwischen Text- und Grafikmodus, wie unter DOS, gibt es nicht mehr, daauch Text als eine spezielle Form von Grafik aufgefasst wird. Delphi bietet für die Grafikprogrammierung folgendegrundsätzliche Varianten:

1. Anzeige von vorgefertigten „Grafikdateien“ (z.B. *.bmp, *.wmf) in speziellen Container-Komponenten(z.B. Image, Paintbox,..)

2. Verwendung von shape-Komponenten (z.B. Rechteck, Ellipse,...)

3. Einsatz von Grafik-Methoden (z.B. LineTo, Ellipse, Draw,...) auf dem Canvas (Leinwand) einerKomponente ( Form, Image, Bitmap, Printer,...)

4. Direkter Zugriff auf die Windows Grafikschnittstelle über GDI-Funktionen

II.2 II.2 Bilder auf dem Image-ObjektBilder auf dem Image-Objekt

Wir wollen schrittweise die Darstellung eines Bildes auf dem Bildschirm mit DELPHI verfolgen. Zur Anzeige vonBildern in Formularen dient das Objekt Image. Ziehen wir also die Komponente Image im Register Zusätzlich durchDoppelklick in die Mitte des leeren Formulars. In diese Komponente wollen wir nun ein fertiges Bild händisch laden.Dazu klicken wir doppelt auf die Fläche Form1 und schreiben den Namen der neuen Prozedur Bilddarstellen hinein.Anschließend ergänzen wir im implementation Teil die neue Prozedur

procedure Bilddarstellen;begin try Bild:=TBitmap.Create; Bild.LoadfromFile('Dilthey.bmp'); Image1.Picture.graphic:=Bild; finally Bild.free; end;end;

und ergänzen unter type die neue Prozedur procedure Bilddarstellen; . Die Deklaration von Image1 vom Typ TImageund die Deklaration der Variablen Bild im var-teil als Tbitmap schließen das Programm ab. Damit können alle WindowsBitmapdateien *.bmp geladen und dargestellt werden.

II.3 II.3 Elementare Zeichenroutinen auf dem Canvas-Objekt Elementare Zeichenroutinen auf dem Canvas-Objekt

II.3.1 II.3.1 Das Canvas-Objekt Das Canvas-Objekt

Grafikelemente gelangten bisher dadurch in die Delphi-Anwendungen, dass vorgezeichnete Bilder (Grafiken) imEntwurfsmodus -eventuell auch zum Laufzeitmodus- in eine Komponente eingefügt wurden. Werden die Grafiken erstzur Laufzeit des Programms, also während der Programmausführung, erstellt, so kann dieses Verfahren nicht verwendetwerden. Der von DOS kommende Umsteiger ist es gewohnt, dass sich Grafikanweisungen stets auf den gesamtenBildschirm beziehen. Zeichnet man in Delphi Grafikelemente, so zeichnet man diese nicht direkt auf das Objekt,sondern immer auf dessen Zeichenfläche (engl. Canvas). Die Leinwand ist eine Eigenschaft der Komponente (desObjekts), ist aber selber wieder ein Objekt, das Eigenschaften und Methoden besitzt. Die wichtigsten grafischenAusgabeobjekte sind das Form-Objekt, die Paintbox- und die Image-Komponente.

Wie zeichnen wir nun auf die Leinwand zur Laufzeit? Dies geschieht in mehreren Schritten (am Beispiel des ObjektsBild):

1. Man zeichnet in der Bildkomponente Bild. Dies ist unser Objekt.

2. Das Objekt Bild besitzt die Eigenschaft Canvas, hat also eine Leinwand, eine Zeichenfläche.Diese Leinwand ist aber wieder ein Objekt, das insbesondere Methoden zum Zeichnen vongeometrischen Figuren besitzt.


3. Zugegriffen wird auf die Leinwand wie auf alle bisherigen Eigenschaften, indem man denNamen des Objekts voranstellt: Bild.Canvas

4. Nun können wir zeichnen, indem wir die Canvas-Methoden z.B. für das Zeichnen einesRechtecks oder einer Linie oder eines Punktes usw. verwenden.

Form1.Canvas.Pen.Color:=clRed; Canvas.Brush.Color:=clYellow; Form1.Image1.Canvas.MovTo(x,y); Bild.Canvas.Rectangle(10,10,30,30);

5. Zum Starten der Zeichnung kann ein Button oder die Prozedur FormCreate dienen, die diebenötigten Befehle aufnehmen.

Zahlreiche Delphi-Komponenten besitzen die Eigenschaft Canvas. Da diese Eigenschaft nur zur Laufzeit des programmsexistiert, können im Objektinspektor keine Einstellungen vorgenommen werden. Man muss sich also die Informationenaus der Hilfedatei beschaffen.

Canvas: Methoden :

Canvas: Eigenschaften


II.3.2 II.3.2 KoordinatensystemeKoordinatensysteme

Will man auf einer Zeichenfläche zeichnen, so muss man wissen, dass die Koordinaten der entsprechenden Punkte in einKoordinatensystem eingezeichnet werden. Dabei liegt der Koordinatenursprung immer links oben, die positive x-Achsezeigt nach rechts und die y-Achse zeigt nach unten. Die Maßeinheit ist das Pixel, d.h. Die Koordinaten sind vom Typinteger.

Mehrere zeichenbefehle auf Canvas fasst man mit der with-Anweisung zusammen: Statt

Canvas.Pen.Color:=clBlack;Canvas.Brush.Color:=clRed;

:kann man auch schreiben

with Canvas do begin Pen.Color:=clBlack; brush.Style:=bsSolid; :

end;


LITERATURLITERATUR1. P.


Einführung in die Programmiersprache DELPHI - g · PDF fileI Einstieg in Delphi I.1...

Documents

Transcript of Einführung in die Programmiersprache DELPHI - g · PDF fileI Einstieg in Delphi I.1...