klassen verknüpfen

[Endymion]

Ich habe folgendes Problem:
Ich möchte Attribute einer Klasse in eine Methode einer anderen Klasse integrieren. In diesem Fall möchte ich die Attribute "hoehe" und "breite" der Klasse "LABYRINTH" in die Methoden "NachSüdenBewegen" und "NachOstenBewegen". Ich habe versucht, das mit

        if(symbol.positionX < labyrinth.breite-1);

beziehungsweise

        if(symbol.positionX < labyrinth.breite-1)

zu machen. Wenn ich auf "Übersetzen" klicke, bekomme ich keine fehlermeldung. Wenn ich die Methoden allerdings anwenden will, wird diese nicht ausgeführt, sondern ich bekomme folgende Fehlermeldungen:
java.lang.ArrayIndexOutOfBoundsException: 8
at LABYRINTH.<init>(LABYRINTH.java:21)
Es wurden schon 2 Mampfidarstellungen hinzugefügt
java.lang.NullPointerException
at MAMPFI.NachSüdenBewegen(MAMPFI.java:87)
java.lang.NullPointerException
at MAMPFI.NachOstenBewegen(MAMPFI.java:78)
java.lang.NullPointerException
at MAMPFI.NachSüdenBewegen(MAMPFI.java:87)
beziehungsweise
java.lang.ArrayIndexOutOfBoundsException: 8
at LABYRINTH.<init>(LABYRINTH.java:21)
Es wurden schon 2 Mampfidarstellungen hinzugefügt
java.lang.NullPointerException
at MAMPFI.NachSüdenBewegen(MAMPFI.java:87)
java.lang.NullPointerException
at MAMPFI.NachOstenBewegen(MAMPFI.java:78)
java.lang.NullPointerException
at MAMPFI.NachSüdenBewegen(MAMPFI.java:87)
java.lang.NullPointerException
at MAMPFI.NachOstenBewegen(MAMPFI.java:78)

Wie verknüpfe ich diese beiden Methoden richtig? Falls notwendig poste ich noch die Quelltexte aller beteiligten Klassen:

public class MAMPFI
{
    // Attribute
    int positionX;
    int positionY;
    boolean verwundbar;
    char blickrichtung;
    
    // Referenzattribute
    MAMPFISYMBOL symbol;
    LABYRINTH labyrinth;
    
    // Konstruktor für Objekte der Klasse MAMPFI
    MAMPFI ()
    {
        verwundbar = true;
        blickrichtung = 'N';
        
        symbol = new MAMPFISYMBOL();
        symbol.RadiusSetzen(25);
        symbol.StartWinkelSetzen(120);
        symbol.BogenWinkelSetzen(300);
        symbol.BogenArtSetzen(2);
        symbol.FuellFarbeSetzen("gelb");
        symbol.PositionXSetzen(0);
        symbol.PositionYSetzen(0);
    }
    
    // Methoden
    void NachOstenBlicken ()
    {
        blickrichtung = 'O';
        symbol.StartWinkelSetzen(30);
    }
    void NachNordenBlicken ()
    {
        blickrichtung = 'N';
        symbol.StartWinkelSetzen(120);
    }
    void NachWestenBlicken ()
    {
        blickrichtung = 'W';
        symbol.StartWinkelSetzen(210);
    }
    void NachSüdenBlicken ()
    {
        blickrichtung = 'S';
        symbol.StartWinkelSetzen(300);
    }
    void VerwundbarSetzen(boolean verwundbarNeu)
    {
        verwundbar = verwundbarNeu;
        if (verwundbar == true)
        {
         symbol.FuellFarbeSetzen("gelb");
        }
        else
        {
            symbol.FuellFarbeSetzen("rot");
        }
    }
    void VerwundbarMachen ()
    {
        verwundbar = true;
        symbol.FuellFarbeSetzen("gelb");
    }
    void UnverwundbarMachen ()
    {
        verwundbar = false;
        symbol.FuellFarbeSetzen("rot");
    }
    void MundBewegtSichSetzen(boolean bewegtSichNeu)
    {
        symbol.MundBewegtSichSetzen(bewegtSichNeu);
    }
    void NachOstenBewegen()
    {
        if(symbol.positionX < labyrinth.breite-1)
        {
            symbol.PositionXSetzen(symbol.positionX+1);
            blickrichtung = 'O';        
            symbol.StartWinkelSetzen(30);
        }
    }
    void NachSüdenBewegen ()
    {
        if(symbol.positionY < labyrinth.hoehe-1)
        {
            symbol.PositionYSetzen(symbol.positionY+1);
            blickrichtung = 'S';
            symbol.StartWinkelSetzen(120);
        }
    }
    void NachWestenBewegen ()
    {
        if(symbol.positionX > 0)
        {
            symbol.PositionXSetzen(symbol.positionX-1);
            blickrichtung = 'W';
            symbol.StartWinkelSetzen(210);
        }
    }
    void NachNordenBewegen ()
    {
        if(symbol.positionY >0)
        {
            symbol.PositionYSetzen(symbol.positionY-1);
            blickrichtung = 'N';
            symbol.StartWinkelSetzen(300);
        }
    }
}

public class LABYRINTH
{
    //Attribute
    int breite;
    int hoehe;
    ZELLE[][] spielFlaeche;
    
    //Referenzattribute
    
    
    //Konstruktor
    LABYRINTH (int breiteNeu, int hoeheNeu)
    {
        breite = breiteNeu;
        hoehe = hoeheNeu;
        spielFlaeche = new ZELLE[breiteNeu][hoeheNeu];
        for (int zaehlerY = 0; zaehlerY<hoeheNeu; zaehlerY = zaehlerY+1)
        {
            for (int zaehlerX = 0; zaehlerX<breiteNeu; zaehlerX = zaehlerX+1)
            {
                spielFlaeche[zaehlerX][zaehlerY] = new ZELLE(zaehlerX,zaehlerY);
            }
        }
    }
    
    //Methoden
    void GaengeErstellen (int positionX, int positionY)
    {
        spielFlaeche[positionX][positionY].IstMauerSetzen(true);
    }
}

import backend.anzeige.Einstellungen;

/**
 *Diese Klasse dient zur Darstellung des Mampfi und zum anmelden des MAMPFI-Objekts am backend.
 *@author Sebastian Zinkhahn
 */
class MAMPFISYMBOL extends MampfiDarstellungImpl
{
	/**Die x-Position.*/
	int positionX;
	/**Die y-Position.*/
	int positionY;
	/**Der Radius.*/
	int radius; 
	 /**Gibt den Startwinkel des Bogens von der horizontalen Achse aus gesehen in Grad an.*/
	int startWinkel;
	 /**Gibt den Bogenumfang in Grad an.*/
	int bogenWinkel;
	/**Gibt an wie und ob der Bogen geschlossen ist.<br> Erlaubt sind: 0, 1, 2.*/
	int bogenArt; 
	/**Die Farbe, mit der das Symbol ausgefuellt werden soll.*/
	String fuellFarbe;
	/**Die Farbe, mit der der Rand des Symbols gezeichnet werden soll.*/
	String randFarbe;
	/**Gibt an, ob das Symbol ausgefuellt werden soll.*/
	boolean fuellungSichtbar;
	/**Gibt an, ob der Rand des Symbols gezeichnet werden soll.*/
	boolean randSichtbar;
	/**Gibt an ob sich der Mund sich abwechselnd &ouml;ffnet und schlie&szlig;t */
	boolean mundBewegtSich;

	/** Erzeugt ein neues Objekt dieser Klasse mit Standardwerten.
	 */
	public MAMPFISYMBOL()
	{
		super();
		radius = Einstellungen.ZellenRadiusGeben();
		startWinkel = (int) super.startWinkel;
		bogenWinkel = (int) super.bogenWinkel;
		bogenArt = super.bogenArt;
		fuellFarbe = "gelb";
		randFarbe = "gelb";
		fuellungSichtbar = true;
		randSichtbar = true;
		super.FuellFarbeSetzen(fuellFarbe);
		super.FuellungSichtbarSetzen(fuellungSichtbar);
		super.RandFarbeSetzen(randFarbe);
		super.RandSichtbarSetzen(randSichtbar);
	}
	
	/**Erzeugt ein neues Objekt dieser Klasse mit den &uuml;bergegebenen x- und y-Werten.
	 * @param xNeu die x-Position
	 * @param yNeu die y-Position
	 */
	public MAMPFISYMBOL(int xNeu, int yNeu)
	{
		super(xNeu, yNeu);
		positionX = xNeu;
		positionY = yNeu;
		radius = Einstellungen.ZellenRadiusGeben();
		startWinkel = (int) super.startWinkel;
		bogenWinkel = (int) super.bogenWinkel;
		bogenArt = super.bogenArt;
		fuellFarbe = "gelb";
		fuellFarbe = "gelb";
		randFarbe = "gelb";
		fuellungSichtbar = true;
		randSichtbar = true;
		super.FuellFarbeSetzen(fuellFarbe);
		super.FuellungSichtbarSetzen(fuellungSichtbar);
		super.RandFarbeSetzen(randFarbe);
		super.RandSichtbarSetzen(randSichtbar);
	}
	
	/**Weist dem Attribut radius einen neuen Wert zu.
	 * @param radiusNeu der neue Wert
	 */
	void RadiusSetzen(int radiusNeu)
	{
		if(radiusNeu >= 0 && radiusNeu <= Einstellungen.ZellenRadiusGeben())
		{
			radius = radiusNeu;
			super.RadiusSetzen(radiusNeu);
		}
		else System.err.println("Der Radius darf nicht negativ und nicht gr\u00f6\u00dfer als der Zellradius sein");
	}
	
	/**Weist dem Attribut startWinkel einen neuen Wert zu.
	 * @param winkelNeu der neue Wert
	 */
	void StartWinkelSetzen(int winkelNeu)
	{	
		super.StartWinkelSetzen(winkelNeu);
		startWinkel = winkelNeu;
	}
	
	/**Weist dem Attribut bogenWinkel einen neuen Wert zu.
	 * @param winkelNeu der neue Wert
	 */
	void BogenWinkelSetzen(int winkelNeu)
	{
		super.BogenWinkelSetzen(winkelNeu);
		bogenWinkel = winkelNeu;
	}
	
	/**Weist dem Attribut bogenArt einen neuen Wert zu.
	 * @param bogenArtNeu der neue Wert<br>
	 * 0 - offen,
	 * 1 - Segment,
	 * 2 - Kuchenstueck
	 */
	void BogenArtSetzen(int bogenArtNeu)
	{
		super.BogenArtSetzen(bogenArtNeu);
		bogenArt = bogenArtNeu;
	}
	
	/**Weist dem Attribut positionX einen neuen Wert zu.
	 * @param xNeu der neue Wert
	 */
	void PositionXSetzen(int xNeu)
	{
		super.PositionXSetzen(xNeu);
		positionX = xNeu;
	}
	

	/**Weist dem Attribut positionY einen neuen Wert zu.
	 * @param yNeu der neue Wert
	 */
	void PositionYSetzen(int yNeu)
	{
		super.PositionYSetzen(yNeu);
		positionY = yNeu;
	}
	
	/**Weist dem Attribut fuellFarbe einen neuen Wert zu
	 * @param farbeNeu der neue Wert (Name der Farbe)
	 */
	void FuellFarbeSetzen(String farbeNeu)
	{
		fuellFarbe = farbeNeu;
		super.FuellFarbeSetzen(farbeNeu);
	}
	
	/** Weist dem Attribut randFarbe einen neuen Wert zu
	 * @param farbeNeu der neue Wert (Name der Farbe)
	 */
	void RandFarbeSetzen(String farbeNeu)
	{
		randFarbe = farbeNeu;
		super.RandFarbeSetzen(farbeNeu);
	}
	
	/** Weist dem Attribut fuellungSichtbar einen neuen Wert zu
	 * @param sichtbarNeu true f&uuml;r sichtbar, false f&uuml;r unsichtbar
	 */
	void FuellungSichtbarSetzen(boolean sichtbarNeu)
	{
		fuellungSichtbar = sichtbarNeu;
		super.FuellungSichtbarSetzen(sichtbarNeu);
	}
	
	/**Weist dem Attribut randSichtbar einen neuen Wert zu
	 * @param sichbarNeu true f&uuml;r sichtbar, false f&uuml;r unsichtbar
	 */
	void RandSichtbarSetzen(boolean sichtbarNeu)
	{
		randSichtbar = sichtbarNeu;
		super.RandSichtbarSetzen(sichtbarNeu);
	}
	


	void MundBewegtSichSetzen(boolean bewegtSichNeu)
	{
		super.Bewegen(bewegtSichNeu);
		mundBewegtSich = bewegtSichNeu;
	}
}

public class ZELLE
{
    // Attribute
    int positionX;
    int positionY;
    boolean istMauer;
    
    // Referenzattribute
    ZELLENSYMBOL zsymbol;
    
    // Konstruktor
    ZELLE (int xNeu, int yNeu)
    {
        positionX = 0;
        positionY = 0;
        istMauer= false;        
        zsymbol = new ZELLENSYMBOL(xNeu, yNeu);
        zsymbol.FuellFarbeSetzen("blau");
        zsymbol.RandFarbeSetzen("schwarz");
        zsymbol.FuellungSichtbarSetzen(false);
        zsymbol.RandSichtbarSetzen(true);
    }
    void IstMauerSetzen (boolean istMauerNeu)
    {
        istMauer = istMauerNeu;
        zsymbol.FuellungSichtbarSetzen(istMauerNeu);
    }
    
}

/**
*
*Diese Klasse dient zur Dastellung einer ZELLE. Dabei ist darauf zu achten, dass
*die ZELLENDARSTELLUNG erst sichtbar wird, wenn ihr x- und y-Position übergeben wurden.
*Einmal übergeben, lassen sich die Koordinaten nicht mehr ändern.
*Willst Du z.B. die mit Mausklicks die ZELLE verändern, musst Du sie zuerst an das backend übergeben.
*Nutze dazu die Methode Anmelden().
*
*@author Sebastian Zinkhahn
*/

public class ZELLENSYMBOL extends ZellDarstellungImpl
{
  int positionX = super.positionX;
  int positionY = super.positionY;
  String fuellFarbe = "blau";
  String randFarbe = "schwarz";
  boolean fuellungSichtbar = false;
  boolean randSichtbar = true;
  
  /**
   * Erzeugt eine Zelle mit der angebeneben x- und y-Position im Labyrinth
   * @param xNeu
   * @param yNeu
   */
  public ZELLENSYMBOL(int xNeu, int yNeu)
  {
    super(xNeu, yNeu);
    super.FuellFarbeSetzen(fuellFarbe);
    super.FuellungSichtbarSetzen(fuellungSichtbar);
    super.RandFarbeSetzen(randFarbe);
    super.RandSichtbarSetzen(randSichtbar);
  }

//  /**
//   * Setzt die x- und y-Position der Darstellung.
//   * Diese Methode kann nur einmal(!) benutzt werden.
//   * Danach wirken sich die Änderungen nicht mehr aus.
//   * @see ZellDarstellungImpl#PositionXYSetzen(int, int)
//   */
//  public void PositionXYSetzen(int xNeu, int yNeu)
//  {
//    if(!super.init)
//    {
//      positionX = xNeu;
//      positionY = yNeu;
//    }
//    super.PositionXYSetzen(xNeu, yNeu);
//  }

  
 
  
  /**
   * Ändert die Füllfarbe dieses Symbols
   * @see KruemelDarstellungImpl#FarbeSetzen(java.lang.String)
   */
  public void FuellFarbeSetzen(String farbeNeu)
  {
    fuellFarbe = farbeNeu;
    super.FuellFarbeSetzen(farbeNeu);
  }
  
  /**
   * Ändert die Randfarbe dieses Symbols
   * @see backend.view.DarstellungImpl#RandFarbeSetzen(java.lang.String)
   */
  public void RandFarbeSetzen(String farbeNeu)
  {
    randFarbe = farbeNeu;
    super.RandFarbeSetzen(farbeNeu);
  }
  
  /**
   * Gibt an ob das Symbol ausgefüllt werden soll
   * @see backend.view.DarstellungImpl#FuellungSichtbarSetzen(boolean)
   */
  public void FuellungSichtbarSetzen(boolean b)
  {
    fuellungSichtbar = b;
    super.FuellungSichtbarSetzen(b);
  }
  
  /**
   * Gibt ob der Rand des Symbols gezeichnet werden soll
   * @see backend.view.DarstellungImpl#RandSichtbarSetzen(boolean)
   */
  public void RandSichtbarSetzen(boolean b)
  {
    randSichtbar = b;
    super.RandSichtbarSetzen(b);
  }
}

 

[Final_Striker]

java.lang.ArrayIndexOutOfBoundsException: 8
Irgendwo versuchst du auf Felder außerhalb deiner Spielfeld-Array zuzugreifen.

Mal ein Tipp: Man schreibt nur den ersten Buchstaben der Klasse groß und nicht alle. Das sieht ja grässlich aus.

 

[Andi_CH]

Da steht ja sogar genau wo die Exception auftritt:

LABYRINTH.<init>(LABYRINTH.java:21)

Klasse LABYRINTH - Methode init - Zeile 21 .....