Hintergrundfarbe einer anderen Klasse ändern

[PeterVomMond]

Hallo!

Ich arbeite noch nicht so lange mit Java und stehe momentan vor einem kleinen Problem. Und zwar programiere ich zur Zeit ein kleines Würfelspiel bei dem zwei Spieler um die höhere Punktzahl würfeln, wie genau es abläuft ist aber für meine Frage unwichtig.

Ich habe eine Klasse Oberfläche, welche letztendlich auch die Oberfläche meines Spiels ist, das heißt hier drückt man die JButtons zum würfeln usw. Diese Klasse hat eine JMenuBar mit verschiedenen JMenus. Eines der JMenus ist Optionen mit dem JMenuItem Farbe. Ich habe es so programmiert, dass wenn man nun auf das JMenuItem Farbe klickt sich ein weiteres Fenster (die weitere Klasse Farbenfenster) öffnet. In diesem Fenster habe ich mehrere Buttons, mit welchen ich nun die Farbe der Oberflaeche ändern möchte.

Und genau hier liegt mein Problem, ich weiß nich wie ich von dieser Klasse aus die Farbe des Hintergrundes der anderen klasse ändern kann. Ich habe verschiedenen Dinge probiert, wie beispielsweise : Oberflaeche.setBackground(Color.Green) oder ähnliche Sachen, aber dies funktioniert nicht. Natürlich ist mir klar, dass es funktionieren würde, wenn ich einfach einen Button mit dieser Funktion in der Oberfläche machen würde, aber ich möchte ja gerade dies über die Menüleiste und den Optionenunterpunkt Farbe, also mithilfe der anderen Klasse erreichen.

Wie gesagt ich arbeite noch nicht lange mit Java und weiß nicht so recht wie hier weiterkommen kann :bahnhof:. Wäre toll, wenn mir jemand helfen könnte .

 

[MarcB]

Naja, du musst halt dem Dialog den du aufrufst eine Referenz auf die Instanz der Oberfläche mitgeben.

 

[Schandro]

Das Fenster zum Farbaussuchen ist eine eigene Klasse, oder? Gut.
Du musst ihm entweder eine referenz auf die Instanz der Oberfläche mitgeben oder einen art "Listener" (musst dafür selber ein passendes Interface definieren), den es aufruft. €dit: Das wäre eigentlich der bessere Weg, da so die Instanz der Oberfläche einfach nur eine Farbe als Parameter bekommt und selber entscheiden kann was damit passiert. Außerdem brauch so das FarbaussuchWindow nichts von der Oberfläche wissen, dadurch wird alles Orthogonaler d.h. du kannst deine Farbaussuch Klasse auch an anderen stellen verwenden. Deswegen würd ich dir den Weg mit den "Listener" empfehlen. Wenn du nicht weißt, wie sowas konkret aussieht, dann frag nochmal nach.

 

[PeterVomMond]

Naja wie gesagt ich arbeite noch nicht lange mit Java, weshalb ich auch noch nich ganz verstanden habe wie das mit dem "Listener" funktioniert.
Wäre toll wenn du mir ein Beispiel geben könntest oder mir anhand meines Programms erklären könntest wie ich was verändern muss.

 

[faetzminator]

Du hast im Farbauswahlfenster eine Methode addColorListener() und removeColorListener(), bei welchen jeweils einen ColorListener übergeben wird - dies ist ein Interface mit der Methode colorChanged(Color) oä.
Nun musst du diesen Typen in dem Hauptfenster verwenden, bei welchem du dann die Swing-spezifische Methode aufrufst.
Die anfänglich genannten Methoden stecken den Typen einfach in eine ArrayList oä bzw entfernen ihn. Wenn du dann auf dem GUI was klickst, musst du einfach in einer for-Schleife alle in der ArrayList vorhandenen ColorListener aufrufen (die Methode colorChanged(...)).

EDIT: natürlich muss sich das "Masterfenster" noch am "Color....fenster" per addColorListener(this) anhängen

 

[Schandro]

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class A{
    public static void main(String[] args){
        ExampleDialog myDialog = new ExampleDialog(new ResultListener(){
            public void incomingResult(Object result){
                System.out.println("myDialog liefert Ergebnis: "+result.toString());
            }
        });
        myDialog.setVisible(true);
    }
}

interface ResultListener{
    public void incomingResult(Object result);
}

class ExampleDialog extends JDialog{

    ResultListener listener;

    public ExampleDialog(final ResultListener listener){
        this.listener = listener;

        JButton ok = new JButton("OK");
        ok.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent event){
                listener.incomingResult("ok gedrückt");
                dispose();
            }
        });
        this.add(ok);
    }
}

Ein grobes Beispiel dafür wie eine solche Kommunikation über nen "Listener" funktionieren würde. (ich bin mir grade nicht sicher ob Listener der perfekte Name für sowas ist, aber egal).

Natürlich fehlt in dem Beispiel noch ein dynamisches Result.

Wenn du sowas anwenden willst, dann erstellst du das "MyDialog" Object natürlich nicht innerhalb der main Methode, sondern irgendwo in deiner Klasse Oberfläche. Und in deinem Beispiel wäre es natürlich sinvoll, das der Parameter der Methode resultIncoming direkt vom Typ "Color" ist..

 

[PeterVomMond]

Also wie gesagt ich bin ein ziemlich Anfänger in Sachen Java und bin im moment eher verwirrt, als das ich verstanden habe, wie ich das ganze auf mein Programm anwenden kann. Ich poste einfach mal meine beiden Klassen, auch wenn das ziemlich viel Platz einnimmt und durch die Kommentare ein bisschen durcheinander wirkt, aber vielleicht kannst du mir ja daran zeigen, wie das ganze in meinem Programm funktioniert, bzw. wie man es machen muss.



import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Farbenfenster extends JFrame implements ActionListener
{
private JButton button1,button2,button3,button4,button5; // es wird festgelegt, dass die genannten Jbuttons existieren
private JLabel intro; // es wird festgelegt, dass die benannten JLabels existieren


public Farbenfenster()
{
super("Farbenfenster"); // erstellt das "Farbenfenster"
Color meinFarbe = new Color(70,200,70); // eine eigene Farbe wird generiert
this.getContentPane().setBackground(meinFarbe); // der Hintergrund wir mit der selbst erstellten Farbe eingefärbt
this.getContentPane().setLayout(null);

button1 = new JButton ("Grün"); // "button1" wird alsa neuer JButton mit dem Text "Grün"bestimmt
button1.setBounds (300,350,130,30); // die Größe und Position von "button1" wird festgelegt
this.getContentPane().add(button1); // der JButton wird zu der Oberfläche hinzugefügt
button1.addActionListener(this); // der Actionlistener legt fest, das der JButton darauf wartet, dass er angeklickt wird
}


public void actionPerformed(ActionEvent event)
{
String cmd = event.getActionCommand();
// falls der Button betätigt wird soll folgendes passieren:
if (cmd.equals("Grün"))
{
this.getContentPane().setBackground(Color.green); // der Hintergrund wird grün eingefäbrt
this.getContentPane().setLayout(null);


}

}

}






import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Oberflaeche extends JFrame implements ActionListener
{
Icon icon = new ImageIcon("wuerfel07.gif"); // das benannte Bild wird in das Programm geladen

private Spiel spiel = new Spiel(); // erstellt ein neues Spiel
private JTextField result, ansage , punkte1 , punkte2 , siege1 , siege2; // legt fest, dass die benannten JTextFields existieren
private JLabel siegespieler1 , siegespieler2 , punktespieler1 , punktespieler2; // legt fest, dass die benannten JLabels existieren
private JButton button1 , button2 , button3, button4; // legt fest, dass die benannten JButtons existieren
private JMenuBar menu; // legt fest, dass die benannte JMenuBar existiert
private JMenu gameMenu, optionMenu , helpMenu; // legt fest, dass die benannten JMenus existieren



public Oberflaeche()
{
super("Wuerfelspiel"); // erstellt das "window" des Programms
Color meinFarbe = new Color(70,200,70); // eine eigene Farbe kann generiert werden
this.getContentPane().setBackground(meinFarbe); // der Hintergrund wir mit der selbst erstellten Farbe eingefärbt
this.getContentPane().setLayout(null);

menu = new JMenuBar(); // "menu" ist eine neue JMenuBar
setJMenuBar(menu);
gameMenu = new JMenu("Spiel"); // "gameMenu" ist ein neues JMenu in welchem "Spiel" steht
menu.add (gameMenu); // "gameMenu" wird zum "menu" hinzugefügt
optionMenu = new JMenu ("Optionen"); // "optionMenu" ist ein neues JMenu in welchem "Optionen" steht
menu.add (optionMenu); // "optionMenu" wird zum "menu" hinzugefügt
helpMenu = new JMenu ("Hilfe"); // "helpMenu" ist ein neues JMenu in welchem "Hilfe" steht
menu.add (helpMenu); // "helpMenu" wird zum "menu" hinzugefügt


JMenuItem playAction = new JMenuItem("Spielen");
gameMenu.add(playAction);

JMenuItem newAction = new JMenuItem("Neues Spiel");
gameMenu.add(newAction);
JMenuItem quitAction = new JMenuItem("Beenden");
gameMenu.add(quitAction);

JMenuItem colorAction = new JMenuItem("Farbe");
optionMenu.add(colorAction);
JMenuItem ruleAction = new JMenuItem("Regeln");
helpMenu.add(ruleAction);




playAction.addActionListener(new ActionListener() // playAction bekommz einen ActionListener
{
public void actionPerformed(ActionEvent event) // wenn der AcionListene benutzt wird passiert folgendes:
{
punkte1.setText(""); // der Text in "punkte1" wird gelöscht
punkte2.setText("");
result.setText("" + spiel.SpielAblauf()); // in "result" sollen die in der Methode Spielablauf in der Klasse Spiel erstellten Texte geschrieben werden
punkte1.setText("" + spiel.Spieler1.punkte); // in "punkte1" sollen die Punkte vom Spieler "Dennis" geschrieben werden
punkte2.setText("" + spiel.Spieler2.punkte); // in "punkte2" sollen die Punkte vom Spieler "Florian" geschrieben werden
siege1.setText("" + spiel.AnzahlDerSiege1()); // in "sieg1" sollen die Siege vom Spieler "Dennis" geschrieben werden
siege2.setText("" + spiel.AnzahlDerSiege2()); // in "sieg1" sollen die Siege vom Spieler "Dennis" geschrieben werden
spiel.neuesSpiel(); // die Methode "neuesSpiel" aus der Klasse "spiel" setzt alle Punkte der Spieler zurück auf 0
}
});


newAction.addActionListener(new ActionListener() // newAction bekommz einen ActionListener
{
public void actionPerformed(ActionEvent event) // wenn der AcionListene benutzt wird passiert folgendes:
{
spiel.neuesSpiel(); // die Methode "neuesSpiel" aus der Klasse "spiel" setzt alle Punkte der Spieler zurück auf 0
result.setText("Neues Spiel!"); // in "result" soll "Neues Spiel!" angezeigt werden
punkte1.setText(""); // der Text in "punkte1" wird gelöscht
punkte2.setText(""); // der Text in "punkte2" wird gelöscht
siege1.setText(""); // der Text in "siege1" wird gelöscht
siege2.setText(""); // der Text in "siege2" wird gelöscht
spiel.resetSiege(); // die Siege werden resetet
}
});


quitAction.addActionListener(new ActionListener() // quitAction bekommz einen ActionListener
{
public void actionPerformed(ActionEvent event) // wenn der AcionListene benutzt wird passiert folgendes:
{
setVisible(false); // das Fenster wird geschlossen / nicht sichtbar gemacht
dispose();
System.exit(1);
}
});


ruleAction.addActionListener(new ActionListener() // ruleAction bekommz einen ActionListener
{
public void actionPerformed(ActionEvent event) // wenn der AcionListene benutzt wird passiert folgendes:
{
String anleitung = "Das Spiel funktioniert wie folgt.\n\nEs gibt 2 Spieler, welche mit jeweils einem Würfelbecher (5 Würfel) abwechselnd 5 mal würfeln.\n\nDie gewürfelten Augenzahlen werden addiert und der Spieler, der die höchste Punktzahl hat, gewinnt das Spiel!\n\n Klicke auf Spielen um das Spiel einmal durchlaufen zu lassen.\n\nDies kannst du so oft wiederholen, wie du möchtest.\n\n Mit Neues Spiel kannst du die gesamten Punkte wieder auf Null setzen.\n\n Viel Spaß!!!";
JOptionPane.showMessageDialog(null, anleitung, "Hilfe", JOptionPane.OK_CANCEL_OPTION); // Der Frame wird ausgeführt.
}
});

colorAction.addActionListener(new ActionListener() // playAction bekommz einen ActionListener
{
public void actionPerformed(ActionEvent event) // wenn der AcionListene benutzt wird passiert folgendes:
{
Farbenfenster wnd2 = new Farbenfenster(); // Oberfläche wird erstellt / gestartet
wnd2.setSize(815,445); // Größe der Oberfläche wird festgelegt
wnd2.setVisible(true);
}
});

result=new JTextField(); // "result" wird als neues JTextField bestimmt
result.setBounds(100,200,150,30); // die Größe und Position von "result" wird festgelegt
this.getContentPane().add(result); // das JTextField wird zu der Oberfläche hinzugefügt
// --> in "result" wird das angezeigt, wer das Spiel gewonnen hat

ansage=new JTextField(); // "ansage" wird als neues JTextField bestimmt
ansage.setBounds(265,200,150,30); // die Größe und Position von "result" wird festgelegt
this.getContentPane().add(ansage); // das JTextField wird zu der Oberfläche hinzugefügt
// --> in "ansage" wird angezeigt, wenn jemand durch eine Zusatzregel gewonnen hat



punktespieler1 = new JLabel ("Punkte Spieler1:"); // "punktespieler1" wird als neues JLabel mit dem Text "Punkte Dennis" bestimmt
punktespieler1.setBounds(25,25,110,15); // die Größe und Position von "punktespieler" wird festgelegt
this.getContentPane().add(punktespieler1); // das JLabel wird zu der Oberfläche hinzugefügt
punkte1 = new JTextField(); // "punkte1" wird als neues JTextField bestimmt
punkte1.setBounds(125,25,70,35); // die Größe und Position von "punkte1" wird festgelegt
this.getContentPane().add(punkte1); // das JTextField wird zu der Oberfläche hinzugefügt
// --> in "punkte1" wird angezeigt, wie viele Punkte der Spieler "Dennis" bei seinem Wurf erzielt hat
punktespieler2 = new JLabel ("Punkte Spieler2:"); // "punktespieler2" wird als neues JLabel mit dem Text "Punkte Florian" bestimmt
punktespieler2.setBounds(225,25,110,15); // die Größe und Position von "punktespieler2" wird festgelegt
this.getContentPane().add(punktespieler2); // das JLabel wird zu der Oberfläche hinzugefügt

punkte2 = new JTextField(); // "punkte2" wird als neues JTextField bestimmt
punkte2.setBounds(325,25,70,35); // die Größe und Position von "punkte2" wird festgelegt
this.getContentPane().add(punkte2); // das JTextField wird zu der Oberfläche hinzugefügt
// --> in "punkte2" wird angezeigt, wie viele Punkte der Spieler "Florian" bei seinem Wurf erzielt hat

siegespieler1 = new JLabel ("Siege Spieler1:"); // "siegespieler1" wird als neues JLabel mit dem Text "Siege Dennis" bestimmt
siegespieler1.setBounds(25,100,110,15); // die Größe und Position von "siegespieler1" wird festgelegt
this.getContentPane().add(siegespieler1); // das JTextField wird zu der Oberfläche hinzugefügt
siege1 = new JTextField(); // "siege1" wird als neues JTextField bestimmt
siege1.setBounds(125,100,70,35); // die Größe und Position von "siege1" wird festgelegt
this.getContentPane().add(siege1); // das JTextField wird zu der Oberfläche hinugefügt
// --> in "siege1" wird angezeigt, wie oft der Spieler "Dennis" gewonnen hat

siegespieler2 = new JLabel ("Siege Spieler2:"); // "siegespieler2" wird als neues JLabel mit dem Text "Siege Dennis" bestimmt
siegespieler2.setBounds(225,100,110,15); // die Größe und Position von "siegespieler2" wird festgelegt
this.getContentPane().add(siegespieler2); // das JTextField wird zu der Oberfläche hinzugefügt

siege2 = new JTextField(); // "siege2" wird als neues JTextField bestimmt
siege2.setBounds(325,100,70,35); // die Größe und Position von "siege2" wird festgelegt
this.getContentPane().add(siege2); // das JTextField wird zu der Oberfläche hinugefügt
// --> in "siege2" wird angezeigt, wie oft der Spieler "Florian" gewonnen hat



button1 = new JButton ("Spielen"); // "button1" wird als neuer JButton mit dem Text "Wuerfeln" bestimmt
button1.setBounds (100,350,130,30); // die Größe und Position von "button1" wird festgelegt
this.getContentPane().add(button1); // der JButton wird zu der Oberfläche hinzugefügt
button1.addActionListener(this); // der Actionlistener legt fest, das der JButton darauf wartet, dass er angeklickt wird
// --> durch "Wuerfeln" wird das Spiel gestartet und durchläuft einmal den kompletten Wurfvorgang

button2 = new JButton ("Neues Spiel"); // "button2" wird als neuer JButton mit dem Text "Neues Spiel" bestimmt
button2.setBounds (300,350,130,30); // die Größe und Position von "button2" wird festgelegt
this.getContentPane().add(button2); // der JButton wird zu der Oberfläche hinzugefügt
button2.addActionListener(this); // der Actionlistener legt fest, das der JButton darauf wartet, dass er angeklickt wird
// --> durch "Neues Spiel" werden die alten Wurfergebnisse gelöscht und es kann erneut gewürfelt werden


button3 = new JButton ("Beenden"); // "button3" wird als neuer JButton mit dem Text "Beenden" bestimmt
button3.setBounds (500,350,130,30); // die Größe und Position von "button3" wird festgelegt
this.getContentPane().add(button3); // der JButton wird zu der Oberfläche hinzugefügt
button3.addActionListener(this); // --> durch "Beenden" wird das gesamte Programm geschlossen // der Actionlistener legt fest, das der JButton darauf wartet, dass er angeklickt wird
button4 = new JButton ("Hilfe");
button4.setBounds (650,350,130,30); // "button4" wird als neuer JButton mit dem Text "Hilfe" bestimmt
this.getContentPane().add(button4); // die Größe und Position von "button4" wird festgelegt
button4.addActionListener(this); // der JButton wird zu der Oberfläche hinzugefügt.l
// --> durch "Hilfe" wird die Anleitung angezeigt
JLabel bild = new JLabel (icon); // "bild" wird als neues JLabel mit der Funktion "icon" erstellt
bild.setBounds(100,125,480,331); // die Größe und Position von "bild" wird festgelegt
this.getContentPane().add(bild); // das JLabel wird zu der Oberfläche hinzugefügt
// --> das in das Programm geladene Bild wird auf der Oberfläche angezeigt
}






public void actionPerformed(ActionEvent event)
{
String cmd = event.getActionCommand(); // falls der JButton "Wurfeln" angeklickt wird soll folgendes passieren:
if (cmd.equals("Spielen"))
{
punkte1.setText(""); // der Text in "punkte1" wird gelöscht
punkte2.setText("");
result.setText("" + spiel.SpielAblauf()); // in "result" sollen die in der Methode Spielablauf in der Klasse Spiel erstellten Texte geschrieben werden
punkte1.setText("" + spiel.Spieler1.punkte); // in "punkte1" sollen die Punkte vom Spieler "Dennis" geschrieben werden

punkte2.setText("" + spiel.Spieler2.punkte); // in "punkte2" sollen die Punkte vom Spieler "Florian" geschrieben werden
siege1.setText("" + spiel.AnzahlDerSiege1()); // in "sieg1" sollen die Siege vom Spieler "Dennis" geschrieben werden
siege2.setText("" + spiel.AnzahlDerSiege2()); // in "sieg1" sollen die Siege vom Spieler "Dennis" geschrieben werden
spiel.neuesSpiel(); // die Methode "neuesSpiel" aus der Klasse "spiel" setzt alle Punkte der Spieler zurück auf 0
}


else if(cmd.equals("Neues Spiel")) // falls der JButton "Neues Spiel" angeklickt wird soll folgendes passieren:
{
spiel.neuesSpiel(); // die Methode "neuesSpiel" aus der Klasse "spiel" setzt alle Punkte der Spieler zurück auf 0
result.setText("Neues Spiel!"); // in "result" soll "Neues Spiel!" angezeigt werden
punkte1.setText(""); // der Text in "punkte1" wird gelöscht
punkte2.setText(""); // der Text in "punkte2" wird gelöscht
siege1.setText(""); // der Text in "siege1" wird gelöscht
siege2.setText(""); // der Text in "siege2" wird gelöscht
spiel.resetSiege(); // das Spiel wird resetet
}


else if (cmd.equals("Beenden")) // falls der JButton "Beenden" angeklickt wird soll folgendes passieren:
{
setVisible(false); // das Fenster wird geschlossen / nicht sichtbar gemacht
dispose();
System.exit(1);
}


else if(cmd.equals("Hilfe")) // falls der JButton "Hilfe" angeklickt wird soll folgendes passieren:
{
String anleitung = "Das Spiel funktioniert wie folgt.\n\nEs gibt 2 Spieler, welche mit jeweils einem Würfelbecher (5 Würfel) abwechselnd würfeln.\n\nDie gewürfelten Augenzahlen werden addiert und der Spieler, der die höchste Punktzahl hat, gewinnt das Spiel!\n\n Klicke auf Würfeln um das Spiel zu starten. Anschließend muss mit Hilfe von Neues Spiel die Punktzahl wieder auf Null gesetzt werden!\n\n Viel Spaß!!!";
JOptionPane.showMessageDialog(null, anleitung, "Hilfe", JOptionPane.OK_CANCEL_OPTION); // Der Frame wird ausgeführt.
}


}



}

 

[Schandro]

Du musst ein Interface definieren. Dieses braucht eine Methode, die das FarbaussuchWindow aufrufen kann.

Dem FarbaussuchWindow übergibst du im Konstruktor eine Instanz dieses Interfaces. Wie man Interfaces macht und eine konkrete Klasse das Interface implementieren lässt bzw. eine anonyme Klasse macht, ließt du am besten in einem Java Buch nach (Insel, das Java Handbuch, usw..)

Der Trick ist hierbei folgender:
Das FarbaussuchWindow speichert die übergebene Instanz des Interfaces in einer Membervaraible.
Sobald es an der Zeit ist, das das FarbaussuchWindow fertig ist, weil der Benutzter z.b. die Farbe ausgewählt hat, ruft das FarbaussuchWindow eine Methode der Instanz des Interfaces auf. Diese Methode hast du selber definiett, als du das Interface erstellst hast. Du kannst also eine Methode machen, die als Parameter ein Color-Object bekommt. Dadurch kann FarbaussuchWindow diese Methode mit der Color aufrufen, die der Benutzer ausgewählt hat.

Wo landed dieser Aufruf?
=> Als du die Instanz von FarbaussuchWindow erstellt hast, hast du ja eine konkrete Instanz des Interfaces hergestellt und als Parameter für den Konstruktor mitgegeben. Beim erstellen dieser konkreten Instanz musstest du ja definieren, was passiert sobald die "incominColorResult" Methode aufgerufen wird (oder wie auch immer du sie nennen willst). Dort könntest du also reinschreiben:
setBackground(colorWhichWasGivenAsParameter);


und fertig, so einfach ist OOP^^