Interface ActionListener in eigener Klasse

[Javaman91]

Hallo zusammen,

ich habe den ActionListener in eine eigene Klasse ausgelagert.Wenn ich nun den ActionListener in der Main-Klasse dem Button zuordne, dann bekomme ich einen Fehler bei der erzeugung des Buttons selbst.

Hier die Klasse mit dem ActionListener:

package Bibliotheken;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;

public class Button extends JButton implements ActionListener {

    public static int richtung;
   
    public JButton button;   
    //public JButton button1;
    //public JButton button2;
    //public JButton button3;
   
    public Button(JButton button){
       
        this.button = button;
        this.setSize(90, 20);
    }
   
    @Override
    public void actionPerformed(ActionEvent event) {
       
        if(event.getSource() == button){
           
            //richtung = 1;
            System.out.println("Es hat funktioniert!");
        }
       
        /*
        else if(event.getSource() == this.button1){
       
            richtung = 2;
        }
   
        else if(event.getSource() == this.button2){
       
            richtung = 3;
        }
       
        else if(event.getSource() == this.button3){
           
            richtung = 4;
        }
        */
}
   
    public int getRichtung(){
       
        return richtung;
    }
}

Hier ist die Main-Klasse, wo der Button erzeugt wird.
Hier wird auch der ActionListener beim Button angemeldet.

package Bibliotheken;

import java.awt.event.ActionEvent;

public class Hauptfenster {

    public static int richtungsangabe;
    public static int xpos;
    public static int ypos;
    public static Spieler spieler;
    public static Rahmen spielfeld ;
    public Button button;
   
    public static Button up;
    public static Button down;
    public static Button left;
    public static Button rigth;
    public static Button stop;
   
    public Hauptfenster(){
       
        spielfeld = new Rahmen();
        spieler = new Spieler();
       
        up = new Button(); // Hier ist "new Button rot unterstrichen"
        up.addActionListener(new Button(up));
       
        //down = new Button();
        //down.addActionListener(new Button(übergabe));
       
        //left = new Button();
        //left.addActionListener(new Button(übergabe));
       
        //rigth = new Button();
        //rigth.addActionListener(new Button(übergabe));
       
        //stop = new Button();
        //stop.addActionListener(new Button(übergabe));
       
        up.setText("AUF");
        down.setText("RUNTER");
        left.setText("LINKS");
        rigth.setText("RECHTS");
        stop.setText("STOP");

        up.setLocation(30, 520);
        down.setLocation(150, 520);
        left.setLocation(280, 520);
        rigth.setLocation(400, 520);
        stop.setLocation(500, 520);
       
        spielfeld.add(up);
        spielfeld.add(down);
        spielfeld.add(left);
        spielfeld.add(rigth);
        spielfeld.add(stop);
        spielfeld.add(spieler);
}
   
    public static void main(String[] args) {
       
        Hauptfenster fenster = new Hauptfenster();
       
        while(true){
           
            up.getRichtung();
            down.getRichtung();
            left.getRichtung();
            rigth.getRichtung();
           
            if(richtungsangabe == 1){    // AUF
               
                ypos = + 1;
            }
           
            else if(richtungsangabe == 2){ // RUNTER
               
                ypos = - 1;
            }
           
            else if(richtungsangabe == 3){ // RECHTS
               
                xpos = + 1;
            }
           
            else if(richtungsangabe == 4){ // LINKS
               
                xpos = - 1;
            }
           
            spieler.setXpos(xpos);
            spieler.setYpos(ypos);
           
            spielfeld.repaint();
           
        }

    }

}

Warum?

 

[Flown]

Ich weiß gar nicht wo man hier anfangen soll.
Bitte beschäftige dich doch mal mit Java-Grundlagen (Datenkapselung, visibility-modifer, separation of concerns, Game-loops, UI-Desing, uvm.).

 

[Meniskusschaden]

up = new Button(); // Hier ist "new Button rot unterstrichen"
up.addActionListener(new Button(up));

Mir ist deine Erwartungshaltung an deinen eigenen Code überhaupt nicht klar. Du versuchst hier zunächst einen Button zu erstellen, was natürlich nicht funktioniert, weil es dafür keinen parameterlosen Konstruktor gibt. Das müsste deine IDE auch anzeigen (bei Eclipse, wenn du mit der Maus auf die rote Unterstreichung gehst).
Danach versuchst du dem Button, der selbst ein ActionListener ist, einen ActionListener hinzuzufügen, der selbst ein Button ist, und zwar einer, dem der erste Button aus irgendeinem Grund übergeben wird.

Ich glaube, du solltest dir überlegen, was deine Klasse Button eigentlich sein soll? Ein Button, ein ActionListener oder beides?

 

[Javaman91]

Hier wurde das so mit dem ActionListener erklärt:

http://javabeginners.de/Ereignisbehandlung/Buttonereignisse.php

Ich habs so probiert, wie es hier angegeben wird.

 

[Joose]

Ja im Beispiel wird von JFrame abgeleitet (abgesehen davon das sehr wenig Situationen gibt wo man sinnvollerweise von JFrame ableitet), warum leitest du von JButton ab?
Weißt du denn was deine Klasse Button nun alles ist? Ein Objekt deiner Klasse Button ist ein JButton und ein ActionListener. Aber der Konstruktor deiner Button Klasse erwartet ein Objekt eines JButton, Sinn?

Entferne das extends JButton, benenne die Klasse in ButtonListener um. In der Klasse Hauptfenster solltest du den Type JButton verwenden.
Sobald du diesen Buttons nun einen ActionListener hinzufügen willst kannst du ein neues Objekt der Klasse ButtonListener erstellen.

 

[Javaman91]

O.K., danke Joose.

Ich werde das heute mal Versuchen.

Wann ist es nun sinnvoll ein extends zu machen (Allgemeine Frage)?

 

[Joose]

Wenn du die Funktionalität einer Klasse erweitern, anpassen bzw. genauer spezifizieren willst.
Hier wäre ein Beispiel: https://de.wikipedia.org/wiki/Vererbung_(Programmierung)#Implementierungsvererbung
Ein Quadrat ist ein spezielles Reckteck, das Reckteck könnte auch von Viereck ableiten (andere Vierecke wären zB: Rhombus, Raute, Trapez, Deltoid)

 

[VfL_Freak]

Moin,

das Wichtigste hat @Joose ja schon geschrieben

Was noch hinzukommt:
"Button" ist in Java bereits ein reserviertes Schlüsselwort, so dass Du NIE eine eigene Klasse so nennen solltest !
In AWT (der "Pre-Swing-Zeit") hieß die Klasse für Schaltflächen halt einfach nur "Button"; mit Swing wurde sie dann zu "JButton" (gilt analog für die meisten weiteren GUI-Elemente) !!

Also wenn es denn eine eigene Klasse sein muss, dann vlt. sowas wie "MyButton", "SpecialButton" etc.

Gruß Klaus

 

[Joose]

"Button" ist in Java bereits ein reserviertes Schlüsselwort, so dass Du NIE eine eigene Klasse so nennen solltest !

Hier muss ich richtig stellen: Button ist kein (Language) Keyword sondern einfach der Name einer Klasse im Java Framework.
Aber richtig ist das man keine Klassen so nennen sollte wie eine Klasse aus dem Java Framework!

 

[VfL_Freak]

Hier muss ich richtig stellen: Button ist kein (Language) Keyword sondern einfach der Name einer Klasse im Java Framework.

ok, da hast Du natürlich Recht .... "Schlüsselwort" war hier verbal falsch
Danke für die Richtigstellung

Gruß Klaus

 

[Javaman91]

Ich habe mich gestern damit nochmals beschäftigt.

Ich habe jetzt eine eigene Klasse für den ActionListener die sieht so aus:

public class MyListener implements ActionListener {

   public JButton button;   
   
   public MyListener(JButton übergabe){
     
     this.button = übergabe;
   }
   
   @Override
   public void actionPerformed(ActionEvent event) {
     
     if(event.getSource() == button){
       
       System.out.println("Es hat funktioniert!");
      }
   }
}

Erklärung zur "MyListener-Klasse":

"public JButton button;" Das hier ist die Instanzvariable.

Bei "public MyListener(JButton übergabe)" habe ich den Konstruktor der einen Übergabeparameter "JButton übergabe" besitzt.

Mit "this.button = übergabe;" bekommt die Instanzvariable den Wert von "übergabe" übergeben.

Anschließend habe ich noch meine actionPerformed-Methode bei der ich einen Text ausgebe, wenn der Button betätigt wurde.

Hier habe ich nun meine Main-Klasse "Hauptfenster":

public class Hauptfenster {

   private JButton button;
   
   public Hauptfenster(){
     
     button = new JButton();
     button.addActionListener(new MyListener(button));
   }
}

In der Klasse "Hauptfenster" habe ich ebenfalls eine Instanzvariable deklariert "private JButton button;"
Jetzt erzeuge ich im Konstruktor den Button und füge diesen dem ActionListener hinzu.

Button erzeugen: button = new JButton();

Den ActionListener dem Button hizufügen: button.addActionListener(new MyListener(button));

Bei "new MyListener(button)" mache ich nichts anderes als ein Objekt meiner MyListener-Klasse zu erzeugen und dem Konstruktor einen Parameter zu übergeben.
Der Parameter lautet: "button"

Stimmt das so??

Sollte doch so funktionieren?

 

[T_T]

public class MyListener implements ActionListener {

   public JButton button;

Ich habe deinen Quellcode nur ganz kurz überflogen, aber hier solltest du dringend deine Button Variable "private" machen. Bzw. stell dir die Frage:

Wer hat alles Zugriff auf meine Variablen, wenn sie folgende Zugriffsrechte haben:

• private
• protected
• public
• (default)

Was passiert, wenn von "außen" folgendes geschieht:

MyListener listen = new MyListener(...)
listen.button = new JButton(); // oder z.b. button = null, oder was auch immer....

?

 

[Javaman91]

Na ja, wenn ich den Zugriffsmodifikator auf "public" habe, dann können Attribute und Methoden der eigenen Klasse (inkl. Unterklassen der eigenen Klassen) und fremde Klassen darauf zugreifen.

Bei "protected" kann nur die eigene Klasse wie eine Unterklasse der eigenen Klasse darauf zugreifen.

Bei "private" kann nur die eigene Klasse zugreifen.

Das heißt, bei deinem Beispiel könnte ich von einer anderen Klasse aus die Instanzvariable z.B. verändern.

 

[Joose]

Das heißt, bei deinem Beispiel könnte ich von einer anderen Klasse aus die Instanzvariable z.B. verändern.

Ja und das sollte man so gut es geht vermeiden. Wenn man mit settern/gettern arbeitet kann man leichter Debuggen wo denn nun der Wert einer Variable geändert wird.

 

[Javaman91]

Ist nun mein Code mit dem ActionListener so richtig oder nicht??

 

[T_T]

Ist nun mein Code mit dem ActionListener so richtig oder nicht??

Ist das ausführende Verhalten, dem deinem gedachten Verhalten, gleich?

Dann kannst du dir die Frage selbst beantworten.

 

[Javaman91]

Es geht jetzt nur darum ob der Code grundsätzlich so korrekt ist oder nicht.
Unabhängig davon ob er jetzt in meinem Programm funktioniert oder nicht.

Eigentlich müsste das alles sein, was ich schreiben muss um den ActionListener in einer eigenen Klasse einsetzen zu können??

 

[T_T]

Ja, dürfte in Ordnung sein. Du musst dir nur im klaren sein, dass wenn du andere Buttons mit diesem Listener verknüpfst, dass sie alle das selbe tun.

 

[Javaman91]

Ja, das habe ich mir auch schon gedacht.

Wie muss ich das machen, wenn ich mehrer Buttons habe?
Muss ich für jeden Button eine eigenen Listener-Klasse erzeugen??

Das wäre ganz schön aufwendig.

 

[T_T]

Du könntest das ganze mit e.getActionCommand() machen. Hier ein Beispiel:

// zwei Buttons wurden via btn.addListener(MyListener()) angelegt...

// 1. Button: JButton btn1 = new JButton("Button1")
// 2. Button genauso.

// im Listener wird dann folgendes abgefragt:

     @Override
     public void actionPerformed(ActionEvent e) {
        // Via If-Anweisung:
        if (e.getActionCommand().equals("Button1")) { 
            System.out.println("button 1 pressed"); // Hier kommt dann die Logik für Button 1 rein
        }else if(e.getActionCommand().equals("Button2")) {
            System.out.println("button 2 pressed"); // Hier kommt die Logik für Button 2 rein
        }

       
        // oder das ganze mit Switch:
        switch (e.getActionCommand()) {
        case "Button1":
            System.out.println("b1 switch case");       
            break;
        case "Button2":
            System.out.println("b2 switch case");
        default:
            // Default
            break;
        }       
    }

 

[Javaman91]

Ja, das funktioniert.

Nun möchte ich noch verstehen wie das ganze funktioniert.

Kann es sein, das bei der verwendung der Methode "getActionCommand()" der Title des Buttons
(z.B. "Drück mich") abgefragt wird und als ActionEvent nun ein String mit dem Inhalt "Drück mich" zurück gegeben wird?

Anschließend wird dieser String in der actionPerformed() - Methode abgefragt.

Bsp:

JButton button1 = new JButton();
button1.addActionListener(new MyListener(button1));
button1.setTitle("Drück mich");

Würde ich hier statt "Drück mich" z.B. "Drücken" schreiben, dann würde das Programm nicht mehr funktionieren, da die actionPerformed-Methode bei der if - Anweisung ein "Drück mich" erwartet:

public void actionPerformed(ActionEvent event) {      
        if (event.getActionCommand().equals("Drück mich")) {
}
}

Wenn ich nun möchte, das mein Button "Drücken" heißen soll, dann müsste ich damit das Programm funktioniert in der actionPerformed-Methode anstatt "Drück mich" -> "Drücken" in die if - Anweisung schreiben.

Hab ich das so richtig verstanden?

Danke!

 

[Meniskusschaden]

Du kannst auch mit button1.setActionCommand()arbeiten. Dann bist du nicht mehr von der Beschriftung des Buttons abhängig.

 

[Javaman91]

Dann habe ich das so richtig Verstanden?

 

[Meniskusschaden]

Genau, wenn mein kein ActionCommand festlegt, ist es der Button-Text.

 

[Flown]

Mal eine Grundsatzfrage: Warum willst du einen ActionListener in eine eigene Klasse auslagern? Hat er einen gewissen State (Zustand)? Das heißt hat er irgendwelche Verantwortung im Programm oder ist er nur dazu gedacht Befehle weiterzuleiten?

 

[Javaman91]

Was ich nicht ganz durchblicke, warum muss ich in der Listener-Klasse den Konstruktor mit einem Übergabe-Parameter setzen?

Obwohl ich im Konstruktor nichts mache:

public class MyListener implements ActionListener {

  public static int richtung;
   
  public MyListener(JButton übergabe){ //???????
   //Hier passiert doch nichts.
  }
   
  @Override
  public void actionPerformed(ActionEvent event) {
   
  if(event.getActionCommand().equals("AUF")){
   
  richtung = 1;
  System.out.println("es hat tunk");
  }
   
  else if(event.getActionCommand().equals("RUNTER")){
   
  richtung = 2;
  }
  }
   
  public int getRichtung(){
   
  return richtung;
  }
}

Weiters muss ich in der Main-Klasse wo ich ein Objekt der MyListener-Klasse erzeuge beim Konstruktor aufruf in die Klammern "null" schreiben:

  button1 = new JButton("AUF");
  button1.addActionListener(new MyListener(button1));
   
  button2 = new JButton();
  button2.addActionListener(new MyListener(button2));

MyListener listener = new MyListener(null); // Wird in der Main-Methode erzeugt.

So funktioniert alles wunderbar.
Nur wenn halt das "null" oder das "JButton übergabe" fehlt geht garnichts mehr.
Ich mache ja nichts mit "JButton übergabe" im Konstruktor, warum besteht er dann darauf?
Und wieso muss ich beim erzeugen eines Objekts der MyListener-Klasse ein "null" schreiben?

??

 

[Meniskusschaden]

warum muss ich in der Listener-Klasse den Konstruktor mit einem Übergabe-Parameter setzen?

Weil du den Konstruktor so programmiert hast, dass er einen JButton als Parameter verlangt. Wenn du einen parameterlosen Konstruktor programmierst oder deinen aktuellen Konstruktor komplett löschst, ist es nicht mehr nötig.

 

[Jardcore]

Scheinbar willst du ja ein Spiel programmieren, für dich selbst oder die Schule?
Anscheinend brauchst du nur einen Listener und zwar den der den Input des Spielers überwacht.
Das heißt wiederum, dass du hier ein sogenanntes Singelton gebrauchen könntest.

public class PlayerInputListener implements ActionListener {

    private static PlayerInputListener instance;
    private PlayerInputListener() {}

    public static PlayerInputListener getInstance() {
        if(instance == null) {
            instance = new PlayerInputListener();
        }
        return instance;
    }
  
    @Override
    public void actionPerformed(ActionEvent event) {
        switch(event.getActionCommand()) {
            case "AUF":
                System.out.println("Auf");
                break;
              
            case "RUNTER":
                System.out.println("Runter");
                break;
              
            default:
                break;
        }
    }
}

In diesem Codebeispiel hast du in deinem System immer nur eine Instanz des PlayerInputListener, und dieser überwacht die Eingaben.

Wichtig: Hier ist der Konstruktor private, damit der nicht irgendwo aufgerufen werden kann.

Mit folgendem Code übergibst du den Listener.

JButton rauf= new JButton("RAUF");
        rauf.addActionListener(PlayerInputListener.getInstance());
JButton runter = new JButton("RUNTER");
        runter.addActionListener(PlayerInputListener.getInstance());

Bei deinem Listener hast du schon wieder nicht auf die Sichtbarkeit geachtet, deine richtung Variable ist static public und hat trotzdem einen getter, sowas sollte nicht vorkommen.