Java Basico_03

Instituto Tecnológico Metropolitano

Programación en Java

Parte 3: Uso del Equipo de Herramientas Gráficas para VentanasObjetivo GeneralAprender el uso de los diferentes objetos gráficos que se agregan a las ventanas y Applets para leer o mostrar de datos.

IntroducciónCuando se hacen Applets o aplicaciones en Java con ventanas es muy común utilizar el equipo de herramientas gráficas AWT (Abstract Windowing Toolkit) ya que son las que proporcionan el soporte gráfico necesario para las interfazs que más gustan a los usuarios actuales. AWT es un paquete que contiene numerosas clases y métodos que permiten crear y gestionar ventanas. Una descripción completa del AWT sería bastante extensa, por lo que se tratarán los temas más relevantes.

TEMA 1 El paquete java.awtEl paquete java.awt contiene un conjunto clases que se pueden dividir en tres categorías:

Gráficos: Clases que definen colores, fuentes, imágenes, polígonos, etc. Componentes: Clases que definen componentes de GUI (interfaz de usuario gráfica), por ejemplo:

botones, menús, listas y cuadros de diálogo. Administradores de diseño: Clases que controlan el diseño de componentes dentro de objetos

contenedores..

Existen algunos paquetes separados como java.awt.datatransfer, java.awt.event y java.awt.image que contienen clases para cortar y pegar, manejar eventos y manipular imágenes.

La clase Graphics incluye métodos que permiten hacer dibujos de línea y texto, así como pintura de imagen. Se le utiliza como parámetro del método paint() de la clase Applet. y no es posible instanciarlo directamente al igual que la clase Image, el cual se puede obtener mediante el método Applet.getImage().

Las clases Font y Color permiten modificar la apariencia del texto que se pueda desplegar, tanto en los componentes como por otro medio.

Los componentes GUI son los que pueden aparecer en interfazs y menús. Clases como la Applet actúan como contenedores de estos componentes y los acomodan visualmente. Se pueden agregar componentes a un contenedor con el método add() y especificar un administrador de diseño para el contenedor con el método setLayout().

Dentro de los componentes más utilizados tenemos:

Componente ClaseEtiqueta Label

Caja de texto TextField

Lista desplegable Choice

Cuadro de lista List

1


Botón de radio Checkbox, CheckboxGroup

Caja de chequeo Checkbox

Botón de comando Button

Dentro de la categoría de los administradores de diseño, las clases GridBagLayout, BorderLayout, GridLayout y CardLayout son las más útiles. Estos se encargan de acomodar los componentes dentro de un contenedor de cuatro formas distintas:

En un número específico de filas y columnas de igual tamaño (GridLayout)

A lo largo de los bordes y en el centro del contenedor (BorderLayout)

En una rejilla de filas y columnas que no necesariamente tienen la misma altura y ancho y que ajusta el tamaño de las celdas según sea adecuado para asegurar que los componentes no se traslapen (GridBagLayout).

El modo cómo se posiciona cada componente dentro de la rejilla del GridBagLayout, se especifica mediante un número de variables en un objeto de la clase GridBagConstraints., el cual se pasa como un parámetro adicional del método add() cuando se agrega el componente.

En un conjunto de fichas con pestañas donde sólo se muestra la que está en la parte superior

El paquete AWT define ventanas en función de una jerarquía de clases que añade funcionalidad y carácter específico con cada nivel. Las dos ventanas más comunes son las que derivan de Panel, que las utilizan los Applets, y las que derivan de Frame (marco), que permiten crear una ventana estándar.

La siguiente lista complementa las clases de este paquete:

Clase DescripciónCanvas Crea una ventana sin una semántica asociadaCheckboxMenuItem Crea un elemento del menú del tipo encendido/apagadoComponent Es una superclase abstracta de varios componentes del AWTContainer Es una subclase abstracta de Component que puede contener otros componentesDialog Crea una ventana de diálogoDimension Especifica las dimensiones de un objeto. El ancho se almacena en width y el alto en

height

2


Event Encapsula eventosFileDialog Crea una ventana desde la que se puede seleccionar un archivoFrame Crea una ventana que tiene una barra de título, esquinas que permiten cambiar el

tamaño de la ventana y un menú.Insets Encapsula los bordes de un contenedorMediaTracker Gestor de cargaMenu Crea un menú desplegableMenuBar Crea una barra de menúMenuComponent Clase abstracta implementada por varias clases del menúMenuItem Crea un elemento de un menúPanel Es una subclase de ContainerPoint Encapsula un par de coordenadas cartesianas almacenadas en x y y.Polygon Encapsula un polígonoRectangle Encapsula un rectánguloScrollbar Crea una barra de desplazamientoTextArea Crea el control para un área de texto con varias líneasTextComponent Es una superclase de TextArea y TextFieldToolkit Clase abstracta implementada por el AWTWindow Crea una ventana sin marco, sin menú ni título

TEMA 2 Componentes GUI básicos y eventos de comandoEl mejor modo de aprender a utilizar el paquete AWT es mediante ejemplos para apreciar los diferentes aspectos que comprende.

A continuación aprenderemos a utilizar cajas de texto, botones de comando, administradores de diseño y el modelo de eventos de comando.

Se trata de realizar un Applet que simule una pequeña calculadora con las operaciones básicas. Los componentes a utilizar son los siguientes:

Observamos que el Applet en primer lugar es un contenedor de la clase Panel. El diseño del contenedor corre a cargo de la clase GridBagLayout, la cual distribuye los controles de acuerdo a parámetros especificados a través de la clase GridBrgConstraints. En la única celda de la primer fila del administrador de diseño (la cual comprende las 5 celdas inferiores), irá una caja de texto para leer y mostrar números. En las celdas inferiores (fila 2) irán botones de comando que activarán cada una de las operaciones disponibles. Son los objetos que tendrán asociados sucesos.

Para que la aplicación pueda reaccionar a sucesos que ocurren con los botones de comando debe heredar la interfaz que permite “escuchar” eventos de acción en componentes AWT. Esta es la clase ActionListener, la cual mediante el método actionPerformed() es notificada cuando ocurre un ActionEvent con cualquiera de los objetos registrados mediante el respectivo método addActionListener().

3


ActionEvent es la clase que representa un evento de “Acción” generado por un componente AWT (los correspondientes a las clases Button y MenuItem). El método getActionCommand() devuelve el String correspondiente a la acción definida para el componente mediante el respectivo método setActionCommand().

Estas dos clases pertenecen al paquete java.awt.event

El siguiente es el código para este Applet. En el método init() (El cual se superpone, es decir, viene heredado de la clase Applet pero se modifica) se define como será su aspecto y las acciones que se pueden activar. La caja de texto es global para poder ser utilizada en los distintos métodos, mientras los botones sólo son definidos inicialmente, ya que posteriormente sólo son referenciadas las acciones asociadas (en el método actionPerformed()). Se definen 5 acciones: 4 para activar las operaciones aritméticas y 1 para mostrar el resultado. Dado que se utiliza una sala caja de texto para leer y mostrar datos, los valores temporales son almacenados en la variable memoria.

El código Java es el siguiente:import java.Applet.*;import java.awt.*;import java.awt.event.*;

public class Calculadora extends Applet implements ActionListener{

/* Caja de texto para leer o mostrar números */TextField txtNum=new TextField(10);/* Variables para conservar el último valor y la última operación */double memoria=0;int operador=0;

public void init(){/* Definir el administrador de diseño*/GridBagLayout gbl=new GridBagLayout();GridBagConstraints gbc=new GridBagConstraints();setLayout(gbl);

/* Definir características de la primer celda de la primer fila y agregar la caja de texto */gbc.gridx=1;gbc.gridy=1;gbc.gridwidth=5;add(txtNum,gbc);

/* Definir características de la primer celda de la segunda fila y agregar el primer botón*/Button bntS=new Button("+");gbc.gridx=1;gbc.gridy=2;gbc.gridwidth=1;add(bntS,gbc);

/* Definir características de las celdas siguientes de la segunda fila y agregar los respectivos botones */Button bntR=new Button("-");gbc.gridx=2;add(bntR,gbc);

Button bntM=new Button("*");gbc.gridx=3;add(bntM,gbc);

Button bntD=new Button("/");gbc.gridx=4;add(bntD,gbc);

Button bntI=new Button("=");gbc.gridx=5;add(bntI,gbc);

4


/* Definir las acciones asociadas a los botones de commando y agregarlas al escuchador de eventos de acción */bntS.setActionCommand("Sum");bntS.addActionListener(this);bntR.setActionCommand("Res");bntR.addActionListener(this);bntM.setActionCommand("Mul");bntM.addActionListener(this);bntD.setActionCommand("Div");bntD.addActionListener(this);bntI.setActionCommand("Igu");bntI.addActionListener(this);}

/* Método que detecta la ocurrencia de un evento */public void actionPerformed(ActionEvent e){/* Obtener el valor numérico de lo digitado en la caja de texto */Double d=new Double(txtNum.getText());

/* Determinar cual fue la acción activada */String accion=e.getActionCommand();

/* Si la acción corresponde a una operación aritmética, se conservan el valor digitado y la operación activada */if(accion.equals("Sum"))

{memoria=d.doubleValue();operador=1;txtNum.setText("");}

if(accion.equals("Res")){memoria=d.doubleValue();operador=2;txtNum.setText("");}

if(accion.equals("Mul")){memoria=d.doubleValue();operador=3;txtNum.setText("");}

if(accion.equals("Div")){memoria=d.doubleValue();operador=4;txtNum.setText("");}

/* Si la acción es el calculo del resultado final, se calcula y se muestra */if(accion.equals("Igu"))

{double valor=memoria;switch(operador)

{case 1:

valor+=d.doubleValue();break;

case 2:valor-=d.doubleValue();break;

case 3:valor*=d.doubleValue();break;

case 4:if(d.doubleValue()!=0)

valor/=d.doubleValue();else

5


valor=0;break;

}txtNum.setText(String.valueOf(valor));}

}}

El Applet ejecutándose se vería así:

TEMA 3 Componentes GUI para listas y eventos de selecciónEn el siguiente ejemplo se empleará una lista desplegable (cuadro combinado) para seleccionar un dato, y cuando ello ocurra, se mostrará una imagen.

Se trata de listar los departamentos de la república de Colombia y cuando se elija uno, se muestra el respectivo mapa.

Para ello el Applet incluye un objeto de la clase Choice el cual permite elegir una opción en una lista desplegable. Para indicar que clase de opciones se listan, se añade un objeto de clase Label el cual permite mostrar texto que no es editable (Lo cual lo diferencia de la clase TextField).

Este Applet dada la sencillez de su interfaz, no utiliza un administrador de diseño.

Para que la aplicación pueda reaccionar a sucesos que ocurren con la lista debe heredar la interfaz que permite “escuchar” eventos de selección en componentes AWT. Esta es la clase ItemListener, la cual mediante el método itemStateChanged() es notificada cuando ocurre un ItemEvent con cualquiera de los objetos registrados mediante el respectivo método addItemListener().

ItemEvent es la clase que representa un evento de “Selección” generado por un componente AWT (los correspondientes a las clases Choice, List y Checkbox). El método getItemSelectable() devuelve el objeto que activa el suceso.

Estas dos clases pertenecen al paquete java.awt.event

La lista desplegable se llena con los nombres de los departamentos de Colombia los cuales se almacenan en el vector de String strDepto. Paralelo a este vector se tiene otro llamado strArchivoDepto el cual contiene los nombres de los archivos con la imágenes de los mapas de cada uno de los departamentos. De esta manera, cuando se elige un departamento de la lista, se obtiene el nombre del archivo de la imagen.

En la siguiente imagen se muestra la carpeta con los archivos:

6


Los objetos de la clase Choice tienen el método addItem() para agregar opciones a la lista. El método getSelectedIndex() sirve para saber cual fue la opción escogida. El método removeAll() quita todas las opciones.

El código del Applet se completa con las instrucciones que muestran la imagen del mapa del departamento.

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

public class Depto extends Applet implements ItemListener{String[] strDepto=new String[]

{"Amazonas", "Antioquia", "Arauca", "Atlántico", "Bolívar", "Boyacá",

7


"Caldas", "Caquetá", "Casanare", "Cauca", "Cesar", "Córdoba", "Cundinamarca", "Chocó", "Guainía","Guajira", "Guaviare", "Huila", "Magdalena", "Meta", "Nariño","Norte de Santander", "Putumayo", "Quindío","Risaralda", "San Andrés y Providencia", "Santander","Sucre", "Tolima", "Valle del Cauca",

"Vichada", "Vaupés"};

String[] strArchivoDepto=new String[]{"Amazonas", "Antioquia", "Arauca", "Atlantico", "Bolivar", "Boyaca", "Caldas", "Caqueta", "Casanare", "Cauca", "Cesar", "Cordoba", "Cundinamarca", "Choco", "Guainia","Guajira", "Guaviare", "Huila", "Magdalena", "Meta", "Nariño","NortedeSantander", "Putumayo", "Quindio","Risaralda", "SanAndres", "Santander","Sucre", "Tolima", "ValledelCauca",

"Vichada", "Vaupes"};

Choice cmbDepto=new Choice();String strArchivo="";

public void init(){/* Definiendo vector con la lista de Departamentos */cmbDepto.removeAll();int i;for(i=0;i<strDepto.length;i++)

cmbDepto.addItem(strDepto[i]);cmbDepto.addItemListener(this);Label lblTitulo=new Label("Departamentos de Colombia");add(lblTitulo);add(cmbDepto);}

/* método para mostrar grágicos en el Applet */public void paint(Graphics g)

{if(strArchivo.length()>0)

{Image imgMapa=getImage(getDocumentBase(),strArchivo);g.drawImage(imgMapa,0,80,this);}

}

/* método que detecta la ocurrencia de eventos para componentes tipo selección */public void itemStateChanged(ItemEvent e)

{if(e.getItemSelectable()==cmbDepto)

{/* Eligió un Departamento */strArchivo=strArchivoDepto[cmbDepto.getSelectedIndex()]+".jpg";repaint();}

}}

8


La ejecución del Applet se vería así en el navegador:

TEMA 4 Un ejemplo que combina eventos de acción y selección

Un ejemplo de una interfaz que hace un uso ilustrativo del paquete java.awt es la siguiente:

9


Esta es una interfaz de un Applet que permite a un usuario calcular el valor de una llamada telefónica con base en la duración, el destino, la tarifa y el horario.

Se pueden observar los diferentes componentes distribuidos de acuerdo a una rejilla.

Para obtener la apariencia inicial de la interfaz del ejemplo, se declaran los componentes y se superpone el código de los métodos init() y paint() de un Applet en los cuales se codifica el estado inicial del Applet:

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

public class Llamada extends Appletimplements ActionListener, ItemListener {

/* Definiendo caja de texto para la Duración de la llamada */TextField txtDuracion=new TextField(5);

/* Definiendo botones de radio para el Destino de la llamada */CheckboxGroup chkGDestino=new CheckboxGroup();Checkbox chkNal=new Checkbox("Nacional", chkGDestino, false);Checkbox chkInternal=new Checkbox("Internacional", chkGDestino, false);

/* Definiendo listas desplegables para la Tarifa y el Horario */Choice cmbHora=new Choice();Choice cmbTarifa=new Choice();

/* Definiendo botón de comando para calcular el Valor de la Llamada */Button cmdCalcular=new Button("Valor Llamada");

/* Definiendo etiquetas para el Valor de la Llamada,el Valor de la Tarifa y el Porcentaje de Descuento */

Label lblValor=new Label(" 0");Label lblValorTarifa=new Label(" 0");Label lblDescuento=new Label(" 0");

/* Definiendo vector con la lista de Destinos Nacionales */String[] strDestinoNal=new String[] {

"Antioquia, Córdoba y Chocó", "Atlántico, Bolívar y Sucre","Cesar, Guajira y Magdalena","Cauca, Nariño y Valle", "Caldas, Quindío y Risaralda","Boyacá, Santander Norte y Sur","Cundinamarca, Huila y Tolima", "Orinoquía","Amazonía"};

/* Definiendo vector con las tarifas para los Destinos Nacionales */int intDestinoNal[]={100, 150, 200, 150, 120, 150, 120, 300, 300};

/* Definiendo vector con la lista de Destinos Internacionales */String[] strDestinoInternal=new String[] {

"EE UU y Canadá", "México, CentroAmérica y el Caribe","Zona Andina","Mercosur", "Zona Euro",

10


"Europa Oriental","Rusia y Asia Menor", "Israel y Oriente Medio","Lejano Oriente","Africa"};

/* Definiendo vector con las tarifas para los Destinos Internacionales */int intDestinoInternal[]={300, 350, 250, 300, 400, 600, 550, 600, 700, 800};

/* Definiendo vector con los porcentajes de descuento según el horario */double dblDescuento[]={2.5, 0, 5, 10};

public void init (){

/* Agregando los botones de radio al administrador de eventos */chkNal.addItemListener(this);chkInternal.addItemListener(this);

/* Agregando los cuadros de lista al administrador de eventos */cmbTarifa.addItemListener(this);cmbHora.addItemListener(this);

/* Agregando los botones de comando al administrador de eventos */cmdCalcular.setActionCommand("Calcular");cmdCalcular.addActionListener(this);

/* Definiendo administrador de diseño */GridBagConstraints gbcLlamada=new GridBagConstraints();GridBagLayout lytLlamada=new GridBagLayout();setLayout(lytLlamada);

/* Definiendo y Agregando fuente, color y etiqueta para el Título */Label lblTitulo=new Label("Valor Llamada Telefónica");Font fntTitulo=new Font("Arial",Font.ITALIC+Font.BOLD,12);lblTitulo.setFont(fntTitulo);lblTitulo.setForeground(Color.blue);gbcLlamada.gridx=1;gbcLlamada.gridy=1;gbcLlamada.gridwidth=3;add(lblTitulo, gbcLlamada);

/* Definiendo y Agregando etiqueta para la Duración de la llamada */Label lblDuración=new Label("Duración (minutos)");gbcLlamada.gridx=1;gbcLlamada.gridy=2;gbcLlamada.anchor=gbcLlamada.WEST;gbcLlamada.gridwidth=1;add(lblDuración, gbcLlamada);

/* Agregando caja de texto para la Duración de la llamada */gbcLlamada.gridx=2;gbcLlamada.gridy=2;gbcLlamada.gridwidth=2;add(txtDuracion, gbcLlamada);

/* Definiendo y Agregando etiqueta para el Destino */Label lblDestino=new Label("Destino");gbcLlamada.gridwidth=1;gbcLlamada.gridx=1;gbcLlamada.gridy=3;add(lblDestino, gbcLlamada);

/* Agregando botón de radio par el Destino Nacional */gbcLlamada.gridx=2;gbcLlamada.gridy=3;add(chkNal, gbcLlamada);

11


/* Agregando botón de radio para el Destino Internacional */gbcLlamada.gridx=3;gbcLlamada.gridy=3;add(chkInternal, gbcLlamada);

/* Definiendo y Agregando etiqueta para la Tarifa */Label lblTarifa=new Label("Tarifa");gbcLlamada.gridx=1;gbcLlamada.gridy=4;add(lblTarifa, gbcLlamada);

/* Agregando opciones a la lista desplegable para la Tarifa (inicialmente vacía) */cmbTarifa.addItem(" ");

/* Agregando lista desplegable para la Tarifa */gbcLlamada.gridx=2;gbcLlamada.gridy=4;add(cmbTarifa, gbcLlamada);

/* Definiendo y Agregando etiqueta para el Valor de la Tarifa */gbcLlamada.gridx=3;gbcLlamada.gridy=4;add(lblValorTarifa, gbcLlamada);

/* Definiendo y Agregando etiqueta para el Horario */Label lblHorario=new Label("Horario");gbcLlamada.gridx=1;gbcLlamada.gridy=5;add(lblHorario, gbcLlamada);

/* Agregando opciones a la lista desplegable para el horario */cmbHora.addItem("Mañana");cmbHora.addItem("Tarde");cmbHora.addItem("Noche");cmbHora.addItem("Madrugada");

/* Agregando lista desplegable para el horario */gbcLlamada.gridx=2;gbcLlamada.gridy=5;add(cmbHora, gbcLlamada);

/* Definiendo y Agregando etiqueta para el Descuento */gbcLlamada.gridx=3;gbcLlamada.gridy=5;add(lblDescuento, gbcLlamada);

/* Agregando boton de comando para Calcular el valor de la llamada */gbcLlamada.gridx=1;gbcLlamada.gridy=6;add(cmdCalcular, gbcLlamada);

/* Agregando etiqueta para el Valor de la Llamada */gbcLlamada.gridx=2;gbcLlamada.gridy=6;add(lblValor, gbcLlamada);

}/* método para mostrar grágicos en el Applet */public void paint(Graphics g){

Image imgLogo=getImage(getDocumentBase(),"Orbitel.gif");g.drawImage(imgLogo,0,0,this);

}

Observe que algunos componentes se declaran fuera del método init() y otros dentro de él. Los que se declaran fuera son elementos globales del Applet, es decir, que se pueden reconocer en cualquier método. Los que se declaran dentro del método init() tales como algunas etiquetas y los administradores de diseño, sólo se necesitan inicialmente.

12


Para agregar cada componente al Applet, se utiliza un objeto GridBagConstraint el cual define como se ubicará dentro de la rejilla del GridBagLayout. Para ello se actualizan algunas propiedades GridBagConstraint:

gridx, gridy que definen la celda del rejilla. gridwidth, gridheight que definen el ancho y el alto en número de celdas. anchor que define la alineación del control respecto a la celda.

gbcLlamada.gridx=2;gbcLlamada.gridy=2;gbcLlamada.gridwidth=2;add(txtDuracion, gbcLlamada);

Para usar un tipo de letra observe el método constructor font() de la clase Font el cual pide especificar la fuente, el estilo (Usando los atributos constantes ITALIC, BOLD) y el tamaño. El tipo de letra se asigna a los componentes con el método setFont().

Font fntTitulo=new Font("Arial",Font.ITALIC+Font.BOLD,12);lblTitulo.setFont(fntTitulo);

Para usar un color se utilizan los atributos de la clase Color identificados con el nombre del color: black, blue, cyan, darkGray, gray, green, lightGray, magenta, orange, pink, red, white y yellow. Y se asigna al componente con el método setForeground().

lblTitulo.setForeground(Color.blue);

Para mostrar la imagen: Se genera un objeto Image mediante el método getImage() de Applet el cual pide como parámetros

la ubicación del archivo (Un objeto de la clase URL que se obtiene usando el método getDocumentBase() de Applet) y el nombre del archivo. Esto implica que el archivo con la imagen debe estar en la misma carpeta del archivo con el Applet.

Se muestra la imagen utilizando el método drawImage() de la clase Graphics el cual pide como parámetros el objeto Image y las coordenadas a partir de donde se mostrará.

Image imgLogo=getImage(getDocumentBase(),"Orbitel.gif");g.drawImage(imgLogo,0,0,this);

Para que componentes de la clase Checkbox actúen como botones de radio y no como cajas de chequeo, deben agruparse en un objeto CheckboxGroup. Para ello en el método constructor Checkbox() se debe especificar el respectivo objeto CheckboxGroup al que pertenecen.

CheckboxGroup chkGDestino=new CheckboxGroup();Checkbox chkNal=new Checkbox("Nacional", chkGDestino, false);Checkbox chkInternal=new Checkbox("Internacional", chkGDestino, false);

Para definir las opciones de la lista desplegable, se debe utilizar el método addItem() de la respectiva clase (Choice).

cmbHora.addItem("Mañana");cmbHora.addItem("Tarde");cmbHora.addItem("Noche");cmbHora.addItem("Madrugada");

La opciones de la lista de tarifas dependen del destino elegido y por tanto varían. Para ello se definen unos vectores constantes que permitirán llenar la lista.

13


Cuando se trata de definir un vector de clases se utiliza el identificador del método constructor seguido de corchetes entre los cuales puede ir el tamaño del vector. Si se desea especificar los valores iniciales del vector se pueden escribir a continuación entre llaves y separados por coma.

String[] strDestinoInternal=new String[] {"EE UU y Canadá", …}

Cuando se trata de definir un vector de variables se utiliza el identificador de la variable seguido de corchetes entre los cuales puede ir el tamaño del vector. Si se desea especificar los valores iniciales del vector se pueden escribir a continuación en una asignación entre llaves y separados por coma.

double dblDescuento[]={2.5, 0, 5, 10};

Dado que la interfaz es un Applet y además debe responder a eventos tanto de acción como de selección, se utiliza la instrucción extends seguida del identificador de la clase e implementa las interfaces para escuchar eventos a continuación mediante la instrucción implements seguida los identificadores de las respectivas clases.

public class Llamada extends Applet implements ActionListener, ItemListener {

Cuando se trata de un componente tipo comando (Button y MenuItem) se debe especificar una cadena identificadora del componente mediante el método setActionCommand(), la cual se incluirá en los eventos ActionEvent generados por los componentes. Además se debe agregar el componente a la lista del administrador de eventos mediante el método addActionListener().

cmdCalcular.setActionCommand("Calcular");cmdCalcular.addActionListener(this);

Para determinar si un evento de acción ha ocurrido, se superpone el método actionPerformed() de la clase ActionListener el cual tiene como parámetro de entrada un objeto de la clase ActionEvent. Para saber que componente activó el evento, se utiliza el método getActionCommand() el cual devuelve la cadena identificadora de la acción.

/* método que detecta la ocurrencia de eventos para componentes tipo comando */public void actionPerformed(ActionEvent e){

String accion=e.getActionCommand();/* Se presionó el botón para calcular el valor de la llamada*/if(accion.equals("Calcular")){

double dblDuracion=Double.valueOf(txtDuracion.getText()).doubleValue();int intTarifa=0;if(chkNal.getState())

intTarifa=intDestinoNal[cmbTarifa.getSelectedIndex()];if(chkInternal.getState())

intTarifa=intDestinoInternal[cmbTarifa.getSelectedIndex()];double dblDescuento1=1-dblDescuento[cmbHora.getSelectedIndex()]/100;double dblValor=dblDuracion*intTarifa*dblDescuento1;lblValor.setText("$ "+Double.toString(dblValor));

}}

Cuando se trata de un componente tipo selección (Choice, List y Checkbox) se debe agregar el componente a la lista del administrador de eventos mediante el método addItemListener().

chkNal.addItemListener(this);chkInternal.addItemListener(this);

Para determinar si un evento tipo selección ha ocurrido, se superpone el método itemStateChanged () de la clase ItemListener el cual tiene como parámetro de entrada un objeto de la clase ItemEvent. Para saber que componente activó el evento, se utiliza el método getItemSelectable ().

14


/* método que detecta la ocurrencia de eventos para componentes tipo selección */public void itemStateChanged(ItemEvent e){

byte i;/* El botón "Nacional" fue seleccionado */if(e.getItemSelectable()==chkNal){

cmbTarifa.removeAll();for(i=0;i<=strDestinoNal.length;i++)

cmbTarifa.addItem(strDestinoNal[i]);}/* El botón "Internacional" fue seleccionado */if(e.getItemSelectable()==chkInternal){

cmbTarifa.removeAll();for(i=0;i<=strDestinoInternal.length;i++)

cmbTarifa.addItem(strDestinoInternal[i]);}/* Se hizo una selección en la lista desplegable de Tarifas */if(e.getItemSelectable()==cmbTarifa){

/* Es una tarifa nacional */if(chkNal.getState())

lblValorTarifa.setText("$"+Integer.toString(intDestinoNal[cmbTarifa.getSelectedIndex()]));/* Es una tarifa Internacional */if(chkInternal.getState())

lblValorTarifa.setText("$"+Integer.toString(intDestinoInternal[cmbTarifa.getSelectedIndex()]));}/* Se hizo una selección en la lista desplegable de Horarios */if(e.getItemSelectable()==cmbHora){

lblDescuento.setText(Double.toString(dblDescuento[cmbHora.getSelectedIndex()])+" %");

}}

Para saber si un botón de radio ha sido seleccionado, se utiliza el método getState() de Checkbox.

Para saber que opción ha sido escogida de una lista desplegable se utiliza el método getSelectedIndex() de Choice.

TEMA 5 Ventanas y Menús

La clase Frame representa una ventana de aplicación de nivel superior, opcionalmente redimensionable, con una barra de título y otras decoraciones que tienen las ventanas dependientes de plataforma (como las que utiliza el sistema operativo MS Windows).

Para operar con ventanas se tienen los siguientes métodos

Método DescripciónsetTitle (String titulo) Especifica el título para la ventanasetMenuBar Especifica un barra de menúsetIconImage Especifica un icono para la ventanasetCursor Especifica un cursorpack() Inicia la administración del diseño de la ventana para ajustar el

tamaño al contenido inicial.Show() Hace que aparezca el trazado de la ventanadispose() Retira la ventana y libera los recursos del sistema para dicha

ventana.

Para el manejo de los menús de barras, Java dispone de las siguientes clases:

15


Clase DescripciónMenuBar Esta clase representa una barra de menú. El método add() agrega objetos de la clase Menu a

la barra de menú, mientras que setHelpMenu() agrega un menú Help (Ayuda) en una ubicación reservada de la barra de menú. Un objeto MenuBar se puede desplegar dentro de un Frame al pasarlo como parámetro del método setMenuBar().

Menu Esta clase representa un panel de menú descendente que aparece dentro de un MenuBar. Cada Menu tiene una etiqueta que aparece en el MenuBar y puede opcionalmente ser un menú. Los métodos add() y addSeparator() agregan elementos individuales a Menu.

MenuItem Esta clase encapsula un elemento de menú con una etiqueta textual específica. Un MenuItem se puede agregar a un panel de menú con el método Menu.add() . El método disable() hace que un elemento no sea seleccionable; esto se puede usar para “aclarar” un elemento del menú cuando el comando que éste represente no sea válido en el contexto en cuestión. El método enable() hace que un elemento sea seleccionable otra vez. El método addActionCommand() permite especificar una cadena identificadora de una acción para que esté incluida en los eventos ActionEvent generados por el elemento de menú.

TEMA 6 Un ejemplo de menús

La siguiente aplicación consiste en una ventana que incluye un menú con las acciones necesarias para consultar y actualizar información de unas elecciones. El código correspondiente a los eventos de dichas acciones no se incluye aquí, ya que hacen parte del tema de acceso a bases de datos.

La siguiente imagen ilustra los objetos que hacen parte de la aplicación.

Esta aplicación no es un Applet por lo que no puede ejecutarse en un navegador. La aplicación es un programa de Java que se ejecuta en una ventana.

Esta aplicación es una herencia de la clase Frame que implementa a ActionListener ya que tendrá eventos de acción (Los comandos del menú). En ella se instancia un objeto MenuBar y un objeto Menu el cual contendrá varios objetos MenuItem para cada una de las opciones.

La aplicación se instancia en el método main() utilizando un método constructor (Elecciones()). Este método constructor contiene las instrucciones necesarias para definir el estado inicial de la ventana, lo cual comprende la construcción del menú. Para ello se utilizan adicionalmente dos vectores que almacenan las etiquetas y las acciones, y con base en ellos se instancia los objetos MenuItem y las respectivas acciones asociadas.

Para que la aplicación ejecute los eventos de acción se incluye el método actionPerformed() en el cual va el código de respuesta a cada acción.

16


El siguiente sería el código completo de la aplicación:

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

public class Elecciones extends Frame implements ActionListener {/* Método inicial */public static void main(String[] args)

{new Elecciones ();}

/* Método constructor de la aplicación */public Elecciones ()

{/* Diseñar la ventana principal */super("Elecciones"); //Instanciar la ventana

String etiquetas[]=new String[] {"Mostrar Votaciones","Agregar Votación","Modificar Votación","Eliminar Votación","Salir"};

String comandos[]=new String[] {"Mostrar","Agregar","Modificar","Eliminar","Salir"};

MenuBar mb=new MenuBar(); //Instanciar un menu de barrasthis.setMenuBar(mb); //Agregarlo a la ventanaMenu mnuArchivo=new Menu("Archivo"); //Instanciar el menu 'Archivo'mb.add(mnuArchivo); //Agregarlo a la barra de menus

/* Llenar las opciones del menú */for(int i=0;i<etiquetas.length;i++)

{MenuItem mi=new MenuItem(etiquetas[i]); //Instanciar una opción del menumnuArchivo.add(mi); //Agregarlo al menu 'Archivo'mi.setActionCommand(comandos[i]); //Definir el comando para la accionmi.addActionListener(this); //Agregarlo el escuchador de eventos}

this.pack(); //Ajustar la ventanathis.show();

}

/* Eventos */public void actionPerformed(ActionEvent e)

{String comando=e.getActionCommand(); //Evento activadoif (comando.equals("Mostrar"))

{}

else if (comando.equals("Agregar")) {}

else if (comando.equals("Modificar")){}

else if (comando.equals("Eliminar")){}

else if (comando.equals("Salir")) System.exit(0);}

}

17


TEMA 7 Acceso a archivosEn el paquete java.io se incluye la clase RandomAccessFile que permite la lectura y escritura de bytes arbitrarios, texto y tipos de datos primitivos de Java desde o a cualquier posición especificada del archivo.

Debido a que esta clase ofrece un acceso aleatorio a los archivos (en lugar de ser secuencial) no es una subclase de InputStream ni de OutputStream (clases encargadas de las entradas y salidas estándar). Por lo tanto, RandomAccessFile proporciona métodos completamente independientes para leer y escribir datos.

El método seek() ofrece un acceso aleatorio al archivo; se usa para seleccionar la posición en el archivo a partir de la cual o en la cual deben leerse o escribirse los datos.

Para saber la actual posición en el archivo se utiliza el método getFilePointer().

El método length() permite conocer la longitud del archivo, y se considera la posición final del archivo para lectura.

Cuando se desea abrir un archivo, se utiliza el método constructor el cual tiene dos argumentos de entrada: Un String con el nombre del archivo Un String con el modo como será abierto el archivo: “r” para lectura, “rw” para lectura y escritura.

Para leer los datos se ofrecen métodos que obtienen datos primitivos producto de la lectura, así:Método DescripciónreadBoolean() Lee un valor booleanoreadByte() Lee un bytereadChar() Lee un carácterreadDouble() Lee un número de tipo doublereadFloat() Lee un número de tipo floatreadInt() Lee un número de tipo intReadLine() Lee un StringreadLong() Lee un número de tipo long

De igual forma, existen métodos para guardar datos en el archivo por cada tipo de dato primitivo:Método DescripciónwriteBoolean() Guarda un valor booleanowriteByte() Guarda un bytewriteChar() Guarda un carácterwriteDouble() Guarda un número de tipo doublewriteFloat() Guarda un número de tipo floatwriteInt() Guarda un número de tipo intwriteBytes() Guarda un StringwriteLong() Guarda un número de tipo long

Para comprender el uso de esta clase y sus métodos, se plantea un ejercicio de una aplicación en Java que administre el directorio telefónico de un usuario. Los datos quedan almacenados en un archivo plano llamado “Directorio.txt”. Estos comprenden el nombre, la dirección, el teléfono y la fecha de cumpleaños.

La apariencia que tendría la aplicación sería la siguiente:

18


Iría incluida una barra de menús que tendría la siguiente apariencia:

En ella se incluyen todos los comandos para administrar el directorio telefónico tales como: Guardar cambios realizados. Agregar un nuevo registro Eliminar un registro Desplazamientos básicos a los registros

Los datos del directorio se administrarán de la siguiente manera: Inicialmente el archivo es leído en su totalidad y llevado a cuatro vectores (uno por cada dato) que

almacenarán temporalmente la información. Cualquier inserción, modificación o eliminación se hace en los vectores. Mediante el comando “Guardar” la información de los vectores es llevada al archivo para que quede

almacenada definitivamente. Siempre que haya un cambio y cuando se carga el archivo inicialmente, se ordenan los vectores por

el dato “nombre “.

El código de la aplicación es el siguiente:

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

public class Directorio extends Frame implements ActionListener {String archivo=new String("directorio.txt"); //nombre del archivoint max=100,tLineas=0,posicion=0;String[] nombres=new String[max];String[] telefonos=new String[max];String[] direcciones=new String[max];String[] cumpleanos=new String[max];

19


TextField txtNom=new TextField(40);TextField txtTel=new TextField(15);TextField txtDir=new TextField(40);TextField txtCum=new TextField(10);

Label lblMen=new Label("");

public static void main(String[] args){new Directorio();}

public Directorio(){super("Directorio Teléfonico"); //Instancia la ventanaGridLayout L = new GridLayout(7,2); //Instancia el contenedorsetLayout(L);

Label lblNom=new Label("Nombre");Label lblTel=new Label("Teléfono");Label lblDir=new Label("Dirección");Label lblCum=new Label("Cumpleaños");

Button btnAnt=new Button("<");Button btnSig=new Button(">");Button btnUlt=new Button(">|");Button btnPri=new Button("|<");btnPri.setActionCommand("Primero");//Define el comando para la accionbtnPri.addActionListener(this);//Agrega el escuchador de eventosbtnAnt.setActionCommand("Anterior");//Define el comando para la accionbtnAnt.addActionListener(this);//Agrega al escuchador de eventosbtnSig.setActionCommand("Siguiente");//Define el comando para la accionbtnSig.addActionListener(this);//Agrega al escuchador de eventosbtnUlt.setActionCommand("Ultimo");//Define el comando para la accionbtnUlt.addActionListener(this);//Agrega al escuchador de eventos

add(lblNom);add(txtNom);add(lblTel);add(txtTel);add(lblDir);add(txtDir);add(lblCum);add(txtCum);add(btnPri);add(btnAnt);add(btnSig);add(btnUlt);add(lblMen);

/* Construír el menú del menú */String comandosArchivo[]=new String[] {"Guardar","Agregar","Eliminar","Salir"};String comandosDesplazar[]=new String[] {"Primero","Ultimo","Siguiente","Anterior"};

MenuBar mb=new MenuBar(); //Instanciar un menu de barrasthis.setMenuBar(mb); //Agregarlo a la ventanaMenu mnuArchivo=new Menu("Archivo"); //Instanciar el menu 'Archivo'mb.add(mnuArchivo); //Agregarlo a la barra de menusMenu mnuDesplazar=new Menu("Desplazar"); //Instanciar el menu 'Desplazar'mb.add(mnuDesplazar); //Agregarlo a la barra de menus

/* Llenar las opciones del menú */for(int i=0;i<comandosArchivo.length;i++)

{MenuItem mi=new MenuItem(comandosArchivo[i]); //Instanciar una opción del menumnuArchivo.add(mi); //Agregarlo al menu 'Archivo'mi.setActionCommand(comandosArchivo[i]); //Definir el comando para la accionmi.addActionListener(this); //Agregarlo el escuchador de eventos}

for(int i=0;i<comandosDesplazar.length;i++){

20


MenuItem mi=new MenuItem(comandosDesplazar[i]); //Instanciar una opción del menumnuDesplazar.add(mi); //Agregarlo al menu 'Desplazar'mi.setActionCommand(comandosDesplazar[i]); //Definir el comando para la accionmi.addActionListener(this); //Agregarlo el escuchador de eventos}

try {// Abre el archivoRandomAccessFile directorio=new RandomAccessFile(archivo,"rw");

//Recorre el archivo y lo lleva al vectorwhile (directorio.getFilePointer()!=directorio.length())

{tLineas++;nombres[tLineas]=directorio.readLine ();telefonos[tLineas]=directorio.readLine ();direcciones[tLineas]=directorio.readLine ();cumpleanos[tLineas]=directorio.readLine ();}

directorio.close();}

catch (IOException e){System.out.println(e);} //Si sucede un errorordenar();// Lleva los datos del vector a los controlesif (tLineas>0){

posicion=1;mostrar();}

this.pack();this.show();}

public void actionPerformed(ActionEvent e){lblMen.setText("");guardarVector();ordenar();String opcion=e.getActionCommand(); //Evento activadoif (opcion.equals("Salir")) System.exit(0);else if (opcion.equals("Anterior")) anterior();else if (opcion.equals("Siguiente")) siguiente();else if (opcion.equals("Primero")) primero();else if (opcion.equals("Ultimo")) ultimo();else if (opcion.equals("Guardar")) guardar();else if (opcion.equals("Agregar")) agregar();else if (opcion.equals("Eliminar")) eliminar();}

public void siguiente(){if (posicion<tLineas && tLineas>0)

{posicion++;mostrar();}

else lblMen.setText("Estamos al final");}

public void anterior(){if (posicion>1)

{posicion--;mostrar();}

else lblMen.setText("Estamos al inicio");}

public void primero(){

21


if (tLineas>0){posicion=1;mostrar();}

else lblMen.setText("No hay datos");}

public void ultimo(){if (tLineas>0)

{posicion=tLineas;mostrar();}

else lblMen.setText("No hay datos");}

public void mostrar(){txtNom.setText(nombres[posicion]);txtTel.setText(telefonos[posicion]);txtDir.setText(direcciones[posicion]);txtCum.setText(cumpleanos[posicion]);}

public void guardar(){try {

// Abre el archivoRandomAccessFile directorio=new RandomAccessFile(archivo,"rw");//Recorre el vector y lo lleva al archivofor(int i=1;i<=tLineas;i++)

{directorio.writeBytes(nombres[i]+"\n");directorio.writeBytes(telefonos[i]+"\n");directorio.writeBytes(direcciones[i]+"\n");directorio.writeBytes(cumpleanos[i]+"\n");}

directorio.close();}

catch (IOException e){System.out.println(e);} //Si sucede un error}

public void agregar(){if(tLineas<max)

{tLineas++;nombres[tLineas]="";telefonos[tLineas]="";direcciones[tLineas]="";cumpleanos[tLineas]="";posicion=tLineas;mostrar();lblMen.setText("Nuevo registro");}

else lblMen.setText("Supera el número máximo de registros");}

public void eliminar(){if (tLineas>0)

{if(posicion==tLineas) posicion--;for(int i=posicion;i<tLineas;i++)

{nombres[i]=nombres[i+1];telefonos[i]=telefonos[i+1];

22


direcciones[i]=direcciones[i+1];cumpleanos[i]=cumpleanos[i+1];}

tLineas--;if(tLineas>0) mostrar();else

{agregar();}

}}

public void guardarVector(){if (posicion>0)

{nombres[posicion]=txtNom.getText();telefonos[posicion]=txtTel.getText();direcciones[posicion]=txtDir.getText();cumpleanos[posicion]=txtCum.getText();}

}public void ordenar()

{for(int i=1;i<tLineas;i++)

for(int j=i+1;j<=tLineas;j++)if(nombres[i].compareTo(nombres[j])>1)

{String strT=nombres[i];nombres[i]=nombres[j];nombres[j]=strT;strT=telefonos[i];telefonos[i]=telefonos[j];telefonos[j]=strT;strT=direcciones[i];direcciones[i]=direcciones[j];direcciones[j]=strT;strT=cumpleanos[i];cumpleanos[i]=cumpleanos[j];cumpleanos[j]=strT;}

}}

TEMA 8 Ejercicios de Aplicación1. Elaborar un Applet que permita calcular el valor de una cuota de un préstamo, dado el valor del

préstamo, la tasa de interés y el número de períodos, el cual debe ser leído en una lista compuesta por los valores 12, 18, 24, 36, 48 y 60 meses:

Para calcular el valor de la cuota usaremos la siguiente fórmula:Cuota = (1 + Interés) Períodos x Interés

(1 + Interés)Períodos - 1

La apariencia del Applet sería:

2. Elaborar una ventana que liste los países del continente americano y que permita listar los respectivos estados o departamentos del país elegido. Cuando se elija un estado, debe mostrar su respectiva capital. La información viene en un archivo de texto.

23

Documents

Java Basico_03