Einführung in dieSoftware-Entwicklung mit
Delphi Teil 3
Klaus Becker
2005
2 Miniprojekt „Roboter“
1 2 3 4
Komplexere Datenmodelle entwerfen Datensammlungen mit Datenstrukturen beschreiben Grafiken mit vordefinierten Objekten erzeugen
3 Teil 1
Erzeugung von Grafiken
4 Zielsetzung
Ziel ist es zunächst, ganz einfache Grafiken mit Hilfe vordefinierter Delphi-Komponenten zu erzeugen.
5 Benutzungsoberfläche
Mit Hilfe eines Buttons soll die gewünschte Grafik auf einer vorgegebenen Zeichenfläche erzeugt werden.
BZeichnen: TButton
IZeichnen: TImage
6 Ereignisverarbeitung
procedure TForm1.FormCreate(Sender: TObject);beginIZeichnen.Canvas.Pen.Color := clWhite;IZeichnen.Canvas.Brush.Color := clYellow;IZeichnen.Canvas.Rectangle (0,0,IZeichnen.Width,IZeichnen.Height);end;
procedure TForm1.BZeichnenClick(Sender: TObject);beginIZeichnen.Canvas.Pen.Color := clBlack;IZeichnen.Canvas.Rectangle(20,40,100,100);IZeichnen.Canvas.Pen.Color := clRed;IZeichnen.Canvas.Brush.Color := clRed;IZeichnen.Canvas.Rectangle(200,300,250,350);end;
BZeichnen: TButton
IZeichnen: TImage
7 Objekthierarchie
IZeichnen: TImage
Width = 400Height = 400Canvas = ...
: TCanvas
Pen =Brush = ...
Rectangle(...)...
: TPen
Color = clWhite...
: TBrush
Color = clYellow...
procedure TForm1.FormCreate(Sender: TObject);beginIZeichnen.Canvas.Pen.Color := clWhite;IZeichnen.Canvas.Brush.Color := clYellow;IZeichnen.Canvas.Rectangle (0,0,IZeichnen.Width,IZeichnen.Height); end;
procedure TForm1.BZeichnenClick(Sender: TObject);beginIZeichnen.Canvas.Pen.Color := clBlack;IZeichnen.Canvas.Rectangle(20,40,100,100);IZeichnen.Canvas.Pen.Color := clRed;IZeichnen.Canvas.Brush.Color := clRed;IZeichnen.Canvas.Rectangle(200,300,250,350); end;
400 400 (400,400)
(0,0)
Rahmen: weiß
Fläche: gelb
8 Objekthierarchie
IZeichnen: TImage
Width = 400Height = 400Canvas = ...
: TCanvas
Pen =Brush = ...
Rectangle(...)LineTo(...)FloodFill(...)...
: TPen
Color = clWhiteWidth = 1...
: TBrush
Color = clYellowStyle = bsSolid ...
Bildkomponente
Leinwand Zeichenstift Malpinsel
Das Bild-Objekt IZeichnen verwaltet über das Attribut Canvas ein Leinwand-Objekt der Klasse TCanvas, das wiederum über Attribute ein Zeichenstift-Objekt der Klasse TPen und ein Malpinsel-Objekt der Klasse TBrush verwaltet. Das genaue Verhalten der einzelnen Objekte kann man in der Delphi-Hilfe nachschlagen.
Ein Objekt kann mit Hilfe eines sog. Referenzattributs auf ein anderes Objekt zugreifen.
9 Punktnotation
IZeichnen: TImage
Width = 400Height = 400Canvas = ...
: TCanvas
Pen =Brush = ...
Rectangle(...)LineTo(...)FloodFill(...)...
: TPen
Color = clWhiteWidth = 1...
: TBrush
Color = clYellowStyle = bsSolid ...
Bildkomponente
Leinwand Zeichenstift Malpinsel
IZeichnen.Canvas.Pen.Color := clWhite;IZeichnen.Canvas.Brush.Color := clYellow;IZeichnen.Canvas.Rectangle(0,0,IZeichnen.Width,IZeichnen.Height);
Beim Zugriff auf Operationen / Methoden eines in der Hierarchie untergeordneten Objekts muss der gesamte Zugriffspfad angegeben werden.
10 With-Anweisung
IZeichnen: TImage
Width = 400Height = 400Canvas = ...
: TCanvas
Pen =Brush = ...
Rectangle(...)LineTo(...)MoveTo(...)FloodFill(...)...
: TPen
Color = clWhiteWidth = 1...
: TBrush
Color = clYellowStyle = bsSolid ...
IZeichnen.Canvas.Pen.Color := clWhite;IZeichnen.Canvas.Brush.Color := clYellow;IZeichnen.Canvas.Rectangle(0,0,IZeichnen.Width,IZeichnen.Height);
with IZeichnen.Canvas do begin Pen.Color := clWhite; Brush.Color := clYellow; Rectangle(0,0,IZeichnen.Width,IZeichnen.Height); end;
11 Aufgabe
Das Zeichenprogramm soll ein Gitternetz aus 10x10 Zellen der Breite 40 erstellen, bei dem die Zellen blau umrahmt sind.
12 Aufgabe
Das Zeichenprogramm soll um ein schwarzes Dreieck ergänzt werden, das sich in der oberen linken Zelle befindet und nach unten zeigt.Version 1: Das Dreieck ist nicht ausgefüllt.Version 2: Das Dreieck ist schwarz ausgefüllt.
13
procedure TForm1.BZeichnenClick(Sender: TObject); var i, j: integer;begin// Gitter zeichnenwith IZeichnen.Canvas do begin Pen.Color := clBlue; Brush.Color := clWhite; for i := 0 to 9 do for j := 0 to 9 do Rectangle(i*40, j*40, (i+1)*40, (j+1)*40); end;// Dreieck ergänzenwith IZeichnen.Canvas do begin Pen.Color := clBlack; Brush.Color := clBlack; Brush.Style := bsSolid; MoveTo(0*40, 0*40); LineTo(0*40 + 20, 1*40); LineTo(1*40, 0*40); LineTo(0*40, 0*40); FloodFill((0+40) div 2, 0*40+2, clBlack, fsBorder); end;end;
Wachsender Quellcode
zellenweltZeichnen;
dreieckSueden (0,0,40,40);
14 Spezifikation von Hilfsprozeduren
Die Prozedur soll ein Gitternetz aus 10x10 Zellen der Breite 40 zeichnen, bei dem jede Zelle blau umrahmt ist.
procedure zellenweltZeichnen;
15 Spezifikation von Hilfsprozeduren
Die Prozedur soll ein schwarz gefärbtes Dreieck zeichnen, das nach Osten zeigt. Die Lage des Dreiecks soll durch Parameter zur Beschreibung der linken oberen und rechten unteren Ecke einer gedachten Zelle festgelegt werden.
procedure dreieckOsten(x1, y1, x2, y2: integer);
dreieckOsten(240, 0, 280, 40);
(240,0)
(280,40)
Gedachte Zelle
16 Aufgabe
Implementieren und testen Sie die spezifizierten Prozeduren „zellenweltZeichnen“ und „dreieckOsten“. Entwickeln Sie analog Prozeduren, mit denen man Dreiecke, die nach Süden bzw. Westen bzw. Norden zeigen.
17 Spezifikation von Hilfsprozeduren
procedure dreieckOsten(x1, y1, x2, y2: integer);procedure dreieckSueden(x1, y1, x2, y2: integer);procedure dreieckWesten(x1, y1, x2, y2: integer);procedure dreieckNorden(x1, y1, x2, y2: integer);
dreieckOsten(240, 0, 280, 40);
dreieckWesten(320, 40, 360, 80);
dreieckNorden(160, 120, 200, 160);
dreieckSueden(120, 320, 160, 360);
18
Implementierung von Hilfsprozeduren
procedure TForm1.dreieckOsten(x1, y1, x2, y2: integer);beginwith IZeichnen.Canvas do begin Pen.Color := clBlack; Brush.Color := clBlack; Brush.Style := bsSolid; MoveTo(x1, y1); LineTo(x2, (y1+y2) div 2); LineTo(x1, y2); LineTo(x1, y1); FloodFill(x1+2, (y1+y2) div 2, clBlack, fsBorder); end;end;
19 Teil 2
Modellierung des Roboters
20 Zielsetzung
Ziel ist es, ein grafisches Simulationsprogramm zu entwickeln, mit dem ein steuerbarer Modellroboter in einem Zellengitter bewegt werden kann.
21 Eigenschaften des Roboters
Der Roboter befindet sich in einer Zelle (z. B. in der Zelle (6,4)) und schaut in eine bestimmte Richtung (z. B. nach Osten).
(0,0)(1,0)(2,0)(3,0)
(0,1)(1,1)(2,1)(3,1)
(0,2)(1,2)(2,2)(3,2)
(0,3)(1,3)(2,3)(3,3)
OstenWesten
Norden
Süden
22 Datenmodell zum Roboter
OstenWesten
Süden
Norden
(6,4)
4roboter: osten
richtung
6
xpos ypos
Der Roboter befindet sich in einer Zelle (z. B. in der Zelle (6,4)) und schaut in eine bestimmte Richtung (z. B. nach Osten).
23 Daten-Verbund
OstenWesten
Süden
Norden
(6,4)
4roboter: osten
richtung
6
xpos ypos
Verbund
Index
Element
Mit Hilfe der Datenstruktur Verbund werden Daten (die vom unterschiedlichem Typ sein können) zu einer Einheit zusammengefasst.
24 Deklaration eines Verbundes
OstenWesten
type tRichtung = (sueden, westen, norden, osten);
type tRoboter = record xpos: integer; ypos: integer; richtung: tRichtung; end;
... roboter: tRoboter;
Süden
Norden
(6,4)
...roboter: ...
richtung
...
xpos ypos
Verbund
Index
Element
25 Zugriff auf die Elemente
type tRichtung = (sueden, westen, norden, osten);
type tRoboter = record xpos: integer; ypos: integer; richtung: tRichtung; end;
... roboter: tRoboter;
4roboter: osten
richtung
6
xpos ypos
Verbund
Bezeichner
Elementroboter.xpos := 6;roboter.ypos := 4;roboter.richtung := osten;
Der Zugriff erfolgt mit Hilfe der Punktnotation über den Bezeichner (Namen) des Elements.
26 With-Anweisung
type tRichtung = (sueden, westen, norden, osten);
type tRoboter = record xpos: integer; ypos: integer; richtung: tRichtung; end;
... roboter: tRoboter;
4roboter: osten
richtung
6
xpos ypos
Verbund
Bezeichner
Elementroboter.xpos := 6;roboter.ypos := 4;roboter.richtung := osten;
with roboter do begin xpos := 6; ypos := 4; richtung := osten; end;
27 Operationen des Roboters
schritt: Der Roboter geht einen Schritt vorwärts (sofern möglich)links: Der Roboter dreht sich um 90° nach links.rechts:Der Roboter dreht sich um 90° nach rechts.
roboterInitialisieren: Der Roboter befindet sich anschließend in der linken oberen Ecke und schaut nach Süden.
28 Erweitertes Datenmodell
type tRichtung = (sueden, westen, norden, osten);
type tRoboter = record xpos: integer; ypos: integer; richtung: tRichtung; end;
type TForm1 = class(TForm) ... private { Private-Deklarationen } roboter: tRoboter; procedure schritt; procedure linksDrehen; procedure rechtsDrehen; procedure roboterInitialisieren; ...
Erweitertes Datenmodell
29 Aufgabe
Entwickeln Sie erst die Algorithmen für die Roboter-Operationen. Implementieren und testen Sie dann das gesamte bisher entwickelte Robotersystem.Benutzen Sie Hilfsprozeduren zum Zeichnen der Zellenwelt und des Roboters.
30 Hilfsprozeduren zum Zeichnen
... {private Deklarationen} roboter: tRoboter; procedure schritt; procedure linksDrehen; procedure rechtsDrehen; procedure roboterInitialisieren; procedure zellenweltZeichnen; // zeichnet das Zellengitter procedure roboterZeichnen; // zeichnet d. aktuellen Roboterzustand
procedure TForm1.FormCreate(Sender: TObject);begin// Datenmodell initialisierenroboterInitialisieren;// Anzeige aktualisierenzellenweltZeichnen;roboterZeichnen;end;
31 Teil 3
Modellierung der Welt
32 Zielsetzung
Der Modellroboter soll in der Zellenwelt Marken und Ziegel ablegen bzw. aufheben können.
33 Zellenwelt mit Ziegel und Marken
Stapel mit 7 Ziegeln, darauf
eine Marke
Stapel mit 4 Ziegeln
Stapel mit 1 Ziegel
Zelle mit Marke
Zelle ohne Ziegel und ohne Marke
34 Zellenwelt mit Ziegel und Marken
Das Robotersystem soll folgende Eigenschaften haben:
/1/ In jeder Zelle können beliebig viele Ziegel gestapelt werden.
/2/ Der Roboter befindet sich beim Hinlegen und Aufheben eines Ziegels in der betreffenden Zelle (hier anders als bei Karol).
/3/ Der Roboter kann über beliebig hohe Ziegelstapel wandern.
/4/ Pro Zelle kann nur eine Marke abgelegt werden. Sie wird immer oben auf einem evtl. vorhandenen Ziegelstapel angezeigt.
...
35 Datenmodellierung
f
marken:
f f f f f
1 2 3 4 5 6
f
0
f f f
7 8 9
f f f f f ff f f f
t f f f f ff f f f
f f f t f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
0
1
2
3
4
5
6
7
8
9
Index Element
Index
Mit Hilfe der Datenstruktur Reihung werden gleichartige Daten (die also vom gleichen Typ sind) zu einer Einheit zusammengefasst.
36 Datenmodellierung
0
ziegel:
0 0 0 0 0
1 2 3 4 5 6
0
0
0 0 0
7 8 9
0 0 0 1 0 00 0 0 0
0 4 0 0 0 00 0 0 0
0
1
2
3
4
5
6
7
8
9
Index
Index
Mit Hilfe der Datenstruktur Reihung werden gleichartige Daten (die also vom gleichen Typ sind) zu einer Einheit zusammengefasst.
0 0 0 7 0 00 0 0 0
0 0 0 0 0 00 0 0 0
0 0 0 0 0 00 0 0 0
0 0 0 0 0 00 0 0 0
0 0 0 0 0 00 0 0 0
0 0 0 0 0 00 0 0 0
0 0 0 0 0 00 0 0 0
Element
37 Reihung von Reihungen
type tMarkenbelegung = array [0..9] of array [0..9] of boolean;
... marken: tMarkenbelegung;
f
marken:
f f f f f
1 2 3 4 5 6
f
0
f f f
7 8 9
f f f f f ff f f f
t f f f f ff f f f
f f f t f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
0
1
2
3
4
5
6
7
8
9
Reihung von Reihungen
38 Mehrdimensionale Reihung
type tMarkenbelegung = array [0..9, 0..9] of boolean;
... marken: tMarkenbelegung;
f
marken:
f f f f f
1 2 3 4 5 6
f
0
f f f
7 8 9
f f f f f ff f f f
t f f f f ff f f f
f f f t f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
0
1
2
3
4
5
6
7
8
9
2-dimensionale Reihung
39 Zugriff auf Elemente
type tMarkenbelegung = array [0..9] of array [0..9] of boolean;
... marken: tMarkenbelegung;
f
marken:
f f f f f
1 2 3 4 5 6
f
0
f f f
7 8 9
f f f f f ff f f f
t f f f f ff f f f
f f f t f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
0
1
2
3
4
5
6
7
8
9
Reihung von Reihungen
marken[1][2]
40 Zugriff auf Elemente
type tMarkenbelegung = array [0..9, 0..9] of boolean;
... marken: tMarkenbelegung;
f
marken:
f f f f f
1 2 3 4 5 6
f
0
f f f
7 8 9
f f f f f ff f f f
t f f f f ff f f f
f f f t f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
0
1
2
3
4
5
6
7
8
9
marken[1,2]
2-dimensionale Reihung
41
Operationen zur Veränderung der Welt
markeSetzen: In der aktuellen Zelle wird eine Marke gesetzt.markeLoeschen: Die Marke in der aktuellen Zelle wird gelöscht (falls vorhanden).hinlegen: In der aktuellen Zelle wird ein Ziegel auf den Stapel gelegt.aufheben: In der aktuellen Zelle wird ein Ziegel vom Stapel genommen (falls möglich).
Beachte:Die aufgeführten Operationen sind Operationen des Roboters. Mit „aktueller Zelle“ ist die Zelle gemeint, in der sich der Roboter aktuell befindet.
42 Erweitertes Datenmodell
markeSetzen: In der aktuellen Zelle wird eine Marke gesetzt.markeLoeschen: Die Marke in der aktuellen Zelle wird gelöscht (falls vorhanden).hinlegen: In der aktuellen Zelle wird ein Ziegel auf den Stapel gelegt.aufheben: In der aktuellen Zelle wird ein Ziegel vom Stapel genommen (falls möglich).
roboter: tRoboter;marken: tMarkenbelegung;ziegel: tZiegelbelegung;
procedure roboterInitialisieren;procedure weltInitialisieren;procedure schritt;procedure linksDrehen;procedure rechtsDrehen;procedure markeSetzen;procedure markeLoeschen;procedure hinlegen;procedure aufheben;
43 Initialisierung der Welt
procedure TForm1.weltInitialisieren; var i, j: integer;beginfor i := 0 to 9 do for j := 0 to 9 do begin marken[i,j] := false; ziegel[i,j] := 0; end;end;
44 Aufgabe
Implementieren und testen Sie das gesamte bisher entwickelte Robotersystem.
45 Schachtelung von Datenstrukturen
f
marken
f f f f f
1 2 3 4 5 6
f
0
f f f
7 8 9
f f f f f ff f f f
t f f f f ff f f f
f f f t f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
0
1
2
3
4
5
6
7
8
9
0
ziegel
0 0 0 0 0
1 2 3 4 5 6
0
0
0 0 0
7 8 9
0 0 0 1 0 00 0 0 0
0 4 0 0 0 00 0 0 0
0
1
2
3
4
5
6
7
8
9
0 0 0 7 0 00 0 0 0
0 0 0 0 0 00 0 0 0
0 0 0 0 0 00 0 0 0
0 0 0 0 0 00 0 0 0
0 0 0 0 0 00 0 0 0
0 0 0 0 0 00 0 0 0
0 0 0 0 0 00 0 0 0
welt:
Die Datensammlung ist als Verbund von zwei mehrdimensionalen Reihungen konzipiert.
46 Modifikation des Datenmodells
type tMarkenbelegung = array [0..9, 0..9] of boolean;
type tZiegelbelegung = array [0..9, 0..9] of integer;
type tWelt = record marken: tMarkenbelegung; ziegel: tZiegelbelegung; end;... roboter: tRoboter; welt: tWelt; procedure roboterInitialisieren; procedure weltInitialisieren; procedure schritt; procedure linksDrehen; procedure rechtsDrehen; procedure markeSetzen; procedure markeLoeschen; procedure hinlegen; procedure aufheben;
Schachtelung von Datenstrukturen
47 Initialisierung der Welt
type tMarkenbelegung = array [0..9, 0..9] of boolean; tZiegelbelegung = array [0..9, 0..9] of integer; tWelt = record marken: tMarkenbelegung; ziegel: tZiegelbelegung; end;... ... welt: tWelt; procedure weltInitialisieren; ...
procedure TForm1.weltInitialisieren; var i, j: integer;beginfor i := 0 to 9 do for j := 0 to 9 do begin welt.marken[i,j] := false; welt.ziegel[i,j] := 0; end;end;
48 Aufgabe
Implementieren und testen Sie das modifizierte Robotersystem.
49
Datensammlung mit variabler Größe
Die Größe der Welt soll jetzt nicht mehr im Vorfeld auf einen festen Wert festgelegt werden, sondern dynamisch verschiedene Werte annehmen können.
f
marken
f f f f f
1 2 3 4 5 6
f
0
f f f
7 8 9
f f f f f ff f f f
t f f f f ff f f f
f f f t f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
f f f f f ff f f f
0
1
2
3
4
5
6
7
8
9
f
marken
f f f f
1 2 3 4 5
f
0
f f f f ff
t f f f ff
f f f t ff
f f f f ff
f f f f ff
0
1
2
3
4
5
50 Welt mit variabler Größe
type tMarkenbelegung = array of array of boolean;
type tZiegelbelegung = array of array of integer;
type tWelt = record xmax: integer; ymax: integer; marken: tMarkenbelegung; ziegel: tZiegelbelegung; end;
(mehrdimensionaler) dynamischer Array
Die Größe der Welt wird hier mit den Verbund-Elementen xmax und ymax erfasst. Da die Werte für diese Größen bei der Deklaration noch nicht feststehen (und ggf. zur Laufzeit verändert werden), müssen die Reihungen mit dynamischen Arrays implementiert werden.
51 Welt mit variabler Größe
procedure TForm1.weltInitialisieren; var i, j, k: integer;beginwith welt do begin xmax := 9; ymax := 9; SetLength(marken, xmax+1); for k := Low(marken) to High(marken) do SetLength(marken[k], ymax+1); SetLength(ziegel, xmax+1); for k := Low(ziegel) to High(ziegel) do SetLength(ziegel[k], ymax+1); for i := 0 to welt.xmax do for j := 0 to welt.ymax do begin marken[i][j] := false; ziegel[i][j] := 0; end; end;end;
Dimensionierung der Reihungen
Die Dimensionierung der Reihungen wird hier zur Laufzeit festgelegt.
52 Aufgabe
Implementieren und testen Sie das modifizierte Robotersystem.
53 Beliebiges Ausführprogramm
procedure TForm1.programmAusfuehren; var i, j: integer;beginfor i := 1 to 4 do begin for j := 1 to 9 do begin markeSetzen; schritt; end; linksDrehen; end;end;
procedure TForm1.BProgrammAusfuehrenClick(Sender: TObject);begin// Datenmodell aktualisierenprogrammAusfuehren;// Anzeige aktualisierenzellenweltZeichnen;roboterZeichnen;end;
wiederhole 4 mal wiederhole 9 mal MarkeSetzen Schritt *wiederhole LinksDrehen*wiederhole
54 Aufgabe
Erweitern Sie das Robotersystem um die Möglichkeit, beliebige Programme ausführen zu können.
55 Teil 4
Zusammenfassung und Ausblick
56 Datensammlungen
Zur Verwaltung von Datensammlungen benutzt man Datenstrukturen wie „Reihung“ und „Verbund“. Die Datenstrukturen „Reihung“ und „Verbund“ können beliebig geschachtelt werden. Sie eignen sich zur Verwaltung statischer Datensammlungen. Für dynamisch variierende Datensammlungen benötigt man weitere Datenstrukturen (wie Liste, Baum oder Graph).
f
marken
f f f f
1 2 3 4 5
f
0
f f f f ff
t f f f ff
f f f t ff
f f f f ff
f f f f ff
0
1
2
3
4
5
0
ziegel
0 0 0 0
1 2 3 4 5
0
0
0 0 0 1 00
0 4 0 0 00
0
1
2
3
4
5
0 0 0 7 00
0 0 0 0 00
0 0 0 0 00
welt:
57 Objekthierarchien
Objekte verwalten Daten und können in der Regel bestimmte Operationen ausführen. Komplexere Aufgaben werden ggf. auch von mehreren Objekten, die in Beziehung zueinander stehen, in Zusammenarbeit erledigt. Jedes Objekt hat dabei seine spezifischen Zuständigkeiten.
IZeichnen: TImage
Width = 400Height = 400Canvas = ...
: TCanvas
Pen =Brush = ...
Rectangle(...)LineTo(...)FloodFill(...)...
: TPen
Color = clWhiteWidth = 1...
: TBrush
Color = clYellowStyle = bsSolid ...
Bildkomponente
Leinwand Zeichenstift Malpinsel
58
Ausblick: Vom Datenmodell zum Objekt
Bisher wurde die GUI mit Hilfe vordefinierter Objekte erstellt. Ziel wird es sein, auch das Datenmodell zur Miniwelt mit Hilfe von Objekten zu beschreiben. Hierzu müssen dann neue Objekte definiert werden.
type tRoboter = record xpos: integer; ypos: integer; richtung: tRichtung; end;... {private Deklarationen} roboter: tRoboter; procedure schritt; procedure linksDrehen; procedure rechtsDrehen; procedure roboterInitialisieren;
roboter: TRoboter
xPos =yPos = richtung =
schrittlinksDrehenrechtsDreheninitialisieren
59 Teil 5
Didaktische Bemerkungen
60 Unterrichtsreihen mit Miniprojekten
Grundlagen der Software-Entwicklung lernt man, indem man Software entwickelt. Hierzu eignen sich überschaubare Miniprojekte, bei denen spezifische Probleme einer Software-Entwicklung systematisch bearbeitet werden können.
1 2 3 4
Miniprojekt mit systematischen
Vertiefungen
Systematischer Lehrgang mit illustrierenden
Beispielen
61 Kleine Systeme
„Kleine Systeme“ haben den Vorteil, dass sie vollständig überschaut und durchschaut werden können. Bei einer Software-Entwicklung lassen sich oft Systeme ausgehend von kleinen Systemen schrittweise entwickeln.
62 Konzepte statt Rezepte
Bei der Entwicklung von Software-Lösungen sollten fundamentale Fachkonzepte im Vordergrund stehen, nicht singuläre Rezepte zur Gewinnung von Teillösungen.
PKonto: TPanel
PKonto: TPanel
Caption = ´Konto´Left = 223...
Klasse
AttributAttributwert
Name
Objektdiagramm
Der Aufbau eines Objekts wird mit Hilfe von Attributen (Eigenschaften) festgelegt. Die Attributwerte legen den aktuellen Objektzustand fest.
So erstellt man mit Delphi ein Formular:...
63 Objektterminologie von Anfang an
Die Objektterminologie sollte von Anfang an korrekt benutzt werden. Insbesondere sollten auch Grundvorstellungen zur objektorientierten Sichtweise frühzeitig entwickelt werden.
IZeichnen: TImage
Width = 400Height = 400Canvas = ...
: TCanvas
Pen =Brush = ...
Rectangle(...)LineTo(...)FloodFill(...)...
: TPen
Color = clWhiteWidth = 1...
: TBrush
Color = clYellowStyle = bsSolid ...
Bildkomponente
Leinwand Zeichenstift Malpinsel
Das Bild-Objekt IZeichnen verwaltet über das Attribut Canvas ein Leinwand-Objekt der Klasse TCanvas, das wiederum über Attribute ein Zeichenstift-Objekt der Klasse TPen und ein Malpinsel-Objekt der Klasse TBrush verwaltet. Das genaue Verhalten der einzelnen Objekte kann man in der Delphi-Hilfe nachschlagen.
64 Entwurfsmuster thematisieren
Entwurfsmuster erleichtern die Entwicklung gut strukturierter Programme. Einfache Muster wie „Eingabe-Verarbeitung-Ausgabe“ und „Trennung zwischen Datenmodell und GUI“ sollten im Unterricht thematisiert und konsequent genutzt werden.
... private { Private-Deklarationen } quelltext: string; geheimtext: string; schluessel: integer; procedure verschluesseln; procedure entschluesseln; procedure vorbereiten;
...
65 Komponenten nach Bedarf
Komponenten sollten nach Bedarf eingeführt, nicht zum Selbstzweck oder auf Vorrat. Der Bedarf richtet sich dabei nach den Wünschen bei der Ausgestaltung des Miniprojektes. Oft ist es sinnvoll, bescheidenere Wünsche zu realisieren als sich im Erfüllen perfektionistischer Anforderungen zu verlieren.
Die Programmoberfläche soll benutzerfreundlicher gestaltet werden:
/1/ Bei der Auswahl des Schlüssels sollen die zur Verfügung stehenden Möglichkeiten voreingestellt sein.
/2/ Für die Eingabe des Quelltextes soll ein mehrzeiliges Eingabefeld zur Verfügung stehen.
/3/ Texte sollen auch geladen und gespeichert werden können.
66 Hilfesysteme nutzen
Detailinformationen zur Implementierung kann man sich oft mit einem integrierten Hilfesystem besorgen. Damit Lerner eigenständig solche Hilfesysteme nutzen können, sollte das Lesen von Schnittstellenbeschreibungen frühzeitig gezielt gefördert werden.
procedure Delete(var S: string; Index, Count: integer);
Beschreibung:Delete entfernt, beginnend mit S[Index], Count Zeichen aus dem String S. Ist der Wert von Index größer als die Länge von S, werden keine Zeichen gelöscht. Werden mit Count mehr Zeichen angegeben, als beginnend bei S[Index] im String vorhanden sind, wird der Rest des Strings gelöscht.
Beispiel:{Wort: 'Delphibuch'}Delete(Wort, 4, 3);{Wort: 'Delbuch'}
Delphi-Hilfe
67 Jeder macht Fehler
Da jeder beim Programmieren Fehler macht (manche immer dieselben – lernfähige immer wieder neue), sollten typische Fehlermuster und systematische Fehlersuchmethoden erarbeitet werden. Wir untersuchen das Laufzeitverhalten des Programms mit dem Delphi-Debugger.
Einzelne Anweisung
Gesamte Routine
{quelltext: 'Obelix'}
i := 2;
quelle := quelltext[2];
{quelle: 'b'}
geheim := kodierung[quelle];
{geheim: ?} Bereichsüberschreitung
68 Strukturierung vermeidet Fehler
Zur Vermeidung von Fehlern empfiehlt es sich, Programmtexte klar zu strukturieren. Hierzu gehört u. a.,
- Bezeichner sinnvoll zu wählen,
- Programmtext systematisch einzurücken,
- Kommentare einzufügen.
69 Teil 6
Übungen zur Vertiefung
70 Aufgabe
Erweitern Sie die Möglichkeiten von Karol und seiner Welt nach eigenen Wünschen und Ideen.z. B.:Die Welt von Karol wird bunter. Neben roten Ziegeln gibt es auch blaue und grüne ...
71 Aufgabe
Karol soll eine Irrfahrt in seiner Welt simulieren. Er startet in der Mitte der Welt. Jedes mal, wenn man einen Button drückt, bestimmt Karol mit einem geeigneten Zufallsgerät eine neue Himmelsrichtung und geht dann einen Schritt in diese Richtung. Zusatz: Es wird eine Statistik angefertigt, wie oft Karol die Zellen der Welt besucht hat.
72 Aufgabe
Ziel ist es, eine Schildkröte (turtle) auf dem Bildschirm zu steuern. Die Schildkröte kann eine beliebig vorgegebene Strecke vorwärts / rückwärts laufen, sich sich beliebig nach rechts / links drehen. Auf Wunsch hinterlässt sie eine Spur auf ihrem Weg durch ihre Welt.
Zeichen-fläche
Turtlespur
Turtle
73 Literaturhinweise
E. Modrow: Informatik mit Delphi, Band 1/2, Dümmler-Stam 1998-2000.
P. Damann, J. Wemßen: Objektorientierte Programmierung mit Delphi, Band 1. Klett-Verlag 2001.
U. Bänisch: Praktische Informatik mit Delphi, Band 1/2. Cornelsen 2001.
Frischalowski: Delphi 5.0, Band 1/2, Herdt-Verlag 1999.
Pohl: Schülerübungen / Klausuren in Delphi, Heft 1/2, Verlag J. Pohl 1997-2001.
Noll, Mayr, Paulus, Selinger: http://informatikag.bildung-rp.de/html/delphi_teil_1.html
K. Merkert:http://hsg.region-kaiserslautern.de/faecher/inf/material/delphi/index.php
R. Mechling:http://www.gk-informatik.de/
K. Heidler:http://www.friedrich.fr.schule-bw.de/delphi/delphi.htm
Hessischer Bildungsserver:http://www.bildung.hessen.de/abereich/inform/skii/material/delphi/index.htm
74 Literaturhinweise
S. Spolwig: http://oszhdl.be.schule.de/gymnasium/faecher/informatik/delphi/index.htm
Weitere Hinweise unter:
http://www.delphi-source.de
Einsteiger-Tutorial
http://www.delphi-treff.de/content/tutorials/einsteigerkurs/
...