Erganzungen zum Buch

Dietmar Ratz, Jens Scheffler, Detlef Seese, Jan Wiesenberger

Grundkurs Programmieren in Java

Band 2: Einfuhrung in die Programmierung kommerzieller Systeme

Inhaltsverzeichnis

1 Zum Aufwarmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.1 Schach dem Computer! . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.1.1 Aufgabenstellung . . . . . . . . . . . . . . . . . . . . . . . . . 61.1.2 Designphase . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.1.3 Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . 10

1.1.3.1 Das Schachbrett an sich . . . . . . . . . . . . . . . . 101.1.3.2 Die Klasse AbstractChessman . . . . . . . . . . 141.1.3.3 Konig, Dame, Turm und Laufer . . . . . . . . . . . 161.1.3.4 Von Bauern und Pferden . . . . . . . . . . . . . . . 211.1.3.5 Zur Wiederholung: die Klassen GameModel und

GameEngine . . . . . . . . . . . . . . . . . . . . . . 251.1.3.6 Die Schnittstelle zum Benutzer . . . . . . . . . . . . 29

1.1.4 Das Programm im Uberblick . . . . . . . . . . . . . . . . . . 351.1.5 Ubungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . 36

1.2 Nichts als Probleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361.2.1 Aufgabenstellung . . . . . . . . . . . . . . . . . . . . . . . . . 361.2.2 Designphase . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371.2.3 Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . 39

1.2.3.1 Scenario und CollectionOfFailures . . . . 391.2.3.2 Die Klasse Solver . . . . . . . . . . . . . . . . . . 42

1.2.4 Das Programm im Uberblick . . . . . . . . . . . . . . . . . . 471.3 Die Losung aller Probleme? . . . . . . . . . . . . . . . . . . . . . . . 51

1.3.1 Aufgabenstellung . . . . . . . . . . . . . . . . . . . . . . . . . 521.3.2 Designphase . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531.3.3 Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . 54

1.3.3.1 Die Klasse BoardOfQueens . . . . . . . . . . . . . 541.3.3.2 Die Klasse BoardOfKnights . . . . . . . . . . . . 57

1.3.4 Die Klassen EightQueenProblem undKnightSwitchProblem . . . . . . . . . . . . . . . . . . . . 61

1.3.5 Ubungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . 651.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

4 Inhaltsverzeichnis

2 Annotations in Java 5.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

Erganzung 1

Zum Aufwarmen

Phantasie ist wichtiger als Wissen, denn Wissen ist begrenzt. Dieses Zitatstammt von niemand Geringerem als Albert Einstein. Wer waren die Autoren die-ses Bandes, dem zu widersprechen?Tasachlich mag es etwas seltsam anmuten, das Kapitel eines Lehrbuchs mit ei-nem solchen Satz zu beginnen. Schlielich sind die Autoren ja angetreten, IhnenWissen zu vermitteln. In diesem Buch werden Sie mit einer Vielzahl neuer Tech-niken und Bereiche sowohl aus der allgemeinen Welt des objektorientierten Pro-grammierens als auch konkret aus der Programmiersprache Java konfrontiert. Sieerwerben also neues Wissen.Bevor wir jedoch diesen Schritt wagen, sollten wir uns erst bewusst machen,dass wir bereits eine Menge gelernt haben. Wenn Sie den ersten Band und seineUbungsaufgaben intensiv durchgearbeitet haben, dann kennen Sie die Sprache Ja-va selbst wie Ihre Westentasche. Sie kennen sich mit objektorientierten Strukturenaus und haben gelernt, auch an komplex erscheinende Problemstellungen analy-tisch heranzugehen und eine Losung zu finden. Sie haben ein stabiles Fundamentgelegt, auf dem wir nun mit diesem Band weiter aufbauen werden.Betrachten wir einmal das in Abbildung 1.1 beschriebene Springer-Problem:1

1Dieses Schachproblem taucht ubrigens in ahnlicher Form im Computerspiele-Klassiker The 11th

hour auf, aus dem wir es auch ubernommen haben.

6 1 Zum Aufwarmen

485224+8+m54nMn54+48 88Abbildung 1.1: Das Springer-Problem

Auf einem beschnittenen Schachbrett stehen vier Springer, jeweils zwei der Far-ben Schwarz und Wei. Ziel der Aufgabe ist es, dass die Pferde ihre Positionentauschen, das heit, an Stelle der schwarzen Springer sollen weie stehen und um-gekehrt. Die Springer durfen die beim Schach ublichen Zuge machen. Sie durfenhierbei nicht das Feld verlassen. Ferner wird bekannt gegeben, dass das Problemin unter 40 Zugen losbar ist.2

Wie Sie sicher sehen, handelt es sich hierbei nicht gerade um ein triviales Problem.Setzen Sie sich einmal an ein Schachbrett und versuchen Sie, die Losung zu finden.Am Ende dieses Kapitels werden wir unseren Computer so programmiert haben,dass er uns die Losung dieses Problemes berechnet. Wir werden keine anderenMittel verwenden als das Wissen, das wir uns im ersten Band angeeignet haben.Abgesehen naturlich von unserer Phantasie . . .

1.1 Schach dem Computer!

1.1.1 Aufgabenstellung

Wir wollen in diesem Abschnitt ein virtuelles Schachbrett programmieren. Aufdem Schachbrett sollen sich die bei diesem Spiel ublichen Figuren befinden: Bauer,Turm, Springer, Laufer, Dame und Konig. Der Benutzer soll in der Lage sein, dieseFiguren auf dem Brett zu bewegen. Er soll dies aber nur im Rahmen der ublichenZugregeln tun durfen. Der Einfachheit halber nehmen wir Besonderheiten wieetwa die Rochade explizit aus.Zu Anfang soll das Brett wie in Abbildung 1.2 beschrieben aufgebaut sein. DerBenutzer soll jederzeit in der Lage sein, das Brett wieder in diesen Ursprungszu-stand zuruckzuversetzen. Weitere Funktionalitaten (Anzeige von Schach bzw.

Matt oder Uberwachung der Zugreihenfolge) sollen nicht realisiert werden.

1.1.2 Designphase

In der Design- oder Modellierungsphase werden wir nun die zu realisieren-de Aufgabe analysieren und versuchen, die gegebene Situation in einem Mo-

2Wir werden spater sehen, dass die optimale Losung tatsachlich 34 Zuge benotigt

1.1 Schach dem Computer! 7

!""""""""#$tMvWlVmT%$OoOoOoOo%$ + + + +%$+ + + + %$ + + + +%$+ + + + %$pPpPpPpP%$RnBqKbNr%/(((((((()

Abbildung 1.2: Ausgangssituation beim Schachspiel

dell von Klassen widerzuspiegeln. Wir benutzen zu diesem Zweck die UML-Klassendiagramme, in denen wir unsere wichtigsten Klassen und deren Zusam-menhange skizzieren. Von diesem Modell ausgehend, werden wir uns an einekonkrete Implementierung wagen.Beginnen wir mit dem Entwurf des Schachbretts, dargestellt in Abbildung 1.3. EinSchachbrett setzt sich zusammen aus dem Brett an sich und den Figuren, die sichauf ihm befinden. Um diesen Aspekt auf dem Computer nachzubilden, sehen wirzwei Klassen vor:

Ein Klasse Chessman3 reprasentiert auf dem Computer eine konkrete Art vonSchachfigur (z. B. schwarze Dame, weisser Turm). Wir legen die Schachfigurhier als ein Interface an, das heit wir geben keine konkrete Implementierungvor. Fur jeden Typ von Schachfigur kann es eine eigene Klasse geben.

Wir schreiben in unserem Interface hierbei vier verschiedene Methoden vor:

1. Die Methode toChar liefert eine Darstellung der Figur in Form eines ein-zelnen Zeichens. Dies kann fur eine Dame beispielsweise der Buchstabe Q(fur die englische Bezeichnung Queen) sein.

2. Die Methode canTake uberpruft, ob diese Figur eine andere Figur zuschlagen in der Lage ist. Beim Schach ist dies immer der Fall, wenn dieandere Figur der gegnerischen Farbe angehort.4

3. Die Methode equals vergleicht zwei Chessman-Objekte auf Gleichheit.Diese Methode ist eigentlich schon in der allgemeinen Oberklasse aller

3Hinweis: Der Name Chessman ist unter Schachkundigen ein wenig umstritten. Normalerweisewerden Sie stattdessen die Bezeichnung Chesspiece lesen, welche gebrauchlicher ist. Offiziell stellt einChesspiece jedoch lediglich eine der Haupt-Figuren, also keine Bauern, dar. Wir wahlen aus diesemGrunde hier die prazise, wenn auch unubliche Ubersetzung.

4Noch einmal zur Verdeutlichung: unser Chessman stellt keine Figur dar, die sich konkret auf demBrett befindet. Sie speichert keine Koordinaten, sondern modelliert lediglich die allgemeinen Charak-teristika der Figur. Daher ist obige Bedingung im Allgemeinen vollkommen ausreichend.

8 1 Zum Aufwarmen

Chessman

interface

toChar() : char

canTake(Chessman) : boolean

equals(Object) : boolean

getDestinations

(Chessboard, int, int) : boolean[][]

content : Chessman[][]

- content : Chessman[][]

Chessboard

+ getContent(int, int) : Chessman

+ setContent

(int, int, Chessman) : void

+ getNumOfColumns() : int

+ getNumOfRows() : int

+ move(int, int, int, int) : Object

+ equals(Object) : boolean

Abbildung 1.3: Der Aufbau von Schachbrett und -figur

Klassen, java.lang.Object , vordefiniert. Wir fuhren sie hier aber nocheinmal explizit auf um zu erinnern, dass wir die Methode uberschreibenmussen.

4. Die Methode getDestinations berechnet anhand einer konkreten Kon-stellation auf dem Schachbrett (das Chessboard ) alle Positionen, auf diesich die Figur von einer ubergebenen Position (die beiden int -Zahlen)aus bewegen konnte. Das zuruckgegebene Feld von Booleschen Wertenbesagt, ob ein Feld mit gewissen Koordinaten betreten werden kann.

Unser eigentliches Schachbrett reprasentieren wir durch eine Klasse namensChessboard . Die Klasse beinhaltet ein zweidimensionales Feld (content ),in dem wir die aktuelle Stellung speichern. Das Feld vereinbaren wir mit Sicht-barkeit protected , sodass Subklassen Zugriff auf die Instanzvariable besit-zen. Verweist ein Feldeintrag auf null , so befindet sich auf diesem Feld keineFigur. Ist das Feld besetzt, speichern wir an der entsprechenden Stelle die Artder Figur ab, die auf das Brett gesetzt wurde (also den Chessman). Wir sehenferner folgende Methoden vor:

Mit Hilfe von get- und set-Methoden konnen wir den Inhalt