Vamos a entrar directamente en materia analizando el programa de ejemplo del capítulo anterior.

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

Con estas dos líneas importamos las clase MIDlet, que es obligatoria para que nuestro programa se ejecute en el dispositivo móvil, y también importamos (con la segunda línea) los elementos que vamos a utilizar el la interfaz de usuario.

public class HelloWorld extends MIDlet implements CommandListener {
 private Command exitCommand;
 private Display display;
 private Form screen;

En la primera línea declaramos la clase principal del programa, que es pública. Hereda de la clase MIDLet e implementa la interfaz CommandListener (en concreto implementaremos el método commandAction()). También declaramos una serie de variables que utilizaremos a continuación.

public HelloWorld() {
  // Obtenemos el objeto Display del midlet.
  display = Display.getDisplay(this);

Este es el constructor de la clase. Observa que tiene el mismo nombre que la clase (mayúsculas y minúsculas incluidas) y además no tiene tipo de retorno, ni siquiera void.

Al ejecutarse un MIDlet, éste crea un objeto display, que es el encargado de mostrar información en la pantalla. Para poder utilizarlo, tenemos que obtener una referencia a este objeto. Esto es lo que hace precisamente la siguiente línea mediante el método getDisplay() del objeto estático Display.

  //  Creamos el comando Salir.
  exitCommand = new Command("Salir", Command.EXIT,2);

Un comando es un elemento que nos permite interaccionar con el usuario y le permite introducir comandos. Para crear un comando creamos una instancia (con new) de la clase Command(). Como parámetro le pasamos el texto del comando, el tipo de comando y la prioridad.

Disponemos de los siguientes tipos de comandos:

Comando            Función
OK                     Confirma una selección
CANCEL           Cancela la acción actual
BACK                Traslada al usuario a la pantalla anterior
STOP                 Detiene una operación
HELP                 Muestra una ayuda
SCREEN            Tipo genérico para uso del programador referente a la pantalla actual
ITEM                  Tipo genérico para uso del programador referente a un elemento de la pantalla actual

A veces, y dependiendo del modelo y marca del dispositivo, sólo se pueden mostrar un número limitado de comandos en la pantalla. Al resto se accederá mediante un menú.

El tercer parámetro nos permite dar más prioridad a unos comandos que a otros a la hora de mostrarlos en la pantalla.

  // Añadimos el comando Salir e indicamos que clase lo manejará
  screen.addCommand(exitCommand);
  screen.setCommandListener(this);

Nos resta añadir el comando (mediante el método addCommand() del objeto screen) a la lista de comandos y establecer que clase permanece a la "escucha" de esos comandos utilizando la clase setCommandListener(). En este caso, el método encargado de procesar los comandos están dentro de la propia clase HelloWorld, por lo que utilizamos el operador this. Si quisiéramos tener una clase separada encargada de procesar los comandos, la indicaríamos aquí. En concreto, el método que se encarga de procesar los comandos es commandAction(). Para eliminar un comando podemos utilizar removeCommand(Command cmd).

 public void commandAction(Command c, Displayable s) {
  // Salir
  if (c == exitCommand) {
   destroyApp(false);
   notifyDestroyed(); 
  } 
 }
Cuando el usuario genera un comando, se llama al método commandAction(). Este método recibirá dos parámetros. El comando que se generó, y un objeto de la clase Displayable, que contiene la pantalla del comando.

Cerraremos la aplicación con los métodos destroyApp() y notifyDestroyed().

  // Creamos la pantalla principal (un formulario)
  screen = new Form("HelloWorld");
  
  // Creamos y añadimos la cadena de texto a la pantalla
  StringItem saludo = new StringItem("","Hola Mundo...");
  screen.append(saludo);
Dentro de la pantalla podemos situar diversos elementos gráficos. Vamos a crear un objeto de tipo Form (formulario) como elemento principal de la pantalla. Veremos dentro de este capítulo cuáles son estos elementos.

Seguidamente creamos una cadena de texto (StringItem) y la añadimos a la pantalla principal mediante el método append().

 public void startApp() throws MIDletStateChangeException {
  // Seleccionamos la pantalla a mostrar
  display.setCurrent(screen); 
 }
Mediante el método setCurrent() del objeto display (aquel del que obtuvimos la referencia al principio del constructor) seleccionamos la pantalla actual para ser mostrada. Lo hacemos en el método startApp() que es el que se ejecuta en primer lugar.

public void pauseApp() {}
public void destroyApp(boolean unconditional) {}

Estas dos líneas pueden parecer extrañas, ya que son métodos vacíos (sin código). Como ya vimos, hay que implementar todas las clases heredadas de MIDlet (pauseApp, destroyApp y startApp), por lo que, aunque no contengan código, hay que declararlas.