Generierte Dokumentation der praktischen Arbeit von Simon Tiffert

Hauptseite | Pakete | Klassenhierarchie | Alphabetische Liste | Auflistung der Klassen | Auflistung der Dateien | Klassen-Elemente

# Matrix.java

gehe zur Dokumentation dieser Datei

    00001 /*
    00002  *
    00003  * Datei:   Matrix.java
    00004  *
    00005  * ---------------------------------
    00006  *
    00007  * Datum:           $Date: 2004/05/13 10:12:38 $
    00008  * Autor:           Simon Tiffert
    00009  * Prüfungsnummer:  40
    00010  * Firma:           T-Systems
    00011  * eMail-Adresse:   simon.tiffert@t-systems.com
    00012  * Version:         $Revision: 1.15 $
    00013  *
    00014  * ---------------------------------
    00015  *
    00016  */
    00017 package main.verarbeitung;
    00018
    00019 import main.Main;
    00020
    00021 /**
    00022  * Klasse, die die Verwaltung der Matrix übernimmt.
    00023  * Dabei befindet sich die Matrix selber als zentrales Element in
    00024  * dieser Klasse.<br>
    00025  * Alle Operationen, die die Matrix verändern, werden
    00026  * durch setter zur Verfügung gestellt, die direkt Konsistenzprüfungen
    00027  * durchführen.<br>
    00028  * Alle Operationen, die Daten aus der Matrix abfragen sind über getter
    00029  * definiert, die die Daten aufbereitet zur Verfügung stellen.<br>
    00030  * Zudem gibt es noch Prüfungen, die auch direkt in dieser Klasse
    00031  * definiert sind und boolesche Ergebnisse zurückliefern.
    00032  * Die Schnittstellen dieser Klasse sind möglichst vielfältig, um
    00033  * alle nötigen Eingaben zu ermöglichen. Um die Algorithmen klein zu
    00034  * halten, wurde hier ein Großteil der Funktionalität für die
    00035  * Matrix implementiert.
    00036  *
    00037  * @version $Revision: 1.15 $
    00038  * @author Simon Tiffert
    00039  */
    00040 public class Matrix
    00041 {
    00042
    00043   /** Variable die anzeigt, ob die Matrix initialisiert wurde */
    00044   private boolean isInitialisiert = false;
    00045
    00046   /** zweidimensionales Feld als zentrales Element */
    00047   private int[][] matrix;
    00048
    00049   /** Anzahl der Sprungfelder */
    00050   private int sperrFeldAnzahl = 0;
    00051
    00052   /** Startpunkt der Sprungfolge */
    00053   private Punkt startpunkt = null;
    00054
    00055   /** Weg gefunden? */
    00056   private boolean wegGefunden = false;
    00057
    00058   /**
    00059    * Diese Funktion gibt zurück, wieviele Felder besuchbar sind.
    00060    * Dabei wird von der Anzahl der Felder die Anzahl der Sperrfelder
    00061    * abgezogen
    00062    *
    00063    * @return Feldanzahl (ohne Sperrfelder)
    00064    */
    00065   public int getFeldAnzahl()
    00066   {
    00067     return getXDimension() * getYDimension() - sperrFeldAnzahl;
    00068   }
    00069
    00070   /**
    00071    * Diese Funktion gibt den Startpunkt als Punkt zurück
    00072    *
    00073    * @return Startpunkt
    00074    */
    00075   public Punkt getStartpunkt()
    00076   {
    00077     return startpunkt;
    00078   }
    00079
    00080   /**
    00081    * Diese Funktion gibt einen Wert in der Matrix zurück
    00082    *
    00083    * @param y y-Koordinate des Punktes
    00084    * @param x x-Koordinate des Punktes
    00085    * @return den Wert der Matrix an der Stelle
    00086    */
    00087   public int getWert(int y, int x)
    00088   {
    00089     return matrix[y][x];
    00090   }
    00091
    00092   /**
    00093    * Diese Funktion gibt die X-Dimension der Matrix zurück
    00094    *
    00095    * @return X-Dimension der Matrix
    00096    */
    00097   public int getXDimension()
    00098   {
    00099     return matrix[0].length;
    00100   }
    00101
    00102   /**
    00103    * Diese Funktion gibt die Y-Dimension der Matrix zurück
    00104    *
    00105    * @return Y-Dimension der Matrix
    00106    */
    00107   public int getYDimension()
    00108   {
    00109     return matrix.length;
    00110   }
    00111
    00112   /**
    00113    * Funktion, die angibt, ob die Matrix schon initialisiert ist
    00114    *
    00115    * @return false: nicht initialisiert, true initialisiert
    00116    */
    00117   public boolean isInitialisiert()
    00118   {
    00119     return isInitialisiert;
    00120   }
    00121
    00122   /**
    00123    * Funktion, die überprüft, ob ein Wert innerhalb der Matrix liegt.
    00124    * Dabei werden folgende Möglichkeiten überprüft:
    00125    * <ul>
    00126    *  <li>y-Koordinate kleiner als 0</li>
    00127    *  <li>x-Koordinate kleiner als 0</li>
    00128    *  <li>y-Koordinate größer als y-Dimension der Matrix</li>
    00129    *  <li>x-Koordinate größer als x-Dimension der Matrix</li>
    00130    * </ul>
    00131    *
    00132    * Ist keiner dieser Fälle eingetreten, so befindet sich der Punkt
    00133    * in der Matrix
    00134    *
    00135    * @param y y-Koordinate des Punktes
    00136    * @param x x-Koordinate des Punktes
    00137    * @return Ob der Punkt innerhalb der Matrix liegt
    00138    */
    00139   public boolean isInMatrix(int y, int x)
    00140   {
    00141     // wenn die y-Koordinate kleiner als 0 ist
    00142     if (y < 0)
    00143     {
    00144       return false;
    00145     }
    00146
    00147     // wenn die x-Koordinate kleiner als 0 ist
    00148     if (x < 0)
    00149     {
    00150       return false;
    00151     }
    00152
    00153     // wenn die y-Koordinate größer als die Y-Dimension der Matrix ist
    00154     if (y >= this.getYDimension())
    00155     {
    00156       return false;
    00157     }
    00158
    00159     // wenn die x-Koordinate größer als die X-Dimension der Matrix ist
    00160     if (x >= this.getXDimension())
    00161     {
    00162       return false;
    00163     }
    00164
    00165     // Punkt ist in Matrix
    00166     return true;
    00167   }
    00168
    00169   /**
    00170    * Funktion, die überprüft, ob das übergebene Feld ein Sperrfeld ist.
    00171    * Dabei wird einfach überprüft, ob der Wert in der Matrix kleiner
    00172    * als 0 ist.
    00173    *
    00174    * @param y y-Koordinate des Punktes
    00175    * @param x x-Koordinate des Punktes
    00176    * @return Ob der Punkt schon ein Sperrfeld ist
    00177    */
    00178   public boolean isSperrfeld(int y, int x)
    00179   {
    00180     // ist der Punkt ein Sperrfeld, gib falsch zurück
    00181     if (this.getWert(y, x) < 0)
    00182     {
    00183       return true;
    00184     }
    00185
    00186     // Punkt ist kein Sperrfeld
    00187     return false;
    00188   }
    00189
    00190   /**
    00191    * Die Funktion überprüft, ob das übergebene Feld der Startpunkt ist.
    00192    * Geprüft wird, ob der übergebene Punkt mit dem gespeicherten
    00193    * Startpunkt übereinstimmt
    00194    *
    00195    * @param y y-Koordinate des Punktes
    00196    * @param x x-Koordinate des Punktes
    00197    * @return Ob der Punkt der Startpunkt ist
    00198    */
    00199   public boolean isStartpunkt(int y, int x)
    00200   {
    00201     // ist der Punkt der Startpunkt, gib wahr zurück
    00202     if (y == this.startpunkt.getY() && x == this.startpunkt.getX())
    00203     {
    00204       return true;
    00205     }
    00206
    00207     // Punkt ist nicht der Startpunkt
    00208     return false;
    00209   }
    00210
    00211   /**
    00212    * Funktion, die angibt, ob ein Weg gefunden wurde.
    00213    *
    00214    * @return <code>false</code>: kein Weg,
    00215    *         <code>true</code>: Weg gefunden
    00216    */
    00217   public boolean isWegGefunden()
    00218   {
    00219     return wegGefunden;
    00220   }
    00221
    00222   /**
    00223    * Diese Funktion erstellt die Matrix mit den übergebenen
    00224    * Dimensionen.
    00225    * Dabei wird direkt die Konsistenzprüfung durchgeführt, ob die
    00226    * angegebenen Dimensionen übereinstimmen.
    00227    * Prüfungen sind hier:
    00228    * <ul>
    00229    *  <li>angegebene Dimension kleiner als 0</li>
    00230    *  <li>angegebene Dimension größer als maximale Dimension</li>
    00231    * </ul>
    00232    *
    00233    * Liegen die angebenen Dimensionen innerhalb dieser Rahmen, so wird
    00234    * die Matrix mit den Dimensionsangaben angelegt.
    00235    *
    00236    * @param m y-Dimension der Matrix
    00237    * @param n x-Dimension der Matrix
    00238    * @throws WrongDimensionException Falsche Dimensionsangabe
    00239    */
    00240   public void setMatrix(int m, int n) throws WrongDimensionException
    00241   {
    00242     if (m <= 0
    00243       || n <= 0
    00244       || m > Main.maxDimension
    00245       || n > Main.maxDimension)
    00246     {
    00247       throw new WrongDimensionException();
    00248     }
    00249
    00250     matrix = new int[m][n];
    00251   }
    00252
    00253   /**
    00254    * Diese Funktion setzt ein Sperrfeld in der Matrix. Dabei werden
    00255    * auch die Konsistenzprüfungen durchgeführt.
    00256    * Geprüft wird:
    00257    * <ul>
    00258    *  <li>ob das Sperrfeld überhaupt innerhalb der Matrix liegt</li>
    00259    *  <li>ob das Sperrfeld schon eingetragen wurde</li>
    00260    *  <li>ob das Sperrfeld auf dem Startpunkt liegt</li>
    00261    * </ul>
    00262    * Wenn diese Prüfungen erfüllt sind, so wird das Sperrfeld als
    00263    * negativer Punkt (-1) in der Matrix eingetragen.
    00264    *
    00265    * @param y y-Koordinate des Sperrfeldes
    00266    * @param x x-Koordinate des Sperrfeldes
    00267    * @throws OutOfMatrixException Sperrfeld außerhalb der Matrix
    00268    * @throws IsSperrfeldException Sperrfeld schon vorhanden
    00269    * @throws IsStartpunktException Sperrfeld auf Startpunkt
    00270    */
    00271   public void setSperrfeld(int y, int x)
    00272     throws
    00273       OutOfMatrixException,
    00274       IsSperrfeldException,
    00275       IsStartpunktException
    00276   {
    00277     // wenn das Sperrfeld nicht in der Matrix liegt
    00278     if (!this.isInMatrix(y, x))
    00279     {
    00280       // werfe die Exception
    00281       throw new OutOfMatrixException(
    00282         "Sperrfeld X(" + (y + 1) + "," + (x + 1) + ")");
    00283     }
    00284
    00285     // wenn das Sperrfeld schon besetzt ist
    00286     if (this.isSperrfeld(y, x))
    00287     {
    00288       // werfe die Exception
    00289       throw new IsSperrfeldException(
    00290         "(" + (y + 1) + "," + (x + 1) + ")");
    00291     }
    00292
    00293     // wenn das Sperrfeld der Startpunkt ist
    00294     if (this.isStartpunkt(y, x))
    00295     {
    00296       // werfe die Exception
    00297       throw new IsStartpunktException(
    00298         "(" + (y + 1) + "," + (x + 1) + ")");
    00299     }
    00300
    00301     // erhöhe die Sperrfeldanzahl
    00302     sperrFeldAnzahl++;
    00303
    00304     // setze den Wert als negative Zahl (-1)
    00305     this.setWert(y, x, -1);
    00306   }
    00307
    00308   /**
    00309    * Diese Funktion speichert den Startpunkt für die Sprungfolge.
    00310    * Dabei wird direkt überprüft, ob der Wert innerhalb der Matrix
    00311    * liegt. Ansonsten wird eine Exception geworfen
    00312    *
    00313    * @param y y-Koordinate des Startpunktes
    00314    * @param x x-Koordinate des Startpunktes
    00315    * @exception OutOfMatrixException Startpunkt außerhalb der Matrix
    00316    * @exception ReDefinedStartpunktException Mehrfacher Startpunkt
    00317    */
    00318   public void setStartpunkt(int y, int x)
    00319     throws OutOfMatrixException, ReDefinedStartpunktException
    00320   {
    00321     // Wenn ein Startpunkt außerhalb der Matrix definiert wird
    00322     if (!this.isInMatrix(y, x))
    00323     {
    00324       // werfe Exception
    00325       throw new OutOfMatrixException(
    00326         "Startpunkt S(" + (y + 1) + "," + (x + 1) + ")");
    00327     }
    00328
    00329     // Wenn ein Startpunkt nochmal definiert wird, was bei der
    00330     // Verwendung als Unterprogramm passieren kann
    00331     if (startpunkt != null)
    00332     {
    00333       // werde Exception
    00334       throw new ReDefinedStartpunktException();
    00335     }
    00336
    00337     //  setze die Matrix auf den Zustand initialisiert
    00338     isInitialisiert = true;
    00339
    00340     // Der Startpunkt wird erstellt und gespeichert
    00341     startpunkt = new Punkt(y, x);
    00342   }
    00343
    00344   /**
    00345    * Funktion, die den Weg als gefunden markiert
    00346    */
    00347   protected void setWegGefunden()
    00348   {
    00349     wegGefunden = true;
    00350   }
    00351
    00352   /**
    00353    * Diese Funktion setzt den Wert der Matrix an einer Stelle
    00354    *
    00355    * @param y y-Koordinate des Punktes
    00356    * @param x x-Koordinate des Punktes
    00357    * @param wert Wert auf den der Punkt gesetzt werden soll
    00358    */
    00359   protected void setWert(int y, int x, int wert)
    00360   {
    00361     matrix[y][x] = wert;
    00362   }
    00363
    00364 }

Documentation created with Doxygen 1.3.6 | Fri May 14 11:15:26 2004