Seguimos con el Frame...

Como había prometido en el post anterior, voy a dejar como sería si la ventana no handleara más sus eventos, sino que lo haga otra clase, pero que este adentro de esa ventana. Pero a su vez aplicando un poco el concepto de herencia y clase abstracta. Si plantearía este modelo para formar todas las ventanas de mi app y todas tendrían la misma forma de cerrarse, abrirse, etc... podría tener una clase base abstracta de la que hereden todas mis ventanas que genere para la app, a esta clase, la declararemos abstracta ( abstract , revisar en la teoría que caracteristicas tienen este tipo de clases ), Además si vamos a tener x tipos de ventanas vamos a tener x tipos de escuchadores de eventos, porque variaran  según los controles de las mismas, entonces Tendremos una clase base también de eventos que implemente actionListener().

Entonces:

public class tut1{
                 public static void main(String [] Args){
                          VentanaListener Ev = new aListener();
                          Ventana a = new Ventana1(Ev);
                 }
}

Clases:

import java.awt.*;
import java.awt.event.*;
abstract class Ventana extends Frame implements WindowListener{

public VentanaListener Eventos;

             public Ventana(){
             }

             public Ventana(VentanaListener Eventos){
                    this.Eventos = Eventos;
                    this.InitVentanaProps();
             }

             private void InitVentanaProps(){
                    this.addWindowListener(this);
                    this.setVisible(true);
             }

              /*WINDOWLISTENER MEMBERS*/
             public void windowDeactivated(WindowEvent We){
              }
              public void windowActivated(WindowEvent We){
              }
              public void windowDeiconified(WindowEvent We){
              }
              public void windowIconified(WindowEvent We){
              }
              public void windowClosed(WindowEvent We){
              }
              public void windowClosing(WindowEvent We){
               /*Evento que se dispara cuando se apreta el boton de cerrar la ventana*/
               this.setVisible(false);
               this.dispose();
              }
              public void windowOpened(WindowEvent We){
              }
}

abstract class VentanaListener implements ActionListener{
              public void actionPerformed(ActionEvent Ae){
              }
}

class Ventana1 extends Ventana{

              private Button btnEjemplo = new Button("asd");

              public Ventana1(){
              }

              public Ventana1(VentanaListener Eventos){
                            super(Eventos);
                            SetControls();
              }

              private void SetControls(){
                            btnEjemplo.addActionListener(this.Eventos);
                            btnEjemplo.setActionCommand("btnEjemplo");
                            this.add(btnEjemplo);
              }
}

class aListener extends VentanaListener{
              public void actionPerformed(ActionEvent Ae){
                            if(Ae.getActionCommand().compareTo("btnEjemplo") == 0){
                                          btnEjemplo_Click(Ae.getSource());
                            }
              }
              private void btnEjemplo_Click(Object sender){
                             Button ej= (Button)sender;
                             System.out.println(ej.getActionCommand());
              }
}

Para que vean ventana1 hereda de ventana y sobre-escribe el constructor de ventana para luego llamarlo pasándole los eventos que va a atender y setea los controles asignándole al botón como actionlistener a los eventos que posee esa ventana, además de darle un comando de acción al botón y agregarlo a la ventana.

Cuando el botón sea cliqueado los eventos que se le asignaron a la ventana van a ser los que atiendan el mensaje, en este caso los de aListener. Vean que también incluí en la clase un método mas que se llama btnEjemplo_Click que recibe un Object llamado sender y cuando catcheo el evento en el Ae.getActionCommand() lo llamo pasandole como parametro el source, esto permite que yo le pueda mandar al método la instancia del botón al cual cliquearon para después castearlo a un botón y manejarlo como quiera...

Una Opinion:

Con respecto a lo que les acabo de mostrar, esto haría que la ventana sea mas "cohesiva" pero fijensen la complexión de este programita que lo único que hace es tener un botón en el cual se cliquea y en consola muestra un mensaje.  Lo que quiero decir es que la cohesión tampoco hay que llevarla a tanto extremo aunque se pueda, porque hay veces que tiende a dificultar las cosas(imaginense crear una clase para cada acción de una app) entonces hay que encontrar un balance en cuanto a este tema. Por ende depende de la app que se desarrolle el nivel de cohesión de sus elementos.

Por Ultimo:

Si hay algo que no quedo muy claro, pido disculpas porque últimamente estuve sin tiempo, si encuentran algo erróneo o para mejorar por favor comenten que nos va a ayudar a crecer a todos.

Para la próxima se viene algo con Gráficos. ^^

 

Rodrigo Sevil

WH.