AWT - Componentes (I)
|
|
|
AWT - Componentes (I) |
| Anterior | Siguiente |
|
Component es una clase abstracta que representa todo lo que tiene una posición, un tamaño, puede ser pintado en pantalla y puede recibir eventos. No tiene constructores públicos, ni puede ser instanciada. Sin embargo, desde el JDK 1.1 puede ser extendida para proporcionar una nueva característica incorporada a Java, conocida como componentes Lightweight. Los Objetos derivados de la clase Component que se incluyen en el Abstract Window Toolkit son los que aparecen a continuación:
Sobre estos Componentes se podrían hacer más agrupaciones y quizá la más significativa fuese la que diferencie a los Componentes según el tipo de entrada. Así habría Componentes con entrada de tipo no-textual como los botones de pulsación (Button), las listas (List), botones de marcación (Checkbox), botones de selección (Choice) y botones de comprobación (CheckboxGroup); Componentes de entrada y salida textual como los campos de texto (TextField), las áreas de texto (TextArea) y las etiquetas (Label); y, otros Componentes sin acomodo fijo en ningún lado, en donde se encontrarían Componentes como las barras de desplazamiento (Scrollbar), zonas de dibujo (Canvas) e incluso los Contenedores (Panel, Window, Dialog y Frame), que también pueden considerarse como Componentes. Los botones de pulsación (Button), son los que se han utilizado fundamentalmente en los ejemplos de este Tutorial, aunque nunca se han considerado sus atributos específicamente. La clase Button es una clase que produce un componente de tipo botón con un título. El constructor más utilizado es el que permite pasarle como parámetro una cadena, que será la que aparezca como título e identificador del botón en el interfaz de usuario. No dispone de campos o variables de instancia y pone al alcance del programador una serie de métodos entre los que destacan por su utilidad los siguientes:
Además dispone de todos los métodos heredados de las clases Component y Object. ActionListener es uno de los eventos de tipo semántico. Un evento de tipo Action se produce cuando el usuario pulsa sobre un objeto Button. Además, un objeto Button puede generar eventos de bajo nivel de tipo FocusListener, MouseListener o KeyListener, porque hereda los métodos de la clase Component que permiten instanciar y registrar receptores de eventos de este tipo sobre objetos de tipo Button. Los botones de selección (Choice) permiten el rápido acceso a una lista de elementos, presentándose como título el item que se encuentre seleccionado. La clase Choice extiende la clase Component e implementa el interfaz ItemSelectable, que es el interfaz que mantiene un conjunto de items en los que puede haber, o no, alguno seleccionado. Además, esta clase proporciona el método addItemListener(), que añade un registro de eventos item, que es muy importante a la hora de tratar los eventos que se producen sobre los objetos de tipo Choice. La clase Choice también dispone de cerca de una veintena de métodos que permiten la manipulación de los items disponibles para la selección, cuya amplia documentación el lector puede consultar en el API del JDK.
El ejemplo que se ha implementado, java1302.java, para ilustrar el uso de los botones de selección, coloca un objeto de tipo Choice sobre un objeto Frame y añade tres objetos de tipo String al objeto Choice, fijando el segundo de ellos como preseleccionado a la hora de lanzar el programa. La presentación inicial de la aplicación al ejecutarla es la que reproduce la imagen. Se instancia y registra un objeto de tipo ItemListener sobre el objeto Choice para identificar y presentar el objeto String que se elige cuando el usuario utiliza una selección. Cuando esto ocurre, se captura un evento en el método sobrescrito itemStateChanged() del objeto ItemListener. El código de este método utiliza una llamada a getSelectedItem() para el item que está marcado y presentar la cadena que le corresponde. También se instancia y registra un objeto receptor de eventos windowClosing() sobre el Frame para concluir el programa cuando el usuario cierre la ventana. import java.awt.*;
import java.awt.event.*;
import java.util.*;
public class java1302 {
public static void main( String args[] ) {
IHM ihm = new IHM();
}
}
// Clase del Interfaz Gráfico que instancia los objetos
class IHM {
public IHM() {
// Instancia un objeto Choice y coloca objetos String sobre el
// para realizar las selecciones
Choice miChoice = new Choice();
miChoice.add( "Primer Choice" );
miChoice.add( "Segundo Choice" );
miChoice.add( "Tercer Choice" );
// Seleccionamos la cadena correspondiente a la tercera selección
// por defecto, al arrancar la aplicación
miChoice.select( "Tercer Choice" );
// Instanciamos y registramos un objeto ItemListener sobre
// el objeto Choice
miChoice.addItemListener( new MiItemListener( miChoice ) );
// Colocamos el objetos Choice sobre el Frame para poder verlo
Frame miFrame = new Frame( "Tutorial de Java, AWT" );
miFrame.setLayout( new FlowLayout() );
miFrame.add( miChoice );
miFrame.setSize( 250,150 );
miFrame.setVisible( true );
// Instanciamos y registramos un objeto receptor de los eventos de
// la ventana, para recoger el evento de cierre del Frame y
// concluir la ejecucion de la aplicacion al recibirlo
miFrame.addWindowListener( new Conclusion() );
}
}
// Clase para recibir los eventos ItemListener generados por el objeto
// Choice de la aplicación
class MiItemListener implements ItemListener{
Choice oChoice;
MiItemListener( Choice choice ) {
// Guardamos una referencia al objeto Choice
oChoice = choice;
}
// Sobreescribimos el metodo itemStateChanged() del interfaz del
// ItemListener
public void itemStateChanged( ItemEvent evt ) {
System.out.println( oChoice.getSelectedItem() );
}
}
// Concluye la ejecución de la aplicación cuando el usuario cierra la
// ventana, porque se genera un evento windowClosing
class Conclusion extends WindowAdapter {
public void windowClosing( WindowEvent evt ) {
System.exit( 0 );
}
}
Los trozos de código que merecen un repaso en el programa anterior son los que se ven a continuación. Empezando por las sentencias siguientes, que son las típicas usadas en la instanciación del objeto Choice y la incorporación de objetos String a ese objeto Choice. Choice miChoice = new Choice(); miChoice.add( "Primer Choice" ); . . . La línea de código siguiente hace que el objeto Tercer Choice de tipo String, sea el que se encuentre visible al lanzar la aplicación. miChoice.select( "Tercer Choice" ); Y la sentencia que se reproduce ahora es la que instancia y registra un objeto de tipo ItemListener sobre el objeto Choice. miChoice.addItemListener( new MiItemListener( miChoice ) ); A esta sentencia le sigue el código que crea el objeto Frame, coloca el objeto Choice en él, etc. Ya se han visto varias veces sentencias de este tipo, así que no merece la pena volver sobre ellas. Así que ya solamente queda como código interesante en el programa el método itemStateChanged() que está sobrescrito, del objeto ItemListener. public void itemStateChanged( ItemEvent evt ) {
System.out.println( oChoice.getSelectedItem() );
}
Eventos de este tipo se producen siempre que el usuario realiza una selección (abre la lista de opciones y pulsa el botón del ratón con el cursor sobre una de ellas). Y, como se puede ver, el método getSelectedItem() es el encargado de obtener la representación en cadena del item que estaba seleccionado en ese momento. La clase CheckBox extiende la clase Component e implementa el interfaz ItemSelectable, que es el interfaz que contiene un conjunto de items entre los que puede haber o no alguno seleccionado. Los botones de comprobación (Checkbox) se pueden agrupar para formar un interfaz de botón de radio (CheckboxGroup), que son agrupaciones de botones de comprobación de exclusión múltiple, es decir, en las que siempre hay un único botón activo. La programación de objetos Checkbox puede ser simple o complicada, dependiendo de lo que se intente conseguir. La forma más simple para procesar objetos Checkbox es colocarlos en un CheckboxGroup, ignorar todos los eventos que se generen cuando el usuario selecciona botones individualmente y luego, procesar sólo el evento de tipo Action cuando el usuario fije su selección y pulse un botón de confirmación. Hay gran cantidad de programas, fundamentalmente para Windows, que están diseñados en base a este funcionamiento. La otra forma, más compleja, para procesar información de objetos Checkbox es responder a los diferentes tipos de eventos que se generan cuando el usuario selecciona objetos Checkbox distintos. Actualmente, no es demasiado complicado responder a estos eventos, porque se pueden instanciar objetos Listener y registrarlos sobre los objetos Checkbox, y eso no es difícil. La parte compleja es la implementación de la lógica necesaria para dar sentido a las acciones del usuario, especialmente cuando ese usuario no tiene clara la selección que va a realizar y cambia continuamente de opinión. El ejemplo que sigue, java1303.java, utiliza la solución simple, permitiendo que el usuario cambie de opción cuántas veces quiera y tome una decisión final pulsando sobre el botón "Aceptar". Se colocan cuatro objetos Checkbox, definidos sobre un objeto CheckboxGroup, y un objeto Button sobre un objeto Frame. La apariencia de estos elementos en pantalla es la que muestra la figura.
Se instancia y registra un objeto de tipo ActionListener sobre el objeto Button. La acción de seleccionar y deseleccionar un objeto Checkbox es controlada automáticamente por el sistema, al formar parte de un CheckboxGroup. Cada vez que se pulse el botón, se generará un evento que al ser procesado por el método sobrescrito actionPerformed(), determina y presenta en pantalla la identificación del botón de comprobación que está seleccionado. En la ventana se muestra tanto la identificación asignada por el sistema a los botones, como la etiqueta que es asignada directamente por el programa, demostrando que tanto una como otra se pueden utilizar para identificar el botón seleccionado. import java.awt.*;
import java.awt.event.*;
import java.util.*;
public class java1303 {
public static void main( String args[] ) {
// Se instancia un objeto Interfaz Hombre-maquina
IHM ihm = new IHM();
}
}
// Clase del Interfaz gráfico
class IHM {
// Constructor de la clase
public IHM() {
// Se crea un objeto CheckboxGroup
CheckboxGroup miCheckboxGroup = new CheckboxGroup();
// Ahora se crea un objeto Button y se registra un objeto
// ActionListener sobre él
Button miBoton = new Button( "Aceptar" );
miBoton.addActionListener( new MiActionListener( miCheckboxGroup ) );
// Se crea un objeto Frame para contener los objetos Checkbox y el
// objeto Button. Se fija un FlowLayout, se incorporan a el los
// objetos, se fija el tamaño y se hace visible
Frame miFrame = new Frame( "Tutorial de Java, AWT" );
miFrame.setLayout( new FlowLayout() );
miFrame.add( new Checkbox( "A",true,miCheckboxGroup ) );
miFrame.add( new Checkbox( "B",false,miCheckboxGroup ) );
miFrame.add( new Checkbox( "C",false,miCheckboxGroup ) );
miFrame.add( new Checkbox( "D",false,miCheckboxGroup ) );
miFrame.add( miBoton );
miFrame.setSize( 250,100 );
miFrame.setVisible( true );
// Instanciamos y registramos un receptor para terminar la
// ejecución de la aplicación, cuando el usuario cierre la
// ventana
miFrame.addWindowListener( new Conclusion() );
}
}
// Esta clase indica la caja de selección que esta seleccionada
// cuando se pulsa el botón de Aceptar
class MiActionListener implements ActionListener {
CheckboxGroup oCheckBoxGroup;
MiActionListener( CheckboxGroup checkBGroup ) {
oCheckBoxGroup = checkBGroup;
}
public void actionPerformed( ActionEvent evt ) {
System.out.println(oCheckBoxGroup.getSelectedCheckbox().getName()+
" " + oCheckBoxGroup.getSelectedCheckbox().getLabel() );
}
}
// Concluye la aplicación cuando el usuario cierra la ventana
class Conclusion extends WindowAdapter {
public void windowClosing( WindowEvent evt ) {
System.exit( 0 );
}
}
Hay cuatro trozos interesantes de código en este ejemplo que merecen un poco de atención especial. El primero es la creación del objeto CheckboxGroup, que posteriormente se utilizará para agrupar a los cuatro objetos Checkbox en un solo grupo lógico. CheckboxGroup miCheckboxGroup = new CheckboxGroup() Luego se crean el botón "Aceptar" y el objeto ActionListener que se va a registrar sobre él. Button miBoton = new Button( "Aceptar" ); miBoton.addActionListener( new MiActionListener( miCheckboxGroup ) ); También está la instanciación de los cuatro objetos Checkbox como parte del grupo CheckboxGroup y su incorporación al Frame. miFrame.add( new Checkbox( "A",true,miCheckboxGroup ) ); Y, finalmente, es interesante el fragmento de código en el que se sobrescribe el método actionPerformed() en el objeto ActionListener que extrae la identificación del objeto Checkbox, que se encuentra seleccionado. Aquí, el método getSelectedCheckbox() es un método de la clase CheckboxGroup, que devuelve un objeto de tipo Checkbox. El método getLabel() es miembro de la clase Checkbox, y el método getName() es miembro de la clase Component, que es una superclase de Checkbox. public void actionPerformed( ActionEvent evt ) {
System.out.println(oCheckBoxGroup.getSelectedCheckbox().getName()+
" " + oCheckBoxGroup.getSelectedCheckbox().getLabel() );
}
Las listas (List) aparecen en los interfaces de usuario para facilitar a los operadores la manipulación de muchos elementos. Se crean utilizando métodos similares a los de los botones Choice. La lista es visible todo el tiempo, utilizándose una barra de desplazamiento para visualizar los elementos que no caben en el área de la lista que aparece en la pantalla. La clase List extiende la clase Component e implementa el interfaz ItemSelectable, que es el interfaz que contiene un conjunto de items en los que puede haber, o no, alguno seleccionado. Además, soporta el método addActionListener() que se utiliza para recoger los eventos ActionEvent que se produce cuando el usuario pica dos veces con el ratón sobre un elemento de la lista. En el ejemplo java1304.java, que ilustra el empleo de las listas, coloca un objeto List y un objeto Button sobre un objeto Frame. Se añaden quince objetos String a la lista y se deja el segundo como seleccionado inicialmente. La apariencia de la ventana así construida, al inicializar el programa, es la que se reproduce en la imagen siguiente.
Sobre la lista se instancia y registra un objeto de tipo ActionListener, cuyo propósito es identificar y presentar en pantalla el objeto String, que el usuario ha seleccionado haciendo un doble pique sobre él. Cuando selecciona y luego pica dos veces con el ratón sobre un elemento de la lista, un evento es capturado por el método sobrescrito actionPerformed() del objeto ActionListener. El código de este método utiliza la llamada a getSelectedItem() de la clase List, para identificar y presentar la cadena que corresponde al elemento seleccionado. Sin embargo, si el usuario realiza una doble pulsación con el ratón sobre un elemento, mientras otro se encuentra seleccionado, el método getSelectedItem() devuelve null y no aparecerá nada en pantalla. Al objeto Frame también se le incorpora un Botón para permitir realizar selección múltiple en la lista; de tal forma que cuando se pulsa, se captura el evento ActionListener que genera y presenta en pantalla los elementos que se encuentren seleccionados en ese momento, incluso aunque sólo haya uno de ellos. También se instancia y registra un objeto receptor de eventos windowClosing() sobre el objeto Frame, para concluir el programa cuando el usuario cierre la ventana. import java.awt.*;
import java.awt.event.*;
public class java1304 {
public static void main( String args[] ) {
IHM ihm = new IHM();
}
}
class IHM {
public IHM(){
// Instancia un objeto List y coloca algunas cadenas sobre el,
// para poder realizar selecciones
List miLista = new List();
for( int i=0; i < 15; i++ )
miLista.add( "Elemento "+i );
// Activa la seleccion multiple
miLista.setMultipleMode( true );
// Presenta el elemento 1 al inicio
miLista.select( 1 );
// Instancia y registra un objeto ActionListener sobre el objeto
// List. Se produce un evento de tipo Action cuando el usuario
// pulsa dos veces sobre un elemento
miLista.addActionListener( new MiListaActionListener( miLista ) );
// Instancia un objeto Button para servicio de la seleccion
// multiple. Tambien instancia y registra un objeto ActionListener
// sobre el boton
Button miBoton = new Button( "Selecciona Multiples Items" );
miBoton.addActionListener( new miBotonActionListener( miLista ) );
// Coloca el objeto List y el objeto Button el el objeto Frame
Frame miFrame = new Frame( "Tutorial de Java, AWT" );
miFrame.setLayout( new FlowLayout() );
miFrame.add( miLista );
miFrame.add( miBoton );
miFrame.setSize( 250,150 );
miFrame.setVisible( true );
// Instancia y registra un objeto receptor de eventos de ventana
// para concluir la ejecucion del programa cuando el Frame se
// cierres por accion del usuario sobre el
miFrame.addWindowListener( new Conclusion() );
}
}
// Clase para recibir eventos de tipo ActionListener sobre el
// objeto List. Presenta en elemento seleccionado cuando el usuario
// pulsa dos veces sobre un item de lista cuando la seleccion es
// individual. Si el usuario pica dos veces sobre una seleccion
// multiple, se produce un evento pero el metodo getSelectedItem()
// de la clase List devuelve null y no se presenta nada en pantalla
class MiListaActionListener implements ActionListener {
List oLista;
MiListaActionListener( List lista ) {
// Salva una referencia al objeto List
oLista = lista;
}
// Sobreescribe el metodo actionPerformed() del interfaz
// ActionListener
public void actionPerformed( ActionEvent evt ) {
if( oLista.getSelectedItem() != null ) {
System.out.println( "Seleccion Simple de Elementos" );
System.out.println( " "+oLista.getSelectedItem() );
}
}
}
// Clase para recoger los eventos Action que se produzcan sobre el
// objeto Button. Presenta los elementos que haya seleccionados
// cuando el usuario lo pulsa, incluso aunque solamente haya uno
// marcado. Si no hubiese ninguno, so se presentaria nada en
// la pantalla
class miBotonActionListener implements ActionListener {
List oLista;
miBotonActionListener( List lista ) {
// Salva una referencia al objeto List
oLista = lista;
}
// Sobreescribe el metodo actionPerformed() del interfaz
// ActionListener
public void actionPerformed( ActionEvent evt ) {
String cadena[] = oLista.getSelectedItems();
if( cadena.length != 0 ) {
System.out.println( "Seleccion Multiple de Elementos" );
for( int i=0; i < cadena.length; i++ )
System.out.println( " "+cadena[i] );
}
}
}
class Conclusion extends WindowAdapter {
public void windowClosing( WindowEvent evt ) {
// Concluye el programa cuando se cierra la ventana
System.exit(0);
}
}
Si se realiza una revisión del código del ejemplo, se encuentran algunos fragmentos que merecen una reflexión. En el primero de ellos, que se reproduce en las líneas siguientes, se instancia un objeto List y se rellenan quince cadenas. La lista se define como una selección múltiple y se fija el segundo elemento como el inicialmente seleccionado en el momento del arranque del programa. // Instancia un objeto List y coloca algunas cadenas sobre el,
// para poder realizar selecciones
List miLista = new List();
for( int i=0; i < 15; i++ )
miLista.add( "Elemento "+i );
// Activa la seleccion multiple
miLista.setMultipleMode( true );
// Presenta el elemento 1 al inicio
miLista.select( 1 );
La sentencia siguiente es la que instancia y registra un objeto de tipo ActionListener sobre la lista, para que responda al doble pique del ratón sobre uno de los elementos de ese lista. miLista.addActionListener( new MiListaActionListener( miLista ) ); Luego, ya se encuentra el archivisto código que instancia un objeto Button, que instancia y registra un objeto ActionListener sobre ese botón, y que lo incorpora al Frame. El siguiente fragmento de código interesante se encuentra en la clase MiListaActionListener, que está diseñada para responder cuando el usuario pulse dos veces con el ratón sobre un item seleccionado de la lista. Si el usuario pica dos veces sobre una única selección de la lista, el método sobrescrito actionPerformed() identifica el elemento a través de una llamada al método getSelectedItem() y lo presenta en pantalla. Sin embargo, si se pulsa dos veces, cuando hay más de un elemento seleccionado, el método getSelectedItem() devuelve null y el elemento será ignorado. public void actionPerformed( ActionEvent evt ) {
if( aLista.getSelectedItem() != null ) {
System.out.println( "Seleccion Simple de Elementos" );
System.out.println( " "+oLista.getSelectedItem() );
}
}
Las líneas de código que se reproducen a continuación, constituyen el código que responde a un evento Action producido sobre el objeto Button, y presenta en pantalla uno, o más, elementos seleccionados de la lista. En este caso, el método empleado es getSelectedItem(), para crear un array que mantenga todos los elementos que estén seleccionado en el momento de pulsar el botón y que luego se presenta en pantalla. public void actionPerformed( ActionEvent evt ) {
String cadena[] = oLista.getSelectedItems();
if( cadena.length != 0 ) {
System.out.println( "Seleccion Multiple de Elementos" );
for( int i=0; i < cadena.length; i++ )
System.out.println( " "+cadena[i] );
}
}
}
|
|
|
