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: [email protected] 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
