Actionlistener - 3 klassen - kompliziert - auf methoden zugreifen

[pcProfie]

moin
vlt kennt ihr die beispiel projekte in bluej. ich wollte das eine projekt bearbeiten. es beinhaltet folgendes:
klasse quadrat - macht quadrat auf leinwand
klasse zeichnung - ablauf mit methoden wie bewege - hier werden neue quadrate usw. gemacht und positionen und so verwaltet - halt ein bild gemacht
klasse leinwand - ein jframe mit panel auf komplizierter weise gemacht

ich habe in der zeichnung ein haus gebaut. halt so sachen wie quadrat fenster = new quadrat... fenster bewege... naja die klassen insgesamt haben keine main aber das wäre eig die zeichnung mit der main. halt die methode zeichne in der das haus gezeichnet wird. in der klasse leinwand habe ich dann ein menu gebaut halt das ding oben damit ich damit methoden aus der zeichnung aufrufen kann zb. sonnenuntergang. da bewegt sich die sonne nach unten (methode bewegeunten aus der klasse quadrat benutzt). man braucht ja einen actionlistener für das menuitem.

kann man den listener in der klasse zeichnung haben obwohl das menu in der klasse leinwand ist

ODER

kann man das menu mit dem listener in der klasse zeichnung haben obwohl das frame in der leinwand ist

im listener (klasse leinwand): Zeichnung.bewegen();
das problem ist wenn ich alles in der klasse leinwand habe, dass er cannot use non-static method bewegen (klasse zeichnung) in static context sagt. wenn ich mit Zeichnung z; z= new Zeichnung(); z.bewegen(); arbeite kriege ich einen nullpointer.

danke schonmal

 

[Michael...]

kann man den listener in der klasse zeichnung haben obwohl das menu in der klasse leinwand ist

macht das Sinn?

kann man das menu mit dem listener in der klasse zeichnung haben obwohl das frame in der leinwand ist

Bahnhof?

Meine (persönliche) Empfehlung: spätestens wenn man Programmieren will sollte man das BlueJ Umfeld verlassen.

 

[nillehammer]

Man kann nicht "den ActionListener irgendwo haben". Es muss eine Klasse dieses Interface implementieren. Fragt sich jetzt welche. Im ersten Schritt würde ich genau die Klassen das Interface implementieren lassen, die auf die Klicks im Menü reagieren sollen. Wenn ich Deine Beschreibung richtig verstehe, wäre das bei Dir wohl die Klasse Zeichnung.

Im zweiten Schritt könnte man jetzt argumentieren, dass man durch direktes Implementieren in Zeichnung eigentlich zwei zu trennende Aufgaben in einer Klasse vermischt und dementsprechend den ActionListener extra implementieren und dann die Methoden der Zeichnung aufrufen lassen. Aber fang vielleicht erstmal einfach an.

 

[pcProfie]

zuallererst: die aufgabe ist eine weiterführung von dem was wir in der schule machen (wir haben gestern mit java angefangen und ich "kanns" schon seit 1,5 jahren. man lehrnt ja immer was dazu. ich habe robos programmiert applets und gui programme XD. ich hab noch mehr I) mit dem programm vor (neuer thread, main, und mehr I))))
2.
klasse quadrat hat folgende methoden:
sichbarMAchen, unsichtbarMachen, größe ändern, farbe ändern, zeichnen, löschen, bewegen
(zeichenen: leinwand.zeichne(this, farbe, new Rectangle(xPosition, yPosition,
groesse, groesse)); ist der kern)
variabeln:
groesse(int), farbe(string), x(int), y(int) und sichtbar(boolean)

klasse zeichnung
sonnenuntergang, zeichne(muss zuerst), in der zeichne werden die quadrate gemacht zb. boden=new Quadrat; boden.sichtbarMachen....
variabeln nur quadrat objekte und ein boolean aber der ist nicht wichtig

klasse leinwand

import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.swing.*;

//actionlistener auch meins XD
public class Leinwand implements ActionListener {
    private static Leinwand leinwandSingleton;

    public static Leinwand gibLeinwand() {
        if (leinwandSingleton == null) {
            leinwandSingleton = new Leinwand("me", 300, 300,
                Color.cyan);
        }
        leinwandSingleton.setzeSichtbarkeit(true);
        return leinwandSingleton;
    }

    private JFrame fenster;
    private Zeichenflaeche zeichenflaeche;
    private Graphics2D graphic;
    private Color hintergrundfarbe;
    private Image leinwandImage;
    private List<Object> figuren;
    private Map<Object, ShapeMitFarbe> figurZuShape;
//von hier
    JMenuBar menuBar;
    JMenuItem menuItem;
    JMenu menu;

    Zeichnung zz;
//bis hier meins

    private Leinwand(String titel, int breite, int hoehe, Color grundfarbe) {
        zz = new Zeichnung();
        fenster = new JFrame();
        zeichenflaeche = new Zeichenflaeche();
        fenster.setContentPane(zeichenflaeche);
        fenster.setTitle(titel);
        zeichenflaeche.setPreferredSize(new Dimension(breite, hoehe));
        hintergrundfarbe = grundfarbe;

//von hier
        menuBar = new JMenuBar();
        menu = new JMenu("Menu");
        menuItem = new JMenuItem("A text-only menu item");
        menu.add(menuItem);
        menuBar.add(menu);
        fenster.setJMenuBar(menuBar);  
        menuItem.addActionListener(this);

        fenster.setResizable(false);
//bis hier von mir

        fenster.pack();
        figuren = new ArrayList<Object>();
        figurZuShape = new HashMap<Object, ShapeMitFarbe>();
    }
    


    public void actionPerformed(ActionEvent event) {
        //Zeichnung.bewegen(); HIER EIN PROBLEM
    }

    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);
        }
    }

}

ich hab euch bisher nicht gesagt dass es auch dreieck und kreis gibt die sind aber genauso wie quadrat XD. passiert das gleiche
nochmal die klasse zeichnung:

public class Zeichnung
{
    private Quadrat wand;
    private Quadrat fenster;
    private Dreieck dach;
    private Kreis sonne;
    Quadrat schornstein;
    Quadrat schwarz;
    Quadrat turunten;
    Quadrat turoben;
    boolean runter=false;
    Quadrat boden;

    /**
     * Erzeuge ein Exemplar der Klasse Zeichnung
     */
    public Zeichnung()
    {
        // nichts zu tun hier, alle Exemplarvariablen werden automatisch
        // mit null initialisiert.
    }

    public void bewegen() {
        try {
            Thread.sleep(1000);
        }
        catch(Exception e) {}
        boden.sichtbarMachen();
        for(int i=0; i<15; i++) {
            boden.sichtbarMachen();
            if(runter) {
                sonne.nachUntenBewegen();
                try {
                    Thread.sleep(200);
                }
                catch(Exception e) {}
                runter=false;
            }
            else{
                runter=true;
            }
            boden.sichtbarMachen();
        }
        
        sonne.farbeAendern("rot");
        boden.sichtbarMachen();
        try {
            Thread.sleep(1000);
        }
        catch(Exception e) {}
        boden.sichtbarMachen();
        sonne.unsichtbarMachen();
    }

    /**
     * Zeichne die Zeichnung.
     */
    public void zeichne()
    {
        //"rot", "gelb", "blau", "gruen", "lila" und "schwarz".

        boden=new Quadrat();
        boden.farbeAendern("gruen");
        boden.horizontalBewegen(-100);
        boden.vertikalBewegen(170);
        boden.groesseAendern(2000);
        boden.sichtbarMachen();

        schwarz=new Quadrat();
        schwarz.farbeAendern("schwarz");
        schwarz.horizontalBewegen(60);
        schwarz.vertikalBewegen(30);
        schwarz.sichtbarMachen();

        schornstein=new Quadrat();
        schornstein.farbeAendern("lila");
        schornstein.horizontalBewegen(60);
        schornstein.vertikalBewegen(35);
        schornstein.sichtbarMachen();

        wand = new Quadrat();
        wand.vertikalBewegen(80);
        wand.groesseAendern(100);
        wand.sichtbarMachen();

        fenster = new Quadrat();
        fenster.farbeAendern("schwarz");
        fenster.horizontalBewegen(20);
        fenster.vertikalBewegen(100);
        fenster.sichtbarMachen();

        dach = new Dreieck();  
        dach.groesseAendern(50, 140);
        dach.horizontalBewegen(60);
        dach.vertikalBewegen(70);
        dach.sichtbarMachen();

        sonne = new Kreis();
        sonne.farbeAendern("gelb");
        sonne.horizontalBewegen(180);
        sonne.vertikalBewegen(-10);
        sonne.groesseAendern(60);
        sonne.sichtbarMachen();

        boden=new Quadrat();
        boden.farbeAendern("gruen");
        boden.horizontalBewegen(-100);
        boden.vertikalBewegen(170);
        boden.groesseAendern(2000);
        boden.sichtbarMachen();
    }

    /**
     * Ändere die Darstellung in schwarz-weiß.
     */
    public void inSchwarzWeissAendern()
    {
        if(wand != null)   // nur wenn schon gezeichnet wurde ...
        {
            wand.farbeAendern("schwarz");
            fenster.farbeAendern("weiss");
            dach.farbeAendern("schwarz");
            sonne.farbeAendern("schwarz");
        }
    }

    /**
     * Ändere die Darstellung in Farbe.
     */
    public void inFarbeAendern()
    {
        if(wand != null)   // nur wenn schon gezeichnet wurde ...
        {
            wand.farbeAendern("rot");
            fenster.farbeAendern("schwarz");
            dach.farbeAendern("gruen");
            sonne.farbeAendern("gelb");
        }
    }
}

und das quadrat

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() {
		groesse = 30;
		xPosition = 60;
		yPosition = 50;
		farbe = "rot";
		istSichtbar = false;
	}

	/**
	 * 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);
		}
	}
}