¿Qué es un applet?

Un applet es una pequeña aplicación escrita en Java, pero que no está diseñada para funcionar "por sí sola", como los ejemplos que habíamos visto en modo texto, sino para formar parte de una página Web, de modo que necesitaremos un visualizador de páginas Web (como Internet Explorer de Microsoft, o Netscape Navigator -parte de Netscape Communicator-) para poder hacer funcionar dichos applets. Si no poseyeramos alguna utilidad de este tipo, en principio tampoco será un problema grave, porque el entorno de desarrollo de Java incluye una utilidad llamada "appletviewer", que nos permitirá probar nuestros applets.

¿Cómo se crea un applet?

Tendremos que dar tres pasos:

El primer paso, similar a lo que ya hemos hecho, consiste en teclear el programa empleando un editor de texto (como Edit, que ya vimos) o un entorno integrado (que veremos más adelante).
El segundo paso es nuevo: tendremos que crear la página Web desde la que se accederá al applet (o modificarla, si se trata de una página que ya existía pero que queremos mejorar).
El último paso será, al igual que antes, probar el programa, pero esta vez no emplearemos la utilidad llamada "java", sino cualquier navegador Web o la utilidad "AppletViewer".

Vamos a verlo con un ejemplo. Crearemos un applet que escriba el texto "Hola Mundo!" en pantalla, al igual que hicimos en nuestra primera aplicación de ejemplo. Recordemos que lo que habíamos escrito en aquel momento fue:

    //
    // Aplicación HolaMundo de ejemplo
    //

   class HolaMundo {
        public static void main( String args[] ) {
            System.out.println( "Hola Mundo!");
        }
    }

Esta vez tendremos que escribir más. Primero vamos a ver cómo debería ser el applet, y después comentaremos los cambios (bastantes) con relación a este programa:

import java.awt.Graphics;

public class AppletHola extends java.applet.Applet {

    public void paint(Graphics g) {
          g.drawString( "Hola Mundo!", 100, 50);
        }
    }

Los cambios son los siguientes:

Al principio aparece una orden "import", porque vamos a emplear una serie de posibilidades que no son parte del lenguaje Java "estándar", sino del paquete "Graphics" (funciones gráficas) que a su vez forma parte del grupo llamado AWT ("Abstract Windowing Toolkit", herramientas "abstractas" para el manejo de ventanas).
Después no creamos una clase nueva "desde cero", sino a partir de una que ya existe, la clase "Applet". Por eso aparece la palabra "extends" en la definición de la clase, como ya vimos en el apartado sobre las clases y Java.
Sólo utilizamos un método de los que nos permite la clase Applet: el método "paint", que es el que dibuja (o escribe) en pantalla la información que nos interese. Tiene un parámetro de tipo "Graphics", que es la pantalla en la que dibujaremos.
En concreto, lo que hacemos en esta pantalla es dibujar una cadena de texto (drawString), en las coordenadas 100 (horizontal), 50 (vertical).

(Un poco más adelante se verá el resultado de este Applet).

Y vamos a ver los tres pasos que tenemos que dar, con mayor detalle.

Primer paso: teclear el fuente.

Repetimos básicamente lo que ya vimos:

Tecleamos el fuente con "Edit", el bloc de notas de Windows, o cualquier otro editor de textos.
Lo guardamos, con el mismo nombre que tiene la clase. En nuestro caso sería "AppletHola.java" (si empleamos otro nombre, el compilador "javac" nos regañará).
Lo compilamos empleando "javac".
Si hay algún error, se nos informará de cual es; si no aparece ningún error, obtendremos un fichero llamado "AppletHola.class", listo para utilizar.

Segundo paso: crear la página Web.

No pretendo "formar maestros" en el arte de crear páginas Web. Apenas veremos lo necesario para poder probar nuestros Applets.

Las páginas Web normalmente son ficheros escritos en un cierto lenguaje. El más sencillo, y totalmente válido para nuestros propósitos, es el lenguaje HTML. Los ficheros HTML son ficheros de texto, que podremos crear con cualquier editor de texto (más trabajoso, pero es como más control se obtiene, de modo que eso es lo que haremos por ahora) o con editores específicos (como Netscape Composer, Microsoft Frontpage, Hot Dog, etc, que permiten "crear" más rápido, aunque a veces eso supone perder en posibilidades).

En nuestro caso, recurriremos nuevamente a "Edit" (o al bloc de notas de Windows, o cualquier otro editor de textos) y escribiremos lo siguiente:

<html>
<head>
      <title>Prueba de applet</title>
</head>
<body>
      <h1>Prueba de applet</h1>
      <hr>
      <applet code=AppletHola.class width=300 height=120>
        alt="El navegador esta no esta mostrando el APPLET"
      </applet>
</body>
</html>

Grabaremos este texto con el nombre "prueba.html" (serviría cualquier otro nombre, con la única condición de que termine en ".htm" o en ".html") para utilizarlo un poco más adelante.

Vamos a ver qué hemos escrito:

Es un fichero de texto, en el que aparecen algunas "etiquetas" encerradas entre < y >. El propio fichero en sí comienza por la etiqueta <html> y termina con </html> (esto será habitual: la mayoría de las etiquetas van "por pares", la primera crea un "bloque" y la segunda -la que contiene una barra al principio- indica el final del bloque).
Después aparece otro bloque, opcional: la cabecera del fichero, que empieza con <head> y termina con </head>.
Dentro de la cabecera hemos incluido una información que también es opcional: el "título" de la página, delimitado entre <title> y </title>. Este dato no es necesario, pero puede resultar cómodo, porque aparecerá en la barra de título del menú (ver las imágenes de ejemplo, un poco más abajo).
Después va el cuerpo del fichero html, que se delimita entre <body> y </body>. (El cuerpo sí es obligatorio).
Dentro del cuerpo, lo primero que aparece es un título (en inglés, "heading"), también opcional, delimitado entre <h1> y </h1>. Tenemos distintos niveles de títulos. Por ejemplo, podríamos poner un título de menor importancia delimitándolo enrtre <h2> y </h2>, o más pequeño aún entre <h3> y </h3>, y así sucesivamente.
La etiqueta <hr> muestra una línea horizontal (en inglés, "horizontal ruler"; claramente, también es opcional), y no necesita ninguna etiqueta de cierre.
Finalmente, la parte en la que se indica el applet comienza con <applet> y termina con </applet>. También es opcional en un "caso general", pero imprescindible en nuestro caso. En la etiqueta de comienzo se pueden indicar una serie de opciones, que veremos después con más detalle. Nosotros hemos utilizado sólo las tres imprescindibles:

code sirve para indicar cual es el nombre del applet a utilizar (en nuestro
width y height indican la anchura y altura de un rectángulo, medida en puntos de pantalla (pixels). Este rectángulo será la "ventana de trabajo" de nuestro applet.

El resultado de todo esto se puede ver en el siguiente apartado...

Tercer paso: probar el resultado.

Si queremos usar la utilidad "AppletViewer" que incorpora el JDK, teclearemos:

appletviewer prueba.html

y al cabo de un momento, tendremos en pantalla algo parecido a:

También podemos usar cualquier otro navegador que soporte Java (cualquiera moderno debería permitirlo). Por ejemplo, Netscape Navigator 4.5 mostraría lo siguiente:

y el Internet Explorer 4 de Microsoft

La "vida" de un applet.

En los applets hay un detalle importante que hemos dejado pasar hasta ahora: no hemos utilizado una función "main" que represente el cuerpo de la aplicación. En su lugar, hemos empleado el método "paint" para indicar qué se debe mostrar en pantalla. Esto es porque un applet tiene un cierto "ciclo de vida":

Cuando el applet se carga en el navegador, se llama a su método "init" (que nosotros no hemos "reutilizado"). Hace las funciones de un constructor.
Cuando el applet se hace visible, se llama a su método "start" (que tampoco hemos empleado). Se volverá a llamar cada vez que se vuelva a hacer visible (por ejemplo, si ocultamos nuestro navegador y luego lo volvemos a mostrar).
Cuando el applet se va a dibujar en pantalla, se llama a su método "paint" (como hemos hecho nosotros).
El método "repaint" se utiliza para redibujar el applet en pantalla. Es normalmente el que nosotros utilizaremos como programadores, llamándolo cuando nos interese, en vez de "paint", que será el que se llame automáticamente. A su vez, "repaint" llama internamente a "update", que en ciertos casos nos puede interesar redefinir (por ejemplo, si no queremos que se borre toda la pantalla sino sólo una parte). Ambos los veremos con más detalle un poco más adelante.
Cuando el applet se oculta (por ejemplo, si minizamos la ventana de nuestro navegador), se llama a su método "stop". Sería conveniente que desde él parásemos las animaciones o cualquier otra tarea que consumiese recursos "sin necesidad".
Cuando se termina de utilizar el applet, se llama a su método "destroy".

De momento sólo hemos empleado "paint". Más adelante iremos sacando partido a otros de estos métodos (y a otros que nos permiten los applets).

Ejemplo.

Hacer un applet que permita elevar un número al cuadrado y al cubo. La entrada será desde un campo de texto y las operaciones se realizarán al momento de presionar un botón asociado con la operación a realizar.

import java.awt.*;

import java.awt.event.*;

import java.applet.*;

public class ej016 extends Applet

{

TextField campo1 = new TextField("0", 15);

int bandera = 0;

Button boton1 = new Button("Uno");

Button boton2 = new Button("Dos");

public void init()

{

add(boton1);

add(boton2);

add(new Label("resultado", Label.RIGHT));

add(campo1);

}

public void paint(Graphics g)

{

switch(bandera)

{

case 1 : g.drawString("has precionado el boton 1", 20, 50); break;

case 2 : g.drawString("has precionado el boton 2", 20, 50); break;

default : g.drawString("No has precionado boton", 20, 50);

}

public boolean action(Event evt, Object arg)

{

if(evt.target instanceof Button)

{

if(arg.equals("Uno"))

{

campo1.setText(cuadrado(Double.valueOf(campo1.getText()).doubleValue()));

}

else if(arg.equals("Dos"))

{

campo1.setText(cubo(Double.valueOf(campo1.getText()).doubleValue()));

}

return true;

}

return false;

}

String cuadrado(double n)

{

String a = "";

a+= n*n;

return a;

}

String cubo(double n)

{

String a = "";

a+= n*n*n;

return a;

}

Ejemplo que describe una interfaz de entrada salida.

import java.awt.*;

import java.awt.event.*;

import java.applet.*;

/**

* <p>Title: Interfaz pspice</p>

* <p>Description: Entrada salida de datos</p>

* <p>Company: UMSN</p>

* @author Dr. Felix Calderon Solorio

* @version 1.0

public class Applet1 extends Applet {

private boolean isStandalone = false;

TextArea textArea1 = new TextArea();

TextArea textArea2 = new TextArea();

Label label1 = new Label();

Label label2 = new Label();

TextField textField1 = new TextField();

Label label3 = new Label();

Button button1 = new Button();

public void init() {

textArea1.setText("");

textArea1.setBounds(new Rectangle(41, 222, 196, 198));

this.setLayout(null);

textArea2.setBounds(new Rectangle(254, 223, 196, 198));

textArea2.setText("");

label1.setText("datos de entrada");

label1.setBounds(new Rectangle(96, 203, 92, 15));

label2.setText("datos de Salida");

label2.setBounds(new Rectangle(311, 204, 82, 15));

textField1.setText("");

textField1.setBounds(new Rectangle(187, 101, 118, 20));

label3.setText("Archivo de entrada");

label3.setBounds(new Rectangle(198, 82, 112, 15));

button1.setLabel("Ok");

button1.setBounds(new Rectangle(211, 141, 71, 25));

this.add(textArea1, null);

this.add(textArea2, null);

this.add(label1, null);

this.add(label2, null);

this.add(textField1, null);

this.add(label3, null);

this.add(button1, null);

}

public boolean action(Event evt, Object arg)

{

if(evt.target instanceof Button)

{

if (arg.equals("Ok")) {

String aux = textField1.getText();

textArea1.setText("Entrada " + aux);

textArea2.setText("salida"+ aux);

}

return false;

}

Regresar.