The Spot Code

Seguimos con el Frame...

2008-05-21T00:52:00.001-03:00

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.

Programación POO en Java

2008-05-15T00:12:00.001-03:00

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.

Instalando el TextPad:

2008-05-06T20:07:00.001-03:00

Antes que nada quería agradecerle a Sergio Ioppolo autor del Blog del Laboratorio y Profesor de la Materia de Laboratorio y Programación en la Escuela donde estudio por su colaboración para que este proyecto pueda crecer.

Bueno ahora que ya tenemos un respaldo teórico sobre lo que vamos a programar, necesitaremos un ambiente de desarrollo para poder compilar y ejecutar nuestras apps nuevas. Como por este año voy a basar la mayoría de los post sobre programación en java y porque se que muchos tuvieron problemas para poder instalarlo, les voy a dejar un tutorial para poder instalar el Textpad y utilizarlo con el JDK para poder comenzar a programar libremente sin que se les presente alguna dificultad para poder instalarlo.

Por ahora utilizaremos el TextPad ya que para los que recién comienzan a programar puede ser muy dificultoso aprender en un ambiente de desarrollo muy grande como lo seria el eclipse por el momento.

Hay dos Maneras:

Bajen el TextPad de la pagina TextPad.Com. Luego de Java.sun.com descarguen el JDK 6 UPDATE 6. Si no tienen la Java Virtual Machine cosa que dudo, también podrán descargarla desde esa misma página.

Una vez que hallan instalado los dos programas, van a tener que configurar el Textpad para que como herramienta de compilación utilice los comandos del JDK.

Entonces, abran el Textpad vayan a configuración, preferencias. En la pantalla que les abre en el listado de preferencias busquen Herramientas/Tools y seleccionenlo. En la misma pantalla a la izquierda busquen el botón Agregar/Add y haganle click. En la lista que se les despliega elijan la que dice "Java SDK Commands" y apliquen y acepten y listo.

Para poder Compilar tienen que apretar Ctrl+1 y para ejecutar Ctrl+2.

La otra Manera es bajandose del Blog del Laboratorio los archivos: El Laboratorio. y siguiendo los pasos de congfiguración que escribí arriba.

El Help recomiendo que se lo descarguen también ya que lo van a necesitar, y pueden encontrarlo en el Blog de Labo.

En el próximo post ya empezaremos a ver desde como declarar una clase hasta armar un Frame entero de una manera que este se encargue de todos los eventos que sucedan en él.

Rodrigo Sevil.

WH.

Principios y Definiciones

2008-05-05T00:55:00.004-03:00

Bueno para empezar voy a dejar los principios y definiciones basicas sobre La Programacion Orientada a Objetos (POO):

La Programacion Orientada a Objetos permite modelar la realidad, e de ahi que un modelo es la representacion limitada de alguna parte de la realidad, o de un sistema real.

Objetos:

Un Objeto es la Instancia de una clase, las clase es el molde o plantilla donde se pueden modelar los Objetos. Aqui se definiran los atributos, pero no los valores de los mismos.
Las Clases pueden ser instanciables o no, a aquellas que no lo son se las llama Abstractas y se utilizan como clases base de una jerarquía de herencia. Estas son compuestas por métodos abstractos que se definen en las clases base y si o si deben ser implementados en las clases derivadas de esta. Si una clase tienen un método abstracto obligatoriamente debe ser una clase abstracta.

Se dice por definicion que un objeto tiene:
Estado: Guarda en sí mismo la información que le corresponde.

Comportamiento: Es la capacidad de un objeto de hacer cosas o interactuar con otros
objetos(acciones). Depende del Estado.

Identidad: Unicidad, cada objeto es unico, no hay 2 objetos iguales, y esto es por más que
pertenescan a la misma clase.

El estado de los objetos está en los Atributos y el Comportamiento está en los Métodos.

Los objetos poseen varias características:
Herencia: Es la capacidad de un objeto de heredar atributos y métodos de otra clase, es decir
es la propiedad de definir una clase a partir de otra. En la mayoria de los lenguajes actuales,
quitando de la lista al C++, ninguno soporta herencia multiple, es decir solo se puede heredar
de una sola clase.

Polimorfismo: Es la propiedad que tienen los objetos de poder comportarse especificamente
por más que se los tratase genéricamente. Sin herencia no existiría el polimorfismo.

Encapsulamiento: El objeto no debe mostrar o exponer su estado sino a través de sus métodos.
El estado de un objeto es propio de sí mismo.

Interfaz de un Objeto: Son las acciones(métodos) publicas de un objeto. Esto quiere decir
que cualquier otro objetos puede verlos y utilizarlos.

Mensajes: Es la manera de comunicacion entre los objetos.

Si quieren profundizar sobre todos estos temas y otros más como la cardinalidad que es importante, vean este link:
Teoría de Objetos

Interfaces:
Es un contrato al cual se tienen que adherir las clases que la implementan. Es decir que si una clase utiliza una interfaz tiene que implementar TODOS los métodos que declara esa interfaz.
Una Interfaz no tiene estado, comportamiento ni unicidad, ya que no se puede instanciar, las interfaces sirven para poder darle un comportamiento especifico a los objetos que la implementan, pudiendo estos utilizar varias interfaces a la vez.

Si quieren saber un poco mas sobre interfaces:
Teoría Interfaces
Teoría Interfaces 2

Clases Abstractas vs Interfaces:
La diferencia entre clases abstractas e interfaces es más que nada conceptual. Debido a lo anteriormente explicado en la herencia de las clases, para cuando se quiere compartir solo un comportamiento utilizaremos interfaces y cuando se quiere compartir también estado usaremos herencia.

Conceptos sobre la buena programación:
Hay dos conceptos básicos a saber sobre como programar POO.
Acoplamiento: Mide el grado de relación y/o dependencia que tienen 2 o más componentes u objetos entre sí.
El acoplamiento se da fuera del objeto mismo, tiene que ver con la dependencia que él tiene de los que lo rodean o que los que lo rodean tienen de él.

Cohesión: Mide el grado de relación que tienen los miembros de un mismo componente para lograr cumplir con el objetivo o responsabilidad del mismo. Es decir la relación que poseen todos sus métodos para cumplir un mismo fin conciso. Seria lógico decir: "Cuanto tiene que ver el objeto con su objetivo o responsabilidad propuesta". Sucede dentro del objeto.

Aca Termina todo lo básico sobre POO. En el Proximo post ya van a poder ver algunos ejemplos de código hechos en java.

Ro Sevil
WH.