Programación POO en Java

Disculpen por la Demora... No Tuve tiempo de atender el blog. Pero ahora volvi.

Ahora que tenemos el respaldo teórico, podemos empezar a programar con una forma de ver a los objetos diferente. Podemos empezar a programar de una manera en la cual estos realicen las tareas para las que fueron creados, utilicen interfaces y/o hereden de otra clase, etc.

Por ahora, vamos a utilizar awt de java para crear nuestras apps. Con este tipo de interfaz surgen varios problemas a la hora de programar, ya que a un programador que no aplique bien las interfaces le puede causar problemas como por ejemplo tener crear muchas clases por cada botón al que le suscriba un actionListener.

Por decir todo lo que dije arriba, no significa que esta sea la única forma de programar, nada más les estoy dando mi punto de vista de como por ahora en mis comienzos empezar a programar y que sea fácil y sencillo.

Bueno, primero, ninguna clase que no sea meramente ejecutable, debe tener atributos o clases definidas adentro, un ejemplo de esto seria crear una clase x que extienda Frame y que adentro de esa misma clase declaremos el main de la app. Esto elimina toda chance de que una clase sea cohesiva y además dificulta la herencia, ya que todas las subclases tendrían un main. ¿Cuál se ejecutaría? esa es la pregunta...

Partiendo de esto declararemos 1 clase ejecutable por cada app que hagamos y las demás clases que declaremos no tendrán un main adentro, para que cuando sea necesario podamos heredar de ellas y también se mantengan cohesivas.

En java, las clases deben tener el mismo nombre que el archivo en el que fueron guardadas, por lo menos las ejecutables.

 

Entonces:

Clase Ejecutable:

Nombre del Archivo: tut1.java

Codigo:

public class tut1{
  public static void main(String [] Args){

              //Lo unico que hago es instanciar una ventana y listo...
               Ventana a = new Ventana();
    }
}

Después Creo Otra Clase en la misma Carpeta:

import java.awt.*;
import java.awt.event.*;

class Ventana extends Frame implements ActionListener, WindowListener{

private Button btnEjemplo = new Button();

public Ventana(){
                /*Como la ventana implementa la interfaz actionListener,
                 esta misma va a poder catchear los eventos de los botones
                 que esten dentro de ella*/
                btnEjemplo.addActionListener(this);

                this.AddControls();
                this.InitVentanaProps();
}

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

private void AddControls(){
                this.add(btnEjemplo);
}

/*ACTIONLISTENER MEMBERS*/
public void actionPerformed(ActionEvent Ae){

  /*Atender Eventos disparados por los botones*/

  /*Ae.getSource() obtiene la instancia del que disparo el evento
  , solo basta con compara por un objeto para saber que hacer*/
  if (Ae.getSource() == btnEjemplo)
  {
                   //Hacer Algo...

                   //System.out.println("Sarasa");
  }

}

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

}

 

Este ejemplo de clase que hereda de frame e implementa window y action listener no es necesaria la creacion de varias clases que implementen algun listener ya que la ventana misma ya la implementa, gracias a esto con el getSource() de un ActionEvent se puede identificar quien es el que dispara el evento. Otra manera interesante de hacer esto seria crear otra clase que se encargue de tener los metodos con la logica que realizaria cada botón y asi poder "sacar" estos métodos de ventana, haciendo que esta sea mas cohesiva, pero a su vez se sigue "encargando" internamente de sus eventos, Eso es lo que voy a postear la proxima vez.

 

PD: Otra manera de poder cerrar la ventana es con el window adapter.

 

Rodrigo Sevil

WH.