Introducción a componentes Swing

Transcripción

1 Introducción a componentes Swing H. Tejeda Mayo 2016 Índice 1. Introducción 1 2. Clase JFrame 2 3. Clase JLabel 6 4. Manejador de diseño 9 5. Extensión de la clase JFrame Clases de entrada Programación de manejo de eventos Receptores de eventos Clases para selección Introducción Las aplicaciones son más amigables al usuario cuando estas contienen componentes interfaz de usuario o UI (User Interface). Los componentes UI son botones, campos de texto, y otros con los cuales el usuario puede interactuar. Los creadores de Java han empacado una cantidad de componentes preescritos en el paquete Swing. Los componentes Swing son elementos UI tales como cuadros de diálogo y botones; se reconocen porque sus nombres inician con J. Nota. Los componentes Swing fueron nombrados por un estilo musical que fue popular allá en El nombre implica que los componentes tienen estilo y dinamismo. Las clases Swing son parte de un 1

2 conjunto más general de capacidades de programación UI que son llamadas las clases de fundación Java o JFC (Java Foundation Classes). JFC incluye las clases componentes Swing y algunas clases del paquete java.awt. Nota. En las primeras versiones de Java, los componentes tenían nombres simples, tales como Frame y Button. Los componentes no tenían una apariencia consistente cuando se usaban con diferentes navegadores y sistemas operativos. Cuando los programadores de Java diseñaron clases nuevas y mejoradas necesitaron nuevos nombres para las clases, así que usaron una J precediendo cada nuevo nombre de clase. Por lo tanto, los componentes Swing tienen nombres como JFrame, JButton, JScrollbar, JOptionPane, etc. Los componentes UI son también llamados controles o widgets (reproductores). Cada componente Swing es un descendiente de un JComponent, el cual a su vez hereda desde la clase java.awt.container. Para usar los componentes UI Swing y sus métodos se debe insertar la sentencia import javax.swing.* al inicio del programa, de esta forma se importa el paquete. La x en el nombre del paquete representa la extensión de las especificaciones del lenguaje Java original. Nota. Casi todos los componentes Swing se dice que son componentes peso ligero porque están escritos completamente en Java y no descansan en el código del sistema operativo local. Esto significa que los componentes no son sobrecargados teniendo que interactuar con el sistema operativo. Algunos componentes Swing, como JFrame, se conocen como componentes peso pesado porque requieren interactuar con el sistema operativo local. Un componente ligero reusa la ventana nativa de su ancestro más cercano peso pesado; un componente peso pesado tiene su propia ventana nativa opaca. Los únicos componentes peso pesado usados en Swing son JFrame, JDialog, JWindow, JApplet, awt.component, awt.container, y JComponent. Cuando se usan componentes Swing estos son puestos, generalmente, en contenedores. Un contenedor es un tipo de componente que guarda otros componentes para que este grupo pueda ser tratado como una sola entidad. Los contenedores están definidos en la clase Container. Frecuentemente, un contenedor toma la forma de una ventana que puede ser arrastrada, redimensionada, minimizada, restaurada, y cerrada. La clase Component es una hija de la clase Object, y la clase Container es una hija de la clase Component. Por lo tanto, cada objeto Container es un Component, y cada objeto Component es un Object. La clase Window es una hija de Container. Los programadores de Java usan poco los objetos Window porque la subclase Frame de Window y su subclase JFrame componente Swing, permiten crear objetos más útiles. Los objetos Window no tienen barra de título, ni bordes. 2. Clase JFrame Se crea un JFrame para poner otros objetos dentro para ser mostrados. Enseguida se muestra el árbol de herencia de la clase JFrame para mostrar la relación con sus ancestros. java.lang.object 2

3 +--java.awt.component +---java.awt.container +---java.awt.window +---java.awt.frame +---javax.swing.jframe La clase JFrame tiene cuatro constructores: JFrame() construye un nuevo marco que inicialmente es invisible y no tiene título. JFrame(String título) crea un nuevo JFrame inicialmente invisible con el título indicado. JFrame(GraphicsConfiguration gc) crea un JFrame en el GraphicsConfiguration de un dispositivo de pantalla sin título. JFrame(String título, GraphicsConfiguration gc) crea un JFrame con el título especificado y el GraphicsConfiguration dado de una pantalla. Se construye un JFrame como cualquier otro objeto, usando el nombre de la clase, un identificador, el operador de asignación, el operador new, y una llamada al constructor. Las siguientes dos sentencias construyen dos JFrame: uno con el título Hola y otro sin título. JFrame primermarco = new JFrame("Hola"); JFrame segundomarco = new JFrame(); Ya teniendo los objetos JFrame creados, se pueden usar algunos de los métodos útiles dados en el cuadro 1. Suponiendo que se ha declarado un JFrame llamado primermarco, se pueden usar las siguientes sentencias para poner el tamaño del objeto primermarco a 250 píxeles horizontalmente por 100 verticalmente y pone el título del JFrame para mostrar un argumento String. Los píxeles son los elementos de imagen, o pequeños puntos de luz, que hacen la imagen en el monitor de la computadora. primermarco.setsize(250, 100); primermarco.settitle("mi marco"); Cuando se pone el tamaño de un JFrame, no se tiene el área completa disponible para usarla porque parte del área es usada por la barra de título y los bordes del JFrame. La aplicación JFrame1, código 1, muestra una aplicación que crea un JFrame pequeño y vacío. 3

4 Método void settitle(string) void setsize(int, int) void setsize(dimension) String gettitle() void setresizable(boolean) boolean isresizable() void setvisible(boolean) void setbounds(int, int, int, int) Descripción Pone el título del JFrame usando el argumento String. Fija el tamaño de un JFrame en píxeles con el ancho y alto como argumento. Fija el tamaño de un JFrame usando un objeto Dimension; el constructor Dimension(int, int) crea un objeto que representa un ancho y una altura. Regresa el título de un JFrame. Pone el JFrame para que sea redimensionable pasando true al método, con false es no redimensionable. Regresa true o false para indicar si el JFrame es redimensionable. Hace un JFrame visible usando el argumento booleano true e invisible usando el argumento false. Sobreescribe el comportamiento por defecto para que el JFrame sea posicionado en la esquina superior izquierda en la pantalla del escritorio de la computadora; los primeros dos argumentos son las posiciones horizontal y vertical de la esquina superior izquierda del JFrame en el escritorio, y los dos argumentos finales fijan el ancho y la altura. Cuadro 1: Métodos útiles heredados por la clase JFrame. 4

5 1 import javax. swing. ; 2 public class JFrame1 { 3 public static void main ( S t r i n g [ ] args ) { 4 JFrame unmarco = new JFrame ( Primer Marco ) ; 5 unmarco. s e t S i z e (250, ) ; 6 unmarco. s e t V i s i b l e ( true ) ; 7 } 8 } Código 1: Aplicación JFrame1. La aplicación JFrame1, código 1, crea un JFrame. Este se parece a marcos que se han visto cuando se usan programas UI diferentes. La razón para usar objetos marco similares es porque los usuarios ya están familiarizados con el ambiente de marcos. Cuando los usuarios ven marcos esperan ver una barra de título en la cima con información de texto. También esperan ver los botones de minimizar, maximizar o restaurar, y cerrar en alguna de la esquinas superiores del marco. Muchos usuarios suponen que pueden cambiar el tamaño del marco arrastrando sus bordes o reposicionar la ventana en la pantalla arrastrando la barra de titulo de la ventana a una nueva localidad. En la aplicación del código 1, las tres sentencias en el método main() son importantes. Después de instancia unmarco, se necesita hacer setvisible(true) para poder ver el JFrame, y también poner su tamaño ya que de otra forma solo la barra de título del JFrame es visible porque el tamaño de este es 0 x 0 por defecto. Una razón por la cual el JFrame es invisible es porque este se podría construir en segundo plano mientras otras acciones están ocurriendo y quizás se desearía hacer visible más tarde. Algunos programadores usan el método show() en vez del método setvisible(). Cuando un usuario cierra un JFrame pulsando en el botón cerrar en alguna de la esquinas superiores, el comportamiento por defecto para el JFrame es ocultarse y para la aplicación continuar ejecutándose. Esto tiene sentido cuando hay otras tareas por completar para el programa después de que el marco principal fue cerrado por ejemplo, mostrar marcos adicionales, cerrar archivos abiertos de datos, o imprimir un reporte de actividad. Cuando un JFrame sirve como una aplicación de Swing se quiere que el programa termine cuando el usuario pulsa el botón cerrar. Para cambiar el comportamiento se puede llamar al método setdefaultcloseoperation() de JFrame con alguno de los siguientes cuatro valores como argumento: JFrame.EXIT ON CLOSE termina el programa cuando el JFrame es cerrado. WindowConstants.DISPOSE ON CLOSE cierra el marco, dispone el objeto JFrame, y mantiene en ejecución la aplicación. WindowConstants.DO NOTHING ON CLOSE mantiene el JFrame abierto y continúa ejecutándose. En otras palabras, deshabilita el botón cerrar. WindowConstants.HIDE ON CLOSE cierra el JFrame y continúa ejecutándose; este es el comportamiento por defecto. Cuando se ejecuta una aplicación en cual se ha olvidado salir cuando el JFrame es cerrado, se puede terminar el programa tecleando CTRL+C. 5

6 Personalización de la apariencia de un JFrame La apariencia de un JFrame es dada por el sistema operativo en el cual el programa esté ejecutándose. El diseño de los elementos que controlan el marco se parecen y se comportan como lo hace cualquier otra aplicación gráfica. Los botones y el ícono, en el caso de que se muestre, son conocidos como decoraciones ventana; por defecto las decoraciones ventana son proporcionadas por el sistema operativo. Se puede pedir que el mirar y sentir de Java dé las decoraciones para un marco. Un mirar y sentir es la apariencia y comportamiento por defecto de cualquier interfaz de usuario. Opcionalmente, se puede poner el mirar y sentir de un JFrame usando el método setdefaultlook- AndFeelDecorated(). La aplicación JFrame2, código 2, hace una llamada a este método en la línea 4. 1 import javax. swing. ; 2 public class JFrame2 { 3 public static void main ( S t r i n g [ ] args ) { 4 JFrame. setdefaultlookandfeeldecorated ( true ) ; 5 JFrame unmarco = new JFrame ( Segundo Marco ) ; 6 unmarco. s e t S i z e (250, ) ; 7 unmarco. s e t V i s i b l e ( true ) ; 8 } 9 } Código 2: La clase JFrame2. Puede ser que al usar el método setdefaultlookandfeeldecorated() el sistema operativo impida modificar su apariencia, como en Mac OS X. Actividad 1. Escribir una aplicación gráfica que muestre en el título de la ventana su nombre y tenga un tamaño cuadrado. Además la aplicación debe terminar cuando se cierre el marco. 3. Clase JLabel Uno de los componentes que se podría poner en un JFrame es un JLabel. JLabel es una clase Swing incorporada que tiene texto que se quiere mostrar. La jerarquía de herencia de la clase JLabel se muestra enseguida: java.lang.object +--java.awt.component +---java.awt.container +---javax.swing.jcomponent +---javax.swing.jlabel 6

7 Los constructores para la clase JLabel incluyen los siguientes: JLabel() crea una instancia JLabel sin imagen con una cadena vacía para el título. JLabel(Icon imagen) crea una instancia JLabel con la imagen especificada. JLabel(Icon imagen, int alineaciónhorizontal) crea una instancia JLabel con la imagen especificada y la alineación horizontal. JLabel(String texto) crea una instancia JLabel con el texto especificado. JLabel(String texto, Icon imagen, int alineaciónhorizontal) crea una instancia J- Label con el texto, la imagen, y la alineación horizontal especificados. JLabel(String texto, int alineaciónhorizontal) crea una instancia JLabel con el texto y la alineación horizontal indicados. Se puede crear un JLabel llamado saludo que tenga las palabras Buen día con la siguiente sentencia: JLabel saludo = new JLabel("Buen día"); Para agregar el objeto saludo al objeto JFrame llamado unmarco usando el método add() como sigue: unmarco.add(saludo); La aplicación JFrame3, código 3, muestra la creación de JFrame al que enseguida se le pone su tamaño y la operación de cierre. Luego un JLabel es creado y agregado al JFrame. 1 import javax. swing. ; 2 public class JFrame3 { 3 public static void main ( S t r i n g [ ] args ) { 4 f i n a l int ANCHOMARCO = 250; 5 f i n a l int ALTO MARCO = 100; 6 JFrame unmarco = new JFrame ( Tercer Marco ) ; 7 unmarco. s e t S i z e (ANCHO MARCO, ALTO MARCO) ; 8 unmarco. s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 9 JLabel saludo = new JLabel ( Buen día ) ; 10 unmarco. add ( saludo ) ; 11 unmarco. s e t V i s i b l e ( true ) ; 12 } 13 } Código 3: La clase JFrame3. La contraparte del método add() es el método remove(). La siguiente sentencia quita saludo de unmarco: 7

8 unmarco.remove(saludo); Si se agrega, o quita un componente de un contenedor después de que este se hizo visible, se debería también llamar los métodos invalidate(), validate() y repaint() para ver los resultados de las acciones. Cada uno realiza funciones ligeramente diferentes pero las tres juntas garantizan que el resultado de cambios en el diseño tomarán efecto. Los métodos invalidate() y validate() son parte de la clase Container, y repaint() es parte de la clase Component. Nota. Si se agrega o quita un componente en un objeto JFrame durante la construcción, no se tiene que llamar al método repaint() si después se modifica el componente, como por ejemplo, cambiando el texto. Sólo se necesita llamar a repaint() si se agrega o quita un componente después de la construcción. Se puede cambiar el texto en un JLabel usando el método settext() de la clase Component con el objeto JLabel y pasándole un String. El siguiente código cambia el valor mostrado en el JLabel saludo: saludo.settext("suerte"); Se puede recuperar el texto en un JLabel, o cualquier otro Component, usando el método gettext(), el cual regresa el String guardado actualmente. Cambiar la fuente de un JLabel Java proporciona una clase Font para crear un objeto que guarde el tipo de fuente, y la información del estilo y del tamaño de la fuente. El método setfont() requiere un argumento objeto Font. Para construir un objeto Font, se necesitan tres argumentos: tipo de fuente, estilo, y tamaño en puntos. El argumento tipo de fuente para el constructor Font es un String representando una fuente. Las fuentes comunes tienen nombres como Arial, Century, Monospaced, y Times New Roman. El argumento tipo de fuente es solo una petición; el sistema operativo en el cual el programa se ejecuta podría no tener acceso, y si es necesario, este lo sustituye con una fuente por defecto. El argumento estilo aplica un atributo al texto mostrado y es uno de tres valores: Font.PLAIN, Font.BOLD, o Font.ITALIC. El argumento tamaño en puntos es un entero que representa aproximadamente 1/72 de una pulgada. El texto impreso es generalmente de 12 puntos; una cabecera podría ser de 30 puntos. Nota. En impresión, el tamaño de punto define una medida entre ĺıneas de texto en un documento de texto con interlineado simple. Java adopta la convención de que un punto en una pantalla es equivalente a una unidad en las coordenadas del usuario. 8

9 Para dar a un objeto JLabel una nueva fuente, se puede crear un objeto Font, como en el siguiente: Font fuentecabecera = new Font("Monospaced", Font.BOLD, 36); Luego se usa el método setfont() para asignar el objeto Font al objeto JLabel con una sentencia como la siguiente: saludo.setfont(fuentecabecera); La aplicación JFrame4, código 4, muestra en las líneas 2, 3, 7, 8, y 12 los cambios que se hicieron a JFrame3 para usar otro tipo de fuente con diferente tamaño y apariencia. 1 import javax. swing. ; 2 import java. awt. ; 3 public class JFrame4 { 4 public static void main ( S t r i n g [ ] args ) { 5 f i n a l int ANCHOMARCO = 250; 6 f i n a l int ALTO MARCO = 100; 7 Font f u e n t e = new Font ( A r i a l, Font.BOLD, 3 6 ) ; 8 JFrame unmarco = new JFrame ( Cuarta Ventana ) ; 9 unmarco. s e t S i z e (ANCHO MARCO, ALTO MARCO) ; 10 unmarco. s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 11 JLabel saludo = new JLabel ( Buen día ) ; 12 saludo. setfont ( f u e n t e ) ; 13 unmarco. add ( saludo ) ; 14 unmarco. s e t V i s i b l e ( true ) ; 15 } 16 } Código 4: La clase JFrame4. No es obligatorio proporcionar un identificador para un objeto Font. Se pudo omitir la línea 7 en el código 4 y poner la fuente en saludo con la siguiente sentencia, la cual usa un objeto Font anónimo: saludo.setfont(new Font("Arial", Font.BOLD, 36)); Después de crear un objeto Font, se puede crear un nuevo objeto con un tipo y tamaño diferente usando el método derivefont() con los argumentos apropiados. Por ejemplo, las siguientes dos sentencias crean el objeto fuentecabecera y el fuentecuerpotexto que está basado en el primer objeto: Font fuentecabecera = new Font("Arial", Font.BOLD, 36); Font fuentecuerpotexto = fuentecabecera.derivefont(font.plain, 14); 4. Manejador de diseño Cuando se quiere agregar múltiples componentes a un JFrame u otro contenedor, usualmente se requiere proporcionar instrucciones para la colocación de los componentes. En la aplicación JFrame5, 9

10 código 5, dos JLabel son creados y agregados a un JFrame en las sentencias de las líneas import javax. swing. ; 2 public class JFrame5 { 3 public static void main ( S t r i n g [ ] args ) { 4 f i n a l int ANCHOMARCO = 250; 5 f i n a l int ALTO MARCO = 100; 6 JFrame unmarco = new JFrame ( Quinta Ventana ) ; 7 unmarco. s e t S i z e (ANCHO MARCO, ALTO MARCO) ; 8 unmarco. s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 9 JLabel saludo = new JLabel ( Hola ) ; 10 JLabel saludo2 = new JLabel ( Quién e r e s? ) ; 11 unmarco. add ( saludo ) ; 12 unmarco. add ( saludo2 ) ; 13 unmarco. s e t V i s i b l e ( true ) ; 14 } 15 } Código 5: La clase JFrame5. Cuando se ejecuta la aplicación JFrame5 sólo la última JLabel que fue agregada es visible, a pesar de que se agregaron dos etiquetas al marco. La segunda JLabel fue puesta encima de la primera, tapándola completamente. Si se continúan agregando más JLabel en el programa, sólo la última agregada al JFrame será visible. Para colocar múltiples componentes en posiciones especificadas en un contenedor de tal forma que no se oculten entre ellas, se debe usar explícitamente un manejador de diseño, una clase que controla el posicionamiento de componentes. El comportamiento por defecto de un JFrame es dado por un manejador llamado BorderLayout. Un manejador BorderLayout divide un contenedor en regiones. Cuando no se indica una región en la cual un componente se coloca, este se coloca siempre en el centro, y si estaba otro componente, lo tapa. Al agregar componentes usando el manejador FlowLayout, estos son colocados en un renglón, y cuando el renglón se llena, los componentes automáticamente se ponen en el siguiente renglón. Tres constantes están definidas en la clase FlowLayout para indicar como los componentes son posicionados en cada renglón de su contenedor. Estas son FlowLayout.LEFT, FlowLayout.RIGHT, y FlowLayout.CENTER. Para crear un manejador de diseño llamado flujo que posicione los componentes a la derecha, se usa la siguiente sentencia: FlowLayout flujo = new FlowLayout(FlowLayout.RIGHT); En caso de no indicar como los componentes son distribuidos, por defecto estos son centrados en cada renglón. Una vez que el manejador de diseño ha sido creado entonces puede ser puesto al objeto JFrame haciendo lo siguiente: unmarco.setlayout(flujo); Se puede compactar el código usando un objeto FlowLayout anónimo con: 10

11 unmarco.setlayout(new FlowLayout(FlowLayout.RIGHT)); La aplicación JFrame6, código 6, ha puesto el manejador de diseño del JFrame para que componentes múltiples sean visibles. 1 import javax. swing. ; 2 import java. awt. ; 3 public class JFrame6 { 4 public static void main ( S t r i n g [ ] args ) { 5 f i n a l int ANCHOMARCO = 250; 6 f i n a l int ALTO MARCO = 100; 7 JFrame unmarco = new JFrame ( Sexta Ventana ) ; 8 unmarco. s e t S i z e (ANCHO MARCO, ALTO MARCO) ; 9 unmarco. s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 10 JLabel saludo = new JLabel ( Hola ) ; 11 JLabel saludo2 = new JLabel ( Quién e r e s? ) ; 12 unmarco. setlayout (new FlowLayout ( FlowLayout.RIGHT ) ) ; 13 unmarco. add ( saludo ) ; 14 unmarco. add ( saludo2 ) ; 15 unmarco. s e t V i s i b l e ( true ) ; 16 } 17 } Código 6: La clase JFrame6. Al ejecutar la aplicación JFrame6 se deben ver los dos JLabel, uno al lado del otro porque se usa un FlowLayout. Si hubiera más JLabel u otros componentes, estos serían colocados continuamente lado por lado a través del JFrame hasta que no haya más espacio. 5. Extensión de la clase JFrame Se puede instanciar un objeto JFrame simple dentro del método main() de una aplicación o en cualquier otro método de cualquier clase que sea escrita. Alternativamente, se puede crear su propia clase que descienda de la clase JFrame. La ventaja de crear una clase hija desde JFrame es la posibilidad de poder poner las propiedades del JFrame dentro del constructor de objetos; luego, cuando se crea su objeto hijo JFrame, este es dotado automáticamente con las características que se hayan especificado, tales como el tamaño, el título, y la operación de cierre por defecto. Para crear una clase hija se usa la palabra reservada extends en la cabecera de la clase, seguido por el nombre de la clase padre. Para llamar el constructor de la clase padre se usa la palabra reservada super(), y deberá ser la primera sentencia en el constructor de la clase hija. La clase JMiMarco, código 7, extiende a JFrame. En el constructor de JMiMarco, el constructor super() JFrame es llamado; este acepta un argumento String para usarlo como el título del JFrame. El constructor de JMiMarco también fija el tamaño, la operación de cierre por defecto y la visibilidad para cada JMiMarco. Cada uno de los métodos setsize(), setdefaultcloseoperation(), y setvisible aparecen en el constructor sin un objeto, porque el objeto es el JMiMarco actual siendo construido. 11

12 1 import javax. swing. ; 2 public c l a s s JMiMarco extends JFrame { 3 f i n a l int ANCHO = 200; 4 f i n a l int ALTO = 120; 5 public JMiMarco ( ) { 6 super ( Mi marco ) ; 7 s e t S i z e (ANCHO, ALTO) ; 8 s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 9 s e t V i s i b l e ( true ) ; 10 } 11 } Código 7: La clase JMiMarco. Cuando se ejecuta la aplicación CrearDosObjetosMiMarco, código 8, los dos objetos JMiMarco son mostrados con el segundo encima del primero. Para ver el primer marco se debe arrastrar el segundo marco. 1 public c l a s s CrearDosObjetosMiMarco { 2 public static void main ( S t r i n g [ ] args ) { 3 JMiMarco mimarco = new JMiMarco ( ) ; 4 JMiMarco misegundomarco = new JMiMarco ( ) ; 5 } 6 } Código 8: La aplicación CrearDosObjetosMiMarco. Nota. Se podría usar el método setbounds() con uno de los objetos JMiMarco para no tener que arrastrar uno de los objetos JMiMarco para ver el otro. La clase Objeto incluye el método setlocation() que se puede usar con un JFrame. Para usar este método, se deben dar valores para las posiciones horizontal y vertical como argumentos del método. Nota. Se termina la aplicación cuando se pulsa en el botón cerrar de alguno de los dos objetos JMiMarco. Cada objeto tiene la misma operación de cierre por defecto porque cada uno usa el mismo constructor que indica esa operación. Para permitir que sólo un JMiMarco controle la terminación del programa, se podría usar el método setdefaultcloseoperation() con alguno de los objetos en la aplicación para cambiar su comportamiento de cierre, quizás usando DISPOSE ON CLOSE para descartar uno de los marcos pero manteniendo la aplicación en ejecución. Cuando se extiende un JFrame para crear una clase nueva personalizada, se debe recordar tomar decisiones con los atributos que se quieren fijar dentro de la clase y los que se quieren dejar a las aplicaciones que usarán la clase. Por ejemplo, se puede poner la sentencia setvisible() dentro del constructor de la clase hija JFrame, o se puede permitir a la aplicación usar el método setvisible() precedido por el nombre de un objeto instanciado seguido de un punto. Cualquiera trabaja, pero si no se hace ninguna, el marco no será visible. Nota. Algunos programadores ponen un método main() dentro de una clase como JMiMarco. Luego la clase da la opción para ser usada para instanciar objetos, como en la aplicación CrearDosObjetosMiMarco, o para ser usada ejecutándose como un programa que crea un objeto. 12

13 6. Clases de entrada Un JFrame también contiene otras características de ventana, tales como JTextField, JButton, e información sobre herramientas (tool tips). Clase JTextField Un JTextField es un componente en el cual un usuario puede teclear una línea de texto. El texto comprende cualquier carácter que se pueda meter del teclado o aplicación, incluyendo números y signos de puntuación. La siguiente figura muestra la jerarquía de herencia de la clase JTextField. java.lang.object +--java.awt.component +---java.awt.container +---javax.swing.jcomponent +---javax.swing.text.jtextcomponent +---javax.swing.jtextfield En un JTextField un usuario teclea una línea de texto y luego presiona la tecla Intro o pulsa un botón con el ratón para meter los datos. Se puede construir un objeto JTextField usando uno de los varios constructores: JTextField() construye un nuevo JTextField. JTextField(int columnas) construye un nuevo JTextField vacío con la cantidad indicada de columnas. JTextField(String texto) construye un nuevo JTextField inicializado con el texto especificado. JTextField(String texto, int columnas) construye un nuevo JTextField inicializado con el texto dado y la cantidad de columnas indicada. Por ejemplo, para tener un JTextField que tenga suficiente espacio para que un usuario puede meter 10 caracteres, se puede codificar lo siguiente: JTextField respuesta = new JTextField(10); Para agregar el JTextField llamado respuesta a un JFrame llamado marco, se indica con: 13

14 marco.add(respuesta); La cantidad de caracteres que un JTextField puede mostrar depende de la fuente usada y los caracteres tecleados. En la mayoría de las fuentes, m es más ancha que i, así un JTextField de tamaño 10 usando la fuente Arial puede mostrar 24 caracteres i, pero sólo 8 caracteres m. Se debe intentar anticipar cuanto caracteres los usuarios podrían ingresar cuando se crea un JTextField. El usuario puede meter más caracteres que aquellos que son mostrados, pero los caracteres extra se desplazan fuera de la vista. Puede ser desconcertante intentar meter datos en un campo que no es lo suficientemente grande, así que es mejor sobreestimar que subestimar el tamaño de un campo de texto. Otros métodos están disponibles para ser usados con objetos JTextField. El método settext() permite cambiar el texto en un JTextField, u otro Componet, que ha sido creado, como se muestra enseguida: respuesta.settext("gracias"); Después de que el usuario ingreso texto en un JTextField, se puede limpiar con una sentencia como la siguiente, la cual asigna una cadena vacía al texto: respuesta.settext(""); El método gettext() permite recuperar el String de texto en un JTextField, u otro Component, como en: String entradausuario = respuesta.gettext(); Cuando un JTextField tiene la capacidad de aceptar pulsaciones de teclas, el JTextField es editable. Un JTextField por defecto es editable. Si no se quierer que el usuario pueda ingresar datos en un JTextField, se puede mandar un valor booleano al método seteditable() para cambiar el estado editable de un JTextField. Por ejemplo, si se quiere dar al usuario una cantidad limitada de oportunidades de contestar una pregunta correctamente, se pueden contar los intentos de entrada de datos y entonces prevenir al usuario de reemplazar o editar los caracteres en el JTextField usando una sentencia como: if (intentos > LIMITE) respuesta.seteditable(false ); Clase JButton Un JButton es un Component en el cual el usuario puede pulsar con el ratón para hacer una selección. Hay cinco constructores JButton y son: 14

15 JButton() crea un botón sin texto. JButton(Icon ícono) crea un botón con un ícono de tipo Icon o ImageIcon. JButton(String texto) crea un botón con texto. JButton(String texto, Icon icon) crea un botón con el texto inicial y un ícono del tipo Icon o ImageIcon. JButton(Action a) crea un botón en el cual sus propiedades son tomadas de la Action proporcionada. La jerarquía de herencia de la clase JButton es la siguiente: java.lang.object +--java.awt.component +---java.awt.container +---javax.swing.jcomponent +---javax.swing.abstractbutton +---javax.swing.jbutton Para crear un JButton con la etiqueta Pulsar cuando esté listo, se puede escribir lo siguiente: JButton botonlisto = new JButton("Pulsar cuando esté listo"); Se puede agregar un JButton a un JFrame usando el método add(). Se puede cambiar la etiqueta de un JButton con el método settext(), como en: botonlisto.settext(" No me presiones nuevamente!"); Se puede recuperar el texto de un JButton y asignarlo a un objeto String con el método gettext(), usando: String queestaenjbutton = botonlisto.gettext(); La clase JFrameConMuchosComponentes, código 9, extiende JFrame y guarda varios componentes. Como los componentes, dos JLabel, un JTextField y un JButton son agregados al marco, estos son puestos de izquierda a derecha en renglones horizontales en la superficie del JFrame. 15

16 1 import javax. swing. ; 2 import java. awt. ; 3 public c l a s s JFrameConMuchosComponentes extends JFrame { 4 f i n a l int ANCHO = 350; 5 f i n a l int ALTO = 150; 6 public JFrameConMuchosComponentes ( ) { 7 super ( Mostrar muchos componentes ) ; 8 s e t S i z e (ANCHO, ALTO) ; 9 s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 10 JLabel cabecera = new JLabel ( Este marco t i e n e v a r i o s componentes ) ; 11 cabecera. setfont (new Font ( A r i a l, Font.BOLD, 1 6 ) ) ; 12 JLabel mensajenombre = new JLabel ( I n g r e s a r su nombre : ) ; 13 JTextField camponombre = new JTextField ( 1 2 ) ; 14 JButton boton = new JButton ( Pulsar para continuar ) ; 15 setlayout (new FlowLayout ( ) ) ; 16 add ( cabecera ) ; 17 add ( mensajenombre ) ; 18 add ( camponombre ) ; 19 add ( boton ) ; 20 } 21 } Código 9: La clase JFrameConMuchosComponentes. La aplicación DemoComponentes, código 10, instancia un objeto del tipo JFrameConMuchosComponentes. 1 public c l a s s DemoComponentes { 2 public static void main ( S t r i n g [ ] args ) { 3 JFrameConMuchosComponentes marco = 4 new JFrameConMuchosComponentes ( ) ; 5 marco. s e t V i s i b l e ( true ) ; 6 } 7 } Código 10: Aplicación DemoComponentes. Al ejecutar la aplicación DemoComponentes, el JFrame contiene todos los componentes que fueron agregados en el constructor del marco. El usuario puede minimizar o restaurar el marca y puede modificar su tamaño arrastrando los bordes del marco. El usuario puede teclea en el JTextField y pulsar el JButton. Cuando el botón es pulsado, este parece que fue presionado al igual que otros botones usados en diferentes aplicaciones. Sin embargo, cuando el usuario teclea o pulsa el botón, no ocurren acciones resultantes porque no se ha sido escrito todavía código para manejar es eventos iniciados por usuario. Uso de información sobre herramientas Información sobre herramientas (tool tips) son ventanas emergentes que pueden ayudar al usuario a entender el propósito de los componentes en una aplicación; la información aparece cuando un usuario flota el apuntador del ratón encima del componente. Se define el texto que será mostrado en una sugerencia usando el método settooltiptext() y pasándole un String apropiado. En la clase JFrameConMuchosComponentes, código 9, se puede agregar una sugerencia al componente 16

17 boton usando la siguiente sentencia en el constructor JFrame: boton.settooltiptext("pulsa este botón"); Actividad 2. Crear una aplicación Swing que muestre un JFrame que tenga un JLabel, un JTextField, y un JButton. El diseño de esta aplicación deberá incluir una clase que extienda a la clase JFrame, la cual tendrá los componentes como campos de esta clase con la correspondiente asignación de los objetos instanciados; en el constructor de la clase hija configurar el marco y agregar los componentes. Luego escribir una aplicación que cree un objeto de la clase hija donde se deberá fijar el tamaño de la ventana en 350 de ancho y 100 de alto usando constantes. 7. Programación de manejo de eventos Un evento ocurre cuando un usuario realiza una acción en un componente, tal como pulsar el ratón en un objeto JButton. En un programa de manejo de eventos, el usuario podría iniciar cualquier cantidad de eventos en cualquier orden. Si se usa un programa procesador de textos, se tienen docenas de opciones disponibles en cualquier momento. Se puede teclear texto, seleccionar el texto con el ratón, pulsar un botón para cambiar el texto a negritas, o a itálicas, escoger un elemento del menú, etc. Con cada documento creado se escogen opciones en el orden que parece más apropiado en el momento. El programa procesador de textos deberá estar listo para responder cualquier evento que haya sido iniciado. Dentro de un programa de manejo de eventos, un componente en el cual un evento es generado es la fuente del evento. Un botón que un usuario puede pulsar es un caso de una fuente; un campo de texto donde un usuario puede ingresar texto es otra fuente. Un objeto que está interesado en un evento es un receptor (listener). No todos los objetos oyen por todos los posibles eventos como en algunos programas en los cuales se pulsa en diferentes áreas de la pantalla y no sucede nada. Si se quiere que un objeto sea un receptor para un evento, se debe registrar el objeto como un receptor de la fuente. Un objeto fuente componente Java, como un botón, mantiene una lista de receptores registrados y notifica a todos ellos cuando cualquier evento ocurre. Un JFrame podría querer ser notificado de cualquier pulsación en su superficie. Cuando un receptor recibe las noticias, un método de manejo de evento contenido en el objeto receptor responde al evento. Nota. Un objeto fuente y un objeto receptor puede ser el mismo objeto. Por ejemplo, se podría programar un JButton para cambiar su propia etiqueta cuando un usuario lo pulse. Para responder a eventos del usuario dentro de alguna clase creada, se debe hacer lo siguiente: Preparar la clase para aceptar mensajes de eventos. Indicar a la clase para que espere eventos que pasarán. Indicar a la clase como responder a los eventos. 17

18 Preparar la clase para aceptar mensajes de eventos Se prepara la clase para aceptar eventos de pulsación del botón importando el paquete java.awt.- event en el programa y agregando la frase implements ActionListener a la cabecera de la clase. En el paquete java.awt.event se incluyen clases evento como ActionEvent, ComponentEvent, y TextEvent. ActionListener es una interfaz un tipo de clase con un conjunto de especificaciones para métodos que se pueden usar. Implementar ActionListener da especificaciones estándar de métodos de eventos que permiten al receptor trabajar con ActionEvent, el cual es el tipo de evento que ocurre cuando se pulsa un botón. Indicar a la clase para que espere eventos que pasarán Se le dice a una clase que espere eventos ActionEvent con el método addactionlistener(). Si se ha declarado un JButton llamado unboton, y se quiere realizar una acción cuando el usuario pulse unboton, unboton es la fuente de un mensaje, y se puede considerar a la clase como un destino al cual se manda este. La referencia this significa este objeto actual, así el código unboton.addactionlistener(this); hace que cualquier mensaje ActionEvent (pulsar botón) que venga de unboton sea enviado a este objeto actual. Nota. No todos los eventos son ActionEvent con un método addactionlistener(). Por ejemplo, KeyListener tiene un método addkeylistener, y FocusListener tiene un método addfocuslistener. Indicar a la clase como responder a los eventos La interfaz ActionListener contiene la especificación del método actionperformed(actionevent e). Cuando una clase, tal como un JFrame, fue registrada como un receptor para un Component, tal como un JButton, y un usuario pulsa el JButton, el método actionperformed() se ejecuta. Se implementa el método actionperformed() usando la siguiente cabecera, donde e representa cualquier nombre que se quiera para el evento que inició la notificación al ActionListener, el cual es el JFrame: public void actionperformed(actionevent e) El cuerpo del método contiene cualquier sentencia que se quiera ejecutar cuando la acción ocurre. Se podría querer realizar un cálculo matemático, construir nuevos objetos, generar salida, o ejecutar cualquier otra operación. En la clase JVentanaHola, código 11, un JFrame contiene un JLabel que pide al usuario un nombre, un JTextField en el cual el usuario puede teclear una respuesta, un JButton para pulsar, y una segunda JLabel que muestra el nombre ingresado por el usuario. El método actionperformed() se ejecuta cuando el usuario pulsa el botón JButton; dentro del método, la cadena que un usuario ha tecleado en el JTextField es recuperada y guardada en la variable nombre. El nombre es luego usado como de un String que altera la segunda JLabel del JFrame. 18

19 1 import javax. swing. ; 2 import java. awt. ; 3 import java. awt. event. ; 4 public c l a s s JVentanaHola extends JFrame 5 implements A c t i o n L i s t e n e r { 6 JLabel pregunta = new JLabel ( Cuá l es su nombre? ) ; 7 Font fuentegrande = new Font ( A r i a l, Font.BOLD, 1 6 ) ; 8 JTextField r e s p u e s t a = new JTextField ( 1 0 ) ; 9 JButton unboton = new JButton ( Pulsa aquí ) ; 10 JLabel saludo = new JLabel ( ) ; 11 f i n a l int ANCHO = 275; 12 f i n a l int ALTURA = 2 25; 13 public JVentanaHola ( ) { 14 super ( Ventana Hola ) ; 15 s e t S i z e (ANCHO, ALTURA) ; 16 pregunta. setfont ( fuentegrande ) ; 17 saludo. setfont ( fuentegrande ) ; 18 setlayout (new FlowLayout ( ) ) ; 19 add ( pregunta ) ; 20 add ( r e s p u e s t a ) ; 21 add ( unboton ) ; 22 add ( saludo ) ; 23 s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 24 unboton. addactionlistener ( this ) ; 25 } 26 public void actionperformed ( ActionEvent e ) { 27 S t r i n g nombre = r e s p u e s t a. gettext ( ) ; 28 S t r i n g mensaje = Hola + nombre ; 29 saludo. settext ( mensaje ) ; 30 } 31 } Código 11: La clase JVentanaHola. La aplicación JDemoHola, código 12, instancia un objeto JVentanaHola y lo hace visible. 1 public class JDemoHola { 2 public static void main ( S t r i n g [ ] args ) { 3 JVentanaHola ventana = new JVentanaHola ( ) ; 4 ventana. s e t V i s i b l e ( true ) ; 5 } 6 } Código 12: Aplicación JDemoHola. Cuando se ejecuta la aplicación JDemoHola, la cual instancia un objeto JVentanaHola, después de que el usuario ingresa un nombre, el programa lo saluda con el nombre después de que el usuario pulsa el botón. Cuando más de un componente es agregado y registrado a un JFrame, podría ser necesario determinar cual componente fue usado para iniciar un evento. En la clase JVentanaHola, código jventanahola, se podría querer que el usuario pueda ver el mensaje después de pulsar el botón o de presionar la tecla Intro en el JTextField. En ese caso, se podría designar a ambos como fuentes 19

20 de mensaje usando el método addactionlistener() con cada uno, como sigue: unboton.addactionlistener(this); respuesta.addactionlistener(this); Estas dos sentencias hacen que el JFrame (this) el receptor de cualquier objeto. El JFrame tiene un sólo método actionperformed(), así que este es el método que se ejecuta cuando el botón unboton mande un mensaje o el campo de texto respuesta. Si se quiere que acciones diferentes ocurran dependiendo del generador del evento, se debe determinar la fuente del evento. Dentro del método actionperformed(), se puede usar el método getsource() del objeto enviado para determinar cual componente generó el evento. Por ejemplo, dentro de un método con la cabecera public void actionperformed(actionevent e), e es un ActionEvent. ActionEvent y otras clases evento son parte del paquete java.awt.event y son subclases de la clase EventObject. Para determinar cual objeto generó el ActionEvent, se usa la siguiente sentencia: Object fuente = e.getsource(); Por ejemplo, si un JFrame contiene dos JButton llamados opcion1 y opcion2, se puede usar la estructura de decisión en el siguiente método para tomar diferentes acciones dependiendo del botón pulsado. Si una fuente de evento es un JButton, JTextField, u otro Component, este puede ser asignado a un Object porque todos los componentes descienden de Object. public void actionperformed(actionevent e) { Object fuente = e.getsource(); if (fuente == opcion1) // ejecutar estas sentencias cuando el usuario pulse opcion1 else // ejecutar estas sentencias cuando el usuario pulse opcion2 } Alternativamente, se puede también usar la palabra reservada instanceof para determinar la fuente del evento. instanceof es usada cuando es necesario conocer sólo el tipo del componente, en vez del componente que disparó el evento. Por ejemplo, si se quiere tomar alguna acción cuando un usuario ingresa datos en cualquier JTextField, pero no cuando un evento es generado por un tipo diferente de Component, se usa el formato de método mostrado enseguida: void actionperformed(actionevent e) { Object fuente = e.getsource(); if (fuente instanceof JTextField) { // ejecutar las sentencias cuando cualquier // JTextField genera el evento, pero no cuando // un JButton u otro Component lo hace. } } 20

21 Método setenabled() Cuando se usan aplicaciones hay ocasiones en las cuales un componente se deshabilita o deja de ser usable. Por ejemplo, un JButton podría oscurecerse y deja de responder cuando el programador no quiera que se tenga acceso a este. Los componentes están habilitados por defecto, pero se puede usar el método setenabled() para hacer un componente disponible o no pasando true o false a este, respectivamente. Actividad 3. Agregar funcionalidad al JButton y al JTextField de la actividad 6. Al pulsar el botón o presionar la tecla Intro se deberá cambiar el texto de la etiqueta para que muestre un mensaje de agradecimiento y para que el botón muestre la cadena Hecho. Actividad 4. Repetir la actividad anterior pero ahora sólo se modificará el texto de la etiqueta para que indique quien fue la fuente del evento, si el botón o el campo de texto. 8. Receptores de eventos Varios tipos de receptores existen en Java, y cada uno de estos puede manejar un tipo de evento específico. Una clase puede implementar tantos receptores como ocupe por ejemplo, una clase podría requerir responder a la pulsación de un botón del ratón y a un teclazo, así que se deberán implementar las interfaces ActionListener y KeyListener. El cuadro 2 lista algunos receptores de eventos y los tipos de eventos para los cuales son usados. Receptor Tipos de eventos Ejemplo ActionListener Eventos de acción Pulsar botón AdjustmentListener Eventos de ajuste Mover barra de desplazamiento ChangeListener Eventos de cambio Reposicionar deslizador FocusListener Eventos del foco del teclado Gana o pierde el foco un campo de texto ItemListener Eventos de elementos Cambiar estado de casilla de verificación KeyListener Eventos del teclado Ingresar texto MouseListener Eventos del ratón Pulsar botón del ratón MouseMotionListener Eventos de movimiento del Mover ratón ratón WindowListener Eventos de la ventana Cerrar ventana Cuadro 2: Lista de algunos receptores de eventos Un evento ocurre cada vez que un usuario teclea o pulsa un botón del ratón. Cualquier objeto puede ser notificado de un evento siempre y cuando este implemente la interfaz apropiada y sea registrado como un receptor de eventos en la fuente de eventos apropiada. Previamente, en la sección 6, se ha mostrado como establecer una relación entre un JButton y un JFrame que lo contiene usando el método addactionlistener(). De igual forma, se pueden crear relaciones entre otros componentes Swing y las clases que reaccionan a las manipulaciones de usuarios de ellos. En el cuadro 3, cada componente listado en la columna izquierda está asociado con un método de la columna derecha. 21

22 Por ejemplo, cuando se quiere que un JCheckBox responda a las pulsaciones del usuario, se puede usar el método additemlistener() para registrar el JCheckBox como el tipo de objeto que puede crear un evento ItemEvent. El argumento que se pone dentro de los paréntesis de la llamda al método additemlistener() es el objeto que debería responder al evento quizás un JFrame que contiene el JCheckBox generador del evento. El formato es: lafuentedelevento.addlistenermetodo(laclasequedeberáresponder); Componente(s) JButton, JCheckBox, JComboBox, JText- Field, y JRadioButton. JScrollBar Todos los componentes Swing. JButton, JCheckBox, JComboBox, y JRadioButton. Todos los componentes JWindow y JFrame. JSlider y JCheckBox. Método(s) registradoresreceptores asociados addactionlistener() addadjustmentlistener() addfocuslistener(), addkeylistener(), addmouselistener(), y addmousemotion- Listener() additemlistener() addwindowlistener() addchangelistener() Cuadro 3: Algunos componentes Swing y su métodos registradores-receptores asociados Nota. Cualquier fuente de eventos puede tener múltipes receptores registrados en este.es decir, una sola instancia de JCheckBox podría generar eventos ItemEvent y FocusEvent, y una sola instancia de la clase JFrame podría responder a los ActionEvent generados por el JButton y a los ItemEvents generados por el JCheckBox. La clase del objeto que responde a un evento debe contener un método que acepte el objeto evento creado por la acción del usuario. Un método que se ejecuta porque es llamado automáticamente cuando un evento apropiado ocurre es un manejador de evento. Es decir, cuando se registra un componente, tal como un JFrame, para ser un receptor para eventos generados por otro componente, como un JCheckBox, se debe escribir un método manejador de evento. No se puede escoger un nombre propio para los manejadores de evento identificadores de métodos específicos reaccionan a tipos específicos de eventos. En el cuadro 4 se listan algunos de los métodos que reaccionan a eventos. Receptor Método ActionListener actionperformed(actionevent) AdjustmentListener adjustmentvaluechanged(adjustmentevent) FocusListener focusgained(focusevent) y focuslost- (FocusEvent) ItemListener itemstatechanged(itemevent) Cuadro 4: Métodos seleccionados que responden a eventos. Las siguientes tareas se deben realizar cuando se declara una clase que maneja un evento: 22

23 La clase que maneja un evento deberá implementar una interfaz receptora o extender una clase que implemente una interfaz receptora. Por ejemplo, si un JFrame llamado MiMarco necesita responder a pulsaciones del usuario en un JCheckBox, se podría escribir la siguiente cabecera de clase: public class MiMarco extends JFrame implements ItemListener Si después se declara una clase que extienda MiMarco, no se necesita incluir implements ItemListener en su cabecera. La nueva clase hereda la implementación. Se debe registrar cada instancia de la clase manejadora de eventos como un receptor para uno o más componentes. Por ejemplo, si MiMarco contiene un JCheckBox llamado micheckbox, entonces dentro de la clase MiMarco se podría codificar: micheckbox.additemlistener(this); La referencia this es a la clase en la cual micheckbox está declarado en este caso, MiMarco. Se debe escribir un método manejador de eventos con un identificador apropiado, como se muestra en el cuadro 4, que acepte el evento generado y reaccione a este. 9. Clases para selección Otros componentes permiten al usuario hacer selecciones en un ambiente interfaz de usuario, como JCheckBox, ButtonGroup, y JComboBox. Clase JCheckBox Un JCheckBox es una casilla de verificación que consiste de una etiqueta puesta a un lado de un cuadro; se puede pulsar el cuadro para mostrar una palomita o quitarla. Se usa un JCheckBox para permitir al usuario prender o apagar una opción. La aplicación DemoCheckBox, código 13, muestra el uso de cuatro JCheckBox. 23

24 1 import java. awt. ; 2 import javax. swing. ; 3 import java. awt. event. ; 4 public class DemoCheckBox 5 extends JFrame implements I t e m L i s t e n e r { 6 JLabel e t i q u e t a = new JLabel ( Qué deseas tomar? ) ; 7 JCheckBox c a f e = new JCheckBox ( Café, f a l s e ) ; 8 JCheckBox c o l a = new JCheckBox ( Cola, f a l s e ) ; 9 JCheckBox l e c h e = new JCheckBox ( Leche, f a l s e ) ; 10 JCheckBox agua = new JCheckBox ( Agua, f a l s e ) ; 11 JLabel estado = new JLabel ( ) ; 12 public DemoCheckBox ( ) { 13 super ( Demostración CheckBox ) ; 14 s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame. EXIT ON CLOSE ) ; 15 setlayout (new FlowLayout ( ) ) ; 16 e t i q u e t a. setfont (new Font ( A r i a l, Font. ITALIC, 2 2 ) ) ; 17 c a f e. additemlistener ( this ) ; 18 c o l a. additemlistener ( this ) ; 19 l e c h e. additemlistener ( this ) ; 20 agua. additemlistener ( this ) ; 21 add ( e t i q u e t a ) ; 22 add ( c a f e ) ; 23 add ( c o l a ) ; 24 add ( l e c h e ) ; 25 add ( agua ) ; 26 add ( estado ) ; 27 } 28 public void itemstatechanged ( ItemEvent e ) { 29 Object f u e n t e = e. getitem ( ) ; 30 JCheckBox cb = ( JCheckBox ) f u e n t e ; 31 int s e l e c c i o n = e. getstatechange ( ) ; 32 i f ( s e l e c c i o n == ItemEvent.SELECTED) 33 estado. settext ( Se ha s e l e c c i o n a d o +cb. gettext ()+! ) ; 34 else 35 estado. settext ( Se ha quitado l a s e l e c c i ón +cb. gettext ()+! ) ; 36 } 37 public static void main ( S t r i n g [ ] arguments ) { 38 f i n a l int FRAME WIDTH = 350; 39 f i n a l int FRAME HEIGHT = 120; 40 DemoCheckBox ventana = new DemoCheckBox ( ) ; 41 ventana. s e t S i z e (FRAME WIDTH, FRAME HEIGHT) ; 42 ventana. s e t V i s i b l e ( true ) ; 43 } 44 } Código 13: Aplicación DemoCheckBox. La jerarquía de herencia de la clase JCheckBox se muestra enseguida. Los métodos más frecuentemente usados aparacen en el cuadro 5. java.lang.object +--java.awt.component 24

25 +---java.awt.container +---javax.swing.jcomponent +---javax.swing.abstractbutton +---javax.swing.jtogglebutton +---javax.swing.jcheckbox Método void settext(string) String gettext() void setselected(boolean) boolean isselected() Propósito pone el texto para el JCheckBox. regresa el texto JCheckBox. pone el estado del JCheckBox a true para seleccionado o false para no seleccionado. obtiene el estado actual (marcado o desmarcado) del JCheckBox. Cuadro 5: Métodos JCheckBox usados frecuentemente. Varios constructores pueden ser usados con JCheckBox. Cuando se construye un JCheckBox, se puede escoger si se le asigna una etiqueta; si el JCheckBox aparece seleccionado, por defecto un JCheckBox no está seleccionado. Las siguientes sentencias crean cuatro objetos JCheckBox: Sin etiqueta y sin selección. JCheckBox casilla1 = new JCheckBox(); Con etiqueta y sin selección. JCheckBox casilla2 = new JCheckBox("Marcar aquí"); Con etiqueta y sin selección. JCheckBox casilla3 = new JCheckBox("Marcar aquí", false ); Con etiqueta y seleccionado. JCheckBox casilla4 = new JCheckBox("Marcar aquí", true ); Si no se quiere inicializar un JCheckBox con una etiqueta y se quiere asignar después, o si se quiere cambiar una etiqueta existente, se puede usar el método settext(), como sigue: casilla1.settext("marcar esta casilla ahora); 25

26 Se puede poner el estado de un JCheckBox con el método setselected(); por ejemplo, se puede usar la siguiente sentencia para asegurar que casilla1 no esté seleccionada: casilla1.setselected(false ); El método isselected() es más útil en expresiones booleanas, como en el siguiente ejemplo, la cual agrega uno a una variable contadorvotos si casilla2 está actualmente marcada. if (casilla2.isselected()) ++contadorvotos; Cuando el estado de un JCheckBox cambia de marcado a no marcado, o viceversa, un evento ItemEvent es generado, y el método itemstatechanged() es ejecutado. Se puede usar el método getitem() para determinar cual objeto generó el evento y método getstatechange() para determinar si el evento fue una selección o no. El método getstatechange() devuelve un entero que es igual a una de las dos constantes de clase ItemEvent.SELECTED o ItemEvent.DESELECTED. En el siguiente extracto de código el método itemstatechanged() llama al método getitem(), el cual regresa el objeto llamado fuente. Luego, el valor de fuente es probado con una sentencia if para determinar si este es equivalente a un objeto JCheckBox llamado casilla. Si las dos referencias son al mismo objeto, el código determina si la casilla fue seleccionada o no, y en cada caso las acciones apropiadas son hechas. public void itemstatechanged(itemevent e) { Object fuente = e.getitem(); if (fuente == casilla) { int seleccion = e.getstatechange(): if (seleccion == ItemEvent.SELECTED) // sentencias que se ejecutan cuando la casilla está seleccionada else // sentencias que se ejecutan cuando la casilla NO está seleccionada } else { // sentencias que se ejecutan cuando la fuente del evento es otro // componente diferente a casilla } } Clase ButtonGroup Cuando se quieren opciones mutuamente exclusivas, es decir, se quiere que el usuario sólo pueda seleccionar una opción de varias, se debe crear un ButtonGroup para agrupar varios componentes, tales como los JCheckBox. Cuando se agrupan objetos JCheckBox y el usuario selecciona cualquiera de las casillas, el resto de las casillas queda sin selección. La clase ButtonGroup desciende directamente de la clase Object y también es parte del paquete javax.swing. 26

27 Nota. Un grupo de JCheckBox en el cual un usuario puede seleccionar uno a la vez actúa como un conjunto de botones de radio, los cuales se pueden crear usando la clase JRadioButton. La clase JRadioButton es similar a la clase JCheckBox, y se debe preferir su uso cuando se tiene una lista de opciones de usuario mutuamente excluyente. Para crear un ButtonGroup en un JFrame y luego agregar un JCheckBox, se deben realizar los siguientes cuatro pasos: 1. Crear un ButtonGroup, tal como: ButtonGroup ungrupo = new ButtonGroup(); 2. Crear un JCheckBox JCheckBox unacasilla = new JCheckBox(); 3. Agregar unacasilla a ungrupo ungrupo.add(unacasilla); 4. Agregar unacasilla al JFrame add(unacasilla); Se puede crear un ButtonGroup y luego crear los objetos individuales JCheckBox, o también invirtiendo el orden. Si se crea un ButtonGroup pero se olvida agregar cualquier objeto JCheckBox a este, entonces los JCheckBox actúan como casillas individuales no exclusivas. Un usuario puede marcar uno de los JCheckBox de un grupo pulsando con el ratón en este, o con código puede seleccionar un JCheckBox dentro de un ButtonGroup con una sentencia como la siguiente: ungrupo.setselected(unacasilla); Solo un JCheckBox puede ser seleccionado dentro de un grupo. Si se asigna el estado selected a un JCheckBox dentro de un grupo, cualquier asignación previa es dejada sin marca. Se puede determinar cual, si hay, de los JCheckBox en un ButtonGroup está seleccionado con el método isselected(). No se puede limpiar la casilla para todos los elementos que son miembros de un ButtonGroup. Se podría hacer que todos los JCheckBox en un ButtonGroup inicialmente se muestren sin selección agregando un JCheckBox que no sea visible, usando en este el método setvisible(). Luego, se podría usar el método setselected() para marcar el JCheckBox no visible, y el resto se muestre sin marca. 27

28 Clase JComboBox Un JComboBox es un componente que combina dos características: una área de visualización mostrando una opción por defecto y un cuadro de lista que contiene opciones adicionales alternas. El área de visualización contiene un botón que el usuario puede pulsar o un campo editable en el cual el usuario puede teclear. Cuando un JComboBox se muestra, la opción por defecto es mostrada. Cuando el usuario pulsa el JComboBox, una lista de elementos alternativos cae; si el usuario selecciona alguno, este reemplaza el elemento del cuadro mostrado. Los usuario esperan ver las opciones de un JComboBox en orden alfabético. Otras formas razonables son poner las opciones en algún otro orden lógico, como pequeño, mediano, y grande, o poniendo a los más frecuentemente seleccionados primero. La jerarquía de herencia de la clase JComboBox se muestra a continuación. java.lang.object +--java.awt.component +---java.awt.container +---javax.swing.jcomponent +---javax.swing.jcombobox Se puede construir un JComboBox usando un constructor sin argumentos y luego agregando elementos, por ejemplo, String a la lista con el método additem(). Las siguientes sentencias crean un JComboBox llamado opcionprincipal que contiene tres opciones de las cuales un usuario puede escoger: JComboBox<String> opcionprincipal = new JComboBox<String>(); opcionprincipal.additem("inglés"); opcionprincipal.additem("matemáticas"); opcionprincipal.additem("sociología"); En la declaración del JComboBox del ejemplo previo, se usa <String> seguido del nombre de la clase. Por defecto, un JComboBox espera elementos que los elementos agregados sean del tipo Object. Usando String encerrado entre paréntesis angulares se notifica al compilador que los elementos esperados en el JComboBox son String y se permite que el compilador revise por errores si elementos inválidos son agregados. Cuando no se indica un tipo de dato para un JComboBox, el programa compila, pero un mensaje de advertencia es marcado con cada llamada al método additem(). Se dice que la clase JComboBox usa genéricos. La programación con genéricos es una característica de los lenguajes modernos que permiten que tipos de datos múltiples sean usados de forma segura con métodos. Otra forma de construir un JComboBox es usando un arreglo de Object como argumento para el constructor; los elementos en el arreglo se convierten en la lista de elementos dentro del JComboBox. El siguiente código crea el mismo JComboBox opcionprincipal como en el código precedente: 28

29 String[] arregloprincipal = {"Inglés","Matemáticas","Sociología"}; JComboBox opcionprincipal = new JComboBox(arregloPrincipal); El cuadro 6 lista algunos métodos que se pueden usar con un objeto JComboBox. Por ejemplo, se puede usar el método setselecteditem() o setselectedindex() para escoger uno de los elementos en un JComboBox para que sea el elemento seleccionado inicialmente. Se puede usar el método getselecteditem() o getselectedindex() para saber cual elemento está actualmente seleccionado. Método void additem(object) void removeitem(object) void removeallitems() Object getitemat(int) int getitemcount() int getmaximumrowcount() int getselectedindex() Object getselecteditem() Object[] getselectedobjects() void seteditable(boolean) void setmaximumrowcount(int) void setselectedindex(int) void setselecteditem(object) Propósito Agrega un elemento a la lista. Quita un elemento de la lista. Quita todos los elementos de la lista. Regresa el elemento de la lista en la posición indicada por el índice entero. Devuelve la cantidad de elementos en la lista. Regresa la cantidad máxima de elementos que el cuadro lista puede desplegar sin una barra de desplazamiento. Da la posición del elemento seleccionado actualmente. Da el elemento seleccionado actualmente. Devuelve un arreglo conteniendo los Object seleccionados. Pone el campo para que sea editable o no. Pone la cantidad de renglones en el cuadro de lista que pueden ser mostrados a la vez. Pone el índice en la posición indicada por el argumento. Pone el elemento seleccionado en el área de visualización. Cuadro 6: Métodos JComboBox usados frecuentemente. Se puede tratar una lista de elementos en un objeto JComboBox como un arreglo; el primer elemento está en la posición cero, el segundo en la posición uno, etc. Es adecuado usar el método getselectedindex() para determinar la posición en la lista del elemento actualmente seleccionado; luego se puede usar el índice para acceder la información correspondiente guardada en un arreglo paralelo. Por ejemplo, si un JComboBox llamado opcioneshistoria ha sido llenado con una lista de eventos históricos, tales como Declaración de Independencia, Batalla de Puebla, y Expropiación Petrolera se puede codificar lo siguiente para recuperar la opción del usuario: int posicionseleccion = opcioneshistoria.getselectedindex(); La variable posicionseleccion guarda la posición del elemento seleccionado, y se puede usar la variable para acceder un arreglo de fechas para poder mostrar la fecha que corresponde al evento. Por ejemplo, si se declara lo siguiente, entondces fechas[posicionseleccion] tiene el año para el evento histórico seleccionado: 29

30 int fechas = {1810,1862,1938}; Nota. Un JComboBox no tiene que guardar los elementos declarados como String; puede guardar un arreglo de Object y mostrar los resultados del método tostring() usados con esos objetos. Es decir, en vez de usar arreglos paralelos para guardar eventos históricos y fechas, se podría designar una clase EventoHistórico que encapsule String para el evento e int para la fecha. Además de un JComboBox para el cual el usuario pulse sobre elementos presentados en una lista, se puede crear un JComboBox en el cual el usuario pueda teclear texto. Para hacer esto, se usa el método seteditable(). Una desventaja de usar un JComboBox es que el texto que el usuario ingresa debe ser exactamente igual a un elemento en el cuadro de lista. Si el usuario introduce incorrectamente la selección o el uso de mayúsculas/minúsculas, no devuelve un valor válido la llamada del método getselectedindex(). Se puede usar una sentencia if para probar el valor regresado de getselectedindex(); si este es negativo, la selección no aparea ningún elemento en el JComboBox, y se puede generar un mensaje de error apropiado. Actividad 5. Crea una aplicación interactiva para un hotel incluyendo JCheckBox para las diferentes selecciones. El precio base para un cuarto es $2000, y un huésped puede escoger de varias opciones. Reservar un cuarto para un fin de semana agrega $1000 al precio, incluir desayuno agrega $200, e incluir un viaje en lancha agrega $750. Un huésped puede seleccionar ninguna, alguna u todos estos servicios. Cada vez que el usuario cambia la opciones del paquete, el precio es recalculado. 30