Vamos a realizar un ejemplo de applet en el que usaremos una lista y varios campos de texto con la finalidad de obtener una sencilla calculadora: en la lista escogemos la operación, en los dos primeros campos de texto ponemos los operandos y en el campo de texto de fondo azul se indica el resultado:

Empezaremos poniendo los campos de texto, clase TextField. Para lo cual comenzamos viendo los constructores que tiene la clase:

• TextField(): crea un campo de texto de 0 caracteres de amplitud.
• TextField( int ): crea un campo de texto con la amplitud señalada en caracteres
• TextField( String ): crea un campo de texto con la amplitud suficiente para poner la cadena de caracteres
• TextField( String, int): crea un campo de texto donde pone la cadena y cuya amplitud será el parámetro entero (si es mayor que la amplitud de la cadena)

• String getText(): devuelve el texto.
• void setText( String ): introduce el objeto String.

En nuestro ejemplo necesitamos una lista donde poner las operaciones. Para ello necesitamos la clase List:

• List(): crea una lista.
• List( int ): crea una lista con la altura señalada
• List( int, boolean ): crea una lista con la altura señalada. El parámetro boolean indica si es de selección múltiple.

Las funciones básicas de esta clase son:

• void add( String ): añade la cadena a la lista.
• void add( String, int ): inserta la cadena a la lista en la posición indicada.
• void remove( int ): borra el item de la posición señalada.
• int getItemCount(): devuelve el número de items de la lista.
• String getItem( int ): devuelve el item de la posición señalada.
• String getSelectedItem(): devuelve el item seleccionado.
• int getSelectedIndex(): devuelve la posición del item seleccionado.
• void select( int ): selecciona el item de la posición señalada.

En nuestro ejemplo necesitamos componentes de texto donde el usuario pondrá los operandos y una lista donde poder seleccionar la operación. Los campos de texto tienen capacidad para ocho dígitos:

	TextField t_n1 = new TextField(8);
	TextField t_n2 = new TextField(8);
	List lista = new List();

Además precisamos un campo de texto donde poner el resultado:

	TextField t_res = new TextField(10);

Este campo de texto tiene una particularidad: no es editable o modificable por el usuario. Definimos esta característica mediante una llamada al método setEditable. Esta llamada se realiza en el método jbInit del applet:

		t_res.setEditable( false );

También en el método jbInit del applet llenamos la lista con los nombres de las operaciones. Para ello, llamamos al método add de la lista:

		lista.add( "Media" );
		lista.add( "Producto" );
		....

No es correcto suponer que estas llamadas se deben hacer necesariamente en jbInit. Se pueden poner en cualquier método del applet. El código fuente sería:

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

public class calculador extends Applet {
	TextField t_n1 = new TextField(8);
	TextField t_n2 = new TextField(8);
	TextField t_res = new TextField(10);
	List lista = new List();
	Button bot = new Button( "C a l c u l a r");

	/******* Inicializar el applet *********/
	public void init() {
		try {  jbInit(); }
		catch(Exception e) {  e.printStackTrace(); }
	}

	/******* Inicialización de componentes *********/
	private void jbInit() throws Exception {
		/***** Añado items a la lista *****/
		lista.add( "Media" );
		lista.add( "Producto" );
		lista.add( "División" );
		lista.add( "Resta" );
		lista.add( "Suma" );

		/*** Indico objetos gestores de eventos */
		bot.addActionListener(new calculador_bot_actionAdapter(this));
		lista.addActionListener(new calculador_lista_actionAdapter(this));

		/*** Campo de resultado: fondo azul y no editable ***/
		t_res.setBackground( Color.CYAN );
		t_res.setEditable( false );

		add( t_n1 );
		add( t_n2 );
		add( t_res );
		add(lista);
		add( bot );
	}

	void bot_actionPerformed(ActionEvent e) {
		calcular();
	}

	void lista_actionPerformed(ActionEvent e) {
		calcular();
	}

	void calcular() {
		try {
			/*** Obtenemos operandos *****/
			double op1 = Double.parseDouble(t_n1.getText());
			double op2 = Double.parseDouble(t_n2.getText());

			switch ( lista.getSelectedIndex()) {
				case 0:                     /////// Media
					t_res.setText( String.valueOf( ( op1 + op2 ) / 2 ) );
					break;

				case 1:                     /////// Producto
					t_res.setText( String.valueOf( op1 * op2 ) );
					break;

				case 2:                     /////// División
					/*** Caso de indeterminación ***/
					if ( op1 == 0 && op2 == 0 )
						t_res.setText("Indeterminación");
					else {
						/*** Caso de infinito ***/
						if (op2 == 0)
						    t_res.setText("Infinito");
						/*** Caso normal ***/
						else
						    t_res.setText( String.valueOf( op1 / op2 ) );
					}
					break;

				case 3:                     /////// Resta
					t_res.setText( String.valueOf( op1 - op2 ) );
					break;

				case 4:                     /////// Suma
					t_res.setText( String.valueOf( op1 + op2 ) );
					break;

			}
		}

		catch (java.lang.NumberFormatException e) {
			t_res.setText( "Error" );
		}
	}
}

Observar que el orden en el que aperecen los componentes es el orden en el que se les añade (add) al applet. Este orden coincide con el orden con el que se mueve el foco de teclado por medio de la tecla de tabulación.

En el método calcular se realiza el cálculo. Antes de realizar el cálculo:

• Obtenemos los números que el usuario ha introducido, por medio de llamadas a getText:

  
  			double op1 = Double.parseDouble(t_n1.getText());
  		

• Conseguimos la operación que el usuario ha seleccionado en la lista. En nuestro ejemplo obtenemos el número (índice) del item seleccionado por medio de una llamada a getSelectedIndex(). El primer item es el cero.

  
  			lista.getSelectedIndex()
  		

Una vez realizado el cálculo tenemos que ponerlo en el campo de texto correspondiente, por medio de una llamada a setText:

		t_res.setText( String.valueOf( resultado ) );
		

Nuestro applet realiza el cálculo cuando el usuario:

• Hace doble clic en la lista
• Presiona el botón

Por ello las funciones que responden a estos eventos hacen lo mismo:

	void bot_actionPerformed(ActionEvent e) {
		calcular();
	}

	void lista_actionPerformed(ActionEvent e) {
		calcular();
	}

Como ya vimos a la hora de hablar de botones, hay que indicar la clase que gestiona el evento. En el caso de la lista la clase es calculador_lista_actionAdapter:

	lista.addActionListener(new calculador_lista_actionAdapter(this));

La clase calculador_lista_actionAdapter es la que recibe el evento y ejecuta el método lista_actionPerformed(ActionEvent e). En general, las clases gestoras de eventos reciben cada evento y ejecutan las funciones correspondientes del applet. En nuestro ejemplo son las siguientes:

class calculador_bot_actionAdapter implements java.awt.event.ActionListener {
	calculador adaptee;

	calculador_bot_actionAdapter(calculador adaptee) {
		this.adaptee = adaptee;
	}

	public void actionPerformed(ActionEvent e) {
		adaptee.bot_actionPerformed(e);
	}
}

class calculador_lista_actionAdapter implements java.awt.event.ActionListener {
	calculador adaptee;

	calculador_lista_actionAdapter(calculador adaptee) {
		this.adaptee = adaptee;
	}

	public void actionPerformed(ActionEvent e) {
		adaptee.lista_actionPerformed(e);
	}
}

Nuestro ejemplo de applet realiza su trabajo, pero todavía debería ser mejorado. Por ejemplo controlar el diseño (layout) del applet para que el botón aparezca en la parte inferior del applet, pero eso es otro capítulo.