PROGRAMACIÓN CON ACCESO A DATOS

Transcripción

1 PROGRAMACIÓN CON ACCESO A DATOS Parte 1 CARRERAS TÉCNICAS 2005 Universitario Autónomo del Sur

2 Objetivos Una vez finalizado el curso el alumno será capaz de crear aplicaciones que brinden una interfaz gráfica amigable al usuario y accedan a información contenida en Sistemas de Manejo de Bases de Datos. Así mismo tendrá los conocimientos necesarios para manejar errores en tiempo de ejecución y hacer un manejo eficiente de colecciones. Estará capacitado además para, si lo desea, hacer uso de las facilidades que brinda Java mediante un sin número de bibliotecas. Información General Carga horaria El curso dura 48 horas en régimen de lunes a jueves, 3 horas por clase. Control de asistencias Se deberá asistir por lo menos a un 60% de las clases. Evaluación Prueba escrita de tres horas de duración el último día de clases. No se puede consultar material. Material Se utilizará el material que se encuentra en la Web. Conocimientos requeridos Haber cursado Introducción a la Programación en Java e Introducción a las Bases de Datos. Bibliografía Los siguientes libros se encuentran en biblioteca. No obstante, el curso no se rige por ninguno de ellos en particular. Se aconseja consultarlos a modo de bibliografía complementaria. COMO PROGRAMAR EN JAVA Deitel / Deitel Editorial: Pearson Education Edición: 1998 MANUAL IMPRESCINDIBLE DE JAVA 2 Martín Tardío, Martín Angel Editorial: GRUPO ANAYA Edición: 2000 MANUAL AVANZADO DE JAVA 2 Lima Díaz, Felipe Editorial: GRUPO ANAYA Edición: 2000 Página 2 de 25.

3 Contenido 1. Capítulo 1: Interfaces gráficas a. Introducción b. El paquete java.awt c. Componentes de awt d. Ejercicios 2. Capítulo 2: Manejo de eventos a. Inner Classes b. Interfaces c. Modelo de delegación de eventos d. Manejo de eventos de botón e. Manejo de eventos de ventana f. Manejo de eventos de ítem g. Ejercicios Capítulo 1 Interfaces gráficas Introducción Una vez finalizado el capítulo y haber realizado los ejercicios indicados el alumno estará en condiciones de crear una interfaz gráfica amigable para el usuario. Será capaz de crear ventanas para las aplicaciones así como utilizar otros componentes para obtener entrada de datos por parte del usuario y eventualmente utilizarlos para desplegar datos de salida. Así mismo estará en condiciones de investigar y posteriormente utilizar los demás componentes que no se presentan en el curso. Hasta ahora hemos visto cómo declarar clases, variables y métodos, cómo usar estructuras de control y utilizar arreglos, pero con los elementos que teníamos nuestros programas no eran capaces de interactuar con el usuario, ya sea obteniendo datos de entrada o desplegando los resultados, por lo menos de una manera fácil y amigable. Ahora nos prepararemos para crear una interfaz gráfica capaz de obtener datos de entrada por parte del usuario y desplegar datos de salida al mismo. Vamos a ver las clases básicas que forman la interfaz del usuario, la forma de usarlos y su propósito. El paquete java.awt Las clases que usaremos para crear los componentes gráficos a utilizar en nuestras interfaces gráficas se encuentran en el paquete java.awt (AWT: Abstract Window Toolkit). El siguiente diagrama muestra la Jerarquía de Clases de este paquete. Página 3 de 25.

4 Frame La clase java.awt.frame provee métodos para construir ventanas para aplicaciones. Si vemos nuevamente la jararquía de clases del paquete java.awt notaremos que la clase Frame hereda indirectamente de la clase Container, esto significa que un objeto Frame tiene la propiedad de poder contener otros componentes gráficos. El siguiente código declara una clase Ventana que utiliza un Frame: // importamos el paquete awt public class Ventana private Frame frm; // método constructor public Ventana // instanciamos el Frame frm = new Frame ("Esto es un Frame"); // configuramos tamaño y posición frm.setbounds(100,100,300,200); // hacemos visible la ventana La siguiente es una forma alternativa de escribir la clase anterior. Cualquiera de las dos alternativas presentada es igualmente válida. Hay programadores que prefieren usar una y otros que prefieren usar otra. En esta nueva alternativa, hacemos que nuestra clase extienda a la clase Frame. La palabra reservada extends responde a un concepto muy importante de la Programación Orientada a Objetos denominado herencia, el cual no profundizaremos explícitamente en este curso, sino en el curso de "Conceptos de Herencia y Polimorfismo". Página 4 de 25.

5 // importamos el paquete awt public class Ventana extends Frame // método constructor public Ventana // instanciamos el Frame super("esto es un Frame"); // configuramos tamaño y posición setbounds(100,100,300,200); // hacemos visible la ventana show(); Ahora que tenemos nuestra clase Ventana declarada, podemos instanciarla desde el método main: public class PrincipalVentana public static void main (String [] args) Ventana ve = new Ventana(); Por el momento, nos vamos a dedicar a dibujar ventanas "tontas" en el sentido de que lo único que haremos será mostrarlas. Todavía no programaremos lo que debe suceder cuando el usuario realice acciones sobre ellas. En este ejemplo, cuando el usuario intente cerrar la ventana, nada sucederá. Aprenderemos a procesar acciones sobre las ventanas cuando estudiemos el manejo de eventos para componentes gráficos provisto por Java. Panel La clase java.awt.panel es, al igual que Frame, una subclase de Container, y representa un contenedor multipropósito. Puede ser usada para contener otros componentes, incluso otros Paneles. La combinación de Frames con Paneles es lo que nos permite elaborar interfaces gráficas más complejas. El siguiente código muestra como agregar un Panel a un Frame. public class Ventana2 private Frame frm; private Panel pan; public Ventana2() frm = new Frame ("Este Frame contiene un Panel"); frm.setbounds(100,100,300,200); // creamos el panel y lo pintamos de azul pan = new Panel(); pan.setbackground(color.blue); Página 5 de 25.

6 // agregamos el panel al frame y lo mostramos frm.add(pan); Ahora mostramos la otra alternativa propuesta para el ejemplo anterior, en la cual hacemos que nuestra clase extienda a la clase Frame. public class Ventana2 extends Frame private Panel pan; public Ventana2() super("este Frame contiene un Panel"); setbounds(100,100,300,200); // creamos el panel y lo pintamos de azul pan = new Panel(); pan.setbackground(color.blue); // agregamos el panel al frame y lo mostramos add(pan); show(); Layout Managers Aprovecharemos ahora para aprender cómo disponer (posicionar) componentes dentro de un contenedor para luego seguir conociendo otros componentes. Para esto utilizaremos un Layout Manager (Manejador de Disposición) que es un objeto que controla la posición y tamaño de los componentes en un contenedor. Todos los contenedores tienen un Layout Manager por defecto. Para los Panels dicho Layout Manager es una instancia de la clase FlowLayout, mientras que para los Frames es una instancia de la clase BorderLayout. BorderLayout BorderLayout es el Layout Manager para todos los objetos Window, tales como Frames y Dialogs. Utiliza cinco áreas para contenener los componentes: North, South, East, West y Center. El siguiente código muestra cómo utilizar dicho Layout Manager: public class Ventana3 Frame frm; Panel p1,p2,p3,p4,p5; public Ventana3() frm = new Frame("Muestra de BorderLayout"); frm.setbounds(100,100,300,200); Página 6 de 25.

7 // le ponemos BorderLayout como Layout Manager frm.setlayout(new BorderLayout()); //creamos los 5 paneles con colores diferentes p1 = new Panel(); p2 = new Panel(); p3 = new Panel(); p4 = new Panel(); p5 = new Panel(); p1.setbackground(color.blue); p2.setbackground(color.red); p3.setbackground(color.orange); p4.setbackground(color.black); p5.setbackground(color.pink); // los agregamos a cada una de las cinco regiones frm.add(p1,borderlayout.north); frm.add(p2,borderlayout.south); frm.add(p3,borderlayout.east); frm.add(p4,borderlayout.west); frm.add(p5,borderlayout.center); // hacemos visible la ventana Observación: En AWT muchas veces existen múltiples métodos para realizar las mismas cosas. Por ejemplo, para configurar el tamaño de una ventana también podemos utilizar el método setsize en lugar del método setbounds. Otra alternativa para agregar los cinco paneles a las distintas regiones es pasarle la región al método add en forma de String. Por ejemplo: frm.add("north",p1); frm.add("south",p2); frm.add("east",p3); frm.add("west",p4); frm.add("center",p5); FlowLayout FlowLayout despliega a los componentes en fila, utilizando su tamaño preferido. Si el espacio horizontal es muy pequeño para desplegar todos los componentes en una sola fila, FlowLayout utilizará las filas que necesite. Dentro de cada fila, los componentes son centrados (por defecto), alineados a la izquierda o a la derecha, según el constructor utilizado. El siguiente código muestra cómo utilizar FlowLayout: public class Ventana4 Frame frm; Panel p1,p2,p3,p4,p5; public Ventana4() frm = new Frame("Muestra de FlowLayout"); frm.setbounds(100,100,300,200); Página 7 de 25.

8 // le ponemos FlowLayout como Layout Manager frm.setlayout(new FlowLayout(FlowLayout.LEFT)); //creamos los 5 paneles con colores diferentes p1 = new Panel(); p2 = new Panel(); p3 = new Panel(); p4 = new Panel(); p5 = new Panel(); p1.setbackground(color.blue); p2.setbackground(color.red); p3.setbackground(color.orange); p4.setbackground(color.black); p5.setbackground(color.pink); // los agregamos al frame frm.add(p1); frm.add(p2); frm.add(p3); frm.add(p4); frm.add(p5); // hacemos visible la ventana Nota: El tamaño de los Panels desplegados es pequeño ya que éstos no contienen otros componentes y por lo tanto no necesitan más espacio. GridLayout GridLayout coloca a los componentes en celdas de una grilla. Cada componente toma todo el espacio disponible en una celda, y cada celda tiene exactamente el mismo tamaño. Si se cambia el tamaño de la ventana, se notará que GridLayout cambiará el tamaño de las celdas para que sean lo más grande posibles, dado el espacio disponible en el contenedor. El siguiente código muestra cómo utilizar GridLayout: public class Ventana5 Frame frm; Panel p1,p2,p3,p4,p5; public Ventana5() frm = new Frame("Muestra de GridLayout"); frm.setbounds(100,100,300,200); // le ponemos GridLayout como Layout Manager // en este caso, una grilla de 3 filas y 2 columnas frm.setlayout(new GridLayout(3,2)); //creamos los 5 paneles con colores diferentes p1 = new Panel(); p2 = new Panel(); p3 = new Panel(); p4 = new Panel(); p5 = new Panel(); Página 8 de 25.

9 p1.setbackground(color.blue); p2.setbackground(color.red); p3.setbackground(color.orange); p4.setbackground(color.black); p5.setbackground(color.pink); // los agregamos al frame frm.add(p1); frm.add(p2); frm.add(p3); frm.add(p4); frm.add(p5); // hacemos visible la ventana Label Un objeto Label es un componente que despliega texto en un contenedor. Despliega una sóla línea de texto que no puede ser editada por el usuario, aunque sí desde el código de nuestro programa. El siguiente código muestra como agregar dos Labels a un Frame: public class Ventana5 private Frame frm; private Label lab1,lab2; public Ventana5() frm = new Frame("Labels"); frm.setbounds(100,100,300,100); frm.setlayout(new FlowLayout()); lab1 = new Label ("Soy un Label"); lab2 = new Label ("Soy otro Label"); frm.add(lab1); frm.add(lab2); TextField Un TextField es un objeto que permite desplegar y editar texto en una sola línea, así como obtener el texto desplegado. El siguiente código muestra cómo trabajar con TextFields: public class Ventana6 private Frame frm; private TextField txt1,txt2; public Ventana6() Página 9 de 25.

10 frm = new Frame("TextFields"); frm.setbounds(100,100,300,100); frm.setlayout(new FlowLayout()); txt1 = new TextField ("Soy un TextField editable"); txt2 = new TextField ("Soy un TextField NO editable"); txt1.seteditable(true); txt2.seteditable(false); frm.add(txt1); frm.add(txt2); TextArea Un TextArea es un objeto para desplegar y/o editar texto en varias líneas. El siguiente código muestra cómo trabajar con TextAreas: public class Ventana7 private Frame frm; private TextArea txt1,txt2; public Ventana7() frm = new Frame("TextFields"); frm.setbounds(100,100,300,100); frm.setlayout(new FlowLayout()); txt1 = new TextArea ("Soy un TextArea"); txt2 = new TextArea ("Soy otro TextArea no editable"); txt1.seteditable(true); txt2.seteditable(false); frm.add(txt1); frm.add(txt2); CheckBox Un Checkbox es un componente gráfico que puede estar en un estado Verdadero o Falso. El hacer clic sobre un Checkbox hace que este cambie su estado de Verdadero a Falso y viceversa. El siguiente código muestra cómo trabajar con Checkboxes: public class Ventana8 private Frame frm; private CheckBox chb1,chb2; public Ventana8() Página 10 de 25.

11 frm = new Frame("CheckBoxes"); frm.setbounds(100,100,300,100); frm.setlayout(new FlowLayout()); chb1 = new CheckBox ("Soy un CheckBox"); chb2 = new CheckBox ("Soy otro CheckBox",true); frm.add(chb1); frm.add(chb2); CheckboxGroup Un CheckboxGroup es usado para agrupar un conjunto de Checkboxes. Solamente un Checkbox perteneciente al CheckboxGrup puede estar encendida a la vez. Aquí vemos un código para trabajar con un CheckboxGroup: public class Ventana9 private Frame frm; private CheckBox chb1,chb2; private CheckBoxGroup chbg; public Ventana9() frm = new Frame("CheckBoxes"); frm.setbounds(100,100,300,100); frm.setlayout(new FlowLayout()); chb1 = new CheckBox ("Soy un CheckBox"); chb2 = new CheckBox ("Soy otro CheckBox",true); chbg = new CheckBoxGroup(); chb1.setcheckboxgroup(chbg); chb2.setcheckboxgroup(chbg); frm.add(chb1); frm.add(chb2); Choice Un Choice representa una lista desplegable de opciones. El código siguiente muestra cómo utilizar estos objetos: public class Ventana10 private Frame frm; private Choice ch; public Ventana10() Página 11 de 25.

12 frm = new Frame("Choices"); frm.setbounds(100,100,300,100); frm.setlayout(new FlowLayout()); ch = new Choice (); ch.add("español"); ch.add("inglés"); ch.add("portugués"); frm.add(ch); List Un List representa una lista de opciones. El siguiente código muestra cómo utilizar uno: public class Ventana11 private Frame frm; private List list; public Ventana11() frm = new Frame("Lists"); frm.setbounds(100,100,300,100); frm.setlayout(new FlowLayout()); list = new List (); list.add("español"); list.add("inglés"); list.add("portugués"); frm.add(list); Button Esta clase crea un botón etiquetado. Los botones son de los componentes más utilizados para que el usuario ingrese comandos. Por ahora nos limitaremos a ver cómo se agregan a un contenedor y no nos preocuparemos cómo manejar los eventos lanzados por éstos. El siguiente código muestra cómo agregar Botones a un contenedor: public class Ventana12 private Frame frm; private Button btn1,btn2; public Ventana12() frm = new Frame("Buttons"); frm.setbounds(100,100,300,100); frm.setlayout(new FlowLayout()); Página 12 de 25.

13 btn1 = new Button("Soy un botón"); btn1 = new Button("Soy otro botón deshabilitado"); // habilito el 1 botón y deshabilito el 2 btn1.setenabled(true); btn2.setenabled(false); frm.add(btn1); frm.add(btn2); Resumen de componentes gráficos Esta lista es sólo un compendio de los métodos básicos disponibles por cada clase vista hasta el momento. Igualmente se aconseja que el alumno consulte en el API los métodos de cada clase vista. Clase Método Descripción java.awt.label settext(string texto) Asigna el string pasado como parámetro como el texto a desplegar String gettext() Obtiene el texto desplegado String gettext() Obtiene el texto desplegado java.awt.textfield settext(string texto) Asigna el string pasado como parámetro como el texto a desplegar seteditable(boolean b) Indica si es editable o no setechochar(char c) Indica el caracter de echo String gettext() Obtiene el texto desplegado java.awt.textarea append(string texto) Agrega el string pasado como parámetro al final del texto desplegado seteditable(boolean b) Indica si es editable o no boolean getstate() Obtiene el estado (prendida o apagada) java.awt.checkbox setcheckboxgroup(checkboxgroup Asigna el cbg) CheckboxGroup al que pertenecerá add(string item) Agrega una opción a java.awt.choice este menú desplegable. String getselecteditem() Obtiene la opción seleccionada. Página 13 de 25.

14 java.awt.list java.awt.button java.awt.component (Recordar que todos los demás componentes heredan sus métodos) String getselectedindex() add(string item) String getselecteditem() String getselectedindex() String getlabel() setlabel(string label) setenabled(boolean b) setvisible(boolean b) setbackground(color c) setforeground(color c) setbounds(int x, int y, int ancho, int alto) Obtiene el índice de la opción seleccionada. Agrega una opción a esta lista. Obtiene la opción seleccionada. Obtiene el índice de la opción seleccionada. Obtiene el texto desplegado por el botón. Setea el texto a desplegar por el botón. Indica si este componente debe estar habilitado o no. Indica si este componente debe ser visible o no. Aplica el Color c al fondo del componente. Aplica el Color c al frente del componente. Mueve y ajusta el tamaño del componente. Conclusiones Hemos visto a lo largo del capítulo las clases básicas que forman la interfaz del usuario, la forma de usarlas y su propósito: Frames Panels Labels TextFields Choices Checkboxes CheckboxGroups Lists Buttons Hemos también visto algunos métodos que ofrecen cada clase, algunos implementados en la misma clase y otros heredados de superclases. En resumen, estamos preparados ahora para crear una interfaz gráfica capaz de obtener datos de entrada por parte del usuario y desplegar datos de salida al mismo. Página 14 de 25.

15 Ejercicios Ejercicio 1 Implementar una clase que dibuje la siguiente ventana. Llamarla VentanaMenu. Recomendaciones: Utilizar un Layout Manager Apropiado Buscar en el API algún método que permita que el usuario no modifique el tamaño de un Frame a voluntad. Ejercicio 2 Implementar una clase que dibuje la siguiente ventana. Llamarla AltaPelicula. Recomendaciones: Utilizar un Layout Manager Apropiado para el Frame Utilizar paneles para contener las diferentes secciones de ingreso de datos. A estos contenedores aplicarles Layout Managers apropiados. Para las listas desplegables utilizar los siguientes ítems: o Tipo (Drama, Thriller, Comedia, Acción, Documental, Musical) o Calificación (Mala, Regular, Buena, Muy Buena, Excelente) Ejercicio 3 Página 15 de 25.

16 Implementar una clase que dibuje la siguiente ventana. Llamarla ConsultaPelicula. Ejercicio 4 Implementar una clase que dibuje la siguiente ventana. Llamarla VentanaPeliculas. Capítulo 2 Manejo de eventos Inner Classes En este capítulo vamos a aprender a procesar las acciones (llamadas eventos) que los usuarios realizan sobre las intrefaces gráficas. Para ello, necesitamos aprender dos conceptos preliminares conocidos como Inner Classes e Interfaces. Ahora vamos a ocuparnos del primero de dichos conceptos: Una Inner Class es una clase que se define dentro de otra clase. Si bien pueden utilizarse en diversos contextos, nosotros las vamos a utilizar mayoritariamente vinculadas al tema de manejo de eventos. Ejemplo: public class Externa private tipo1 atributo1; private tipo2 atributo2;... public tipo1 metodo1 (...)... public tipo2 metodo2 (...)... private class Interna private tipo1 atributointerno1; private tipo2 atributointerno2; Página 16 de 25.

17 public tipo1 metodointerno1 (...)... public tipo2 metodointerno2 (...)... // Interna // Externa Hemos declarado privada a la Inner Class porque en general nos interesa accederla únicamente desde el contexto de la clase Externa (la que la contiene). Si bien es posible declararlas públicas, no es algo que en general sea muy utilizado, puesto que si optamos porque una clase sea interna a otra, es porque lo que nos interesa principalmente es accederla desde el contexto de la Externa. Las Inner Classes pueden contener sus propios atributos y métodos al igual que cualquier clase en Java. Las Inner Classes tienen la propiedad adicional de que pueden acceder directamente a todos los miembros (atributos y métodos) de la clase Externa que las contiene. Este punto nos será de especial utilidad durante el estudio del manejo de eventos en Java. Interfaces Veamos ahora el segundo concepto preliminar necesario para nuestro estudio del manejo de eventos en Java. Se trata de las interfaces. Una interface es un tipo especial de clase que no puede contener atributos y que solamente contiene cabezales de métodos. Dichos métodos no pueden ser métodos constructores, solamente pueden ser funciones y/o procedimientos. Se guardan en archivos con extensión.java al igual que cualquier clase común y corriente. Ejemplo: public interface MiInterface public tipo1 metodointerface1 (...); public tipo2 metodointerface2 (...); public tipo3 metodointerface3 (...); Las interfaces se crean con el fin de que otras clases implementen sus métodos. Podemos pensar que una interface es algo así como un contrato. Una clase que implemente los métodos de la intreface se compromete a implementar todos los métodos definidos en ella. De otro modo, el compilador produce un error. Veamos ahora un ejemplo de una clase que implementa los métodos de una interface: public class MiClase implements MiInterface // atributos y métodos propios de MiClase // métodos de la interface Página 17 de 25.

18 public tipo1 metodointerface1 (...)... public tipo2 metodointerface2 (...)... public tipo3 metodointerface3 (...)... Como dijimos arriba, la clase que implementa los métodos de la interface debe proveer una implementación para cada uno de los cabezales definidos en la interface. De otro modo, el compilador produce un error. Además de implementar los métodos de la interface, la clase puede a su vez tener sus propios atributos y métodos, en forma adicional a los métodos que la interface le obliga a implementar. Veremos el uso práctico tanto de las interfaces como de las Inner Classes a medida que vayamos adentrándonos en nuestro estudio del manejo de eventos en Java. Modelo de delegación de eventos Un evento se define como una acción que puede ser reconocida, capturada y procesada dentro de un determinado ambiente. Cuando el usuario realiza acciones sobre una interfaz gráfica, genera eventos. Los eventos pueden ser muy variados y diversos. Por ejemplo: El usuario hace click sobre un botón El usuario intenta cerrar una ventana El usuario selecciona un ítem de un choice. En Java existe un mecanismo conocido como Modelo de delegación de eventos el cual consiste en los siguientes pasos: 1. El usuario genera un evento de cierto tipo. 2. Java reconoce el evento ocurrido y acto seguido, invoca a un método que contiene el código necesario para procesar dicho evento. 3. Se ejecuta el código del método invocado, el cual contiene las instrucciones necesarias para procesar el evento. Los dos primeros pasos son realizados automáticamente por la JVM en respuesta a la ocurrencia del evento. En cuanto al tercer paso, somos nosotros, los programadores quienes debemos implementar (en el método invocado) las instrucciones que deseamos que se ejecuten en respuesta a la ocurrencia del evento. Página 18 de 25.

19 Cualquiera sea el tipo de evento ocurrido, el programador debe programar un método que lo procese. Dicho método debe ser tal que pueda luego ser invocado por la JVM ante la ocurrencia del evento. Obsérvese que es la primera vez que hablamos de un método escrito por nosotros que sea invocado por la JVM. Hasta ahora, todos los métodos que definíamos eran invocados por nosotros mismos, y nunca por la JVM. Dependiendo del tipo de evento, vamos a tener que programar un método apropiado para dicho tipo de evento. Enseguida veremos cómo se hace, para lo cual utilizaremos los conceptos de Interfaces e Inner Classes vistos recientemente. Manejo de eventos de botón Considere el código de la siguiente ventana: Ejemplo: public class Ventana private Frame f; private TextField tf; private Button b; private TextArea ta; public Ventana() f = new Frame("Ventana"); tf = new TextField(); b = new Button ("Aceptar"); ta = new TextArea(); ta.seteditable(false); f.setlayout(new BorderLayout()); f.add(tf,borderlayout.north); f.add(ta,borderlayout.center); f.add(b,borderlayout.south); f.setsize(300,300); f.show(); Página 19 de 25.

20 La ventana correspondiente luce de la siguiente manera: Supongamos que cuando el usuario presione el botón "Aceptar" sucedan las siguientes cosas: Se extraiga el texto del TextField y se lo agregue al la TextArea Se emita un mensaje en la salida estándar indicando que el botón ha sido presionado. Para poder procesar eventos ocurridos sobre un botón, vamos a realizar las siguientes acciones: Vamos a programar una clase que contenga el método encargado de procesar ese evento. Por comodidad y por su estrecha relación con la ventana, lo vamos a hacer dentro de una Inner Class. Vamos a indicarle a Java cuál es la clase que contiene el método encargado de procesar el evento. En Java, para procesar un evento de botón, debemos implementar una interface denominada ActionListener. Dicha interface contiene un método llamado actionperfomed, dentro del cual programaremos lo que queremos que suceda en respuesta al evento ocurrido. Veamos cómo queda el código resultante. import java.awt.event.*; // debemos importar las clases del paquete de eventos para AWT. public class Ventana private Frame f; private TextField tf; private Button b; private TextArea ta; public Ventana() // armo los componentes gráficos Página 20 de 25.

21 f = new Frame("Ventana"); tf = new TextField(); b = new Button ("Aceptar"); ta = new TextArea(); ta.seteditable(false); // engancho el manejador de eventos del botón b.addactionlistener(new ManejadorBoton()); // agrego los componentes gráficos a la ventana f.setlayout(new BorderLayout()); f.add(tf,borderlayout.north); f.add(ta,borderlayout.center); f.add(b,borderlayout.south); f.setsize(300,300); f.setvisible(true); // inner class para procesar el evento de botón private class ManejadorBoton implements ActionListener public void actionperformed (ActionEvent e) System.out.print("Soy el botón "); System.out.println(e.getActionCommand()); ta.append("el Cuadro de texto dice:"); ta.append(tf.gettext() + "\n"); Manejo de eventos de ventana Considere nuevamente la ventana del ejemplo anterior. Hasta el momento, el único tipo de evento que hemos procesado sobre ella es el evento de hacer click sobre el botó "Aceptar". Ahora nos ocuparemos de procesar los eventos generados sobre la propia ventana. En total, hay siete tipos de evento que pueden ocurrir sobre una ventana. Ellos son: El usuario intenta cerrar la ventana La ventana fue abierta La ventana fue cerrada La ventana fue minimizada La ventana fue restaurada La ventana fue seleccionada La ventana fue des-seleccionada La interface utilizada para procesar los eventos de Ventana en Java se denomina WindowListener y contiene siete métodos, uno para cada tipo de evento posible. A continuación modificamos el código de la ventana anterior para procesar estos siete tipos de evento. Ejemplo: import java.awt.event.*; Página 21 de 25.

22 public class Ventana // mismos componentes gráficos que en el ejemplo anterior public Ventana() // armo los componentes gráficos... // engancho manejadores de eventos del botón y la ventana b.addactionlistener(new ManejadorBoton()); f.addwindowlistener(new ManejadorVentana()); // agrego los componentes gráficos a la ventana... private class ManejadorBoton implements ActionListener public void actionperformed (ActionEvent e) // mismo código que en el ejemplo anterior... private class ManejadorVentana implements WindowListener public void windowclosing (WindowEvent e) f.dispose(); public void windowopened (WindowEvent e) System.out.println("Fui abierta"); public void windowclosed (WindowEvent e) System.out.println("Fui cerrada"); System.exit(0); // esta instrucción finaliza el programa public void windowiconified (WindowEvent e) System.out.println("Fui minimizada"); public void windowdeiconified (WindowEvent e) System.out.println("Fui restaurada"); public void windowactivated (WindowEvent e) System.out.println("Fui seleccionada"); public void windowdeactivated (WindowEvent e) System.out.println("Fui des-seleccionada"); Página 22 de 25.

23 Obsérvese que WindowListener es una interface, lo que nos obliga a implementar todos los métodos definidos en la misma (de otro modo, el compilador produce un error). Ahora bien, podría suceder que no siempre deseemos procesar todos los eventos posibles que puedan generarse sobre la ventana. Por ejemplo, podríamos querer procesar solamente el evento de intentar cerrar la ventana y no procesar ningún otro. Para poder hacer esto, Java nos provee una alternativa: Utilizar una clase adaptadora. Esto es, en lugar de que nuestra clase "ManejadorVentana" implemente directamente la interface WindowListener, vamos a hacer que extienda una clase predefinida denominada WindowAdapter. Esta clase adaptadora nos permite implementar solamente el o los métodos de la interface WindowListener que nosotros deseemos en lugar de estar obligados a implementar todos los métodos de dicha interface. El código resultante para procesar solamente el evento de intentar cerrar la ventana sería el siguiente (debemos mosdificar nuestra clase ManejadorVentana): private class ManejadorVentana extends WindowAdapter // implementamos sólo los métodos que queremos public void windowclosing (WindowEvent e) f.dispose(); System.exit(0); Manejo de eventos de ítem Este es el tercer tipo de eventos que vamos a estudiar en este curso, además de los eventos de botón y de ventana. Existen en Java muchos otros tipos de eventos que podemos procesar, como ser, por ejemplo, eventos de teclado o de mouse, pero no los abordaremos en este curso. Los eventos de ítem ocurren generalmente cuando el usuario selecciona uno de entre varios ítems posibles en componentes gráficos destinados a tales efectos. Típicamente, dichos componentes son: Checkboxes Choices Lists La interface utilizada para procesar los eventos de item en Java se denomina ItemListener y contiene un único método denominado itemstatechanged. Presentamos ahora un ejemplo en el cual procesamos el evento ocurrido cuando el usuario selecciona un valor de un Choice. El manejo para el caso de los Checkboxes y de los Lists es análogo. Ejemplo: import java.awt.event.*; Página 23 de 25.

24 public class Ventana2 private Frame frm; private Choice ch; public Ventana2() // creo los componentes gráficos y los agrego al frame frm = new Frame("Ventana 2"); frm.setlayout(new FlowLayout()); ch = new Choice(); ch.add("peñarol"); ch.add("nacional"); ch.add("otro"); frm.add(ch); frm.setbounds(100,100,300,100); frm.setbackground(color.yellow); // engancho los manejadores de eventos frm.addwindowlistener(new ManejadorVentana()); ch.additemlistener(new ManejadorChoice()); frm.setvisible(true); private class ManejadorVentana extends WindowAdapter public void windowclosing (WindowEvent e) frm.dispose(); System.exit(0); private class ManejadorChoice implements ItemListener public void itemstatechanged (ItemEvent e) String opcion = e.getitem().tostring(); System.out.println(opcion); Ejercicios A continuación se propone un conjunto de ejercicios guiados orientados a programar una calculadora simple con las cuatro operaciones aritméticas usuales: Suma, Resta, Producto, División: Ejercicio 1 Implementar una clase llamada Calculadora que dibuje la siguiente ventana. El cuadro de texto para el resultado no debe ser editable para el usuario. Página 24 de 25.

25 Ejercicio 2 Agregarle una Inner Class llamada ManejadorVentana que procese únicamente el evento de cerrar la ventana. Ejercicio 3 Agregarle cuatro Inner Classes adicionales que procesen los eventos generados al presionar cada uno de los cuatro botones. Llamar a dichas clases: ManejadorSuma ManejadorResta ManejadorProducto ManejadorDivision Cada vez que el usuario presione alguno de los cuatro botones, se debe extraer el texto almacenado en los cuadros de texto value1 y value2, convertirlos a números reales (double), realizar la operación correspondiente al botón y posteriormente emitir el resultado en el cuadro de texto result. Observaciones: Dado que aún no sabemos procesar errores en tiempo de ejecución (lo veremos más adelante en el curso), suponga que los textos ingresados por el usuario efectivamente serán números reales y no otra cosa. Para convertir un string en un número real, utilizar el siguiente método: Double.parseDouble(String txt) Página 25 de 25.