Dokumentation

Werbung
Anwendungsprojekt
JAVA
Projekt
„Su-do-ku Generator“
unter der Leitung von
Univ.-Ass. Dr. Michael Hahsler
verfasst für
Abteilung für Informationswirtschaft
Wirtschaftsuniversität Wien, UZA II – 3.Ebene
Augasse 2-6, A-1090 Wien, Austria
von
Jasna Tusek
Email: jasna.tusek@wu-wien.ac.at
Homepage: www.wu-wien.ac.at/~h9950128
Wien, 2006-12-21
1
Anwendungsprojekt
JAVA
Für Su-do-ku Fans
2
Anwendungsprojekt
JAVA
Inhaltsverzeichnis
1. PROJEKTPHASEN....................................................................................................................................5
1.1 PROBLEMDEFINITION...................................................................................................................5
1.1.1 PROJEKTBESCHREIBUNG.............................................................................................5
1.1.2 SPIELREGELN...........................................................................................................5
1.1.3 PROJEKTZIELE..........................................................................................................6
1.1.4 IDEEN FÜR UMSETZUNG.............................................................................................6
1.2 PROJEKTPLAN............................................................................................................................7
1.3 MODELLIERUNG.........................................................................................................................8
1.3.1 KLASSENDIAGRAMM..................................................................................................9
1.3.2 SEQUENZDIAGRAMM................................................................................................10
1.3.3 USE CASE DIAGRAMM............................................................................................11
1.3.5 ZUSTANDSDIAGRAMM..............................................................................................14
1.4 IMPLEMENTIERUNG ..................................................................................................................15
1.4.1 KLASSE SUDOKUZAHL.............................................................................................15
1.4.2 KLASSE GENERATOR...............................................................................................15
1.4.3 KLASSE MENÜ .....................................................................................................15
1.4.4 KLASSE GUI........................................................................................................15
1.4.5 KLASSE MAIN.......................................................................................................15
1.5 TEST......................................................................................................................................16
1.5.1 FUNKTIONALITÄT IN DETAILS...................................................................................16
1.5.2 FUNKTIONALITÄT UND BENUTZERFREUNDLICHKEIT IN DETAILS......................................16
1.5.3 PLATTFORMUNABHÄNGKEIT......................................................................................17
1.5.4 GETESTETE FUNKTIONEN.........................................................................................18
1.6 ABNAHME UND PRÄSENTATION..................................................................................................19
2. PROJEKT-API....................................................................................................................................19
2.1 JAVA.UTIL.*;..........................................................................................................................19
2.2 JAVA.IO.*;..............................................................................................................................19
2.3 JAVA.AWT.*;..........................................................................................................................20
2.4 JAVAX.SWING.*;......................................................................................................................20
2.5 JAVA.NET.*;...........................................................................................................................21
3 BESONDERHEITEN.................................................................................................................................21
3.1 AUSNAHMEBEHANDLUNG (= EXCEPTIONS)...................................................................................21
3.2 ZWEIDIMENSIONALES ARRAY.....................................................................................................22
4 GRAFISCHE BENUTZEROBERFLÄCHE.........................................................................................................23
4.1 GUI-KOMPONENTEN...............................................................................................................23
4.1.1 JFRAME................................................................................................................23
4.1.2 JMENU.................................................................................................................23
4.1.3 JPANEL.................................................................................................................23
4.1.4 JBUTTON..............................................................................................................24
4.1.5 JFORMATTEDTEXTFIELD.........................................................................................24
4.1.6 JTEXTAREA..........................................................................................................24
4.1.7 JTABBEDPANE.......................................................................................................24
4.1.8 JOPTIONPANE........................................................................................................25
4.2 LAYOUT-MANAGER.................................................................................................................25
4.2.1 GRIDLAYOUT........................................................................................................25
4.2.2 BOXLAYOUT.........................................................................................................26
4.2.3 BORDERLAYOUT....................................................................................................26
3
Anwendungsprojekt
JAVA
5. BESCHREIBUNG DER PROJEKTKLASSEN....................................................................................................26
5.1 KLASSE SUDOKUZAHL..............................................................................................................26
5.1.1 VARIABLEN...........................................................................................................27
5.1.2 METHODEN............................................................................................................27
5.1.3 MODIFIZIERER........................................................................................................27
5.2 KLASSE GENERATOR................................................................................................................28
5.2.1 VARIABLEN...........................................................................................................28
5.2.2 METHODEN............................................................................................................28
5.2.3 MODIFIZIERER........................................................................................................30
5.3 KLASSE MENÜ........................................................................................................................31
5.3.1 VARIABLEN...........................................................................................................31
5.3.2 METHODEN............................................................................................................31
5.3.3 MODIFIZIERER........................................................................................................32
5.4 KLASSE GUI..........................................................................................................................32
5.4.1 VARIABLEN...........................................................................................................32
5.4.2 METHODEN............................................................................................................32
5.4.3 MODIFIZIERER........................................................................................................33
5.5 KLASSE MAIN ........................................................................................................................33
6. INSTALLATION UND WARTUNG..............................................................................................................34
7. FAZIT................................................................................................................................................35
BILDVERZEICHNIS....................................................................................................................................36
TABELLENVERZEICHNIS............................................................................................................................36
LITERATURVERZEICHNIS...........................................................................................................................37
4
Anwendungsprojekt
JAVA
1. Projektphasen
Das vorliegende Projekt wird in folgende Projektphasen gegliedert: Problemdefinition, Projektplan,
Modellierung, Implementierung, Test und Präsentation.
1.1 Problemdefinition
Die Problemdefinition wird stets zu Beginn des Projekts erstellt und gibt die wesentlichen Ziele des
Projekts vor.
1.1.1 Projektbeschreibung
Mit diesem Projekt wird ein Su-do-ku Generator modelliert und implementiert. Das mit Abstand
beliebteste Rätsel der Welt besteht aus 81 Feldern, welche in einer 9 x 9 Matrix angeordnet sind.
Diese Matrix kann auch als ein einfaches Quadrat beschrieben werden, welches sich wiederum in
neun weitere Subquadrate eingliedern lässt. Die Subquadrate entsprechen dann nur noch mehr einer
3 x 3 Matrix (siehe Bild 1). Daraus lässt sich auch ableiten, dass der ganze Su-do-ku Quadrat aus
neun Zeilen und neun Spalten und jedes Subquadrat aus drei Zeilen und drei Spalten besteht.
Nun werden die Zahlen 1 bis 9 so eingefügt, dass in keiner Zeile, keiner Spalte und in keiner 3 x 3
Matrix eine Zahl doppelt vorkommt. Der Generator muss daher diese Bedingung prüfen, bevor er
die Zahlen schließlich in einer Su-do-ku Benutzeroberfläche ausgibt. Das Programm wird
permanent neue Su-do-ku Angaben generieren. Zudem wird das Programm auf Wunsch des
Benutzers das generierte Su-do-ku lösen.
1.1.2 Spielregeln
Um das Programm etwas interessanter zu gestalten, wird zu der allgemeinen Regel auch eine
spezielle Regel eingeführt. Der Su-do-ku Generator wird somit folgende Bedingungen erfüllen:
1. keine Zahl darf doppelt vorkommen (dies gilt für jedes Subquadrat, für jede Zeile und jede
Spalte)
2. jede Zahl kommt auf eine und dieselbe Position nur einmal vor (gilt für alle 9 Subquadrate)
Bild 1 Su-do-ku Feld
5
Anwendungsprojekt
JAVA
Bild 1 zeigt das Su-do-ku Feld und markiert die Position 11. Diese Position liegt in jedem einzelnen
Subquadraten stets in der ersten Zeile und ersten Spalte. Die zweite Regel besagt daher, dass die
Zahlen 1 bis 9 auf diese neun Felder so verteilt werden müssen, dass keine Zahl in der Position 11
doppelt vorkommt. Dasselbe gilt für die restlichen Positionen.
Somit ist die Benutzeroberfläche des Su-do-ku Generators in folgende Positionen gegliedert:
Bild 2 Gliederung des Su-do-ku in Positionen
Erläuterung zu Bild 2:
p11 = Position in der ersten Zeile und ersten Spalte des jeweiligen Subquadrats
p12 = Position in der ersten Zeile und zweiten Spalte des jeweiligen Subquadrats
p13 = Position in der ersten Zeile und dritten Spalte des jeweiligen Subquadrats
p21 = Position in der zweiten Zeile und ersten Spalte des jeweiligen Subquadrats
p22 = Position in der zweiten Zeile und zweiten Spalte des jeweiligen Subquadrats
p23 = Position in der zweiten Zeile und dritten Spalte des jeweiligen Subquadrats
p31 = Position in der dritten Zeile und ersten Spalte des jeweiligen Subquadrats
p32 = Position in der dritten Zeile und zweiten Spalte des jeweiligen Subquadrats
p33 = Position in der dritten Zeile und dritten Spalte des jeweiligen Subquadrats
Anmerkung: Die einzelnen Subquadrate sind daher hinsichtlich ihrer Positionsstruktur ident.
1.1.3 Projektziele
Mit der Umsetzung des Su-do-ku Generators werden folgende Ziele verfolgt:
1. Die Funktionalität des Generators muss alle Bedingungen des Rätsels erfüllen.
2. Die Benutzoberfläche (GUI) hat eine besondere Benutzerfreundlichkeit zu gewährleisten.
3. Informationen und Hilfe werden vom Programm zur Verfügung gestellt.
1.1.4 Ideen für Umsetzung
1. Klassen: Zahl, Generator, GUI, Main
2. Verwendung von Java-API:
✗
java.util.*; (Collections)
✗
java.awt.*; (ActionEvent, ActionListener)
✗
javax.swing.*; (GUI)
✗
java.io.Serializable; (Interface)
6
Anwendungsprojekt
JAVA
1.2 Projektplan
Da dieses Projekt zu den Standardprojekten zählt, werden folgende Phasen des Projekts in der
Planung berücksichtigt:
•
•
•
•
•
•
Problemdefinition
Projektplan
Modellierung
Implementierung
Test
Abnahme und Präsentation
Der Projektplan wird anhand einer Zeittafel und nach eigener Schätzung erstellten Stundenprognose
dargestellt. Die erstellten Tabellen spiegeln die wichtigsten Daten wieder und fassen wichtige
Informationen (u.a Dauer der Aktivitäten) zusammen.
I ZEITTAFEL
Monat
1.Woche
2.Woche
3.Woche
4.Woche
Oktober 2006
---
Kick off
Problemdefinition,
Modellierung
Projektplan,
Modellierung,
Umsetzung, Test
November 2006
Umsetzung, Test
Umsetzung, Test
Umsetzung, Test
Umsetzung
Dezember 2006
Umsetzung, Test
Test
---
---
Januar 2007
---
Korrektur, Test
Abnahme,
Präsentation
---
Tabelle 1 Zeittafel
II STUNDENPROGNOSE
Projektphasen
Stunden pro Woche
Anzahl an Wochen
Gesamt
Kick off
2h
1
2h
Problemdefinition
1h
1
1h
Projektplan
1h
1
1h
Modellierung
2h
2
4h
10h
8
80h
Test
1h
6
6h
Abnahme, Präsentation
1h
1
1h
Implementierung
Summe
95h
Tabelle 2 Stundenprognose
Anschließend wird die Modellierung der gängigen Diagramme erstellt.
7
Anwendungsprojekt
JAVA
1.3 Modellierung
Entspreched der Grundlagenliteratur [BeSt04] werden die wesentlichen Modellierungsdiagramme
erstellt, d.h das Klassendiagramm, Sequenzdiagramm, Use Case Diagramm und das
Zustandsdiagramm. Die Wahl dieser Diagramme liegt insbesondere daran, dass es sich hier um eine
objektorientierte Implementierung handelt.
Das Klassendiagramm stellt die wichtigsten Ansatzpunkte für die erfolgreiche Implementierung des
Programms dar: die Klassen mit den dazugehörigen Variablen und Methoden sowie die Beziehung
zwischen den Klassen.
Beim Sequenzdiagramm steht der zeitliche Ablauf von Kommandos im Mittelpunkt [BeSt04]. So
ist das Lösen eines Sudoku-Beispiels immer dann möglich, wenn der Generator aktiviert ist, d.h
wenn ein Sudoku-Beispiel generiert wurde.
Das Use Case Diagramm zeigt insbesondere die Rolle des Benutzers und die des Generators.
Sobald der Benutzer ein Kommando abgibt, d.h eine Funktion aktiviert, reagiert der Generator
entsprechend darauf. Für das Abfangen möglicher Fehler wird die Ausnahmebehandlung
berücksichtigt.
Dabei
werden
entsprechende
Exceptions
(NullPointerException,
NumberFormatException) vom Programm abgefangen.
Das Zustandsdiagramm basiert auf der Dynamik der Objekte und ihrer Zustände. Die genannten
Diagramme werden anschließend dargestellt. Bild 3 stellt das Klassendiagramm dar. Bild 4 zeigt
das Sequenzdiagramm. Das Use Case Diagramm ist im Bild 5 dargestellt und Bild 6 zeigt das
Zustandsdiagramm an.
8
Anwendungsprojekt
JAVA
1.3.1 Klassendiagramm
Bild 3 Klassendiagramm
9
Anwendungsprojekt
JAVA
1.3.2 Sequenzdiagramm
Bild 4 Sequenzdiagramm
10
Anwendungsprojekt
JAVA
1.3.3 Use Case Diagramm
Für das bessere Verständnis des Use Case Diagramms wird zunächst der Use Case beschrieben.
Use Case Name:
Su-do-ku Generator
Akteure:
Spieler
Vorbedingungen:
PC oder Notebook mit JDK 5.0 (Java Development Kits), Empfehlung: Starten mit der
freiverfügbaren Entwicklungsumgebung Eclipse (Free Download unter http://www.eclipse.org/)
Nachbedingungen:
Ausreichend Akku-Kapazität oder Kabelanschluss (stellen sicher, dass der Use Case auch
tatsächlich erfolgreich zu Ende durchgeführt werden kann)
Auslöser:
Spieler startet das Programm
Ablaufbeschreibung:
Nach dem Programmstart kann der Spieler ein neues Su-do-ku generieren oder ein Su-do-ku aus
einer Datei öffnen. Der Spieler kann nun das Su-do-ku vom Generator lösen lassen. Es versteht sich
von selbst, dass hier die richtige Reihenfolge eingehalten werden soll, ansonsten tritt
Ausnahmebehandlung ein (es werden sog. Exceptions ausgelöst). Das Programm kann jederzeit
ohne oder mit vorheriger Aktivierung des Generators beendet werden.
Fehlsituationen:
Mögliche Erwartungsabweichungen hinsichtlich dem System können bei der Benutzeroberfläche
des Su-do-ku Generators erkannt werden (lässt sich leicht mit der Umprogrammierung oder
Ergänzung im Code beseitigen). Bei der Lösung des Rätsels durch den Spieler können Fehler
auftreten, die der Spieler leicht beheben kann, indem er das Rätsel vom Generator kontrollieren
lässt. Scheint das Rätsel zu schwierig zu sein, bietet das System Unterstützung in Form der
Positions-Pointer. Ist der Benutzer mit dem Generator noch nicht vertraut, können Fehlsituationen
entstehen, welche mittels gegebener Hilfestellung ebenfalls beseitigt werden.
Variationen:
– Der Spieler kann ein neues Sudoku generieren, dieses selbst lösen oder es vom Generator lösen
lassen.
– Der Spieler kann das Sudoku aus einer bereits bestehenden Datei öffnen, diese selbst lösen oder
vom Generator lösen lassen.
– Der Spieler kann das generierte Sudoku oder auch das aus der Datei geöffnete Sudoku teilweise
lösen und diese in dieselbe Datei oder in eine neue Datei speichern.
– Der Spieler kann das teilweise gelöste Sudoku vom Generator kontrollieren lassen und nach der
Fehlerbehebung weitermachen oder speichern um später weitermachen zu können.
Instanzen:
– Dr. McCallister ließt täglich seine beliebte Tageszeitung. An einem frühen Morgen findet er wie
gewohnt seine Zeitung auf dem Frühstückstisch. Nur dieses Mal wurde von der Redaktion der
Su-do-ku Teil ausgelassen. Enttäuscht wendet er sich an seine Tochter. Auch seine Tochter ist
11
Anwendungsprojekt
–
JAVA
ein Su-do-ku Fan und hat für alle Fälle vorgesorgt: im Laufe des Anwendungsprojekts aus Java
hat sie ein Su-do-ku Generator implementiert, welchen sie nun vom Vater testen lässt. Von nun
an rätselt Dr. McCallister öfters als nur ein Mal am Tag.
Kevin löst gerne Rätsel, nur dass er nie genug davon bekommt. Zuletzt erhielt er von seinem
Vater ein ganzes Buch voller Su-do-ku Rätsel und nun sind auch alle diese Rätsel komplett
gelöst. Als er an einem ruhigen Abend das Telefonat seiner Schwester belauscht, erfährt er von
dem Su-do-ku Generator und nutzt die erste Gelegenheit, die ihm geboten wird. Sobald seine
Schwester das Wohnzimmer verlässt (auch wenn es nur für einige Sekunden ist), nimmt Kevin
das Notebook seiner Schwester um nach dem Generator Programm zu suchen. Aber erst als ihm
seine große Schwester zu Hilfe kommt, kann er das Programm finden. Kevin bekommt ein
eigenes Notebook zu Weihnachten und seine Schwester wird ihm den Su-do-ku Generator gerne
installieren.
Ergebnisse:
Nach Beendigung des Use Case lässt sich höhere Zufriedenheit des Spielers feststellen
(insbesondere im Vergleich zu alternativen Möglichkeiten, wie z. B Rätsel aus Tageszeitungen).
Zudem können die zahlreichen Funktionen zum erneuten Programmstart motivieren und zu einer
anderen Zeit weitere Neugier hervorrufen.
Nicht-funktionale Anforderungen:
Wie gründlich die Funktionen des Su-do-ku Generators vom Spieler erforscht werden, ist völlig
dem Spieler überlassen. Der Use Case stellt Anforderungen hinsichtlich der Qualität der Funktionen
und der Reihenfolge. Nicht destotrotz kann der Spieler die Funktionen völlig flexibel wählen und
entscheidet selbst über die Dauer seines Spiels und über die Art und Weise wie er zur Lösung
gelangt.
Autorin:
Jasna Tusek
Ursprung:
Dokumentation des Projektes Su-do-ku Generator
12
Anwendungsprojekt
JAVA
Bild 5 zeigt den zuvor beschriebenen Use Case im Use Case Diagramm.
Bild 5 Use Case Diagramm
13
Anwendungsprojekt
JAVA
1.3.5 Zustandsdiagramm
Bild 6 Zustandsdiagramm
14
Anwendungsprojekt
JAVA
1.4 Implementierung
In diesem Kapitel wird die Funktionsweise der einzelnen Projektklassen beschrieben. Die
detaillierte Beschreibung dieser Klassen erfolgt in Kapitel 5.
1.4.1 Klasse Sudokuzahl
Die Klasse Sudokuzahl erzeugt Zufallszahlen zwischen 1 und 9 und speichert diese in eine Liste um
sicherzustellen, dass keine Zahl doppelt aufgenommen wird. Jede Zahl, die sich bereits in der Liste
befindet, wird nicht mehr gespeichert. Stattdessen wird eine neue Zahl erzeugt.
1.4.2 Klasse Generator
Der Generator führt ein Positionsrandom durch und speichert die einzelnen Sudokuwerte in
zweidimensionale Arrays, um die Werte leichter an die Benutzeroberfläche zu übergeben. Dabei
werden mehrere Arrays initialisiert. Ein Array stellt das Sudokubeispiel dar, mit dem nächsten
Array wird die gesamte Lösung festgehalten und ein drittes Array speichert die Werte aus einer
geöffneten Sudoku-Datei.
1.4.3 Klasse Menü
Die Klasse Menü legt alle Funktionen fest, die in der Menüleiste angezeigt werden. Zu jeder
Funktion wird das ActionCommand gesetzt und der ActionListener hinzugefügt. Um die einzelnen
Funktionen auch über Tastatur auswählen zu können (mittels einer Tastenkombination), wird die
Klasse KeyStroke aus dem Paket javax.swing.*; importiert. Anschließend kann die
Tastenkombination mittels der Methode setAccelerator(KeyStroke tastenkombination) der
entsprechenden Funktion zugewiesen werden.
1.4.4 Klasse GUI
Die grafische Benutzeroberfläche des Su-do-ku Generators wird mit der Klasse GUI realisiert.
Dabei werden die meisten Klassen (JFrame, JFormattedTextField, JPanel, JButton, JTextArea etc.)
aus dem Paket importiert. Mit JFormattedTextField werden 81 Su-do-ku Felder implementiert. Das
Menü wird an das Frame angehängt und die Methode actionPerformed(ActionEvent e)
implementiert.
1.4.5 Klasse Main
Die Klasse Main führt die Hauptmethode aus, mit der das gesamte Programm gestartet wird.
15
Anwendungsprojekt
JAVA
1.5 Test
Im Rahmen des Projekts „Su-do-ku Generator“ werden folgende Klassen hinsichtlich ihrer
Funktionalität bzw. der Benutzerfreundlichkeit getestet:
✔
✔
✔
✔
✔
Klasse Sudokuzahl
Klasse Generator
Klasse GUI
Klasse Menü
Klasse Main (= ganzes Programm)
Tabelle 3 zeigt alle getesteten Klassen an, die den Test zufriedenstellend bestanden haben.
Monat
Testgegenstand
Testdatum
Testdauer
Oktober 2006
Klasse Sudokuzahl
31.10.2006
1h
November 2006
Klasse Generator
20.11.2006
1h
November 2006
Klasse Menu + GUI
20.11.2006
1h
Dezember 2006
Ganzes Programm
04.12.2006
1h
Summe
4h
Tabelle 3 Getestete Klassen
1.5.1 Funktionalität in Details
Folgende Klassen werden hinsichtlich ihrer Funktionalität getestet:
Klasse Sudokuzahl generiert Zufallszahlen und prüft die erste Su-do-ku Regel. Wird eine
Zufallszahl doppelt generiert, wird sie ausgelassen und stattdessen wird eine neue Zahl generiert.
Die ersten fünf von neun Zahlen sind Zufallszahlen, die restlichen vier Zahlen werden nacheinander
in eine Liste aufgenommen (um eine Endlosschleife zu vermeiden). Diese Liste enthält bei jedem
erneuten Durchlauf die Zahlen 1 bis 9 in jeweils unterschiedlicher Reihenfolge. Diese
Funktionalitäten sind mit diesem Test bestätigt.
Klasse Generator initialisiert einen Durchlauf und speichert die dabei ermittelte Zahlenreihenfolge
in eigene Methoden. Immer wenn der Generator aktiviert wird, werden die Sudokuzahlen in
unterschiedlicher Reihenfolge gespeichert. Der Test bestätigt auch diese Funktionalität.
1.5.2 Funktionalität und Benutzerfreundlichkeit in Details
Folgende Klassen werden insbesondere hinsichtlich ihrer Benutzerfreundlichkeit, aber auch
hinsichtlich ihrer Funktionalität getestet:
Klasse GUI stellt die notwendige Benutzeroberfläche dar. Daher werden insbesondere Funktionen,
welche die Benutzerfreundlichkeit optimieren, berücksichtigt. Mit der Verwendung einer eigenen
Menüleiste und dem KeyListener (siehe Klasse Menü) wird das Ziel verwirklicht. Das Programm
wird erfolgreich implementiert und besteht den Test.
16
Anwendungsprojekt
JAVA
Klasse Menü erbt von JMenuBar die notwendigen Komponenten und sorgt für entsprechende
Benutzerfreundlichkeit des Programms. Die Klasse Menü wird in das Frame der Klasse GUI
eingefügt. Test bestätigt die vollständige Funktionalität.
Mit der Klasse Main werden sowohl die Funktionalität als auch die Benutzerfreundlichkeit, d.h.
das gesamte Programm getestet. Mit diesem Test werden die Mängel erkannt und beseitigt.
1.5.3 Plattformunabhängkeit
Der Generator wird auch auf Plattformunabhängigkeit getestet. Tabelle 4 zeigt das Ergebnis an.
Betriebssystem
Voraussetzung
Ergebnis
Testdatum
Windows
Java 5.0
OK
04.12.2006
Linux
Java 5.0
OK
12.12.2006
Mac OS X
Java 5.0
--
--
(already preinstalled)
--
--
Mac OS X Tiger
Tabelle 4 Plattformunabhängkeit
Der Screenshot im Bild 7 zeigt den Prototyp und im Hintergrund die Eclipse mit der das Programm
implementiert wurde. Die Klassen, die für das Programm verwendet werden, sind in eigenen
Subfenstern zu sehen, dabei ist die Klasse Main jene, die aktiv ist – da für den Start des Programms
genau diese Klasse aufgerufen werden muss. Darunter ist die Console abgebildet, welche
Informationen über das erfolgreiche Generieren von Sudokuzahlen liefert. Um die Details zu sehen,
müsste man einfach hinaufscrollen. Um die Details des Codes gut nachzuvollziehen, ist es daher
ratsam, dass Programm mit der Eclipse starten zu lassen um auch Zugriff zu den Informationen in
der Console zu erhalten.
Bild 7 Prototyp mit Eclipse im Hintergrund
17
Anwendungsprojekt
JAVA
1.5.4 Getestete Funktionen
Die Tabelle 5 zeigt alle getesteten Funktionen in der Reihenfolge, in welcher sie auch in der
Menüleiste angezeigt werden um sicherzustellen, dass keine Funktion ausgelassen wird.
Funktion
Testergebnis
Testdatum
✔
04.12.2006
Menü-Funktion: „Neu“
✔
04.12.2006
Menü-Funktion: „Datei öffnen“
✔
04.12.2006
Menü-Funktion: „Su-do-ku öffnen“
✔
04.12.2006
Menü-Funktion: „Su-do-ku speichern“
✔
04.12.2006
Menü-Funktion: „Übersicht“
✔
04.12.2006
Menü-Funktion: „Beenden“
✔
04.12.2006
Menü-Funktion: „Su-do-ku generieren“
✔
04.12.2006
Menü-Funktion: „Su-do-ku vereinfachen“
✔
04.12.2006
Menü-Funktion: „Su-do-ku lösen“
✔
04.12.2006
Menü-Funktion: „Einträge kontrollieren“
✔
04.12.2006
Menü-Funktion: „Eingaben löschen“
✔
04.12.2006
Menü-Funktion: „Position 11“
✔
04.12.2006
Menü-Funktion: „Position 12“
✔
04.12.2006
Menü-Funktion: „Position 13“
✔
04.12.2006
Menü-Funktion: „Position 21“
✔
04.12.2006
Menü-Funktion: „Position 22“
✔
04.12.2006
Menü-Funktion: „Position 23“
✔
04.12.2006
Menü-Funktion: „Position 31“
✔
04.12.2006
Menü-Funktion: „Position 32“
✔
04.12.2006
Menü-Funktion: „Position 33“
✔
04.12.2006
Menü-Funktion: „Alle Positionen aktivieren“
✔
04.12.2006
Menü-Funktion: „Info zu Positionen“
✔
04.12.2006
Menü-Funktion: „Hintergrund-Farben“
✔
04.12.2006
Menü-Funktion: „Hintergrund deaktivieren“
✔
04.12.2006
Menü-Funktion: „Info zu Hintergrund“
✔
04.12.2006
Programmstart
Menü: „DATEI“
Menü: „BEARBEITEN“
Menü: „ANSICHT“
Menü: „OPTIONEN“
Menü: „HILFE“
18
Anwendungsprojekt
JAVA
Funktion
Testergebnis
Testdatum
Menü-Funktion: „Welcome“
✔
04.12.2006
Menü-Funktion: „Hilfe“
✔
04.12.2006
Menü-Funktion: „Info zu Su-do-ku“
✔
04.12.2006
Button: „Neues Su-do-ku generieren“
✔
04.12.2006
Tabelle 5 Getestete Funktionen des Su-do-ku Generators
1.6 Abnahme und Präsentation
Der Termin wird mit dem Projektleiter festgelegt. Das Projekt wird zum gegeben Zeitpunkt, jedoch
spätestens am 23.01.2007, präsentiert.
2. Projekt-API
Die Java-Bibliothek stellt zahlreiche Hilfspakete zur Verfügung. Für das vorliegende Projekt ist der
Import von Klassen aus folgenden Paketen erforderlich:
1. java.util.*;
2. java.io.*;
3. java.awt.*;
4. javax.swing.*;
5. java.net.*;
2.1 Java.util.*;
Aus dem Paket Java.util.*; wird eine neue Instanz von LinkedList erzeugt.
LinkedList liste = new LinkedList();
Die verlinkte Liste wird in der Klasse Sudokuzahl implementiert um mit Hilfe dieser Liste
einerseits sicherzustellen, dass keine Zahl doppelt in die Liste aufgenommen wird und andererseits
eine entsprechende Reihenfolge der Sudokuzahlen zu gewährleisten.
2.2 Java.io.*;
Aus dem Paket Java.io.*; werden neue Objekte von FileReader und BufferedReader erzeugt.
File datei;
BufferedReader in = new BufferedReader(new FileReader(datei));
19
Anwendungsprojekt
JAVA
Der FileReader ließt jene Datei ein, die dem FileReader-Konstruktor übergeben wird. Diese Datei
ist der übergebene Parameter von Typ File. Weiters wird die neu erzeugte FileReader-Instanz an
BufferedReader übergeben. Der BufferedReader ließt nun den übergebenen Parameter ein.
In der Klasse Generator werden File, FileReader, BufferedReader und IOException importiert.
Für die Klasse GUI ist der Import von File, FileReader, FileWriter, BufferedReader und
BufferedWriter erforderlich, da das Speichern und Öffnen von Dateien implementiert werden.
Zudem wird auch die Klasse IOException importiert um die beim Speichern und Öffnen
auftretenden Fehler abzufangen. Das Programm kann somit mit Hilfe der Ausnahmebehandlung
optimiert werden.
2.3 Java.awt.*;
Aus dem Paket Java.awt.*; werden die Klassen Event und Color importiert um die Menüleiste zu
formatieren. Die Klasse Event wird als Hilfsklasse verwendet und wird insbesondere bei der
Implementierung der Tastenkombination (siehe KeyStroke im Paket javax.swing.*;) herangezogen.
Das Paket Java.awt.*; stellt auch das Paket Java.awt.event.*; zur Verfügung. Aus dem Event-Paket
werden ActionListener und KeyEvent importiert, welche insbesondere in der Klasse Menü zum
Einsatz kommen. In der Klasse GUI werden die ActionListener und ActionEvent aus dem
genannten Paket importiert.
2.4 Javax.swing.*;
Das Paket Javax.swing.*; stellt die wesentlichsten Komponenten zur Implementierung der
Benutzeroberfläche dar. Für die Implementierung einer Menüleiste sind daher insbesondere
JMenuBar, JMenu und JMenuItem erforderlich und werden daher aus dem genannten Paket
importiert.
Zudem
werden
auch
ButtonGroup,
JRadioButtonMenuItem
und
JCheckBoxMenuItem importiert. Eine Menüleiste wird mit Hilfe der Vererbung realisiert:
public class Menu extends JMenuBar{ ... }
Jedes einzelne Menüpunkt wird mit der Erzeugung einer neuen Instanz der Klasse JMenu
implementiert.
JMenu menu;
menu = new JMenu("Datei");
menu = new JMenu("Bearbeiten");
menu = new JMenu("Ansicht");
menu = new JMenu("Optionen");
menu = new JMenu("Hilfe");
Einzelne Menüfunktionen werden mit Hilfe von JMenuItem initialisiert, indem jeweils eine neue
Instanz von JMenuItem erzeugt wird:
JMenuItem welcome;
welcome = new JMenuItem("Welcome");
20
Anwendungsprojekt
JAVA
Die Erzeugung eines ButtonGroup Objekts ermöglicht das Selektieren jeweils eines einzelnen
Objekts vom Objektdatentyp JRadioButton bzw. JRadioButtonMenuItem. Unter dem
Menüpunkt Optionen kann die Hintergrundfarbe des Su-do-ku Generators verändert werden. Wird
nun Silber eingestellt, kann nicht gleichzeitig auch Gold eingestellt werden. Bei jeweiligem
Funktionsaufruf wird daher die Hintergrundfarbe geändert, in diesem Fall von Silber auf Gold. Die
Klasse JCheckBoxMenuItem dient der Implementierung einer True-False Beziehung. Ist die
entsprechende Funktion selektiert dann erhält die boolean-Variable den Wert true, sonst erhält sie
den Wert false:
JCheckBoxMenuItem checkbox;
checkbox = new JCheckBoxMenuItem("Hintergrund nicht definiert", false);
Für die Menüleiste ist zudem der Import der Klasse KeyStroke erforderlich um die
Tastenkombinationen der einzelnen Funktionen zu implementieren.
JMenuItem generieren;
generieren = new JMenuItem("Su-do-ku generieren");
generieren.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_1, Event.ALT_MASK));
Die Menüfunktion „Su-do-ku generieren“ kann mit der Tastenkombination ALT+1 aktiviert
werden. Weitere aus dem genannten Paket importierte Klassen werden in Kaptel 4 näher erläutert,
da die Beschreibung der grafischen Benutzeroberfläche für diesen Abschnitt zu umfangreich ist.
2.5 Java.net.*;
Aus dem Paket Java.net.*; wird der Uniform Resource Locator (=URL) importiert. Mithilfe der
URL-Adresse können Objekte aus dem World Wide Web in das Programm eingefügt werden. Im
Falle des Su-do-ku Generators wird ein PNG-Objekt eingefügt, d.h ein selbsterstelltes Su-do-ku
Bild.
String name; //Name des Bildes (=icon.png)
URL imgURL = GUI.class.getResource(name);
3 Besonderheiten
Die wesentlichsten Besonderheiten für den Su-do-ku Generator sind die Ausnahmebehandlung und
die zweidimensionalen Arrays. Die Ausnahmebehandlung sorgt für das Abfangen von möglichen
Fehlern. Die zweidimensionalen Arrays helfen bei der korrekten Generierung von Sudokuzahlen.
3.1 Ausnahmebehandlung (= Exceptions)
In der Klasse Generator wird die Ausnahmebehandlung mithilfe der Try-Catch Schleife
21
Anwendungsprojekt
JAVA
berücksichtigt.
String datei;
try{
BufferedReader in = new BufferedReader(new FileReader(datei));
......
}catch (IOException ex){
System.err.println(ex);
}
Beim Öffnen eines Su-do-ku aus einer bereits bestehenden Datei werden die Zahlen aus der Datei
gelesen und vom Generator interpretiert. Die Zahl Null steht für ein leeres Feld, restliche Zahlen
von 1 bis 9 werden übernommen, so dass der Generator nach erfolgreichem Einlesen das Su-do-ku
auch selbstständig lösen kann.
In der Klasse GUI werden überall dort Try-Catch-Schleifen implementiert, wo eine Ausnahme
(=Exception) auftreten kann.
Try{
..........
}catch(NumberFormatException nf){
System.err.println(nf);
}catch(NullPointerException np){
System.err.println(np);
}
3.2 Zweidimensionales Array
In der Klasse Generator werden drei verschiedene Integer-Arrays implementiert. Alle drei sind
zweidimensionale Arrays, die zumindest einer 9x9 Sudokumatrix entsprechen.
1.
Integer[][] wert;
2.
Integer[][] daten;
3.
Integer[][] zahl;
Das erste Array „wert“ speichert die vom Generator erzeugten Werte in der richtigen Reihenfolge.
Dabei wird insbesondere die zweite Su-do-ku Bedingung berücksichtigt: keine Sudokuzahl darf auf
einer und derselben Position doppelt vorkommen (egal in welchem Subquadraten sich die Zahl
befindet). Das erste Array speichert alle 81 Werte in der richtigen Position und stellt daher auch die
Lösung des Su-do-ku dar.
Das zweite Array „daten“ speichert die aus einer Datei gelesenen Werte, ebenfalls in der richtigen
Reihenfolge und in der richtigen Position. Der Unterschied liegt nur darin, dass die Werte nicht
generiert werden müssen.
Das dritte Array „zahl“ übernimmt nur einzelne Werte des ersten Arrays und gibt ein Su-do-ku
Beispiel aus. Welche Sudokuzahlen nun ausgegeben werden und welche Felder leer bleiben, hängt
daher zum Großteil vom dritten Array ab.
22
Anwendungsprojekt
JAVA
4 Grafische Benutzeroberfläche
Für eine benutzerfreundliche grafische Oberfläche werden zahlreiche Klassen aus dem Paket
Javax.swing.*; importiert. Alle in diesem Kapitel angeführten Klassen werden in der Klasse GUI
verwendet.
4.1 GUI-Komponenten
Die wesentlichsten Klassen sind JMenu, JFrame, JPanel, JButton, JFormattedTextField und
JTextArea. Zusätzliche Komponenten werden implementiert um einerseits die Benutzeroberfläche
zu optimieren (JTabbedPane) und andererseits Hilfestellung (JOptionPane) anzubieten.
4.1.1 JFrame
Die Klasse JFrame stellt das Fenster des Su-do-ku Generators dar. Der übergebene Parameter vom
Typ String ist der Name des Fensters.
JFrame frame;
frame = new JFrame("Su-do-ku Generator");
4.1.2 JMenu
In der Klasse GUI wird eine neue Instanz vom Objektdatentyp Menü in einer eigenen Methode,
newMenu() mit dem Rückgabewert Menü, erzeugt:
public Menu newMenu(){
menubar = new Menu(this);
return menubar;
}
Daraufhin wird das Menü an das Frame mit Hilfe der Methode setJMenuBar() angehängt:
frame.setJMenuBar(newMenu());
4.1.3 JPanel
Für die Benutzeroberfläche werden die notwendigen JPanels initialisiert.
JPanel mainPanel;
mainPanel = new JPanel();
.....
23
Anwendungsprojekt
JAVA
4.1.4 JButton
Im vorliegenden Projekt wird nur ein JButton initialisiert, nämlich für die wesentlichste Funktion
eines Generators: „neues Su-do-ku generieren“.
JButton taste = new JButton("Neues Su-do-ku generieren");
taste.addActionListener(this);
taste.setActionCommand("generieren");
Zudem wird der JButton an das JFrame angehängt.
frame.add(taste, BorderLayout.PAGE_END);
JButton mit dem Namen „taste“ wird an das Ende des Frames (PAGE_END) angehängt.
4.1.5 JFormattedTextField
Der Default-Konstruktor der Klasse JFormattedTextField erstellt ein einfaches JTextField, welches
die Eingabe und Änderung von Textzeichen ermöglicht. Jedes Textfeld ermöglicht die Darstellung
nur einer Zeile. In Verbindung mit den LayoutManagern (siehe Kapitel 4.2) ist die Größe dieser
formatierten Felder mit der Größe des Fensters abstimmbar. Wird das JFrame-Fenster vergrößert,
dann werden die einzelnen JFormattedTextFields größer und vice versa.
4.1.6 JTextArea
Mit der Klasse JTextArea wird ein Textbereich dargestellt, welches im Vergleich zu JTextField die
Darstellung von vielen Zeilen ermöglicht. JTextArea wird für die Darstellung des Inhalts der
geöffneten Su-do-ku Datei verwendet. Zudem wird auch der Willkommenstext im Textbereich
dargestellt.
4.1.7 JTabbedPane
Die Benutzeroberfläche des Su-do-ku Generators beinhaltet zwei anklickbare Karten. Die erste
Karte, die defaultmäßig selektiert wird (sudokuBorder), zeigt das Su-do-ku Gitter und die zweite
Karte ist defaultmäßig im Hintergrund und zeigt den Textbereich (textBorder). Die erste Karte hat
stets den Index 0, die zweite hat den Index 1 usw.
JTabbedPane tabbedPane;
tabbedPane = new JTabbedPane();
tabbedPane.addTab("Su-do-ku", icon2, sudokuBorder, null);
tabbedPane.addTab("Information", icon2, textBorder, null);
tabbedPane.setSelectedIndex(0);
24
Anwendungsprojekt
JAVA
Anschließend wird JTabbedPane in das Fenster (frame) eingefügt und zentriert:
frame.add(tabbedPane, BorderLayout.CENTER);
4.1.8 JOptionPane
Der Su-do-ku Generator bietet nicht nur bei Ausnahmen Hilfestellung in Form von Standardialogen
sondern auch Informationen und Spielregeln zu Farb-Sudoku. Die Standardialoge öffnen in einem
neuen Fenster und zeigen die Information an. Welche Information nun wie angezeigt wird, hängt
davon ab, welche Methode aufgerufen wird.
Im Rahmen des Su-do-ku Generators werden zwei Methoden aus der Klasse JOptionPane
aufgerufen:
1.
JOptionPane.showMessageDialog(frame, "\nProject: Su-do-ku Generator\nAuthor: Jasna Tusek\n\nFor
Players Of All Countries\nGreetings from Croatia and Austria", "INFO zu SU-DO-KU Generator",
JOptionPane.INFORMATION_MESSAGE);
2.
JOptionPane.showConfirmDialog(frame,
"Programm
jetzt
JoptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);
beenden?",
"beenden",
Die erste Methode zeigt ein Dialog mit einer Nachricht. Die zweite Methode zeigt ein Dialog mit
der Option. Dabei ist eine Bestätigung erforderlich. Der Su-do-ku Generator wird daher erst nach
erfolgreicher Bestätigung geschlossen.
4.2 Layout-Manager
Das Design eines Programms wird überwiegend vom Layout-Manager bestimmt. Der LayoutManager kann die Komponenten unterschiedlich anordnen, wie sie jeweils gut zusammenpassen.
Der Vorteil eines Layout-Managers liegt insbesondere an der automatischen Anpassung der
Komponentengröße. Wird das Fenster verkleinert, dann werden proportional auch die einzelnen
Komponenten verkleinert und vice versa.
Für das vorliegende Projekt werden folgende Layout-Manager verwendet: GridLayout, BoxLayout
und BorderLayout.
4.2.1 GridLayout
Die Klasse GridLayout ordnet mehrere Komponenten in Zeilen und Spalten und bestimmt den
Abstand zwischen den Komponenten.
JPanel sudokuPanel, panel1, panel2 .... panel9;
sudokuPanel = new JPanel(new GridLayout(3, 3, 15, 15));
sudokuPanel.add(panel1);
sudokuPanel.add(panel2); ....
sudokuPanel.add(panel9);
25
Anwendungsprojekt
JAVA
Die neun Panels werden an das sudokuPanel angehängt und in drei Zeilen und drei Spalten
angeordnet mit dem horizontalen und vertikalen Abstand zwischen den Komponenten von 15. Jeder
dieser Panels besitzt neun Textfelder, die ebenfalls in 3 Zeilen und 3 Spalten angeordnet sind. Das
Resultat dieser Konstruktion ist das Su-do-ku Gitter bestehend aus 81 Textfeldern.
4.2.2 BoxLayout
Mit der Klasse BoxLayout werden Komponenten entweder in horizontaler (BoxLayout.X_AXIS)
oder in vertikaler Richtung (BoxLayout.Y_AXIS) angeordnet. Zudem können weitere zwei
Ausrichtungen bestimmt werden: BoxLayout.LINE_AXIS und BoxLayout.PAGE_AXIS.
JPanel sudokuBorder, textBorder;
sudokuBorder.setLayout(new BoxLayout(sudokuBorder, BoxLayout.PAGE_AXIS));
textBorder.setLayout(new BoxLayout(textBorder, BoxLayout.PAGE_AXIS));
4.2.3 BorderLayout
Mit dem BorderLayout wurde die Komponente „tabbedPane“ ins Zentrum des Fensters gerückt
und die Komponente „taste“ an das Fensterende.
frame.add(tabbedPane, BorderLayout.CENTER);
frame.add(taste, BorderLayout.PAGE_END);
5. Beschreibung der Projektklassen
Die wesentlichen Merkmale der Projektklassen sind ihre Variablen, Methoden und Modifizierer.
Die Konstruktoren sind spezielle Methoden und werden daher unter Methoden zusammengefasst.
5.1 Klasse Sudokuzahl
Die Klasse Sudokuzahl besitzt zwei Variablen und folgende Methoden:
1. Sudokuzahl()
2. generiereZufallszahl()
3. generiereSudokuzahl()
4. restlicheWerte()
26
Anwendungsprojekt
JAVA
5.1.1 Variablen
Zunächst wird die Variable „zahl“ vom primitiven Datentyp integer deklariert und anschließend die
Variable „liste“ vom Objektdatentyp List initialisiert.
private int zahl;
private List liste = new LinkedList();
5.1.2 Methoden
Der Default-Konstruktor der Klasse Sudokuzahl ruft die Methode generiereZufallszahl() auf.
public Sudokuzahl(){ ...........}
Die Methode generiereZufallszahl() ruft aus der Klasse Math die Methode random() auf und
generiert eine Zufallszahl zwischen 1 und 9. Diese Zufallszahl ist zugleich der Rückgabewert vom
Typ integer.
public int generiereZufallszahl() {
zahl = (int)(9*Math.random()+1); //liefert eine Zahl zwischen 1 und 9
return zahl;
}
Die Methode generiereSudokuzahl() ruft die Methode generiereZufallszahl() auf und prüft ob die
Zahl bereits in der Liste enthalten ist. Ist dies nicht der Fall wird die Zahl der Liste hinzugefügt.
Jede Zahl, die in die Liste hinzugefügt wird, ist zugleich auch der Rückgabewert dieser Methode
vom Typ integer.
public int generiereSudokuzahl(){
.......
return naechsteZahl;
}
Die Methode restlicheWerte() fügt jene Zahlen von 1 bis 9, die noch nicht in der Liste enthalten
sind, der Reihe nach hinzu. Jene Zahl, die der Liste hinzugefügt wird, wird von der Methode
zurückgegeben.
public int restlicheWerte(){
....
return zahl;
}
5.1.3 Modifizierer
Alle Methoden sind öffentlich zugänglich (public), das heißt aus anderen Klassen kann auf diese
Methoden zugegriffen werden. Auf die Variablen zahl und liste kann nicht zugegriffen werden, da
27
Anwendungsprojekt
JAVA
dies auch nicht notwendig ist. Daher sind die deklarierten Variablen mit private versehen.
5.2 Klasse Generator
Die Klasse Generator besteht aus zahlreichen Variablen, jeweils neun Variablen für neun
Sudokuzahlen und neun Positionen. Die implementierten Methoden sorgen für einen reibungslosen
Programmablauf.
5.2.1 Variablen
Die zweidimensionalen Arrays vom Typ Integer zählen zu den wesentlichsten deklarierten
Variablen. Die Arrays speichern die Sudokuwerte. Damit aber richtige Werte gespeichert werden,
werden die generierten Sudokuzahlen vorübergehend in den Variablen a, b ... i festgehalten. Die
Werte der einzelnen Positionen werden in den Variablen p1, p2 ... p9 gelagert.
private int a, b, c, d, e, f, g, h, i;
private boolean p1, p2, p3, p4, p5, p6, p7, p8, p9;
private Integer[][] wert;
private Integer[][] daten;
private Integer[][] zahl;
private Sudokuzahl sudokuzahl;
5.2.2 Methoden
Die Klasse Generator besitzt folgende Methoden:
1. Generator()
Der Default-Konstruktor erzeugt eine Instanz vom Objektdatentyp Sudokuzahl und ruft die
Methoden generiereZahl(Sudokuzahl zahl) und bestimmePosition() auf.
public Generator(){
System.out.println("\nGenerator aktiviert");
sudokuzahl = new Sudokuzahl();
generiereZahl(sudokuzahl);
bestimmePosition();
System.out.println("\nGenerieren abgeschlossen");
}
2. Generator(File datei)
Der Konstruktor mit dem Parameter datei vom Typ File ließt den übergebenen Parameter
ein und speichert die Werte in das zweidimensionale Array. Mit dem Aufruf der Methode
setSudokuzahl(daten) werden die gespeicherten Werte in entsprechenden Variablen
festgehalten.
28
Anwendungsprojekt
JAVA
public Generator(File datei){
.......
try{
BufferedReader in = new BufferedReader(new FileReader(datei));
daten[zeile][spalte] = new Integer(aktuelleZeile.charAt(1..n)+"");
......
}
in.close();
}catch (IOException ex){
System.err.println(ex);
}
setSudokuzahl(daten);
}
3. setWerte()
setzt die richtigen Werte auf die richtige Stelle. Um eine Verwechslung zu vermeiden
werden die Werte in ein neues Array gespeichert.
public void setWerte(){
wert = new Integer[10][10];
wert[1..9][1..9] = new Integer(zeigeErsteZahl() .... zeigeNeunteZahl());
......
}
4. setSudokuzahl(Integer[][] daten)
die Werte aus der Datei werden den Variablen zugewiesen um daraufhin auch die
ungelösten Felder lösen zu können.
public void setSudokuzahl(Integer[][] daten){
.....
if(daten[1..9][1..9].intValue() != 0){a, b, ... i = daten[1..9][1..9].intValue();}
}
Damit nun das ganze Sudokubeispiel gelöst werden kann, müssen die Sudokuzahlen 1, 2... 9
mindestens einmal in der Datei vorkommen.
5. zeigeSudoku(int zeile, int spalte)
Diese Methode wird immer dann aufgerufen, wenn ein Sudokuwert aus einer Datei
angezeigt werden soll. Die übergebenen Parameter zeile und spalte vom Typ integer geben
an, welcher Wert zurückgegeben werden soll.
public int zeigeSudoku(int zeile, int spalte){
int sudokuzahl= daten[zeile][spalte].intValue();
return sudokuzahl;
}
6. generiereBeispiel()
Mit der Methode generiereBeispiel() werden die Werte aus dem Array „wert“ einzeln
selektiert und jene Werte, die im Beispiel angezeigt werden sollen, werden dem Array
„zahl“ zugewiesen.
29
Anwendungsprojekt
JAVA
7. generiereSudoku(int zeile, int spalte)
Diese Methode ruft die Methode generiereBeispiel() auf. Die Methode selbst wird von der
Klasse GUI aufgerufen.
public int generiereSudoku(int zeile, int spalte){
generiereBeispiel();
int sudokuzahl = zahl[zeile][spalte].intValue();
return sudokuzahl;
}
8. loeseSudoku(int zeile, int spalte)
liefert die Lösung des Sudoku für jedes Feld. Der einmalige Aufruf gibt eine Sudokuzahl
zurück. Die Lösung eines Sudokubeispiels besteht aus 81 Feldern, so dass die Methode 81
mal aufgerufen wird.
public int loeseSudoku(int zeile, int spalte){
int sudokuzahl= wert[zeile][spalte].intValue();
return sudokuzahl;
}
9. generiereZahl(Sudokuzahl zahl)
Wird ein Sudokubeispiel vom Generator generiert, dann wird die Methode
generiereZahl(Sudokuzahl zahl) aufgerufen. Diese Methode weist die generierten
Sudokuzahlen den Variablen a, b, ... i zu.
public void generiereZahl(Sudokuzahl zahl){
a = zahl.generiereSudokuzahl();
......
i = zahl.restlicheWerte();
}
10. bestimmePosition()
Zudem werden in der Methode bestimmePosition() die boolean Werte den einzelnen
Positionen zugewiesen. Mittels einfachem Math.random wird bei fünf von neun Positionen
der boolean Wert auf true geändert. Defaultmäßig haben die restlichen vier Positionen den
boolean Wert false. Diese Methode entscheidet maßgeblich darüber welche Werte
tatsächlich im Sudokubeispiel ausgegeben werden.
11. zeigeErsteZahl() .... zeigeNeunteZahl(); isP1, ... isP9, setP1, ... setP9
Für die Speicherung der neun Sudokuzahlen und neun Positionen dienen restliche
Methoden:
zeigeErsteZahl(), zeigeZweiteZahl .... zeigeNeunteZahl()
isP1, isP2 .... isP9
setP1, setP2 ..... setP9
5.2.3 Modifizierer
Das einfache Prinzip wurde auch in der Klasse Generator umgesetzt. Die Variablen bleiben für
30
Anwendungsprojekt
JAVA
weitere Klassen unsichtbar (private), während die Methoden auch von anderen Klassen abrufbar
sein sollen (public).
5.3 Klasse Menü
Die Menüleiste des Su-do-ku Generators wird mit der Klasse Menü implementiert. Die zahlreichen
Funktionen des Generators werden als eigene Variablen initialisiert, die meisten Variablen sind
vom Objektdatentyp JMenu bzw. JMenuItem.
5.3.1 Variablen
Zusätzlich zu den Variablen vom Typ JMenu und JMenuItem ist es erforderlich folgende Variablen
zu deklarieren:
ActionListener listener;
ButtonGroup buttongroup;
Der ActionListener-Parameter wird an den Konstruktor übergeben.
5.3.2 Methoden
Der Konstruktor mit dem Parameter vom Typ ActionListener ist die einzige notwendige Methode,
mit der auch die gesamte Menüleiste implementiert werden kann. Besonderheiten sind die
Implementierung der Tastenkombination, mit der ebenfalls Funktionen aufgerufen werden können.
JMenuItem neu;
neu.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_1, Event.CTRL_MASK));
Damit die Funktion auch erkannt wird, wird ein Kommando gesetzt und der Listener (Zuhörer)
hinzugefügt.
neu.setActionCommand("neu");
neu.addActionListener(listener);
Zudem muss die Hierarchie der Komponenten eingehalten werden. Die einzelnen Funktionen
werden jeweils dem übergeordneten Menü (Datei, Bearbeiten, Ansicht, Optionen oder Hilfe)
zugewiesen und diese Menüs werden wiederum einem übergeordneten Menü hinzugefügt.
JMenuItem gold, silber;
layout.add(gold);
layout.add(silber);
menu.add(layout);
Zum Beispiel werden die Variablen gold und silber zuerst dem übergeordneten JMenu layout
31
Anwendungsprojekt
JAVA
zugeordnet. Daraufhin wird layout wiederum dem übergeordneten JMenu menu zugewiesen.
5.3.3 Modifizierer
Die Variable listener vom Typ ActionListener wird außerhalb der Klasse Menü aufgerufen und
enthält daher den Modifizierer „public“. Bei der Implementierung von serialisierbaren
Komponenten (z.B Klassen mit dem Interface Serializable) wird stets die Deklaration der Variable
static final serialVersionUID vom Typ long verlangt. In diesem Fall erbt die Klasse Menü die
Komponenten der Klasse JMenuBar und zählt daher ebenfalls zur serialisierbaren Klasse.
5.4 Klasse GUI
Für das Design der grafischen Benutzeroberfläche muss die Hierarchie der Komponenten
eingehalten werden. Textfelder und Textbereiche werden an JPanels angehängt, und mehrere
JPanels werden einem übergeordneten JPanel zugewiesen, dieser JPanel wird wiederum an das
übergeordnete JFrame angehängt. Die eingesetzten Layout-Manager sorgen dafür, dass die
unterschiedlichen Komponenten auch in der gewünschten Reihenfolge angezeigt werden.
5.4.1 Variablen
Die Klasse GUI erbt von der Klasse JFrame und zählt somit genauso wie die Klasse Menü zu den
serialisierbaren Klassen. Somit wird auch hier die Deklaration der Variable static final
serialVersionUID notwendig. Die restlichen Variablen sind entweder vom primitiven Datentyp (int,
boolean) oder vom Objektdatentyp (String, JFrame, Menu, JTextArea, JPanel,
JFormattedTextField[][], JTabbedPane und Generator).
5.4.2 Methoden
Folgende Methoden (inkl. Default-Konstruktor) werden in der Klasse GUI implementiert:
1. GUI()
die wichtigsten Komponenten des Programms (JFrame, JPanel, JTabbedPane) werden schon
im Konstruktor initialisiert. Auch notwendige Methoden (newMenu() und
newSudokuPanel()) werden aufgerufen, so dass defaultmäßig ein leeres Sudoku-Gitter
angezeigt wird.
2. newMenu()
erzeugt neue Instanz vom Typ Menü
3. newSudokuPanel()
liefert die grafische Benutzeroberfläche des Su-do-ku Gitters
4. newGenerator()
32
Anwendungsprojekt
JAVA
aktiviert Generator, d.h neue Instanz vom Typ Generator wird erzeugt und die Sudokuwerte
werden initialisiert
5. zeigeImageIcon(String name)
zeigt den übergebenen Parameter an, in diesem Fall ein PNG-Objekt
6. oeffneDatei(File datei)
öffnet den übergebenen Parameter vom Typ File. D.h nur Dateien mit der Endung .txt
werden geöffnet, sonstige Dateien werden nicht geöffnet. Der Inhalt wird im Textbereich
angezeigt.
7. oeffneSudoku(File datei)
öffnet zwar auch eine Datei, jedoch wird der Inhalt direkt im Sudoku Gitter angezeigt, so
dass dieses Sudoku zugleich gelöst werden kann.
8. speichereSudoku(File datei)
speichert Sudoku in das übergebene Parameter vom Typ File.
9. zeigeHintergrund(int i)
zeigt die Hintergrundfarbe von der jeweiligen Position an. Der übergebene Parameter i
bestimmt welche Position angezeigt wird. Der übergebene Parameter i kann die Werte 1 bis
9 einnehmen, da es neun verschiedene Positionen gibt.
10. actionPerformed(ActionEvent e)
behandelt alle Erreignisse. Jene Funktion, die vom Benutzer abgerufen wird, wird von der
Methode erkannt, so dass anschließend der - diesem Kommando zugewiesene Programmcode ausgeführt wird.
5.4.3 Modifizierer
Alle Methoden mit Ausnahme der zeigeImageIcon(String name) werden public deklariert. Die
Klasse zeigeImageIcon(String name) kann auf bestimmte Objekte im World Wide Web zugreifen
und wird daher vor unerlaubtem Zugriff außerhalb der Klasse geschützt, d.h protected.
protected static ImageIcon zeigeImageIcon(String name) {
URL imgURL = GUI.class.getResource(name);
......
}
5.5 Klasse Main
Die Klasse Main dient der Dokumentationsfunktion und ergänzt somit die Javadoc. Zudem startet
sie das gesamte Programm mithilfe der Hauptmethode. Die Deklaration von Variablen ist in dieser
Klasse nicht notwendig. Zusätzlich wird der Default-Konstruktor implementiert. Um für die
Javadoc ersichtlich zu werden, wird die Initialisierung der grafischen Benutzeroberfläche ebenfalls
in einer eigenen Methode implementiert. Alle Methoden werden „public“ deklariert.
33
Anwendungsprojekt
JAVA
6. Installation und Wartung
Um das Programm starten zu können, ist die Java-Software erforderlich. Diese kann kostenlos
runtergeladen und installiert werden.
Free Download der Software:
Java Entwicklungsumgebung
Editor
http://java.sun.com/j2se/1.5.0/download.html
http://www.eclipse.org/
Zusammengefasst besteht das Programm „Su-do-ku Generator“ aus folgenden JAVA-Klassen:
„Sudokuzahl“, „Generator“, „Menu“, „GUI“, und „Main“. Daher müssen diese Klassen zuerst
installiert und kompiliert werden. Daraufhin ist der Benutzer aufgefordert die Hauptklasse
aufzurufen. Mit dem Aufruf der Hauptklasse „Main“ wird das Programm gestartet.
An den einwandfreien Betrieb wurde bereits bei der Implementierung des Codes gedacht. So
werden mögliche Fehler vom Programm abgefangen. Zudem wird dem Benutzer notwendige
Hilfestellung geboten.
Funktionen wie das Speichern und Öffnen von Su-do-ku erfordert zudem eine genaue Einstellung
des Verzeichnisses auf welches der Generator zugreifen soll. Im Original-Programmcode ist das
Verzeichniss C:\\ eingestellt:
file.setDirectory("C:\\Dokumente und Einstellungen\\Admin\\workspace\\");
Wird mit dem Betriebssystem Windows XP gearbeitet, ist lediglich der Administratorname (Admin)
anzupassen. Unter Mac OS X (Tiger) und Linux kann das Verzeichnis von Fall zu Fall variieren (z.B
Name des Servers, persönliche Präferenzen und Einstellungen, etc.). Der Verzeichnisname unter
Linux kann folgendermaßen lauten:
/srv/ai/xmbalrog/home/j99/j9950128/workspace/
Unabhängig davon auf welchem Betriebssystem gearbeitet wird, sollten alle Sudoku-Dateien in
dem workspace-Ordner gespeichert werden, um einen reibungslosen Programmablauf zu
garantieren. Der workspace-Ordner wird von der Eclipse automatisch erzeugt. Wird der workspaceOrdner umbenannt, muss auch dieser im Verzeichnisname angepasst werden.
Die Änderung des Verzeichnisses kann in der Methode actionPerformed(ActionEvent e) aus der
Klasse GUI durchgeführt werden. Der Befehl zum Setzen des Zugriffsverzeichnisses lautet:
file.setDirectory("...\\ ...\\ ...\\workspace\\");
34
Anwendungsprojekt
JAVA
7. Fazit
Mit dem Programm „Su-do-ku Generator“ wurde ein eigens entwickeltes Algorithmus für FarbSudoku implementiert. Bei der Entwicklung des Algorithmus wurde von Bedingungen des Rätsels
ausgegangen. Der Farb-Sudoku erfüllt im Vergleich zu dem gängigen Su-do-ku eine spezielle
Bedingung: keine Zahl darf auf einer und derselben Farbe (d.h Position) doppelt vorkommen. Die
eigentliche Herausforderung im Rahmen dieses Projekts lag in der Implementierung eines
Algorithmus, der auch die spezielle Bedingung berücksichtigt.
Das gesamte Programm stellt Open Software dar und ist daher für private Zwecke frei nutzbar. Die
Autorin wünscht viel Spaß mit dem Su-do-ku Generator.
Bild 8 Getestete Version des Su-do-ku Generators
35
Anwendungsprojekt
JAVA
Bildverzeichnis
Bild 1 Su-do-ku Feld ...........................................................................................................................................................5
Bild 2 Gliederung des Su-do-ku in Positionen ....................................................................................................................6
Bild 3 Klassendiagramm .....................................................................................................................................................9
Bild 4 Sequenzdiagramm ..................................................................................................................................................10
Bild 5 Use Case Diagramm ...............................................................................................................................................13
Bild 6 Zustandsdiagramm .................................................................................................................................................14
Bild 7 Prototyp mit Eclipse im Hintergrund......................................................................................................................17
Bild 8 Getestete Version des Su-do-ku Generators ......................................................................................................... 35
df
Tabellenverzeichnis
Tabelle 1 Zeittafel ...............................................................................................................................................................7
Tabelle 2 Stundenprognose .................................................................................................................................................7
Tabelle 3 Getestete Klassen ..............................................................................................................................................16
Tabelle 4 Plattformunabhängigkeit ...................................................................................................................................17
Tabelle 5 Getestete Funktionen des Su-do-ku Generators ................................................................................................18
dk
36
Anwendungsprojekt
JAVA
Literaturverzeichnis
[Abts02]
Abts, Dietmar: Grundkurs JAVA – Von den Grundlagen bis zu Datenbank- und Netzanwendungen, Friedr. Vieweg & Sohn Verlag GmbH, 3. Auflage, Braunschweig/Wiesbaden
2002.
[BeSt04]
Bernroider, Edward; Stix, Volker: Grundzüge der Modellierung – Anwendungen für die
Softwareentwicklung, Facultas Verlag- und Buchhandels AG, Wien 2004.
[Diet01]
Dieterich, Ernst-Wolfgang: Java 2 – Von den Grundlagen bis zu Threads und Netzen,
Oldenbourg Wirtschaftsverlag GmbH, 2. Auflage, München 2001.
[ScSc99]
Schader, Martin; Schmidt-Thieme, Lars: Java – Eine Einführung, Springer-Verlag,
Heidelberg 1999.
37
Herunterladen
Random flashcards
Laser

2 Karten anel1973

lernen

2 Karten oauth2_google_6c83f364-3e0e-4aa6-949b-029a07d782fb

Literaturepochen

2 Karten oauth2_google_55780ed8-d9a3-433e-81ef-5cfc413e35b4

Erstellen Lernkarten