✔ BlueJ

[Hoeze]

[Erledigt] BlueJ

Ich hab mal ne Frage bezüglich bluej:
In der Schule haben wir eine etwas ältere bluej version (2.x denke ich) und wir sollen/haben ein TicTacToe programmiert, allerdings muss man zum Ausführen der Aktionen immer so umständlich die versch. Methoden eingeben.

EDIT:
Hatte eine viel einfachere Idee: Warum nicht einfach die Klassen in Buttons umwandeln?
Ist das möglich? Wie stell ich das an?

Die vorgegebenen Klassen:

import java.awt.geom.Ellipse2D;

/**
 * Ein Kreis, der manipuliert werden kann und sich selbst auf einer Leinwand
 * zeichnet.
 * 
 * @author Michael Kölling und David J. Barnes
 * @version 2006.03.30
 */

public class Kreis {
	private int durchmesser;

	private int xPosition;

	private int yPosition;

	private String farbe;

	private boolean istSichtbar;

	/**
	 * Erzeuge einen neuen Kreis an einer Standardposition mit einer
	 * Standardfarbe.
	 */
	public Kreis(int d, int x, int y, String f) {
		durchmesser = d;
		xPosition = x;
		yPosition = y;
		farbe = f;
		istSichtbar = false;
		sichtbarMachen();
	}

	/**
	 * Mache diesen Kreis sichtbar. Wenn es bereits sichtbar ist, tue nichts.
	 */
	public void sichtbarMachen() {
		istSichtbar = true;
		zeichnen();
	}

	/**
	 * Mache diesen Kreis unsichtbar. Wenn es bereits unsichtbar ist, tue
	 * nichts.
	 */
	public void unsichtbarMachen() {
		loeschen();
		istSichtbar = false;
	}

	/**
	 * Bewege diesen Kreis einige Bildschirmpunkte nach rechts.
	 */
	public void nachRechtsBewegen() {
		horizontalBewegen(20);
	}

	/**
	 * Bewege diesen Kreis einige Bildschirmpunkte nach links.
	 */
	public void nachLinksBewegen() {
		horizontalBewegen(-20);
	}

	/**
	 * Bewege diesen Kreis einige Bildschirmpunkte nach oben.
	 */
	public void nachObenBewegen() {
		vertikalBewegen(-20);
	}

	/**
	 * Bewege diesen Kreis einige Bildschirmpunkte nach unten.
	 */
	public void nachUntenBewegen() {
		vertikalBewegen(20);
	}

	/**
	 * Bewege diesen Kreis horizontal um 'entfernung' Bildschirmpunkte.
	 */
	public void horizontalBewegen(int entfernung) {
		loeschen();
		xPosition += entfernung;
		zeichnen();
	}

	/**
	 * Bewege diesen Kreis vertikal um 'entfernung' Bildschirmpunkte.
	 */
	public void vertikalBewegen(int entfernung) {
		loeschen();
		yPosition += entfernung;
		zeichnen();
	}

	/**
	 * Bewege diesen Kreis langsam horizontal um 'entfernung' Bildschirmpunkte.
	 */
	public void langsamHorizontalBewegen(int entfernung) {
		int delta;

		if (entfernung < 0) {
			delta = -1;
			entfernung = -entfernung;
		} else {
			delta = 1;
		}

		for (int i = 0; i < entfernung; i++) {
			xPosition += delta;
			zeichnen();
		}
	}

	/**
	 * Bewege diesen Kreis langsam vertikal um 'entfernung' Bildschirmpunkte.
	 */
	public void langsamVertikalBewegen(int entfernung) {
		int delta;

		if (entfernung < 0) {
			delta = -1;
			entfernung = -entfernung;
		} else {
			delta = 1;
		}

		for (int i = 0; i < entfernung; i++) {
			yPosition += delta;
			zeichnen();
		}
	}

	/**
	 * Ändere den Durchmesser dieses Kreises in 'neuerDurchmesser' (Angabe in
	 * Bildschirmpunkten). 'neuerDurchmesser' muss größer gleich Null sein.
	 */
	public void groesseAendern(int neuerDurchmesser) {
		loeschen();
		durchmesser = neuerDurchmesser;
		zeichnen();
	}

	/**
	 * Ändere die Farbe dieses Kreises in 'neueFarbe'. Gültige Angaben sind
	 * "rot", "gelb", "blau", "gruen", "lila" und "schwarz".
	 */
	public void farbeAendern(String neueFarbe) {
		farbe = neueFarbe;
		zeichnen();
	}

	/**
	 * Zeichne diesen Kreis mit seinen aktuellen Werten auf den Bildschirm.
	 */
	private void zeichnen() {
		if (istSichtbar) {
			Leinwand leinwand = Leinwand.gibLeinwand();
			leinwand.zeichne(this, farbe, new Ellipse2D.Double(xPosition,
					yPosition, durchmesser, durchmesser));
			leinwand.warte(10);
		}
	}

	/**
	 * Lösche diesen Kreis vom Bildschirm.
	 */
	private void loeschen() {
		if (istSichtbar) {
			Leinwand leinwand = Leinwand.gibLeinwand();
			leinwand.entferne(this);
		}
	}

}

import java.awt.Polygon;

/**
 * Ein Dreieck, das manipuliert werden kann und sich selbst auf einer Leinwand
 * zeichnet.
 * 
 * @author Michael Kölling und David J. Barnes
 * @version 2006.03.30
 */

public class Dreieck {
	private int hoehe;

	private int breite;

	private int xPosition;

	private int yPosition;

	private String farbe;

	private boolean istSichtbar;

	/**
	 * Erzeuge ein Dreieck mit einer Standardfarbe an einer Standardposition.
	 */
	public Dreieck(int h, int b, int x, int y, String f) {
		hoehe = h;
		breite = b;
		xPosition = x;
		yPosition = y;
		farbe = f;
		istSichtbar = false;
		sichtbarMachen();
	}

	/**
	 * Mache dieses Dreieck sichtbar. Wenn es bereits sichtbar ist, tue nichts.
	 */
	public void sichtbarMachen() {
		istSichtbar = true;
		zeichnen();
	}

	/**
	 * Mache dieses Dreieck unsichtbar. Wenn es bereits unsichtbar ist, tue
	 * nichts.
	 */
	public void unsichtbarMachen() {
		loeschen();
		istSichtbar = false;
	}

	/**
	 * Bewege dieses Dreieck einige Bildschirmpunkte nach rechts.
	 */
	public void nachRechtsBewegen() {
		horizontalBewegen(20);
	}

	/**
	 * Bewege dieses Dreieck einige Bildschirmpunkte nach links.
	 */
	public void nachLinksBewegen() {
		horizontalBewegen(-20);
	}

	/**
	 * Bewege dieses Dreieck einige Bildschirmpunkte nach oben.
	 */
	public void nachObenBewegen() {
		vertikalBewegen(-20);
	}

	/**
	 * Bewege dieses Dreieck einige Bildschirmpunkte nach unten.
	 */
	public void nachUntenBewegen() {
		vertikalBewegen(20);
	}

	/**
	 * Bewege dieses Dreieck horizontal um 'entfernung' Bildschirmpunkte.
	 */
	public void horizontalBewegen(int entfernung) {
		loeschen();
		xPosition += entfernung;
		zeichnen();
	}

	/**
	 * Bewege dieses Dreieck vertikal um 'entfernung' Bildschirmpunkte.
	 */
	public void vertikalBewegen(int entfernung) {
		loeschen();
		yPosition += entfernung;
		zeichnen();
	}

	/**
	 * Bewege dieses Dreieck langsam horizontal um 'entfernung'
	 * Bildschirmpunkte.
	 */
	public void langsamHorizontalBewegen(int entfernung) {
		int delta;

		if (entfernung < 0) {
			delta = -1;
			entfernung = -entfernung;
		} else {
			delta = 1;
		}

		for (int i = 0; i < entfernung; i++) {
			xPosition += delta;
			zeichnen();
		}
	}

	/**
	 * Bewege dieses Dreieck langsam vertikal um 'entfernung' Bildschirmpunkte.
	 */
	public void langsamVertikalBewegen(int entfernung) {
		int delta;

		if (entfernung < 0) {
			delta = -1;
			entfernung = -entfernung;
		} else {
			delta = 1;
		}

		for (int i = 0; i < entfernung; i++) {
			yPosition += delta;
			zeichnen();
		}
	}

	/**
	 * Ändere die Höhe in 'neueHoehe' und die Breite in 'neueBreite'. Beide
	 * Angaben müssen größer gleich Null sein.
	 */
	public void groesseAendern(int neueHoehe, int neueBreite) {
		loeschen();
		hoehe = neueHoehe;
		breite = neueBreite;
		zeichnen();
	}

	/**
	 * Ändere die Farbe dieses Dreiecks in 'neueFarbe'. Gültige Angaben sind
	 * "rot", "gelb", "blau", "gruen", "lila" und "schwarz".
	 */
	public void farbeAendern(String neueFarbe) {
		farbe = neueFarbe;
		zeichnen();
	}

	/**
	 * Zeichne dieses Dreieck mit seinen aktuellen Werten auf den Bildschirm.
	 */
	private void zeichnen() {
		if (istSichtbar) {
			Leinwand leinwand = Leinwand.gibLeinwand();
			int[] xpoints = { xPosition, xPosition + (breite / 2),
					xPosition - (breite / 2) };
			int[] ypoints = { yPosition, yPosition + hoehe, yPosition + hoehe };
			leinwand.zeichne(this, farbe, new Polygon(xpoints, ypoints, 3));
			leinwand.warte(10);
		}
	}

	/**
	 * Lösche dieses Dreieck vom Bildschirm.
	 */
	private void loeschen() {
		if (istSichtbar) {
			Leinwand leinwand = Leinwand.gibLeinwand();
			leinwand.entferne(this);
		}
	}
}

import java.awt.Rectangle;

/**
 * Ein Quadrat, das manipuliert werden kann und sich selbst auf einer Leinwand
 * zeichnet.
 * 
 * @author Michael Kölling und David J. Barnes
 * @version 2006.03.30
 */

public class Quadrat {
	private int groesse;

	private int xPosition;

	private int yPosition;

	private String farbe;

	private boolean istSichtbar;

	/**
	 * Erzeuge ein neues Quadrat mit einer Standardfarbe an einer
	 * Standardposition.
	 */
	public Quadrat(int g, int x, int y, String f) {
		groesse = g;
		xPosition = x;
		yPosition = y;
		farbe = f;
		istSichtbar = true;
		zeichnen();
	}

	/**
	 * Mache dieses Quadrat sichtbar. Wenn es bereits sichtbar ist, tue nichts.
	 */
	public void sichtbarMachen() {
		istSichtbar = true;
		zeichnen();
	}

	/**
	 * Mache dieses Quadrat unsichtbar. Wenn es bereits unsichtbar ist, tue
	 * nichts.
	 */
	public void unsichtbarMachen() {
		loeschen();
		istSichtbar = false;
	}

	/**
	 * Bewege dieses Quadrat einige Bildschirmpunkte nach rechts.
	 */
	public void nachRechtsBewegen() {
		horizontalBewegen(20);
	}

	/**
	 * Bewege dieses Quadrat einige Bildschirmpunkte nach links.
	 */
	public void nachLinksBewegen() {
		horizontalBewegen(-20);
	}

	/**
	 * Bewege dieses Quadrat einige Bildschirmpunkte nach oben.
	 */
	public void nachObenBewegen() {
		vertikalBewegen(-20);
	}

	/**
	 * Bewege dieses Quadrat einige Bildschirmpunkte nach unten.
	 */
	public void nachUntenBewegen() {
		vertikalBewegen(20);
	}

	/**
	 * Bewege dieses Quadrat horizontal um 'entfernung' Bildschirmpunkte.
	 */
	public void horizontalBewegen(int distance) {
		loeschen();
		xPosition += distance;
		zeichnen();
	}

	/**
	 * Bewege dieses Quadrat vertikal um 'entfernung' Bildschirmpunkte.
	 */
	public void vertikalBewegen(int entfernung) {
		loeschen();
		yPosition += entfernung;
		zeichnen();
	}

	/**
	 * Bewege dieses Quadrat langsam horizontal um 'entfernung'
	 * Bildschirmpunkte.
	 */
	public void langsamHorizontalBewegen(int entfernung) {
		int delta;

		if (entfernung < 0) {
			delta = -1;
			entfernung = -entfernung;
		} else {
			delta = 1;
		}

		for (int i = 0; i < entfernung; i++) {
			xPosition += delta;
			zeichnen();
		}
	}

	/**
	 * Bewege dieses Quadrat langsam vertikal um 'entfernung' Bildschirmpunkte.
	 */
	public void langsamVertikalBewegen(int entfernung) {
		int delta;

		if (entfernung < 0) {
			delta = -1;
			entfernung = -entfernung;
		} else {
			delta = 1;
		}

		for (int i = 0; i < entfernung; i++) {
			yPosition += delta;
			zeichnen();
		}
	}

	/**
	 * Ändere die Größe dieses Quadrates in 'neueGroesse'. 'neueGroesse' muss
	 * groesser gleich Null sein.
	 */
	public void groesseAendern(int neueGroesse) {
		loeschen();
		groesse = neueGroesse;
		zeichnen();
	}

	/**
	 * Ändere die Farbe dieses Quadrates in 'neueFarbe'. Gültige Angaben sind
	 * "rot", "gelb", "blau", "gruen", "lila" und "schwarz".
	 */
	public void farbeAendern(String neueFarbe) {
		farbe = neueFarbe;
		zeichnen();
	}

	/**
	 * Zeichne dieses Quadrat mit seinen aktuellen Werten auf den Bildschirm.
	 */
	private void zeichnen() {
		if (istSichtbar) {
			Leinwand leinwand = Leinwand.gibLeinwand();
			leinwand.zeichne(this, farbe, new Rectangle(xPosition, yPosition,
					groesse, groesse));
			leinwand.warte(10);
		}
	}

	/**
	 * Lösche dieses Quadrat vom Bildschirm.
	 */
	private void loeschen() {
		if (istSichtbar) {
			Leinwand leinwand = Leinwand.gibLeinwand();
			leinwand.entferne(this);
		}
	}
}

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Shape;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.swing.JFrame;
import javax.swing.JPanel;

/**
 * Leinwand ist eine Klasse, die einfache Zeichenoperationen auf einer
 * leinwandartigen Zeichenfläche ermöglicht. Sie ist eine vereinfachte Version
 * der Klasse Canvas (englisch für Leinwand) des JDK und wurde speziell für das
 * Projekt "Figuren" geschrieben.
 * 
 * 
 * @author: Bruce Quig
 * @author: Michael Kölling (mik)
 * @author: Axel Schmolitzky
 * 
 * @version: 2006.03.30
 */
public class Leinwand {
	// Hinweis: Die Implementierung dieser Klasse (insbesondere die
	// Verwaltung der Farben und Identitäten der Figuren) ist etwas
	// komplizierter als notwendig. Dies ist absichtlich so, weil damit
	// die Schnittstellen und Exemplarvariablen der Figuren-Klassen
	// für den Lernanspruch dieses Projekts einfacher und klarer
	// sein können.

	private static Leinwand leinwandSingleton;

	/**
	 * Fabrikmethode, die eine Referenz auf das einzige Exemplar dieser Klasse
	 * zurückliefert. Wenn es von einer Klasse nur genau ein Exemplar gibt, wird
	 * dieses als 'Singleton' bezeichnet.
	 */
	public static Leinwand gibLeinwand() {
		if (leinwandSingleton == null) {
			leinwandSingleton = new Leinwand("BlueJ Figuren Demo", 300, 300,
					Color.white);
		}
		leinwandSingleton.setzeSichtbarkeit(true);
		return leinwandSingleton;
	}

	// ----- Exemplarvariablen -----

	private JFrame fenster;

	private Zeichenflaeche zeichenflaeche;

	private Graphics2D graphic;

	private Color hintergrundfarbe;

	private Image leinwandImage;

	private List<Object> figuren;

	private Map<Object, ShapeMitFarbe> figurZuShape;
	
	/**
	 * Erzeuge eine Leinwand.
	 * 
	 * @param titel
	 *            Titel, der im Rahmen der Leinwand angezeigt wird
	 * @param breite
	 *            die gewünschte Breite der Leinwand
	 * @param hoehe
	 *            die gewünschte Höhe der Leinwand
	 * @param grundfarbe
	 *            die Hintergrundfarbe der Leinwand
	 */
	private Leinwand(String titel, int breite, int hoehe, Color grundfarbe) {
		fenster = new JFrame();
		zeichenflaeche = new Zeichenflaeche();
		fenster.setContentPane(zeichenflaeche);
		fenster.setTitle(titel);
		zeichenflaeche.setPreferredSize(new Dimension(breite, hoehe));
		hintergrundfarbe = grundfarbe;
		fenster.pack();
		figuren = new ArrayList<Object>();
		figurZuShape = new HashMap<Object, ShapeMitFarbe>();
	}

	/**
	 * Setze, ob diese Leinwand sichtbar sein soll oder nicht. Wenn die Leinwand
	 * sichtbar gemacht wird, wird ihr Fenster in den Vordergrund geholt. Diese
	 * Operation kann auch benutzt werden, um ein bereits sichtbares
	 * Leinwandfenster in den Vordergrund (vor andere Fenster) zu holen.
	 * 
	 * @param sichtbar
	 *            boolean für die gewünschte Sichtbarkeit: true für sichtbar,
	 *            false für nicht sichtbar.
	 */
	public void setzeSichtbarkeit(boolean sichtbar) {
		if (graphic == null) {
			// erstmaliger Aufruf: erzeuge das Bildschirm-Image und fülle
			// es mit der Hintergrundfarbe
			Dimension size = zeichenflaeche.getSize();
			leinwandImage = zeichenflaeche.createImage(size.width, size.height);
			graphic = (Graphics2D) leinwandImage.getGraphics();
			graphic.setColor(hintergrundfarbe);
			graphic.fillRect(0, 0, size.width, size.height);
			graphic.setColor(Color.black);
		}
		fenster.setVisible(sichtbar);
	}

	/**
	 * Zeichne für das gegebene Figur-Objekt eine Java-Figur (einen Shape) auf
	 * die Leinwand.
	 * 
	 * @param figur
	 *            das Figur-Objekt, für das ein Shape gezeichnet werden soll
	 * @param farbe
	 *            die Farbe der Figur
	 * @param shape
	 *            ein Objekt der Klasse Shape, das tatsächlich gezeichnet wird
	 */
	public void zeichne(Object figur, String farbe, Shape shape) {
		figuren.remove(figur); // entfernen, falls schon eingetragen
		figuren.add(figur); // am Ende hinzufügen
		figurZuShape.put(figur, new ShapeMitFarbe(shape, farbe));
		erneutZeichnen();
	}

	/**
	 * Entferne die gegebene Figur von der Leinwand.
	 * 
	 * @param figur
	 *            die Figur, deren Shape entfernt werden soll
	 */
	public void entferne(Object figur) {
		figuren.remove(figur); // entfernen,falls schon eingetragen
		figurZuShape.remove(figur);
		erneutZeichnen();
	}

	/**
	 * Setze die Zeichenfarbe der Leinwand.
	 * 
	 * @param farbname
	 *            der Name der neuen Zeichenfarbe.
	 */
	public void setzeZeichenfarbe(String farbname) {
		if (farbname.equals("rot")) {
			graphic.setColor(Color.red);
		} else if (farbname.equals("schwarz")) {
			graphic.setColor(Color.black);
		} else if (farbname.equals("blau")) {
			graphic.setColor(Color.blue);
		} else if (farbname.equals("gelb")) {
			graphic.setColor(Color.yellow);
		} else if (farbname.equals("gruen")) {
			graphic.setColor(Color.green);
		} else if (farbname.equals("lila")) {
			graphic.setColor(Color.magenta);
		} else if (farbname.equals("weiss")) {
			graphic.setColor(Color.white);
		} else {
			graphic.setColor(Color.black);
		}
	}

	/**
	 * Warte für die angegebenen Millisekunden. Mit dieser Operation wird eine
	 * Verzögerung definiert, die für animierte Zeichnungen benutzt werden kann.
	 * 
	 * @param millisekunden
	 *            die zu wartenden Millisekunden
	 */
	public void warte(int millisekunden) {
		try {
			Thread.sleep(millisekunden);
		} catch (Exception e) {
			// Exception ignorieren
		}
	}

	/**
	 * Zeichne erneut alle Figuren auf der Leinwand.
	 */
	private void erneutZeichnen() {
		loeschen();
		for (Object figur : figuren) {
			figurZuShape.get(figur).draw(graphic);
		}
		zeichenflaeche.repaint();
	}

	/**
	 * Lösche die gesamte Leinwand.
	 */
	private void loeschen() {
		Color original = graphic.getColor();
		graphic.setColor(hintergrundfarbe);
		Dimension size = zeichenflaeche.getSize();
		graphic.fill(new Rectangle(0, 0, size.width, size.height));
		graphic.setColor(original);
	}

	/***************************************************************************
	 * Interne Klasse Zeichenflaeche - die Klasse für die GUI-Komponente, die
	 * tatsächlich im Leinwand-Fenster angezeigt wird. Diese Klasse definiert
	 * ein JPanel mit der zusätzlichen Möglichkeit, das auf ihm gezeichnet Image
	 * aufzufrischen (erneut zu zeichnen).
	 */
	private class Zeichenflaeche extends JPanel {
		private static final long serialVersionUID = 20060330L;

		public void paint(Graphics g) {
			g.drawImage(leinwandImage, 0, 0, null);
		}
	}

	/***************************************************************************
	 * Interne Klasse ShapeMitFarbe - Da die Klasse Shape des JDK nicht auch
	 * eine Farbe mitverwalten kann, muss mit dieser Klasse die Verknüpfung
	 * modelliert werden.
	 */
	private class ShapeMitFarbe {
		private Shape shape;

		private String farbe;

		public ShapeMitFarbe(Shape shape, String farbe) {
			this.shape = shape;
			this.farbe = farbe;
		}

		public void draw(Graphics2D graphic) {
			setzeZeichenfarbe(farbe);
			graphic.fill(shape);
		}
	}

}

 

[Hoeze]

Ich verzweilfle langsam... ICH HASSE BLUEJ!! Nichts funktioniert hier vernünftig...
Hab jetzt einfach mal versucht, aus diesem Beilspiel ein paar Sachen zu übernehmen, aber jetzt lässt er mich das package events nicht importieren, und wenn ichs dann ohne versuche, meint er "invalid method declaration, return type required"...

import java.awt.event;
import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
import java.awt.Rectangle;

/**
 * Ein Quadrat, das manipuliert werden kann und sich selbst auf einer Leinwand
 * zeichnet.
 * 
 * @author Michael Kölling und David J. Barnes
 * @version 2006.03.30
 */

public class Quadrat implements MouseListener
{
    addMouseListener(this);
    
    private int groesse;

    private int xPosition;

    private int yPosition;

    private String farbe;

    private boolean istSichtbar;

    /**
     * Erzeuge ein neues Quadrat mit einer Standardfarbe an einer
     * Standardposition.
     */
    public Quadrat(int g, int x, int y, String f) {
        groesse = g;
        xPosition = x;
        yPosition = y;
        farbe = f;
        istSichtbar = true;
        zeichnen();
    }

    /**
     * Mache dieses Quadrat sichtbar. Wenn es bereits sichtbar ist, tue nichts.
     */
    public void sichtbarMachen() {
        istSichtbar = true;
        zeichnen();
    }

    /**
     * Mache dieses Quadrat unsichtbar. Wenn es bereits unsichtbar ist, tue
     * nichts.
     */
    public void unsichtbarMachen() {
        loeschen();
        istSichtbar = false;
    }

    /**
     * Bewege dieses Quadrat einige Bildschirmpunkte nach rechts.
     */
    public void nachRechtsBewegen() {
        horizontalBewegen(20);
    }

    /**
     * Bewege dieses Quadrat einige Bildschirmpunkte nach links.
     */
    public void nachLinksBewegen() {
        horizontalBewegen(-20);
    }

    /**
     * Bewege dieses Quadrat einige Bildschirmpunkte nach oben.
     */
    public void nachObenBewegen() {
        vertikalBewegen(-20);
    }

    /**
     * Bewege dieses Quadrat einige Bildschirmpunkte nach unten.
     */
    public void nachUntenBewegen() {
        vertikalBewegen(20);
    }

    /**
     * Bewege dieses Quadrat horizontal um 'entfernung' Bildschirmpunkte.
     */
    public void horizontalBewegen(int distance) {
        loeschen();
        xPosition += distance;
        zeichnen();
    }

    /**
     * Bewege dieses Quadrat vertikal um 'entfernung' Bildschirmpunkte.
     */
    public void vertikalBewegen(int entfernung) {
        loeschen();
        yPosition += entfernung;
        zeichnen();
    }

    /**
     * Bewege dieses Quadrat langsam horizontal um 'entfernung'
     * Bildschirmpunkte.
     */
    public void langsamHorizontalBewegen(int entfernung) {
        int delta;

        if (entfernung < 0) {
            delta = -1;
            entfernung = -entfernung;
        } else {
            delta = 1;
        }

        for (int i = 0; i < entfernung; i++) {
            xPosition += delta;
            zeichnen();
        }
    }

    /**
     * Bewege dieses Quadrat langsam vertikal um 'entfernung' Bildschirmpunkte.
     */
    public void langsamVertikalBewegen(int entfernung) {
        int delta;

        if (entfernung < 0) {
            delta = -1;
            entfernung = -entfernung;
        } else {
            delta = 1;
        }

        for (int i = 0; i < entfernung; i++) {
            yPosition += delta;
            zeichnen();
        }
    }

    /**
     * Ändere die Größe dieses Quadrates in 'neueGroesse'. 'neueGroesse' muss
     * groesser gleich Null sein.
     */
    public void groesseAendern(int neueGroesse) {
        loeschen();
        groesse = neueGroesse;
        zeichnen();
    }

    /**
     * Ändere die Farbe dieses Quadrates in 'neueFarbe'. Gültige Angaben sind
     * "rot", "gelb", "blau", "gruen", "lila" und "schwarz".
     */
    public void farbeAendern(String neueFarbe) {
        farbe = neueFarbe;
        zeichnen();
    }

    /**
     * Zeichne dieses Quadrat mit seinen aktuellen Werten auf den Bildschirm.
     */
    private void zeichnen() {
        if (istSichtbar) {
            Leinwand leinwand = Leinwand.gibLeinwand();
            leinwand.zeichne(this, farbe, new Rectangle(xPosition, yPosition,
                    groesse, groesse));
            leinwand.warte(10);
        }
    }

    /**
     * Lösche dieses Quadrat vom Bildschirm.
     */
    private void loeschen() {
        if (istSichtbar) {
            Leinwand leinwand = Leinwand.gibLeinwand();
            leinwand.entferne(this);
        }
    }
    
     public void mousePressed(MouseEvent e) {
       saySomething("Mouse pressed; # of clicks: "
                    + e.getClickCount(), e);
    }

    public void mouseReleased(MouseEvent e) {
       saySomething("Mouse released; # of clicks: "
                    + e.getClickCount(), e);
    }

    public void mouseEntered(MouseEvent e) {
       saySomething("Mouse entered", e);
    }

    public void mouseExited(MouseEvent e) {
       saySomething("Mouse exited", e);
    }

    public void mouseClicked(MouseEvent e) {
       saySomething("Mouse clicked (# of clicks: "
                    + e.getClickCount() + ")", e);
    }

   
}

 

[SE]

Um dich erstemal etwas runterzubringen : die richtigen Tags für Java sind [code=java][/code] und nicht [code][/code] oder gar [code=php][/code].
Das ist für das richtige Syntaxhighlightning wichtig !
Zweitens : natürlich kannst du

import java.awt.event;

nicht importieren weil es diese Klasse nicht gibt !
Richtiger weise müsste dein import so aussehen

import java.awt.*;
import java.awt.event.*;

Dadurch sparrst du dir die Expliziten Klassen importe wenn du gleich ein größeres Package importierst.
Drittens : du kannst keine Objektzuweisung außerhalb einer Methode machen. Davon abgesehen das THIS als solches nicht in einer Klasse sondern nur innerhalb eines Objektes existiert und sich auf die Referenz des eigenen Objektes bezieht.
Viertens : in deiner Klasse ist nirgendwo eine Methode mit der Signatur

<T> saySomething(String)

deklariert wesshalb der Compiler die Zeilen in denen darauf zugegriffen werden soll mit recht beanstandet.

Man sieht du bist noch ziemlicher neuling was Java angeht. Ich empfehle dir umfangreiche Fachliteratur wie z.B. die JavaInsel *Google : "openbook javainsel". Dieses Buch ist sowohl für Ein- und Umsteiger zum erlenen von Java als auch als Nachschlagewerk für Fortgeschrittene konzipiert und erfüllt dies meiner persönlichen Meinung nach mehr als nur SEHR GUT.

Was du dir vielleicht angewöhnen solltest : Aussagen wie "geht nicht" sind nicht wirklich hilfreich. Du musst uns schon genau sagen was wo wie nicht geht und auch die Fehlermeldungen dazu posten *diese am besten in [code][/code] wegen der Formatierug*.

Wir stehen dir bei konkreten Problemen gerne zur verfügung, aber wir können weder hellsehen noch erledigen wir Aufgaben die eigentlich deine Arbeit und Leistung sein sollen.

 

[Hoeze]

Danke, das mit dem saySomething weiß ich, war ja nur als Test gedacht, ich bin sowieso nicht über den ersten Fehler hinausgekommen

Mittlerweile glaube ich zu wissen, worauf ich zu achten habe:
1. das mit dem Import und das "implements MouseListener",
2. dass ich alle Events implementiere (sofern ich keinen adapter habe),
3. dass ich "addMouseListener(this)" in den Konstruktor einfüge
Richtig?

Denn das funktioniert nicht, ich bekommefür addMouseListener(this) den Fehler "cannot find symbol - method addMouseListener(Quadrat)":
Wie behebe ich das?

import java.awt.*;
import java.awt.event.*;
import java.awt.Rectangle;


/**
 * Ein Quadrat, das manipuliert werden kann und sich selbst auf einer Leinwand
 * zeichnet.
 * 
 * @author Michael Kölling und David J. Barnes
 * @version 2006.03.30
 */

public class Quadrat implements MouseListener
{

    
    private int groesse;
    private int xPosition;
    private int yPosition;
    private String farbe;
    private boolean istSichtbar;

    /**
     * Erzeuge ein neues Quadrat mit einer Standardfarbe an einer
     * Standardposition.
     */
    public Quadrat(int g, int x, int y, String f) {
        
        addMouseListener(this);
        groesse = g;
        xPosition = x;
        yPosition = y;
        farbe = f;
        istSichtbar = true;
        zeichnen();
    }
    
    public void mouseDown(MouseEvent event) { farbeAendern("rot"); }
    public void mouseEntered(MouseEvent e) { farbeAendern("gelb"); }
    public void mouseExited(MouseEvent e) { farbeAendern("gruen"); }
    public void mouseClicked(MouseEvent e) { farbeAendern("blau"); }
    public void mouseReleased(MouseEvent e) { farbeAendern("lila"); }
    public void mousePressed(MouseEvent e) { farbeAendern("lila"); }
    
    
    //Der Rest, an dem ich nichts geändert habe

    /**
     * Mache dieses Quadrat sichtbar. Wenn es bereits sichtbar ist, tue nichts.
     */
    public void sichtbarMachen() {
        istSichtbar = true;
        zeichnen();
    }

    /**
     * Mache dieses Quadrat unsichtbar. Wenn es bereits unsichtbar ist, tue
     * nichts.
     */
    public void unsichtbarMachen() {
        loeschen();
        istSichtbar = false;
    }

    /**
     * Bewege dieses Quadrat einige Bildschirmpunkte nach rechts.
     */
    public void nachRechtsBewegen() {
        horizontalBewegen(20);
    }

    /**
     * Bewege dieses Quadrat einige Bildschirmpunkte nach links.
     */
    public void nachLinksBewegen() {
        horizontalBewegen(-20);
    }

    /**
     * Bewege dieses Quadrat einige Bildschirmpunkte nach oben.
     */
    public void nachObenBewegen() {
        vertikalBewegen(-20);
    }

    /**
     * Bewege dieses Quadrat einige Bildschirmpunkte nach unten.
     */
    public void nachUntenBewegen() {
        vertikalBewegen(20);
    }

    /**
     * Bewege dieses Quadrat horizontal um 'entfernung' Bildschirmpunkte.
     */
    public void horizontalBewegen(int distance) {
        loeschen();
        xPosition += distance;
        zeichnen();
    }

    /**
     * Bewege dieses Quadrat vertikal um 'entfernung' Bildschirmpunkte.
     */
    public void vertikalBewegen(int entfernung) {
        loeschen();
        yPosition += entfernung;
        zeichnen();
    }

    /**
     * Bewege dieses Quadrat langsam horizontal um 'entfernung'
     * Bildschirmpunkte.
     */
    public void langsamHorizontalBewegen(int entfernung) {
        int delta;

        if (entfernung < 0) {
            delta = -1;
            entfernung = -entfernung;
        } else {
            delta = 1;
        }

        for (int i = 0; i < entfernung; i++) {
            xPosition += delta;
            zeichnen();
        }
    }

    /**
     * Bewege dieses Quadrat langsam vertikal um 'entfernung' Bildschirmpunkte.
     */
    public void langsamVertikalBewegen(int entfernung) {
        int delta;

        if (entfernung < 0) {
            delta = -1;
            entfernung = -entfernung;
        } else {
            delta = 1;
        }

        for (int i = 0; i < entfernung; i++) {
            yPosition += delta;
            zeichnen();
        }
    }

    /**
     * Ändere die Größe dieses Quadrates in 'neueGroesse'. 'neueGroesse' muss
     * groesser gleich Null sein.
     */
    public void groesseAendern(int neueGroesse) {
        loeschen();
        groesse = neueGroesse;
        zeichnen();
    }

    /**
     * Ändere die Farbe dieses Quadrates in 'neueFarbe'. Gültige Angaben sind
     * "rot", "gelb", "blau", "gruen", "lila" und "schwarz".
     */
    public void farbeAendern(String neueFarbe) {
        farbe = neueFarbe;
        zeichnen();
    }

    /**
     * Zeichne dieses Quadrat mit seinen aktuellen Werten auf den Bildschirm.
     */
    private void zeichnen() {
        if (istSichtbar) {
            Leinwand leinwand = Leinwand.gibLeinwand();
            leinwand.zeichne(this, farbe, new Rectangle(xPosition, yPosition,
                    groesse, groesse));
            leinwand.warte(10);
        }
    }

    /**
     * Lösche dieses Quadrat vom Bildschirm.
     */
    private void loeschen() {
        if (istSichtbar) {
            Leinwand leinwand = Leinwand.gibLeinwand();
            leinwand.entferne(this);
        }
    }
    
     

    
}

EDIT:
Sry, hab ich falsch kopiert (hab zu früh kopiert), die Fehlermeldung stimmt aber wirklich.

 

[SE]

So wird da nicht. Du hast meinen Post scheinbar nicht richtig gelesen.
1) Warum importierst du javax.swing.* ? In deinem aktuellen Source finde ich keine Swing-Komponent > kann raus.
2) Warum importierst du java.awt.* und java.awt.event.* und dann noch mal explizit darin enthaltenen Klassen ? Wenn du ein Paket importierst werden ALLE darin enthaltenen Klassen *KEINE Sub-Packages* importiert.
Dein gesamtes import sollte also so aussehen :

import java.awt.*;
import java.awt.event.*;

NICHT MEHR !
3) Wo bitte liegt addMouseListener() innerhalb des Konstruktors ? Es ist immer noch falsch ! Wenn dann gehört das wie du schon richtig gesagt IN den Konstruktor ... also innerhalb von

public Quadrat(int, int, int, String)

4) Du kannst nicht einfach wahllos addMouseListener aufrufen. Du musst schon von einer Klasse ableiten die diese Methode implementiert hat. Für AWT also mindestens java.awt.Component oder einer der Sub-Klassen.
5) Hast du dir mal die JavaInsel angesehen ? Dort gibt es gleich mehrere Kapitel die sich mit AWT und Swing beschäftigen. Dort ist alles erklärt. Und das sogar für Anfänger.
6) Es geht mich nichts an aber dieses rumgecaste mit deinen Klassen und Methoden da ... *Leinwand.entferne(Component) ...* ähm .. JA ... nur so viel dazu : es ist kein Problem wenn sich jemand caster-Klassen baut wenn er nicht gut Englisch kann oder dierektes Arbeiten nicht kann ... aber letztendlich ist es nichts weiter als vorgeschaltete Klassen die lediglich die Aufrufe an die entsprechenden Objekte weitergeben. Da du auf dem Gebiet eh noch nicht sehr viel Ahnung hast wäre es ratsam dir von Anfang an das dierekte Arbeiten mit den vorgebenen Klassen und Objekten zu lernen und nicht da noch irgendwas vorgegebenes außendrum. Das wird dich später mal vor einige Probleme stellen wenn du diese Klassen nicht mehr zur Verfügung hast.
Du hast echt noch einiges an Lernbedarf auf dem Gebiet GUI. Auch würde ich dir von BlueJ abraten da dies eher schlecht als recht sein soll. Wenn du schon mit einer IDE programmieren lernen willst nimm entweder Eclipse *eine Umgebung für mehrere Sprachen* oder das selbst in Java geschrieben NetBeans von Sun.

Wie gesagt : wirf erstmal einen Blick in die JavaInsel und frage dann bitte bei konkreten Problemen nach. Wir können dir nicht helfen wenn du da solche Konstrukte mit caster-Klassen verwendest. Auch würdest du es dann sicher nicht verstehen wenn sich jemand den Aufwand machen würde und das ganze komplett neu implementieren würde ... was aber nicht unsere Aufgabe ist.

 

[Hoeze]

Hab den vorherigen Post editiert, die Fehlermeldung stimmt, ich hab nur den falschen quellcode kopiert.
Wegen dieser Klassen: Ich hab die nicht geschrieben, wir sollten daraus in der Schule nur ein Spiel programmieren, allerdings sollte man für einen Spielzug die Methode manuell aufrufen, einen Wert eingeben und dann änderte sich ein bestimmtes Feld. Das ist einfach UMSTÄNDLICH.
Deswegen wollte ich versuchen, sowas über Mauseingabe zu regeln. Vom graphischen Oberflächen programmieren hab ich gar keine Ahnung weil ich das bisher noch nie gemacht habe, weder in C++ noch in Java, in Java kann ich noch ungefähr so viel anfangen wie wir in der Schule gelernt haben und was man aus C++ übernehmen kann.
Ich dachte das lässt sich mit ner zusätzlichen Funktion regeln, aber anscheinend zieht MouseListener doch nen ziemlichen Rattenschwanz nach sich.
Grundsätzlich mag ich eclipse viel lieber aber was soll ich machen in der Schule kann/darf ich das nicht verwenden
Die Javainsel hab ich nach Listener durchsucht und bin dadurch auf genau die drei Sachen gekommen aus meinem vorherigen Post.

Grundsätzlich würde mich mal interessieren, ob ich da jetzt etwas FALSCH gemacht habe.

EDIT:
Du hast geschrieben:

4) Du kannst nicht einfach wahllos addMouseListener aufrufen. Du musst schon von einer Klasse ableiten die diese Methode implementiert hat. Für AWT also mindestens java.awt.Component oder einer der Sub-Klassen.

DAS war es, warum es nicht funktioniert hat. Wenn ich extends java.awt.Component hinschreibe funktionierts.
DANKE DIR

 

[SE]

Du hast das mit den import-Anweisungen noch nicht ganz verstanden.

Wenn du in deiner Klasse ganz oben drinstehen hast

import java.awt.*;
import java.awt.event.*;

und damit die beiden Pakete java.awt und java.awt.event KOMPLETT importierst ... warum hast du dann da drunter noch mal ein explizites import von java.awt.Rectangle stehen ? Das ist
1) überflüssig da bereits durchs Paket importiert
2) der Compiler diese Zeile eh rausschmeißt aus dem bei 1) genannten Sachverhalt.

Und was den MouseListener angeht ... es gibt die abstrakte Klasse java.awt.event.MouseAdapter
Diese kannst du als anonyme Klasse an den MouseListener übergeben. Der vorteil von diesen abstrakten Adapter-Klassen ist das du nur die Methode zu implementieren brauchst die du auch verwendest *gut .. das spart dir dann pro unbenutzter Methode 1 Zeile*.
Wenn du Fragen zu inneren Klassen hast > JavaInsel ... da ist das lang und breit erklärt *sogar mit allen 4 Formen*

//EDIT
btw : Wenn dein Problem nun gelöst ist makieren den Thread bitte als ERLEDIGT.