Applets de Java explicados: Conceptos básicos y diferencias clave

Un applet es un programa Java que se ejecuta en un navegador web. Un applet puede ser una aplicación Java totalmente funcional porque tiene a su disposición toda la API de Java.

Existen diferencias importantes entre un applet y una aplicación Java independiente:

Un applet es una clase Java que extiende java.applet.Applet.
No se invoca un método main() en un applet, y una clase applet no define main().
Los applets están diseñados para incrustarse dentro de una página HTML.
Cuando un usuario ve una página HTML que contiene un applet, el código del applet se descarga en la máquina del usuario.
Se requiere una JVM para ver un applet. Puede ser un complemento del navegador o un entorno de ejecución independiente.
La JVM en la máquina del usuario crea una instancia de la clase applet e invoca varios métodos durante su vida útil.
Los applets tienen estrictas reglas de seguridad impuestas por el navegador (seguridad de "caja de arena" o sandbox).
Otras clases que el applet necesita pueden descargarse en un solo archivo Java Archive (JAR).

Ciclo de vida de un applet

Cuatro métodos en la clase Applet proporcionan el marco para construir cualquier applet serio:

init – Inicialización necesaria para el applet. Se llama después de procesar las etiquetas <param> dentro de la etiqueta applet.
start – Se llama automáticamente después de que el navegador llama a init(). También se llama cuando el usuario regresa a la página que contiene el applet.
stop – Se llama automáticamente cuando el usuario abandona la página donde está el applet. Puede llamarse repetidamente.
destroy – Solo se llama cuando el navegador se cierra normalmente. Como los applets viven en una página HTML, no deberías dejar recursos tras la salida del usuario.
paint – Se invoca inmediatamente después de start() y cada vez que el applet necesita repintarse en el navegador. Hereda de java.awt.

Applet "Hola, Mundo"

Applet simple llamado HelloWorldApplet.java:

import java.applet.*;
import java.awt.*;
public class HelloWorldApplet extends Applet {
    public void paint(Graphics g) {
        g.drawString("Hola Mundo", 25, 50);
    }
}

Estas importaciones ponen las clases en el ámbito de nuestra clase applet:

java.applet.Applet
java.awt.Graphics

Sin ellas, el compilador no reconocería las clases Applet y Graphics.

La clase Applet

Cada applet extiende java.applet.Applet. La clase base proporciona métodos que una clase derivada puede llamar para obtener información y servicios del contexto del navegador:

Obtener parámetros del applet
Obtener la ubicación de red del archivo HTML que contiene el applet
Obtener la ubicación de red del directorio de la clase applet
Imprimir mensaje de estado en el navegador
Obtener una imagen
Obtener un clip de audio
Reproducir un clip de audio
Redimensionar el applet

Además, la clase Applet proporciona una interfaz para que el visor o navegador obtenga información y controle la ejecución:

Solicitar información sobre autor, versión y copyright
Solicitar descripción de parámetros que el applet reconoce
Inicializar, destruir, iniciar y detener la ejecución del applet

La clase Applet proporciona implementaciones por defecto que pueden sobrescribirse según sea necesario. El applet "Hola, Mundo" solo sobrescribe el método paint.

Invocando un applet

Un applet se invoca incrustando directivas en un archivo HTML y viéndolo a través de un visor de applets o navegador con Java habilitado.

La etiqueta <applet> es la base para incrustar un applet. Ejemplo que invoca el applet "Hola, Mundo":

<html> <title>El applet Hola, Mundo</title> <hr>
<applet code="HelloWorldApplet.class" width="320" height="120">
Si tu navegador tuviera Java habilitado, aparecería un mensaje "Hola, Mundo" aquí.
</applet> <hr> </html>

Nota – Consulta la etiqueta HTML Applet para más detalles sobre cómo llamar applets desde HTML.

El atributo code es obligatorio y especifica la clase Applet a ejecutar. width y height también son obligatorios para el tamaño inicial del panel. La directiva debe cerrarse con </applet>.

Si un applet toma parámetros, los valores se pasan con etiquetas <param> entre <applet> y </applet>. El navegador ignora texto y otras etiquetas entre las etiquetas applet.

Los navegadores sin Java no procesan <applet> y </applet>; por tanto, cualquier cosa entre las etiquetas no relacionada con el applet es visible en esos navegadores.

El visor busca el código Java compilado en la ubicación del documento. Para especificar otra ubicación, usa el atributo codebase:

<applet codebase="https://amrood.com/applets" code="HelloWorldApplet.class" width="320" height="120">

Si un applet reside en un paquete distinto al predeterminado, el paquete contenedor debe especificarse en el atributo code usando punto (.) para separar componentes:

<applet code="mipaquete.subpaquete.TestApplet.class" width="320" height="120">

Obteniendo parámetros del applet

Ejemplo que muestra cómo hacer que un applet responda a parámetros de configuración en el documento. Este applet muestra un patrón de tablero de ajedrez en negro y un segundo color.

El segundo color y el tamaño de cada cuadro pueden especificarse como parámetros.

CheckerApplet obtiene sus parámetros en init(). También podría obtenerlos en paint(), pero obtener los valores una vez al inicio es más eficiente.

El visor llama a init() una vez, inmediatamente después de cargar el applet. Applet.getParameter() obtiene un parámetro dado su nombre (el valor siempre es una cadena). Si el valor es numérico u otro dato no caracter, la cadena debe parsearse.

Esqueleto de CheckerApplet.java:

import java.applet.*;
import java.awt.*;
public class CheckerApplet extends Applet {
    int squareSize = 50;
    public void init() {}
    private void parseSquareSize(String param) {}
    private Color parseColor(String param) {}
    public void paint(Graphics g) {}
}

Métodos init() y parseSquareSize():

public void init() {
    String squareSizeParam = getParameter("squareSize");
    parseSquareSize(squareSizeParam);
    String colorParam = getParameter("color");
    Color fg = parseColor(colorParam);
    setBackground(Color.black);
    setForeground(fg);
}
private void parseSquareSize(String param) {
    if (param == null) return;
    try { squareSize = Integer.parseInt(param); }
    catch (Exception e) { /* mantener valor por defecto */ }
}

parseSquareSize() llama a Integer.parseInt(), que lanza excepción si el argumento es inválido; se captura para no fallar por mala entrada.

parseColor() compara cadenas para coincidir con nombres de colores predefinidos. Debes implementar estos métodos para que el applet funcione.

Especificando parámetros del applet

Ejemplo de archivo HTML con CheckerApplet incrustado, especificando ambos parámetros mediante <param>:

<html> <title>Applet Tablero</title> <hr>
<applet code="CheckerApplet.class" width="480" height="320">
<param name="color" value="blue">
<param name="squaresize" value="30">
</applet> <hr> </html>

Nota – Los nombres de parámetros no distinguen mayúsculas/minúsculas.

Conversión de aplicación a applet

Es fácil convertir una aplicación Java gráfica (que usa AWT y se inicia con el lanzador Java) en un applet para incrustar en una web.

Pasos específicos:

Crear una página HTML con la etiqueta apropiada para cargar el código del applet.
Proporcionar una subclase de JApplet. Hazla pública, de lo contrario no se puede cargar.
Eliminar el método main. No construyas una ventana frame; la aplicación se mostrará dentro del navegador.
Mover código de inicialización del constructor del frame al método init del applet. No necesitas construir explícitamente el objeto applet; el navegador lo instancia y llama a init.
Eliminar la llamada a setSize; en applets el tamaño se hace con width y height en HTML.
Eliminar setDefaultCloseOperation. Un applet no se cierra; termina cuando el navegador sale.
Si la aplicación llama a setTitle, elimínalo. Los applets no tienen barras de título (puedes titular la página web con la etiqueta HTML title).
No llames a setVisible(true). El applet se muestra automáticamente.

Manejo de eventos

Los applets heredan métodos de manejo de eventos de la clase Container. Para reaccionar a un evento, un applet debe sobrescribir el método específico apropiado.

import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
import java.applet.Applet;
import java.awt.Graphics;
public class ExampleEventHandling extends Applet implements MouseListener {
    StringBuffer strBuffer;
    public void init() {
        addMouseListener(this);
        strBuffer = new StringBuffer();
        addItem("inicializando el applet ");
    }
    public void start() { addItem("iniciando el applet "); }
    public void stop() { addItem("deteniendo el applet "); }
    public void destroy() { addItem("descargando el applet"); }
    void addItem(String word) {
        System.out.println(word);
        strBuffer.append(word);
        repaint();
    }
    public void paint(Graphics g) {
        g.drawRect(0, 0, getWidth() - 1, getHeight() - 1);
        g.drawString(strBuffer.toString(), 10, 20);
    }
    public void mouseEntered(MouseEvent event) {}
    public void mouseExited(MouseEvent event) {}
    public void mousePressed(MouseEvent event) {}
    public void mouseReleased(MouseEvent event) {}
    public void mouseClicked(MouseEvent event) { addItem("clic del ratón! "); }
}

Invocación del applet:

<html> <title>Manejo de Eventos</title> <hr>
<applet code="ExampleEventHandling.class" width="300" height="300">
</applet> <hr> </html>

Inicialmente muestra "inicializando el applet. Iniciando el applet." Al hacer clic dentro del rectángulo, aparece "clic del ratón".

Visualización de imágenes

Un applet puede mostrar imágenes GIF, JPEG, BMP, etc. Usa drawImage() de java.awt.Graphics.

import java.applet.*;
import java.awt.*;
import java.net.*;
public class ImageDemo extends Applet {
    private Image image;
    private AppletContext context;
    public void init() {
        context = this.getAppletContext();
        String imageURL = this.getParameter("image");
        if(imageURL == null) imageURL = "java.jpg";
        try {
            URL url = new URL(this.getDocumentBase(), imageURL);
            image = context.getImage(url);
        } catch (MalformedURLException e) {
            e.printStackTrace();
            context.showStatus("¡No se pudo cargar la imagen!");
        }
    }
    public void paint(Graphics g) {
        context.showStatus("Mostrando imagen");
        g.drawImage(image, 0, 0, 200, 84, null);
        g.drawString("www.javalicense.com", 35, 100);
    }
}

Invocación:

<html> <title>Applet ImageDemo</title> <hr>
<applet code="ImageDemo.class" width="300" height="200">
<param name="image" value="java.jpg">
</applet> <hr> </html>

Reproducción de audio

Un applet puede reproducir audio mediante la interfaz AudioClip en java.applet. Tres métodos:

play() – Reproduce el clip una vez desde el principio.
loop() – Reproduce el clip continuamente.
stop() – Detiene la reproducción.

Para obtener un AudioClip, invoca getAudioClip() de la clase Applet. El archivo no se descarga hasta que se intenta reproducir.

import java.applet.*;
import java.awt.*;
import java.net.*;
public class AudioDemo extends Applet {
    private AudioClip clip;
    private AppletContext context;
    public void init() {
        context = this.getAppletContext();
        String audioURL = this.getParameter("audio");
        if(audioURL == null) audioURL = "default.au";
        try {
            URL url = new URL(this.getDocumentBase(), audioURL);
            clip = context.getAudioClip(url);
        } catch (MalformedURLException e) {
            e.printStackTrace();
            context.showStatus("¡No se pudo cargar el archivo de audio!");
        }
    }
    public void start() { if(clip != null) clip.loop(); }
    public void stop() { if(clip != null) clip.stop(); }
}

Invocación:

<html> <title>Applet AudioDemo</title> <hr>
<applet code="AudioDemo.class" width="0" height="0">
<param name="audio" value="test.wav">
</applet> <hr> </html>

Puedes usar test.wav en tu PC para probar.

Dominando el multihilo en Java: Programación concurrente eficiente Comentarios de documentación en Java: Dominando Javadoc y tipos de comentarios

Java