style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

utilizar eventos de otra clase

que tal tengo una duda respecto al manejo de eventos, mi duda a de ser mas bien de lógica o desconocimiento profundo de java no lo se..

bueno la cosa esta así estoy realizando una interfaz en la cual tendra unos botones tipo calculadora, la cuestión es que se me ocurrió que, para no llenar mi clase de tanto codigo se me ocurrio hacer una clase llamada Botones en la cual heredo un JPanel y dentro meto los botones que quiero, luego creo un objeto de la clase Botones en mi clase donde estara mi ventana y listo se agregan..

ahora la cuestión es, que quiero crear eventos para los botones al darle clic, si los creo dentro de la clase Botones, no podre tener acceso desde la clase donde esta mi ventana

tengo una solución hacer protected a los JButton y después crear los eventos en mi clase de la ventana, eso funciona bien aun que no se si es algo bien echo, y lo que no quería es tener ese código ahí.

mi idea era tener absolutamente todo el código junto con cada uno de sus eventos en la clase Botones y después automagicamente XD al crear el objeto Botones y agregarlo a la ventana de alguna manera capturar esos eventos.

alguien tiene alguna solución mas viable? o esta bien lo que hice.

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de beto.bateria

Asignacion de tareas.

Antes que nada debes de conocer y comprender bien la herencia, el manejo de eventos y la asignacion de tareas que los arquitectos de java hicieron en sus clases swing, despues, debes entender bien la solucion que quieres ofrecer, es decir, describe bien tu solucion, divide la solucion en pasos y/o tareas, crea clases y asigna responsabilidades o tareas, prueba como te salio, si no te convencio, con lo que aprendiste puedes iniciar todo de nuevo.

Imagen de genitalico

si conozco bien eso.. mas

si conozco bien eso.. mas bien esto es problema como dije de logica o algun conocimiento mas profundo creo yo.. mi duda sigue siendo la misma, como dije la solucion que tengo hasta ahora es tener los JButtons como protected para que al crear como objeto la clase que los contiene puedo mandar a llamarla, no la puedo heredar ya que en esa clase ya heredo un JFrame para crear mi ventana..

Imagen de beto.bateria

implements ActionListener

Espero que te haya entendido y que te pueda servir este ejemplo:

public class ListenerA implements ActionListener {
 
    public void actionPerformed(ActionEvent e) {
        //Aqui haces lo que quieres.
    }
 }

public class ButtonDemo extends JPanel{
    private JButton b1;
    private ListenerA listenerA;
    public ButtonDemo() {

        listenerA = new ListenerA();
        b1 = new JButton("Disable middle button");
        b1.addActionListener(listenerA);
        add(b1);
    }
 
}

Con respecto a lo que planteas....

En mi opinión pudieras no dividir tu interfaz gráfica en más clases, para así tener todos los controles con sus respectivos get y set en una sola clase, sin embargo ya que lo estas haciendo de esta manera, lo que podrías hacer para manejar las acciones de los botones sería algo como esto:

Primer clase, los botones:

import java.awt.Color;
import javax.swing.JButton;
import javax.swing.JPanel;

public class PanelBotones extends JPanel {

    private JButton boton1;
    private JButton boton2;

    public PanelBotones() {

        boton1 = new JButton();
        boton2 = new JButton();

        boton1.setSize(100, 25);
        boton2.setSize(100, 25);
        boton1.setLocation(0, 0);
        boton2.setLocation(0, 26);
        boton1.setText("Boton 1");
        boton2.setText("Boton 2");
        /*
         * ActionCommand. Se utiliza en la clase Acciones para saber qué botón
         * se está presionando.
         */

        boton1.setActionCommand("BOTON1");
        boton2.setActionCommand("BOTON2");

        this.setSize(200, 36);
        this.setBackground(Color.WHITE);
        this.add(boton1);
        this.add(boton2);

    }

    /* Metodos get que son utilizados para acceder a los objetos private */
    public JButton getBoton1() {
        return boton1;
    }

    public JButton getBoton2() {
        return boton2;
    }

}

Segunda clase, tu frame principal:

import javax.swing.JFrame;
import javax.swing.JTextField;

public class Frame extends JFrame {

    private JTextField txtBotonPresionado;

    /* Método main de la clase */
    public static void main(String[] args) {
        new Frame();
    }

    public Frame() {

        txtBotonPresionado = new JTextField();
        txtBotonPresionado.setSize(150, 25);
        txtBotonPresionado.setLocation(75, 55);
        txtBotonPresionado.setEditable(false);

        PanelBotones botones = new PanelBotones();
        botones.setLocation(50, 10);
        setDefaultCloseOperation(EXIT_ON_CLOSE);

        /*
         * Agregar ActionListener a los botones Se les pone la referencia this
         * porque cuando se presione un boton debe interactuarse con la interfaz
         * gráfica para plasmar algun cambio. Si vas a estar dividiendo la
         * interfaz gráfica debes tener en cuenta que para crear los
         * actionListener debes acceder a los objetos que los van a implementar,
         * por eso los botones tienen un método get que regresa los objetos,
         * para agregarles su acción.
         */

        botones.getBoton1().addActionListener(new Acciones(this));
        botones.getBoton2().addActionListener(new Acciones(this));

        this.getContentPane().setLayout(null);
        this.add(botones);
        this.add(txtBotonPresionado);
        this.setSize(300, 115);
        this.setResizable(false);
        this.setLocationRelativeTo(null);
        this.setVisible(true);
    }

    /* Método get que devuelve el objeto JTextField */
    public JTextField getTxtBotonPresionado() {
        return txtBotonPresionado;
    }

    /* Método que permite colocar texto en el textfield de la interfaz gráfica */
    public void setTxtBoton(String boton) {
        getTxtBotonPresionado().setText(boton);
    }

}

Tercer clase, el controlador (en donde se procesan las acciones de la vista):

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Acciones implements ActionListener {

    private Frame frame;

    /*
     * Este constructor es llamado en la interfaz cuando se crea la referencia a
     * esta clase con el .addActionListener(new Acciones(this)); Se debe tener
     * en cuenta que la referencia this es una referencia hacia el JFrame. Esta
     * referencia sirve para tener contacto con todos los objetos de la vista.
     * Como con el TextField que se tiene, en el cual se ve qué boton se
     * presionó.
     */

    public Acciones(Frame frame) {
        // TODO Auto-generated constructor stub
        this.frame = frame; // Con esto se maneja el objeto de forma global en
                            // esta clase.
    }

    @Override
    public void actionPerformed(ActionEvent evt) {
        /*
         * Aqui se revisa qué botón se está presionando dependiendo del
         * ActionCommand que se le puso
         */

        if (evt.getActionCommand().equals("BOTON1")) {
            frame.setTxtBoton("Se presiono Boton 1");
        }
        if (evt.getActionCommand().equals("BOTON2")) {
            frame.setTxtBoton("Se presiono Boton 2");
        }
    }

}

En si, esta división de clases te permite tener todos los controles que comprenden la vista en un lado y la lógica en otro.... a esto solo le agregaría otra clase para procesar las operaciones de la vista, para que así la clase acciones solo sea un controlador y ahi no se haga nada más que pasar los datos entre clases.

Con esta división podrías tener una idea más de cómo resolver tu problema, saludos.

Imagen de genitalico

bien creo que ya me di una

bien creo que ya me di una idea mas concreta de hacer lo que quiero.. ya estaba por hacerlo todo en una sola clase como dicen ..pero lo que queria lograr es tener una clase reutilizable con sus eventos y todo eso..de un teclado tipo calculadora.. para no tener que estar haciendo cada vez que necesite un teclado. esa es mi idea..
aunq no para ello se crean los beans?

alguien que me corrija ..

Tienes razón

Creo que si podría ser de esa manera y sería talvez más conveniente hacer uso de beans, por ejemplo para los botones y ya dentro de estos poner todos los métodos que utilizaras, asi por ejemplo para el caso del controlador de acciones quedaría algo como:

public class BotonBean extends JButton {

    public BotonBean(Frame frame) {
        setActionListener(frame);
    }

    public void setActionListener(Frame frame) {
        this.addActionListener(new Acciones(frame));
    }

}

(Este código es sólo una idea que se me acaba de ocurrir, pero me parece que por hay va la cosa jeje).

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">