Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Einführung in die Software-Entwicklung mit Delphi Teil 3

Ähnliche Präsentationen


Präsentation zum Thema: "Einführung in die Software-Entwicklung mit Delphi Teil 3"—  Präsentation transkript:

1 Einführung in die Software-Entwicklung mit Delphi Teil 3
Klaus Becker 2005

2 Miniprojekt „Roboter“
Komplexere Datenmodelle entwerfen Datensammlungen mit Datenstrukturen beschreiben Grafiken mit vordefinierten Objekten erzeugen

3 Erzeugung von Grafiken
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. IZeichnen: TImage BZeichnen: TButton

6 Ereignisverarbeitung
IZeichnen: TImage BZeichnen: TButton procedure TForm1.FormCreate(Sender: TObject); begin IZeichnen.Canvas.Pen.Color := clWhite; IZeichnen.Canvas.Brush.Color := clYellow; IZeichnen.Canvas.Rectangle (0,0,IZeichnen.Width,IZeichnen.Height); end; procedure TForm1.BZeichnenClick(Sender: TObject); begin IZeichnen.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;

7 Objekthierarchie Rahmen: weiß
IZeichnen: TImage : TCanvas : TPen : TBrush Width = 400 Height = 400 Canvas = ... Pen = Brush = ... Color = clWhite ... Color = clYellow ... Rectangle(...) ... Rahmen: weiß procedure TForm1.FormCreate(Sender: TObject); begin IZeichnen.Canvas.Pen.Color := clWhite; IZeichnen.Canvas.Brush.Color := clYellow; IZeichnen.Canvas.Rectangle (0,0,IZeichnen.Width,IZeichnen.Height); end; procedure TForm1.BZeichnenClick(Sender: TObject); begin IZeichnen.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; (0,0) Fläche: gelb 400 400 (400,400)

8 Objekthierarchie Bildkomponente Leinwand Zeichenstift Malpinsel IZeichnen: TImage : TCanvas : TPen : TBrush Width = 400 Height = 400 Canvas = ... Pen = Brush = ... Color = clWhite Width = 1 ... Color = clYellow Style = bsSolid ... Rectangle(...) LineTo(...) FloodFill(...) ... 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 Bildkomponente Leinwand Zeichenstift Malpinsel IZeichnen: TImage : TCanvas : TPen : TBrush Width = 400 Height = 400 Canvas = ... Pen = Brush = ... Color = clWhite Width = 1 ... Color = clYellow Style = bsSolid ... Rectangle(...) LineTo(...) FloodFill(...) ... 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 : TCanvas : TPen : TBrush Width = 400 Height = 400 Canvas = ... Pen = Brush = ... Color = clWhite Width = 1 ... Color = clYellow Style = bsSolid ... Rectangle(...) LineTo(...) MoveTo(...) FloodFill(...) ... 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 Wachsender Quellcode procedure TForm1.BZeichnenClick(Sender: TObject); var i, j: integer; begin // Gitter zeichnen with 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änzen with IZeichnen.Canvas do begin Pen.Color := clBlack; Brush.Color := clBlack; Brush.Style := bsSolid; MoveTo(0*40, 0*40); LineTo(0* , 1*40); LineTo(1*40, 0*40); LineTo(0*40, 0*40); FloodFill((0+40) div 2, 0*40+2, clBlack, fsBorder); end; end; zellenweltZeichnen; dreieckSueden (0,0,40,40);

14 Spezifikation von Hilfsprozeduren
procedure zellenweltZeichnen; Die Prozedur soll ein Gitternetz aus 10x10 Zellen der Breite 40 zeichnen, bei dem jede Zelle blau umrahmt ist.

15 Spezifikation von Hilfsprozeduren
procedure dreieckOsten(x1, y1, x2, y2: integer); 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. (240,0) Gedachte Zelle (280,40) dreieckOsten(240, 0, 280, 40);

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); begin with 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 Modellierung des Roboters
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). Norden (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) Westen Osten Süden

22 Datenmodell zum Roboter
Der Roboter befindet sich in einer Zelle (z. B. in der Zelle (6,4)) und schaut in eine bestimmte Richtung (z. B. nach Osten). Norden (6,4) roboter: 6 4 osten Westen Osten xpos ypos richtung Süden

23 Daten-Verbund Mit Hilfe der Datenstruktur Verbund werden Daten (die vom unterschiedlichem Typ sein können) zu einer Einheit zusammengefasst. Norden Verbund Element (6,4) roboter: 6 4 osten Westen Osten xpos ypos richtung Index Süden

24 Deklaration eines Verbundes
type tRichtung = (sueden, westen, norden, osten); tRoboter = record xpos: integer; ypos: integer; richtung: tRichtung; end; roboter: tRoboter; Norden Verbund Element (6,4) Westen Osten roboter: ... ... ... xpos ypos richtung Index Süden

25 Zugriff auf die Elemente
type tRichtung = (sueden, westen, norden, osten); tRoboter = record xpos: integer; ypos: integer; richtung: tRichtung; end; roboter: tRoboter; roboter.xpos := 6; roboter.ypos := 4; roboter.richtung := osten; Verbund Element roboter: 6 4 osten Der Zugriff erfolgt mit Hilfe der Punktnotation über den Bezeichner (Namen) des Elements. xpos ypos richtung Bezeichner

26 With-Anweisung type tRichtung = (sueden, westen, norden, osten);
tRoboter = record xpos: integer; ypos: integer; richtung: tRichtung; end; roboter: tRoboter; roboter.xpos := 6; roboter.ypos := 4; roboter.richtung := osten; Verbund Element with roboter do begin xpos := 6; ypos := 4; richtung := osten; end; roboter: 6 4 osten xpos ypos richtung Bezeichner

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); 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 initialisieren roboterInitialisieren; // Anzeige aktualisieren zellenweltZeichnen; 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
Zelle mit Marke Stapel mit 1 Ziegel Stapel mit 4 Ziegeln Stapel mit 7 Ziegeln, darauf eine 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 Mit Hilfe der Datenstruktur Reihung werden gleichartige Daten (die also vom gleichen Typ sind) zu einer Einheit zusammengefasst. Index marken: 1 2 3 4 5 6 7 8 9 f f f f f f f f f f 1 f f f f f f f f f f 2 f t f f f f f f f f 3 f f f f t f f f f f 4 f f f f f f f f f f 5 f f f f f f f f f f 6 f f f f f f f f f f 7 f f f f f f f f f f 8 f f f f f f f f f f 9 f f f f f f f f f f Index Element

36 Datenmodellierung Mit Hilfe der Datenstruktur Reihung werden gleichartige Daten (die also vom gleichen Typ sind) zu einer Einheit zusammengefasst. Index ziegel: 1 2 3 4 5 6 7 8 9 1 1 2 4 3 7 4 5 6 7 8 9 Index Element

37 Reihung von Reihungen type
tMarkenbelegung = array [0..9] of array [0..9] of boolean; ... marken: tMarkenbelegung; Reihung von Reihungen marken: 1 2 3 4 5 6 7 8 9 f f f f f f f f f f 1 f f f f f f f f f f 2 f t f f f f f f f f 3 f f f f t f f f f f 4 f f f f f f f f f f 5 f f f f f f f f f f 6 f f f f f f f f f f 7 f f f f f f f f f f 8 f f f f f f f f f f 9 f f f f f f f f f f

38 Mehrdimensionale Reihung
type tMarkenbelegung = array [0..9, 0..9] of boolean; ... marken: tMarkenbelegung; 2-dimensionale Reihung marken: 1 2 3 4 5 6 7 8 9 f f f f f f f f f f 1 f f f f f f f f f f 2 f t f f f f f f f f 3 f f f f t f f f f f 4 f f f f f f f f f f 5 f f f f f f f f f f 6 f f f f f f f f f f 7 f f f f f f f f f f 8 f f f f f f f f f f 9 f f f f f f f f f f

39 Zugriff auf Elemente type
tMarkenbelegung = array [0..9] of array [0..9] of boolean; ... marken: tMarkenbelegung; Reihung von Reihungen marken: 1 2 3 4 5 6 7 8 9 f f f f f f f f f f marken[1][2] 1 f f f f f f f f f f 2 f t f f f f f f f f 3 f f f f t f f f f f 4 f f f f f f f f f f 5 f f f f f f f f f f 6 f f f f f f f f f f 7 f f f f f f f f f f 8 f f f f f f f f f f 9 f f f f f f f f f f

40 2-dimensionale Reihung
Zugriff auf Elemente type tMarkenbelegung = array [0..9, 0..9] of boolean; ... marken: tMarkenbelegung; 2-dimensionale Reihung marken: 1 2 3 4 5 6 7 8 9 f f f f f f f f f f marken[1,2] 1 f f f f f f f f f f 2 f t f f f f f f f f 3 f f f f t f f f f f 4 f f f f f f f f f f 5 f f f f f f f f f f 6 f f f f f f f f f f 7 f f f f f f f f f f 8 f f f f f f f f f f 9 f f f f f f f f f f

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
roboter: tRoboter; marken: tMarkenbelegung; ziegel: tZiegelbelegung; procedure roboterInitialisieren; procedure weltInitialisieren; procedure schritt; procedure linksDrehen; procedure rechtsDrehen; procedure markeSetzen; procedure markeLoeschen; procedure hinlegen; procedure aufheben; 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).

43 Initialisierung der Welt
procedure TForm1.weltInitialisieren; var i, j: integer; begin for i := 0 to 9 do for j := 0 to 9 do marken[i,j] := false; ziegel[i,j] := 0; end;

44 Aufgabe Implementieren und testen Sie das gesamte bisher entwickelte Robotersystem.

45 Schachtelung von Datenstrukturen
welt: 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 f f f f f f f f f f 1 f f f f f f f f f f 1 1 2 f t f f f f f f f f 2 4 3 f f f f t f f f f f 3 7 4 f f f f f f f f f f 4 5 f f f f f f f f f f 5 6 f f f f f f f f f f 6 7 f f f f f f f f f f 7 8 f f f f f f f f f f 8 9 f f f f f f f f f f 9 marken ziegel Die Datensammlung ist als Verbund von zwei mehrdimensionalen Reihungen konzipiert.

46 Modifikation des Datenmodells
type tMarkenbelegung = array [0..9, 0..9] of boolean; tZiegelbelegung = array [0..9, 0..9] of integer; 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; begin for i := 0 to 9 do for j := 0 to 9 do welt.marken[i,j] := false; welt.ziegel[i,j] := 0; end;

48 Aufgabe Implementieren und testen Sie das modifizierte Robotersystem.

49 Datensammlung mit variabler Größe
1 2 3 4 5 6 7 8 9 1 2 3 4 5 f f f f f f f f f f f f f f f f 1 f f f f f f f f f f 1 f f f f f f 2 f t f f f f f f f f 2 f t f f f f 3 f f f f t f f f f f 3 f f f f t f 4 f f f f f f f f f f 4 f f f f f f 5 f f f f f f f f f f 5 f f f f f f 6 f f f f f f f f f f marken 7 f f f f f f f f f f 8 f f f f f f f f f f 9 f f f f f f f f f f marken Die Größe der Welt soll jetzt nicht mehr im Vorfeld auf einen festen Wert festgelegt werden, sondern dynamisch verschiedene Werte annehmen können.

50 Welt mit variabler Größe
type tMarkenbelegung = array of array of boolean; tZiegelbelegung = array of array of integer; 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; begin with welt do 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 marken[i][j] := false; ziegel[i][j] := 0; 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.BProgrammAusfuehrenClick(Sender: TObject); begin // Datenmodell aktualisieren programmAusfuehren; // Anzeige aktualisieren zellenweltZeichnen; roboterZeichnen; end; procedure TForm1.programmAusfuehren; var i, j: integer; begin for i := 1 to 4 do for j := 1 to 9 do markeSetzen; schritt; end; linksDrehen; 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 Zusammenfassung und Ausblick
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). welt: 1 2 3 4 5 1 2 3 4 5 f f f f f f 1 f f f f f f 1 1 2 f t f f f f 2 4 3 f f f f t f 3 7 4 f f f f f f 4 5 f f f f f f 5 marken ziegel

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. Bildkomponente Leinwand Zeichenstift Malpinsel IZeichnen: TImage : TCanvas : TPen : TBrush Width = 400 Height = 400 Canvas = ... Pen = Brush = ... Color = clWhite Width = 1 ... Color = clYellow Style = bsSolid ... Rectangle(...) LineTo(...) FloodFill(...) ...

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 = schritt linksDrehen rechtsDrehen initialisieren

59 Didaktische Bemerkungen
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. 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. 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: ... Name Klasse PKonto: TPanel Caption = ´Konto´ Left = 223 ... Attribut Attributwert PKonto: TPanel Objektdiagramm

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. Bildkomponente Leinwand Zeichenstift Malpinsel IZeichnen: TImage : TCanvas : TPen : TBrush Width = 400 Height = 400 Canvas = ... Pen = Brush = ... Color = clWhite Width = 1 ... Color = clYellow Style = bsSolid ... Rectangle(...) LineTo(...) FloodFill(...) ... 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 Bereichsüberschreitung
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 Übungen zur Vertiefung
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 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 Noll, Mayr, Paulus, Selinger: K. Merkert: R. Mechling: K. Heidler: Hessischer Bildungsserver:

74 Literaturhinweise S. Spolwig: Weitere Hinweise unter: Einsteiger-Tutorial ...


Herunterladen ppt "Einführung in die Software-Entwicklung mit Delphi Teil 3"

Ähnliche Präsentationen


Google-Anzeigen