Download Implementar Métodos de un Applet

Survey
yes no Was this document useful for you?
   Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Document related concepts
no text concepts found
Transcript
Escribir Applets
Autor: Sun
Traductor: Juan Antonio Palos (Ozito)




















Escribir Applets
La Anatomía de un Applet
o Importar Clases y Paquetes
o Definir una Subclase de Applet
o Implementar Métodos del Applet
o Ejecutar un Applet
Importar Clases
Definir una Subclase Applet
Implementar Métodos de un Applet
Ejecutar un Applet
Introducción a los Applets
o Un Applet Sencillo
o El Ciclo de Vida de un Applet
o Métodos para Hitos
o Métodos para Dibujar y Manejar Eventos
o Métodos para Añadir Componentes al UI
o ¿Qué Puede y qué no Puede hacer un Applet?
o Probar un Applet
o Sumario
Ciclos de Vida de un Applet
o Cargar el Applet
o Abandonar y Volver a la Página del Applet
o Recargar un Applet
o Salir del Navegador
o Sumario
Métodos de Applet
Métodos de Dibujo y Manejo de Eventos
Métodos para Añadir Componentes UI
o Componentes UI Pre-Fabricados
o Métodos para Usar Componentes UI en Applets
o Añadir un Campo de Texto no Editable al Applet Simple
¿Qué puede y qué no puede hacer un Applet?
o Restricciones de Seguridad
o Capacidades de los Applets
Probar un Applet
Sumario de Introducción a los Applets
Aprovecharse del API de Applet
Encontrar y Cargar Ficheros de Datos
Mostrar Cadenas Cortas de Estado
Mostrar Documentos en el Navegador
Enviar Mensajes a Otros Applets
o Encontrar un Applet por su Nombre: El Método getApplet
o Encontrar Todos los Applets de una Página: El Método getApplets
Ejecutar Sonidos
o
o




















Métodos Relacionados por el Sonido
Un Ejemplo
Definir y Usar Parámetos en un Applet
o Decidir Qué Parámetros Soportar
o Escribir Código Para Soportar Parámetros
o Dar Información Sobre los Parámetros
Decidir qué Parámetros Soportar
o ¿Qué debería un Applet permitir que el usuario configurara?
o ¿Cómo deberían llamarse los Parámetros?
o ¿Qué tipo de Valor debería Aceptar cada Parámetro?
o ¿Qué valor por Defecto Debería Tener cada Parámetro?
o Un ejemplo: AppletButton
Escribir el Código para Soportar Parámetros
o Un ejemplo: AppletButton
Dar Información sobre los Parámetros
Usar la Etiqueta APPLET
o Especificar Parámetros
o Especificar Código HTML Alternativo y Texto
o Especificar el Directorio del Applet
o Combinar ficheros de Applets en un Sólo Archivo
o Otros Atributos de la Etiqueta <APPLET>
Consideraciones Prácticas para Escribir Applets
Restricciones de Seguridad
Construir un Interface de Usuario
Usar el AWT para crear un Interface de Usuario
Mostrás Diagnósticos por los Streams de Salida Estándar y de Error
Obtener Propiedades del Sistema
o Propiedades de Sistema que los Applets Pueden Leer
o Propiedades del Sistema Prohibidas
Threads en Applets
Threads en Applets: Ejemplo
o Usar un Thread para Realizar Tareas Repetitivas
o Usar un Thread para Realizar Inicializaciones de un Sóla Vez
Trabajar con Aplicaciones del Lado del Servidor
o Un Sencillo Applet Cliente de Red
o Usar un Servidor para Evitar las Restricciones de Seguridad
Un Sencillo Applet Cliente de una Red
Utilizar un Servidor para Evitar las Restricciones de Seguridad
Finalizar un Applet
o Antes de Liberar Nuestro Applet
o El Applet Pefectamente Finalizado
Antes de Desplegar un Applet
El Applet Perfectamente Finalizado
Problemas con los Appelts (y sus Soluciones)
o El AppletViewer dice que no hay una etiqueta <APPLET> en la página
HTML, pero si que existe.
o He recompilado mi Applet, pero el navegador no muestra la nueva
versión, incluso aunque le digo que la recargue.
o El color gris claro del fondo de mi applet hace que parpadee cuando se
dibuja en una página de diferente color.
o
o
o
El método getImage de Applet no funciona.
Ahora que he copiado el fichero class del applet en mi servidor HTTP, el
applet no funciona
No puedo hacer que mi applet funcione. El navegador muestra una
ClassCastException.
Escribir Applets
Directa o Indirectamente, esta sección cubre todo lo necesario para esribir Applets Java.
Como los Applets pueden usar casi cualquier API de Java está sección menciona
muchas características que son mencionadas en otros lugares.

Introducción a los Applets nos enseña como funcionan los applets. Deberemos
entender perfectamente esta sección andes de continuar.
Aprovechar el API Applet nos explica cómo usar los APIs a los que sólo los applets
tienen acceso. Cubre los sonidos, los parámetros de applets, la etiqueta <APPLET>,
comunicación inter-applets, y hacer peticiones al navegador.
Consideraciones Prácticas cuando se Escriben Applets explica los tópicos que se
cubren en otras partes de este tutorial pero que afectan al entorno de los applets. Por
ejemplo, menciona algunos factores que deberíamos considerar cuando escribamos un
Interface Gráfico de Usuario (GUI) para nuestro applet. También explica las
restricciones de seguridad que tienen los applets y cómo una aplicación del lado del
servidor nos puede ayudar a evitar estas restricciones.
Finalizar un Applet Describe las características de un applet de alta calidad. Incluye
Antes de Envíar nuestro Applet, una lista de chequeo de algunos comportamientos
añadidos que debería evitar nuestro applet.
Problemas Más Comunes (y sus Soluciones) explica las soluciones a algunos
problemas que podríamos encontrar mientras escribimos nuestros applets.
La Anatomía de un Applet
Cada vez que has visto un applet Java, probablemente te habrás preguntado cómo
funciona. Recuerda que un applet Java es un programa que se adhiere a una serie de
convenciones que le permiten ejecutarse en un navegador compatible con Java.
Aquí tenemos el código del applet "Hello World":
import java.applet.Applet;
import java.awt.Graphics;
public class HelloWorld extends Applet {
public void paint(Graphics g) {
g.drawString("Hello world!", 50, 25);
}
}
Importar Clases y Paquetes
El código de arriba empieza con dos sentencias import. Importando clases y paquetes,
una clase puede referirse más fácilmente a las clases de otros paquetes. En el lenguaje
Java, los paquetes se usan para agrupar clases, de forma similar como la librerías se
usaban para agrupar funciones C. Importar Clases y Paquetes nos ofrece más
información sobre los paquetes y la sentencia import.
Definir una Subclase de Applet
Todo applet debe definir una subclase de la clase Applet. En el Applet "Hello World",
esta subclase se llama HelloWorld. Los applets heredan gran parte de su funcionalidad
de la clase Applet, desde la comunicación con el navegador hasta la presentación de un
interface gráfico de usuario (GUI).
Implementar Métodos del Applet
El Applet HelloWorld implementa sólo un método, el método paint. Todo applet debe
implementar al menos uno de los siguientes métodos: init, start, o paint. Al
contrario que las aplicaciones Java, los applets no necesitan implementar un método
main.
Ejecutar un Applet
Los applets están pensados para incluirse en páginas HTML. Usando la etiqueta
<APPLET>, especificamos (como mínimo) la localización de la subclase Applet y las
dimensiones de la ventana del applet. Cuando una navegador que soporta Java
encuentra una etiqueta Applet, reserva espacio en la pantalla para el applet, carga la
subclase Applet dentro del ordenador donde se está ejecutando el navegador y crea un
ejemplar de la subclase Applet
Importar Clases
Las dos primeras líneas del siguiente listado importan dos clases usadas en el applet.
Applet y Graphics.
import java.applet.Applet;
import java.awt.Graphics;
public class HelloWorld extends Applet {
public void paint(Graphics g) {
g.drawString("Hello world!", 50, 25);
}
}
Si eliminaramos las dos primera líneas, el applet podría compilarse y ejecutarse, pero
sólo si cambiamos el resto del código de esta forma:
public class HelloWorld extends java.applet.Applet {
public void paint(java.awt.Graphics g) {
g.drawString("Hello world!", 50, 25);
}
}
Como puedes ver, importar las clases Applet y Graphics permite al programa referirse
a ellas posteriormente sin ningún prefijo. Los prefijos java.applet. y java.awt. le
dicen al compilador en qué paquetes debería buscar las clases Applet y Graphics. Los
paquetes java.applet y java.awt son parte del API corazón de Java -- el API con el
que todo programa Java puede contar en el entorno Java. El paquete java.applet
contiene clases que son esenciales para los applets Java. El paquete java.awt contiene
la clases más usadas del AWT (Abstract Window Toolkit), que proporciona el interface
gráfico de usuario (GUI) de Java.
Además de importar clases individuales, también podemos importar paquetes enteros.
Aquí tenemos un ejemplo:
import java.applet.*;
import java.awt.*;
public class HelloWorld extends Applet {
public void paint(Graphics g) {
g.drawString("Hello world!", 50, 25);
}
}
En el lenguaje Java, toda clase está en un paquete. Si el código fuente para una clase no
tiene una sentencia package al principio, declarando el paquete en el que está la clase,
entonces la clase está en el paquete por defecto. Casi todas las clases de ejemplo de
este tutorial están en el paquete por defecto.
Dentro de un paquete todas las clases pueden referirse unas otras sin prefijos. Por
ejemplo, la clase java.awt Component se refiere a la clase java.awt Graphics sin
ningún prefijo, y sin importar la clase Graphics.
Definir una Subclase Applet
La primera línea en negrita del siguiente listado empieza un bloque que define la clase
HelloWorld:
import java.applet.Applet;
import java.awt.Graphics;
public class HelloWorld extends Applet {
public void paint(Graphics g) {
g.drawString("Hello world!", 50, 25);
}
}
La palabra clave extends indica que HelloWorld es una subclase de la clase cuyo
nombre sigue:Applet.
De la clase Applet, los applets heredan una gran cantidad de funcionalidades. Quizás la
más importante es responder a las peticiones del navegador. Por ejemplo, cuando una
navegador que soporta Java carga una página que contiene un applet, el navegador envía
una petición al applet, diciéndole que se auto-inicialice y empiece su ejecución.
Aprenderemos más sobre esto en la lección Introducción a los Applets.
Una applet no está restringido a usar sólo una clase. Junto a la necesaria clase Applet
un applet puede definir clases personalizadas adicionales. Cuando un applet intenta usar
una clase, la aplicación que está ejecutando el applet primero la busca en el host local.
Si la clase no está disponible localmente, se carga desde la dirección desde la que se
cargo originalmente el Applet.
Implementar Métodos de un Applet
Las líneas en negrita del siguiente listado implementan el método paint.
import java.applet.Applet;
import java.awt.Graphics;
public class HelloWorld extends Applet {
public void paint(Graphics g) {
g.drawString("Hello world!", 50, 25);
}
}
Todo applet debe implementar uno o más de los métodos init, start, o paint.
Aprenderemos sobre estos métodos en la lección Introducción a los Applets.
Junto a los métodos init, start, y paint, los applets pueden implementar dos métodos
más a los que llama el navegador cuando ocurren eventos importantes (como salir de la
página del applet) stop y destroy. Los applets también pueden implementar otros
métodos.
Volviendo al código de arriba, el objeto Graphics pasado al método paint representa
el contexto de dibujo del applet en la pantalla. El primer argumento del método
drawString de Graphics es el string a dibujar en la pantalla. El segundo y tercer
argumentos son las posiciones (x,y) de la esquina superior izquieda del texto sobre la
pantalla. Este applet dibuja el string "Hello world!" empezando en la posición (50,25).
Las coordenadas del sistema del applet empiezan en (0,0), que es la esquina superior
izquierda del área de pantalla del applet.
Ejecutar un Applet
Las líneas en negrita del siguiente listado componen la etiqueta <APPLET> que incluye
el applet "Hello World" en una página HTML.
<HTML>
<HEAD>
<TITLE> A Simple Program </TITLE>
</HEAD>
<BODY>
Here is the output of my program.
<APPLET CODE="HelloWorld.class" WIDTH=150 HEIGHT=25>
</APPLET>
</BODY>
</HTML>
La etiqueta <APPLET> de arriba especifica que el navegador debería cargar la clase cuyo
código compilado está en el fichero llamado HelloWorld.class. El navegador busca
este fichero en el mismo directorio que contiene el documento HTML que contiene la
etiqueta.
Cuando el navegador encuentra el fichero de la clase, la carga a través de la red, si es
necesario, en el ordenador donde se está ejecutando el navegador. Entonces el
navegador crea un ejemplar de la clase. Si incluimos un applet dos veces en la misma
página, el navegador sólo cargará el applet una vez y creará dos ejemplares de esa clase.
Los atributos WIDTH y HEIGHT son como los atributos de la etiqueta <IMG>. Especifican
el tamaño en pixels del área de pantalla del applet. La mayoría de los navegadores no
permiten que el applet se auto-redimensione para ser más grande o más pequeño que su
área de pantalla. Por ejemplo, cada dibujo que hace el applet "Hello World" en su
método paint ocurre dentro de un área de pantalla de 150x25-pixels que la anterior
etiqueta <APPLET> reserva para él.
Para más información sobre la etiqueta <APPLET>, puedes ver la página Usar la Etiqueta
APPLET.
Introducción a los Applets
Esta lección explica las partes de un applet.
Todo applet se implementa creando una subclase de la clase Applet. La siguiente figura
muestra el árbol de herencia de la clase Applet. Este árbol determina lo que un applet
puede hacer y cómo.
Un Applet Sencillo
Abajo está el código fuente de un applet llamado Simple. Este applet muestra una
cadena descriptiva siempre que encuentra un hito importante en su vida, como cuando el
usuario visita por primera vez la página donde se encuentra el applet. Las siguientes
páginas usan el applet Simple y construyen sobre él para mostrar conceptos que son
comunes a todos los applets.
/*
* 1.0 code.
*/
import java.applet.Applet;
import java.awt.Graphics;
public class Simple extends Applet {
StringBuffer buffer;
public void init() {
buffer = new StringBuffer();
addItem("initializing... ");
}
public void start() {
addItem("starting... ");
}
public void stop() {
addItem("stopping... ");
}
public void destroy() {
addItem("preparing for unloading...");
}
void addItem(String newWord) {
System.out.println(newWord);
buffer.append(newWord);
repaint();
}
public void paint(Graphics g) {
//Draw a Rectangle around the applet's display area.
g.drawRect(0, 0, size().width - 1, size().height - 1);
//Draw the current string inside the rectangle.
g.drawString(buffer.toString(), 5, 15);
}
}
El Ciclo de Vida de un Applet
Podemos usar el applet Simple para aprender los hitos importantes en la vida de un
applet.
Métodos para Hitos
La clase Applet proporciona un marco de trabajo para la ejecución del applet,
definiendo métodos que el sistema llama cuando ocurren hitos -- eventos mayores en el
ciclo de vida de un applet.
Métodos para Dibujar y Manejar Eventos
Los Applets heredan los métodos de dibujo y de manejo de eventos de la clase
Component del AWT (Abstract Windowing Toolkit); los applets y aplicaciones usan el
AWT para producir interfaces de usuario. Dibujo se refiere a cualquier cosa relacionada
con la representación del applet en la pantalla -- dibujar imágenes, presentar
componentes del interface de usuario como botones, o usar gráficos primitivos. Manejo
de Eventos se refiere a la detección y procesamiento de entradas de usuario como
pulsaciones del ratón o de teclas, así como a eventos más abstractos como grabar
ficheros y minimizar ventanas.
Métodos para Añadir Componentes al UI
Los Applets descienden de la clase Container de AWT. Esto significa que están
diseñados para contener Components -- objetos de interface de usuario como botones,
etiquetas, listas desplegables y barras de desplazamiento. Como otros Containers, los
applets usan controladores de distribución para posicionar sus Components.
¿Qué Puede y qué no Puede hacer un Applet?
Por razones de seguridad, los applets que son cargados a través de la red tienen muchas
restricciones. Una es que un applet normalmente no puede leer o escribir ficheros en el
ordenador donde se está ejecutando. Otra es que un applet no puede hacer conexiones
de red excepto con el host desde el que se descargó. A pesar de estas restricciones, los
applets pueden hacer algunas cosas que no te imaginas. Por ejemplo, un applet puede
invocar métodos públicos de otros applets que haya en la misma página.
Probar un Applet
Una vez que hemos escrito un applet, necesitaremos añadirlo a una página HTML para
poder probarlo. Esta sección nos dice cómo usar la etiqueta <APPLET> de HTML para
añadir un applet a una página HTML.
Sumario
Después de haber leído todas las páginas de esta lección, habrás visto casi todo lo
necesario para escribir applets.
Ciclos de Vida de un Applet
Aquí tenemos el applet Simple.
Pulsa sobre la Imagen para ver el Applet...
Nota:
Como algunos viejos navegadores no soportan 1.1, el applet anterior es un versión 1.0
(aquí tienes el código 1.0; y aquí tienes el código 1.1). Para ejecutar la versión 1.1 del
applet, puedes ir a la página example-1dot1/Simple.html.
Cargar el Applet
Deberías ver "initializing... starting..." arriba, como resultado de la carga del applet.
Cuando se carga un applet, aquí está lo que sucede:



Se crea un ejemplar de la clase que controla el applet (una subclase de Applet).
El applet se auto-initializa.
El applet empieza su ejecución.
Abandonar y Volver a la Página del Applet
Cuando un usuario deja la página del applet -- por ejemplo, para ir a otra página -- el
applet tiene la opción de pararse a sí mismo. Cuando el usuario retorna a la página, el
applet puede autoarrancarse otra vez. La misma secuencia ocurre cuando el usuario
minimiza y reabre la ventana que contiene el applet.
Prueba esto:
Abandona la página del applet y vuelve luego otra vez. Verás que se añadido
"stopping..." a la salida del applet cuando el applet se le da la oportunidad de pararse a
si mismo. También veremos "starting...", cuando se le dice al applet que arranque de
nuevo. Luego, minimiza esta ventana y abréla de nuevo. Muchos sistemas de ventanas
proporcionan botones en la barra de título que nos permiten minizar la ventana.
Deberíamos ver "stopping...." y luego "starting...." añadido a la salida del applet.
Recargar un Applet
Algunos navegadores nos permiten recargar el applet, que consiste en descargar el
applet y volver a cargarlo de nuevo. Antes de que se descargue el applet, se le da la
oportunidad de pararse a si mismo y luego realizan una limpieza final, para que el applet
pueda liberar cualquier recurso que contenga el applet. Después de esto, el applet es
descargado y luego cargado otra vez, como se decribe en Cargar el Applet.
Prueba esto:
Si tu navegador o visualizador de applets te permiten recargar applets, recargalo. Mira
la salida estándar para ver qué sucede cuando recargas el applet. (puedes ver Mostrar
Cadenas Cortas de Estado para más información sobre la salida estándar). Deberías ver
"stopping..." y "preparing for unloading..." cuando el applet se descarga. No podemos
ver esto en el GUI del applet porque el applet es descargado antes de que el texto pueda
mostrarse. Cuando el applet se recarga, deberíamos ver "initializing..." y "starting...",
igual que cuando se cargó el applet por primera vez.
Salir del Navegador
Cuando el usuario cierra el navegador (o cualquier otra aplicación que muestra el
applet), el applet tiene la oportunidad de pararse y hacer una limpieza final antes de que
el navegador salga.
Sumario
Un Applet puede reaccionar ante los eventos mayores de las siguientes formas:




Puede auto-inicializarse.
Puede arrancar su ejecución.
Puede parar su ejecución.
Puede realizar una limpieza final, como preparación para ser descargado.
La siguiente página describe los cuatro métodos del applet que corresponden a estos
cuatro tipos de reacciones.
Métodos de Applet
public class Simple extends Applet {
. . .
public void init() { . . . }
public void start() { . . . }
public void stop() { . . . }
public void destroy() { . . . }
. . .
}
El applet Simple, como cualquier otro applet, es una subclase de la clase Applet. La
clase Simple sobreescribe cuatro métodos de Applet para poder responder a los
principales eventos.
init
Para inicializar el applet cada vez que se carga (o se recarga).
start
Para arrancar la ejecución del applet, como cuando el applet se carga o cuando el
usuario revisita la página que contiene el applet.
stop
Para parar la ejecución del applet, como cuando el usuario deja la página del
applet o cierra el navegador.
destroy
Para realizar una limpieza final como preparación para la descarga.
No todos los applets necesitan sobreescribir todos estos métodos. Algunos applets muy
simples no sobreescriben ninguno de ellos. Por ejemplo el applet "Hello World" sólo
mostraba un string, una sóla vez, usando el método paint. Este método se describie en
la siguiente página. Sin embargo, la mayoría de los applets hacen más cosas.
El método init es útil para una inicialización de una vez que tarde mucho tiempo. En
general, el método init debería contener el código que normalmente pondríamos en un
constuctor. La razón por la que los applets no deberían tener constructores es que un
applet no tiene garantizado un entorno completo hasta que se llame a su método init.
Por ejemplo, la carga de imágenes en un applet simplemente no funciona dentro de un
constructor de applet. Por otro lado, el método init, es una gran lugar para llamar a los
métodos de carga de imágenes ya que los métodos se ejecutan rápidamente.
Nota de Navegador:
Algunos navegadores, algunas veces llaman al método init más de una vez después de
que el applet haya sido cargado. Puedes ver la página anterior para más detalles.
Todo applet que haga algo después de la inicialización (excepto en respuesta a acciones
de usuario) debe sobreescribir el método start. Este método realiza el trabajo del
applet, o (mejor dicho) arranca uno o más threads que realizan el trabajo. Podrás
aprender más sobre los threads en la sección Threads de Control. Aprenderás más sobre
el manejo de eventos que represetan acciones de usuario en la página siguiente.
La mayoría de los applet sobreescriben start deberían sobreescribir el método stop. El
método stop deberían suspender la ejecución del applet, para liberar los recursos del
sistema cuando el usuario no está viendo la página del applet. Por ejemplo, un applet
que muestra animaciones debería intentar parar la animación cuando el usuario no la
está mirando.
Muchos applets no necesitan sobreescribir el método destroy, ya que su método stop
(al que se le llama antes de destroy) hace todo lo necesario para parar la ejecución del
applet. Sin embargo, destroy está disponible para los applets que necesitan liberar
recursos adicionales.
Los métodos init, start, stop, y destroy se explican a lo largo de este tutorial. Para
más información, puedes ver la página del API Applet API reference page.
Métodos de Dibujo y Manejo de Eventos
El applet Simple define su apariencia de pantalla sobreescribiendo el método paint.
class Simple extends Applet {
. . .
public void paint(Graphics g) { . . . }
. . .
}
El método paint es uno de los métodos de pantalla que un applet puede sobreescribir.
paint
El método de dibujo básico.
Muchos applets implementan el método paint para dibujar la representación de
un applet dentro de una página del navegador.
update
Un método que podemos usar junto con paint para mejorar el rendimiento del
dibujo.
Los applets heredan sus métodos paint y update de la clase Applet, que descienden de
la clase Component del Abstract Window Toolkit (AWT) .
Los applets heredan un grupo de métodos de manejo de eventos de la clase Component.
La clase Component define varios métodos, como action y mouseDown, para manejar
tipos de eventos particulares, y luego un método que captura todos los eventos llamado
handleEvent.
Para reaccionar ante un evento, un applet debe sobreescribir su método de evento
especifico apropiado o el método handleEvent. Por ejemplo, añadiendo el siguiente
código al applet Simple hace que responda a las pulsaciones del raton.
import java.awt.Event;
. . .
public boolean mouseDown(Event event, int x, int y) {
addItem("click!... ");
return true;
}
Abajo está el applet resultante. Cuando pulsamos sobre sus rectángulos, muestra la
palabra "click!...".
Pulsa sobre la imagen para ver ejecutar el Applet...
Nota:
Como algunos viejos navegadores no soportan 1.1, el applet de arriba es una versión 1.0
(aquí está el código 1.0; y aquí está el código 1.1). Para ejecutar la versión 1.1 del
applet, puedes ir a la página example-1dot1/SimpleClick.html
Métodos para Añadir Componentes UI
El código de dibujo del applet Simple (implementado en su método paint) no es
bueno. No soporta scroll. Una vez que el texto alcanza el final del rectángulo de
pantalla, no podemos ver ningún nuevo texto. Aquí tenemos un ejemplo del problema.
La cura más sencilla para este problema es usar un componconte prefabricado de
interface de usuario que tenga el comportamiento correcto.
Componentes UI Pre-Fabricados
El AWT suministra los siguientes componentes UI (las clases que implementan cada
componente se listán entre paréntesis):











Botones (java.awt.Button)
Checkboxes (java.awt.Checkbox)
Campos de texto de una-línea (java.awt.TextField)
Grandes campos de texto y área de edición (java.awt.TextArea)
Etiquetas (java.awt.Label)
Listas (java.awt.List)
Listas desplegables de opciones (java.awt.Choice)
Deslizadores y Barras de Desplazamiento (java.awt.Scrollbar)
Áreas de Dibujo (java.awt.Canvas)
Menús (java.awt.Menu, java.awt.MenuItem, java.awt.CheckboxMenuItem)
Contenedores (java.awt.Panel, java.awt.Window y sus subclases)
Métodos para Usar Componentes UI en Applets
Como la clase Applet desciende de la clase Container del AWT, es fácil añadir
componentes a los applets y usar controladores de distribución para controlar la
posición de los componentes en la pantalla. Aquí tenemos algunos métodos de
Container que un applet puede usar:
add
Añade el Component especificado.
remove
Elimina el Component especificaco.
setLayout
Selecciona el controlador de distribución.
Añadir un Campo de Texto no Editable al Applet Simple
Para hacer que el applet Simple use un campo de texto no editable y scrollable,
podemos usar la clase TextField. Aquí está el código fuente revisado. Los
cambios se muestran abajo:
//Importing java.awt.Graphics is no longer necessary
//since this applet no longer implements the paint method.
. . .
import java.awt.TextField;
public class ScrollingSimple extends Applet {
//Instead of using a StringBuffer, use a TextField:
TextField field;
public void init() {
//Create the text field and make it uneditable.
field = new TextField();
field.setEditable(false);
//Set the layout manager so that the text field will be
//as wide as possible.
setLayout(new java.awt.GridLayout(1,0));
//Add the text field to the applet.
add(field);
validate();
addItem("initializing... ");
}
. . .
void addItem(String newWord) {
//This used to append the string to the StringBuffer;
//now it appends it to the TextField.
String t = field.getText();
System.out.println(newWord);
field.setText(t + newWord);
repaint();
}
//The paint method is no longer necessary,
//since the TextField repaints itself automatically.
El métodoinit crea un campo de texto no editable (un ejemplar de TextField).
Seleccionar el control de distribución del applet a uno hace el campo de texto tan ancho
como sea posible y luego añade el campo de texto al applet.
Después de esto, el método init llama al método validate (que Applet hereda de
Component). Llamar a validate después de haber añadido uno o más componentes a
un applet es un poco de vudu que nos asegura que los Component se dibujarán a si
mismos en la pantalla.
Abajo tenemos el applet resultante:
Pulsa sobre la imagen para ejecutar el applet...
¿Qué puede y qué no puede hacer un Applet?
Esta página nos ofrece una introducción de las restricciones de los Applets frente a las
capacidades especiales que éstos tienen. Podrás encontrar más detalles en la lección
Restriciones de Seguridad.
Restricciones de Seguridad
Todo navegador implementa políticas de seguridad para evitar que los applets
compromentan la seguridad del sistema. Esta sección descibe las políticas de seguridad
a las que se adhieren los navegadores actuales. Sin embargo, esta implementación de
políticas de seguridad es diferente entre navegadores. Y también, estás políticas están
sujetas a cambios. Por ejemplo, si un navegador se ha desarrollado sólo para ejecutarse
en entornos verdaderos su política de seguridad será más relajada que la de los descritos
aquí.
Los navegadores actuales imponen las siguientes restricciones a cualquier applet que se
cargue a través de la red:






Un applet no puede cargar librerías o definir métodos nativos.
Normalmente no puede leer o escribir ficheros en el host en el que se está
ejecutando.
No puede hacer conexiones de red excepto con el host desde el que vino.
No puede arrancar ningún programa en el host donde se está ejecutando.
No puede leer ciertas propiedades del sistema.
Las vetanas que muestran los applets son distintas a las que muestra una
aplicación.
Todo navegador tiene un objeto SecurityManager que implementa sus políticas de
seguridad. Cuando un SecurityManager detecta una violación, lanza una
SecurityException. Nuestro applet puede capturar dicha excepción y reaccionar de la
forma apropiada.
Capacidades de los Applets
El paquete java.applet proporciona una API que ofrece a los Applets algunas
capacidades que las aplicaciones no tienen. Por ejemplo, los applets puede ejecutar
sonidos, mientras que otros programas no pueden hacerlo todavía.
Aquí hay algunas otras cosas que los navegadores actuales y otros visualizadores
permiten hacer a los applets:

Normalmente pueden hacer conexiones de red hacia el host del que vinieron.




Los applets que se ejecutan dentro de un navegador Web pueden hacer
fácilmente que se muestren documentos HTML.
Los Applets pueden incovar métodos públicos de otros applets que haya en la
misma página.
Los Applets que se cargan desde el sistema local de ficheros (desde un directorio
en el CLASSPATH del usuario) no tienen ninguna de las restriccones que tienen
los applets cargados a través de la red.
Aunque la mayoría de los applets detienen su ejecución una vez que hemos
abandonado su página, no tienen porque hacerlo.
Probar un Applet
Una vez que hemos escrito algún código para nuestro applet, querremos ejecutarlo para
probarlo. Para ejecutar un applet, primero necesitamos añadir el applet a una página
HTML, usando la etiqueta <APPLET>. Y luego especificamos la URL de la página
HTML a nuestro navegador que soporte Java.
Nota:
Como no siempre podremos tratar con navegadores que recarguen nuestras clases
Applet, podríamos usar un herramienta de arranque rápido como el AppletViewer del
JDK para probar la mayoría de nuestros applets. Cada vez que modifiquemos nuestro
applet, podemos re-arrancar el AppletViewer para asegurarnos que carga todas las
últimas versiones de las clases.
Aquí tenemos la forma más simple de una etiqueta <APPLET>:
<APPLET CODE=AppletSubclass.class WIDTH=anInt HEIGHT=anInt>
</APPLET>
Esta etiqueta le dice al navegador que carge el applet cuya subclase Applet se llama
AppletSubclass. La siguiente figura muestra dónde debe estar el fichero de la clase del
applet en relación al documento HTML que contiene la etiqueta <APPLET>. Como
muestra la figura, a menos que el applet sea declarado como pertenciente a un paquete,
su clase debe estar en el mismo directorio que el fichero HTML que tiene la etiqueta
<APPLET>.
Cuando un navegador que soporte Java encuentra una etiqueta <APPLET>, reserva un
área de pantalla de la anchura y altura especificadas, carga los bytecodes de la subclase
Applet especificada, crea un ejemplar de la subclase y luego llama a los métodos init y
start del ejemplar.
La etiqueta <APPLET> tiene muchas opciones que podemos usar para personalizar la
ejecución del applet. Por ejemplo podemos poner los ficheros del applet en un archivo.
Estas opciones se describen en la lección Usar la Etiqueta APPLET.
Sumario de Introducción a los Applets
Esta lección nos ha ofrecido mucha información -- casi todo lo que necesitamos saber
para escribir un applet Java. Está página sumariza lo que hemos aprendido, añadiendo
un poco de información para ayudarnos a comprender la totalidad.
Primero hemos aprendido que para escribir un applet, debemos crear una subclase de la
clase java.applet.Applet. En nuestra subclase Applet, debemos implementar al
menos uno de los siguientes métodos: init, start, o paint. A los métodos init y
start, junto con stop y destroy, se les llama cuando cocurren eventos mayores (hitos)
en ciclo de vida del applet. Al método paint se le llama cuando el applet necesita
dibujarse a sí mismo en la pantalla.
La clase Applet desciende de la clase Panel del AWT, que deciende de la clase
Container, que a su vez desciende de la clase Component todas del AWT. De
Component, un applet hereda la habilidad de dibujar y de manejar eventos. De
Container, un applet hereda la habilidad de incluir otros componentes y hacer que un
controlador de distribución controle el tamaño y posición de dichos componentes. De
Applet, un applet hereda muchas capacidades, incluyendo la capacidad de responder a
hitos mayores como la carga y la desarga.
Incluimos los applets en páginas HTML usando la etiqueta <APPLET>. Cuando un
navegador visitia una página que contiene un applet, aquí está lo que sucede:
1. El navegador busca el fichero class de la subclase del Applet.
La localización del fichero class (que contiene los bytecodes Java) se especifica
con los atributos CODE y CODEBASE de la etiqueta <APPLET> .
2. El navegador descarga los bytecodes a través de la red hasta el ordenador del
usuario.
3. El navegador crea un ejemplar de la subclase Applet.
Cuando nos referimos a un applet, generalmente nos referimos a este ejemplar.
4. El navegador llama al método init del applet.
Este método realiza cualquier inicialización que sea necesaria.
5. El navegador llama al método start del applet.
Este método normalmente arranca un thread que realiza las tareas del applet.
Una subclase Applet es la clase principal, la clase controladora, pero los applets
también pueden usar otras clases. Estas otras clases pueden ser locales del navegador,
proporcionadas como parte del entorno Java, o ser clases personalizadas que nosotros
suministramos. Cuando el applet intenta utilizar una clase por primera vez, el navegador
intenta encontrarla en el host en el que se está ejecutando. Si no puede encontrarla allí,
busca la clase en el mismo lugar de donde vino la subclase de Applet. Cuando el
navegador encuentra la clase, carga sus bytecodes (a través de la red, si es necesario) y
continúa ejecutando el applet.
Cargar código ejecutable a través de la red es un riesgo de seguridad clásico. Para los
Applets Java, este riesgo se reduce porque el lenguaje Java está diseñado para ser
seguro -- por ejemplo, no permite punteros a memoria. Además, los navegadores
compatibles Java mejoran la seguridad imponiendo sus propias restricciones. Estas
restricciones incluyen no permitir a los applets que carguen código escrito en otros
lenguajes distintos de Java, y no permitiendo que los applets lean o escriban ficheros en
el host del navegador.
Aprovecharse del API de Applet
El API Applet nos permite aprovecharnos de la estrecha relación que hay entre los
applets y los navegadores. Este API lo proporciona el paquete java.applet -principalmente a través de la clase Applet y el interface AppletContext. Gracias a este
API los applets pueden hacer lo siguiente:







Ser notificados de los eventos del navegador.
Cargar ficheros de datos especificados en relación a la URL del applet o de la
página en la que se está ejecutando.
Mostrar cadenas cortas de estado.
Hacer que el navegador muestre un documento.
Encontrar otros applets que se están ejecutando en la misma página.
Ejecutar Sonidos.
Obtener parámetros especificados por el usuario en la etiqueta <APPLET>.
Esta lección explica cada uno de esto tópicos, excepto los métodos de hitos importantes
(init, start, etc.), que se explicaron en Métodos de Applet. Para más información
sobre como usar un API no específico de applet en un applet, puedes ver la lección
Consideraciones Prácticas Cuando se Escriben Applets.
Los métodos getCodeBase y getDocumentBase de Applet obtienen información del
navegador sobre de donde vienen el applet y la página HTML. Encontrar y Cargar
Ficheros de Datos describe cómo usar estos métodos para ayudarnos a cargar ficheros
de datos del applet, como imágenes.
Mostra Cadenas Cortas de Estado describe cómo hacer que un applet muestre una
cadena en la línea de estado de la aplicación en la que se está ejecutando.
Mostrar Documentos en el Navegador nos explica cómo usar los dos métodos
showDocument para pedirle al navegador que visite una URL particular.
Usando los métodos getApplet y getApplets de AppletContext, un applet puede
obtener los objetos Applet de otros applets que se estén ejecutando en la misma página.
Una vez que un applet tiene otro objeto Applet, puede enviarle mensajes. Enviar
Mensajes a Otros Applets proporciona detalles y ejemplos de applets que se comunican
unos con otros.
La clase Applet y el interface AudioClip proporcionan soporte para ejecutar sonidos.
La sección Ejecutar Sonidos nos explica este soporte e incluye un ejemplo de uso de
sonidos en un applet.
Podemos mejorar la versatilidad de un applet proporcionando parámetros. Definir y
Usar Parámetros de Applets describe cómo decidir qué parámetros proporcionar, cómo
implementarlos, y cómo informar al usuario sobre ellos.
Finalmente, Usar la Etiqueta <APPLET> nos explica cómo personalizar un applet
editando su etiqueta HTML.
Encontrar y Cargar Ficheros de Datos
Siempre que un applet necesita cargar algún dato desde un fichero que se especifica con
una URL relativa (una URL que no especifica completamente la localización del
fichero), el applet normalmente usa su code base o document base para formar la URL
completa. El code base, devuelto por el método getCodeBase de Applet, es una URL
que especifica el directorio desde el que se cargó la clase del applet. El document base,
devuelto por el método getDocumentBase de Applet, especifica el directorio de la
página HTML que contiene el applet.
A menos que la etiqueta <APPLET> especifique un code base tanto el code base como el
document base se refieren al mismo directorio en el mismo servidor.
Los datos que un applet siempre necesita, o necesita relacionar con una copia,
normalmente se especifican en relación al code base. Los datos que el usuario de applet
especifica, normalmente usando parámetros, se especifican en relación al document
base.
Nota:
Por razones de seguridad, los navegadores limitan las URLs desde las que pueden leer
los appelts sin firmar. Por ejemplo, la mayoría de los navegadores no permiten que los
applets sin firmar usen ".." para obtener directorios por encima del code base o del
document base. También, como los applets no firmandos no pueden leer ficheros
excepto aquellos que hay en el host originario del applet, el document base
generalmente no es útil si el documento y el applet no firmado están en diferentes
servidores.
La clase Applet define formas convenientes de métodos para cargar imágenes y sonidos
que nos permiten especificar ficheros de imágenes y sonidos en relación a un URL base.
Por ejemplo, imaginemos un applet construido con la estructura de directorios que se ve
en la siguiente figura:
Para crear un objeto Image usando el fichero de imagen a.gif bajo el directorio
imgDir, podemos usar el siguiente código:
Image image = getImage(getCodeBase(), "imgDir/a.gif");
Mostrar Cadenas Cortas de Estado
Todos los visualizadores de applets -- desde el AppletViewer del JDK hasta los
navegadores compatibles Java -- permiten que los applets muestren una cadena corta de
estado. En implementaciones actuales, esta cadena aparece en la línea de estado en la
parte inferior del visualizador de applets. En los navegadores, todos los applets de la
página, así como el propio navegador, generalmente comparten la misma línea de
estado.
Nunca se debe poner información crucial en la línea de estado. Si muchos usuarios
podrían necesitar esa información, deberíamos ponerla dentro del área del applet. Si
sólo unos pocos, y sofisticados usuarios podrían necesitar la información, deberíamos
considerar el mostar la información en la salida estándar.
La línea de estado normalmente no es muy prominente, y puede ser sobreescrita por
otros applets o por el navgeador. Por estas razones, es mejor utilizarla para información
incidental o transitoria. Por ejemplo, un applet que carga muchos ficheros de imágenes,
podría mostrar el nombre del fichero que se está cargando actualmente.
Los applets muestran líneas de estado con el método showStatus. Aquí tenemos un
ejemplo de su uso.
showStatus("MyApplet: Loading image file " + file);
Note:
Por favor no pongas texto en movimiento en la línea de estado. Los usuarios de
navegadores encuentran altamente aburrido y una pérdida de tiempo el abuso en el uso
de la línea del estado!
Mostrar Documentos en el Navegador
¿Has querido alguna vez que un applet muestre texto HTML formateado? Aquí está la
forma fácil de hacerlo. Pídele al navegador que muestre el texto por tí.
Con los métodos showDocument de AppletContext, un applet puede decirle al
navegador qué URL mostrar y en qué ventana del navegador. (Por supuesto, el
AppletViewer del JDK ignora estos métodos, ya que no puede mostrar documentos).
Aquí tenemos las dos formas de showDocument.
public void showDocument(java.net.URL url)
public void showDocument(java.net.URL url, String targetWindow)
La forma de un-argumento de showDocument simplemente le dice al navegador que
muestre el documento de la URL especificada, sin especificar la ventana en la que
mostrarlo.
Nota de Terminología:
En esta explicación, frame no se refiere a un Frame del AWT, si no a un frame HTML
(marco) dentro de una ventana del navegador.
La forma de dos-argumentos de showDocument nos permite especificar en que ventana
o marco HTML mostrar el documento. El segundo argumento puede tener cualquiera de
los siguientes valores:
"_blank"
Muestra el documento en una nueva ventana, sin nombre.
"nombredeventana"
Muestra el documento en la ventana llamada nombredeventana.
La ventana se crea si es necesario.
"_self"
Muestra el documento en la ventana o marco que contiene el applet.
"_parent"
Mustra el documento en la ventana que contiene el applet pero en el marco padre
del marco del applet.
Si el marco del applet no tiene marco padre, esto actúa igual que "_self".
"_top"
Muestra el documento en la ventana del applet pero en el marco de más alto
nivel.
Si el marco del applet es el marco de más alto nivel, esto actúa igual que
"_self".
El siguiente applet nos permite probar todas las opciones de ambas formas de
showDocument. El applet trae una ventana que nos permite teclear una URL y elegir
cualquiera de las opciones de showDocument. Cuando pulsamos Return o pulsamos el
botón Show document, el applet llama a showDocument.
Pulsa sobre la imagen para ejecutar el applet...
Nota:
Como algunos viejos navegadores no soportan 1.1, el applet de arriba es una versión 1.0
(aquí está el código 1.0; y aquí el código 1.1). Para ejecutar la versión 1,1 del applet,
puedes ir a la página example-1dot1/ShowDocument.html.
Abajo está el código del applet que llama a showDocument. (Aquí puedes encontrar el
programa completo.)
...//In an Applet subclass:
urlWindow = new URLWindow(getAppletContext());
. . .
class URLWindow extends Frame {
. . .
public URLWindow(AppletContext appletContext) {
. . .
this.appletContext = appletContext;
. . .
}
. . .
public boolean action(Event event, Object o) {
. . .
String urlString = /* user-entered string */;
URL url = null;
try {
url = new URL(urlString);
} catch (MalformedURLException e) {
...//Inform the user and return...
}
if (url != null) {
if (/* user doesn't want to specify the window */) {
appletContext.showDocument(url);
} else {
appletContext.showDocument(url,
/* user-specified
window */);
}
}
. . .
Enviar Mensajes a Otros Applets
Los applets pueden encontrar otros applets y enviarles mensajes, con las siguientes
restricciones de seguridad:



Muchos navegadores requieren que los applets sean originarios desde el mismo
servidor.
Muchos navegadores además requieren que los applets procedan del mismo
directorio del servidor (el mismo code base).
El API Java requiere que los applets se estén ejecutando en la misma página, en
la misma ventana del navegador.
Nota:
Algunos navegadores permiten a los applets invocar métodos de otros applets -- incluso
de applets en diferentes páginas del mismo navegador -- siempre que todos los applets
tengan el mismo code base. Este método de comunicación entre applets no está
soportado por el API Java, y posiblemente no será soportado por todos los navegadores.
Un applet puede encontrar otro applet buscándolo por su nombre (usando el método
AppletContext getApplet) o buscando todos los applets que hay en una página
(usando el método AppletContext getApplets). Ambos métodos, si tienen éxito le
dan al llamador uno o más objetos Applet. Una vez que el llamador encuentra un objeto
Applet, el llamador puede invocar los métodos del objeto.
Encontrar un Applet por su Nombre: El Método getApplet
El método getApplet busca a través de todos los applets de la página actual para ver si
uno de ellos tiene el nombre especificado. Si es así, getApplet devuelve el objeto
Applet del Applet.
Por defecto, un applet no tiene nombre. Para que un applet tenga nombre, se debe
especificar en el código HTML que añade el applet a la página. Podemos especificar el
nombre de una applet de dos formas:

Especificando el atributo NAME dentro de la etiqueta <APPLET>.
Por ejemplo:
<APPLET CODEBASE=example/ CODE=Sender.class
WIDTH=450
HEIGHT=200
NAME="buddy">
. . .
</applet>

Especificando un parámetro NAME con una etiqueta <PARAM> .
Por ejemplo:
<APPLET CODEBASE=example/ CODE=Receiver.class
WIDTH=450
HEIGHT=35>
<PARAM NAME="name" value="old pal">
. . .
</applet>
Nota de Navegador:
Aunque al menos un navegador compatible Java concede una búsqueda sensible a las
maýusculas, el comportamiento esperado para el método getApplet es realizar un
búsqueda no sensible a las mayúsculas. Por ejemplo, getApplet("old pal") y
getApplet("OLD PAL") deberían encontrar un applet llamado "Old Pal".
Pulsa sobre la imagen del applet para ver el ejemplo de búsqueda por nonbre en acción:
El primero, el emisor, busca al segundo, el receptor. Cuando el emisor encuentra al
receptor, le envía un mensaje llamando a uno de sus métodos (pasándo el nombre del
emisor como argumento) El receptor reacciona a esta llamada a método cambiando el
string más la izquierda a "Received message from sender-name!".
Nota:
Como algunos viejos navegadores no soportan 1.1, los applets del ejemplo son
versiones 1.0. Aquí están los enlaces al código 1.0 para las clases Sender y el
Receiver.
Para ejecutar las versiones 1.1 de los applets puedes ir a la página example1dot1/iac.html.
Prueba esto:
Pulsa sobre el botón Send message del applet de la parte superior (el Sender). En su
ventana aparecerá alguna información de estado y el Receiver confirmará (con su propia
cadena de estado) que ha recibido el mensaje. Después de haber leído la cadena de
estado del Receiver, pulsa el botón Clear para resetear el receptor. En el Campo de
texto llamado "Receiver name:," del Sender, teclea buddy y pulsa Return. Como
"buddy" es el nombre del propio Sender, éste encontrará un applet llamado buddy pero
no querrá enviarle un mensaje porque no es un ejemplar de Receiver.
Aquí está el programa completo del Sender. El código usado para buscar y
comunicarse con el Receiver se lista abajo. El código que podemos usar sin modificar
en nuestros propios applets está en negrita.
Applet receiver = null;
String receiverName = nameField.getText(); //Get name to search for.
receiver = getAppletContext().getApplet(receiverName);
El Sender se asegura de que ha encontrado un Receiver y que es un ejemplar de la clase
correcta (Receiver). Si todo va bien, el Sender envía un mensaje al Receiver. (Aquí
está el Programa Receiver.)
if (receiver != null) {
//Use the instanceof operator to make sure the applet
//we found is a Receiver object.
if (!(receiver instanceof Receiver)) {
status.appendText("Found applet named "
+ receiverName + ", "
+ "but it's not a Receiver object.\n");
} else {
status.appendText("Found applet named "
+ receiverName + ".\n"
+ " Sending message to it.\n");
//Cast the receiver to be a Receiver object
//(instead of just an Applet object) so that the
//compiler will let us call a Receiver method.
((Receiver)receiver).processRequestFrom(myName);
}
} . . .
Desde el punto de vista de un applet, su nombre se almacena en un parámetro llamado
NAME. Puede obtener el valor del parámetro usando el método Applet getParameter.
Por ejemplo, Sender obtiene su propio nombre con el siguiente código:
myName = getParameter("NAME");
Para más información sobre como usar getParameter, puedes ver la página Escribir
Código para Soportar Parámetros.
Los applets de esta página realizan comunicación en un sentido -- desde el emisor al
receptor. Si queremos que el receptor pueda enviar mensajes al emisor, sólo tenemos
que hacer que el emisor le de una referencia de sí mismo (this) al receptor. Por
ejemplo:
((Receiver)receiver).startCommunicating(this);
Encontrar Todos los Applets de una Página: El Método getApplets
El método getApplets devuelve una lista (una Enumeration, para ser precesisos) con
todos los applets de la página. Por razones de seguridad, muchos navegadores y
visualizadores de applets implementan getApplets para que sólo devuelva aquellos
applets originarios del mismo host del applet que llamó a getApplets. Aquí tenemos
un applet que simplemente lista los applets que puede encontrar en esta página:
Pulsa sobre la imagen para ejecutar los applets...
Nota:
Como algunos viejos navegadores no soportan 1.1, los applets de lejemplo son
versiones 1.0. Aquí está el enlace al código 1.0 para la clase GetApplets y el código de
la versión 1.1.
Para ejecutar las versiones 1.1 de los applets puedes ir a la página example1dot1/iac2.html.
Abajo tenemos las partes importantes del método que llama a getApplets. (Aquí está
el programa completo.)
public void printApplets() {
//Enumeration will contain all applets on this page (including
//this one) that we can send messages to.
Enumeration e = getAppletContext().getApplets();
. . .
while (e.hasMoreElements()) {
Applet applet = (Applet)e.nextElement();
String info = ((Applet)applet).getAppletInfo();
if (info != null) {
textArea.appendText("- " + info + "\n");
} else {
textArea.appendText("- "
+ applet.getClass().getName()
+ "\n");
}
}
. . .
}
Ejecutar Sonidos
En el paquete (java.applet), la clase Applet y el interface AudioClip proporcionar
un soporte básico para ejecutar sonidos. Actualmente, el API sólo soporta un formato de
sonido: ficheros de 8 bit, µlaw, 8000 Hz, one-channel, Sun ".au". Podemos crearlos en
una estación Sun usando la aplicación audiotool. Podemos convertir ficheros desde
otras fuentes de datos usando un programa de conversión de formatos de audio.
Métodos Relacionados por el Sonido
Abajo tenemos los métodos de Applet relacionados con el sonido. El formato de dos
argumentos de cada método toma una URL base, que normalmente es devuelto por un
getDocumentBase o un getCodeBase, y la localización del fichero de sonido en
relación a la URL base. Deberíamos usar el code base para sonidos que son integrales
en el applet. El document base se usa para sonidos especificados por el usuario del
applet, a través de los parámetros del applet.
getAudioClip(URL)
Devuelve un objeto que implementa el interface AudioClip.
play(URL)
Ejecutar el AudioClip correspondiente a la URL especificada.
El interface AudioClip define los siguientes métodos:
loop
Empieza la ejecución del clip repetidamente.
play
Ejecuta el sonido una vez.
stop
Para el clip.
Funciona con ambos sonidos, el de bucle y el de una sola vez.
Un Ejemplo
Aquí tenemos un applet llamado SoundExample que ilustra unas cuantas cosas sobre
los sonidos. Observa que, para propósitos de isntrucción, el appler añade 10 segundos al
tiempo de carga para cada sonido. Si el sonido fuera más largo o la conexión del usuario
más lenta que la neustra, estos retardos podrían ser realistas.
Pulsa sobre la imagen para ejecutar el applet...
Nota:
Como algunos viejos navegadores no soportan 1.1, el applet anterior es una versión 1.0
(aquí está el código 1.0; y aquí está el código 1.1). Para ejecutar una versión 1.1 del
applet, puedes ir a la página example-1dot1/SoundExample.html.
El applet SoundExample proporciona una arquitectura para cargar y ejecutar múltiples
sonidos en un applet. Por esta razón, es más complejo de lo necesario. Esencialmente, el
código de carga y ejecución de sonidos se cuece aquí:
AudioClip onceClip, loopClip;
onceClip = applet.getAudioClip(getCodeBase(), "bark.au");
loopClip = applet.getAudioClip(getCodeBase(), "train.au");
onceClip.play();
//Play it once.
loopClip.loop();
loopClip.stop();
//Start the sound loop.
//Stop the sound loop.
Como no hay nada más aburrido que un applet que contínuamente hace ruido; después
de dejar su página, el applet SoundExample deja de ejecutar el bucle de sonidos, y
empieza la ejecución cuando el usuario vuelve a la página. Hace esto implementando
sus métodos stop y start de esta forma:
public void stop() {
//If one-time sound were long, we'd stop it here, too.
//looping is a boolean instance variable that's initially
//false. It's set to true when the "Start sound loop" button
//is clicked and to false when the "Stop sound loop" or "Reload
//sounds" button is clicked.
if (looping) {
loopClip.stop();
//Stop the sound loop.
}
}
public void start() {
if (looping) {
loopClip.loop();
}
}
//Restart the sound loop.
El applet SoundExample usa tres clases:


Una subcalse Applet, SoundExample, que controla la ejecución del applet.
Una subclase Hashtable, SoundList, que contiene los AudioClips.
Esto es demasiado para este applet, pero si fueramos a escribir un applet
queusara muchos ficheros de sonido, una clase como ésta sería muy útil

Una subclase de ThreadSoundLoader, cada uno de cuyos ejemplares carga un
AudioClip en segundo plano.
Durante la inicialización del applet, éste precarga cad sonido creando un
SoundLoader para él.
Precargar los sonidos en un thread de segundo plano (con SoundLoader) mejora el
rendimiento percivido reduciendo la cantidad de tiempo que el usuario tiene que esperar
para poder interactúar con el applet. Hace esto reduciendo la cantidad de tiendo que
gasta en el método init. Si simplemente llamamos a getAudioClip en el método init
del applet, pasaría bastante tiempo antes de getAudioClip volviera, lo que significa
que el applet no podría ejecutar otras sentencias de su método init, y que el método
start del applet no podría ser llamado. (Para este applet un retardo en la llamda al
método start no importa).
Otra ventana de la carga de sonidos en un thread se segundo plano es que permite al
applet responder apropiadamente (e inmediatamente) a las entradas del usuario que
normalmente harán que se ejecute el sonido, incluso si el sonido no se ha cargado
todavía. Si simplemente usamo los método Applet play, por ejemplo, la primera vez
que el usuario hace algo para hacer que el applet ejecute un sonido particular, el dibujo
y el manejo de eventos del applet quedarán congelados mientras se carga el sonido. En
su lugar, el applet detecta que el sonido no se ha cargado todavía y responde
apropiadamente.
Este ejemplo se explica en más detalle en la página Threads en Applets: Ejemplos.
Definir y Usar Parámetos en un Applet
Los parámetros son a los applets lo que los argumentos de la línea de comandos a las
aplicaciones. Permiten al usuario personalizar la operación del applet. Definiendo
parámetros, podemos incrementar la flexibilidad de nuestro applet, haciendo que trabaje
en múltiples situaciones sin tener que codificarlo y recompilarlo de nuevo.
Las siguientes páginas explican los parámetros desde el punto de vista del programador
de applets. Para aprender sobre el punto de vista del usuario de parámetros, puedes ver
Especificar Parámetros.
Decidir Qué Parámetros Soportar
Cuando implementamos parámetros, debemos responder a cuatro preguntas:




¿Qué deberia dejar el applet que configurara el usuario?
¿Cómo deberían llamarse los parámetros?
¿Qué tipo de valores debería tomar cada parámetro?
¿Cuál debería ser el valor por defecto de cada parámetro?
Escribir Código Para Soportar Parámetros
Los applets obtienen los valores definidos por el usuario para los parámetros llamando
al método getParameter de Applet.
Dar Información Sobre los Parámetros
Implementando el método getParameterInfo, los applets proporcionan información
que los navegadores pueden utulizar para ayudar al usuario a configurar los valores de
los parámetros.
Decidir qué Parámetros Soportar
Esta página nos guía a través de las cuatro preguntas que deberíamos responder cuando
implementemos parámetros:



¿Qué debería un Applet permitir que el usuario configurara?
¿Cómo deberían llamarse los parámetros?
¿Qué tipos de valores debería tomar cada parámetro?

¿Cuál debería ser el valor por defecto de cada parámetro?
Termina con una explicación de los parámetros definidos por una clase de ejemplo
llamada AppletButton.
¿Qué debería un Applet permitir que el usuario configurara?
Los parámetros que nuestro applet debería soportar dependen de lo que haga y de cómo
queramos que sea de flexible. Los applets que muestran imágenes podrían tener un
parámetro para especificar las localizaciones de las imágenes. Deforma similar, los
applets que ejecutan sonidos, podrían tener parámetros para especificar los sonidos.
Junto con los parámetros que especifican localizaciones de recursos (como ficheros de
imagen y sonido), algunas veces los applets proporcionan parámetros para especificar
detalles de la operación o de la apariencia del applet. Por ejemplo, un applet de
animación, podría permitir que el usuario especifique el número de imágenes por
segundo a mostrar. O un applet podría dejar que el usuario modifique los textos que
muestra el applet. Todo es posible.
¿Cómo deberían llamarse los Parámetros?
Una vez que hemos decidido que parámetros va a soportar nuestro applet, necesitamos
imaginarnos sus nombres. Aquí tenemos algunos nombres típicos de parámetros:
SOURCE o SRC
Para ficheros de datos como un fichero de imagen.
XXXSOURCE (por ejemplo, IMAGESOURCE)
Usado en applets que permiten que el usuario especifique más de un tipo de
ficheros de datos.
XXXS
Para un parámetro que toma una lista de XXXs (donde XXX podría ser IMAGE,
por ejemplo).
NAME
Usado sólo para el nombre del applet.
Los nombres de los applets se utilizan para comunicarse unos con otros como se
describió en Enviar Mensajes a Otros Applets.
La claridad de los nombres es más importante que su longitud. No debemos usar
nombres de atributos de la etiqueta <APPLET>, que se documentan en La Etiqueta
<APPLET>.
Nota:
Aunque este tutorial se refiere a los nombres de parámetros usando TODO
MAYÚSCULAS, éstos no son sensibles a las mayúsculas. Por ejemplo, IMAGESOURCE y
imageSource se refieren al mismo parámetro. Por otro lado, los valores de los
parámetros si son sensibles a las mayúsculas, a menos que realicemos los pasos
necesarios para intepretarlos de otra forma, como usando el método String
toLowerCase
antes de interpretar el valor del parámetro.
¿Qué tipo de Valor debería Aceptar cada Parámetro?
Todos los valores de parámetros son strings. No importa si el usuario pone comillas o
no alrededor del valor de parámetro, el valor pasado al applet es un string. Sin embargo,
nuestro applet puede interpretar el string de muchas formas:
Normalmente los applets interpretan un valor de parámetro como uno de los siguientes
tipos:






Una URL
Un integer
Un número en coma flotante
Un valor booleano -- normalmente "true"/"false" o "si"/"no"
Un string -- por ejemplo, el texto usado como título para la ventana.
Una lista de los de arriba.
¿Qué valor por Defecto Debería Tener cada Parámetro?
Los Applets deberían intentar proporcionar valores útiles por defecto para cada
parámetro, para que el applet se pueda ejecutar incluso si el usuario no especifica
ningún parámetro o los especifia incorrectamente. Por ejemplo, un applet de animación
debería proporcionar una selección razonable para el número de imágenes que debe
mostrar por segundo. De esta forma, si el usuario no especifica el parámetro importante,
el applet aún funcionará bien.
Un ejemplo: AppletButton
A lo largo de esto tutorial, los applets que necesitan traer ventanas usan la clase
AppletButton que es altamente configurable.
Nota:
Si estás usando 1.1 o 1.2, deberías mirar la versión Swing de AppletButton.java.
La clase AppletButton es tan flexible porque define parámetros que permiten al
usuario especificar lo siguiente:





El tipo de la ventana a mostrar
El título de la ventana
La altura de la ventana
La anchura de la ventana
La etiqueta para el botón que trae la ventana.
Aquí tenemos una etiqueta <APPLET> para AppletButton. Puedes ver este applet en
la página Usar Controladores de Distribución.
<APPLET CODE=AppletButton.class CODEBASE=example
WIDTH=350 HEIGHT=60>
<PARAM NAME=windowClass VALUE=BorderWindow>
<PARAM NAME=windowTitle VALUE="BorderLayout">
<PARAM NAME=buttonText
VALUE="Click here to see a BorderLayout in action">
</APPLET>
Cuando el usuario no especifica un valor para un parámetro, AppletButton usa un
valor por defecto razonable. Por ejemplo, si el usuario no especifica el título de la
ventana, AppletButton usa el tipo de la ventana como título.
La página siguiente nos enseña el código que usa AppletButton para obtener lo valores
de sus parámetros.
Escribir el Código para Soportar Parámetros
Los Applets usan el método Applet getParameter para obtener los parámetros
especificados por el usuario. El método getParameter se define de esta forma:
public String getParameter(String name)
Nuestro applet podría necesitar convertir el string que devuelve getParameter a otro
formato, como a un entero. El paquete java.lang proporciona clases como Integer,
que podemos usar para ayudarnos a convertir strings a tipos primitivos. Aquí tenemos
un ejemplo de conversión de la clase AppletButton que convierte el valor de un
parámetro a un entero:
int requestedWidth = 0;
. . .
String windowWidthString = getParameter("WINDOWWIDTH");
if (windowWidthString != null) {
try {
requestedWidth = Integer.parseInt(windowWidthString);
} catch (NumberFormatException e) {
//Use default width.
}
}
Observa que si el usuario no especifica un valor para el parámetro WINDOWWIDTH, el
código anterior usa un valor por defecto de 0, que el applet interpreta como "usa el
tamaño natural de la ventana". Es importante que suministremos valores por defecto
siempre que sea posible.
Además de la utilización del método getParameter para obtener valores de parámetros
en un applet, también podemos usar getParameter para obtener atributos de la etiqueta
<APPLET>. Puedes ir a la página La Etiqueta <APPLET> para ver una lista de estos
atributos.
Un ejemplo: AppletButton
Abajo tenemos el código de AppletButton que obtiene los parámetros del applet.
String windowClass;
String buttonText;
String windowTitle;
int requestedWidth = 0;
int requestedHeight = 0;
. . .
public void init() {
windowClass = getParameter("WINDOWCLASS");
if (windowClass == null) {
windowClass = "TestWindow";
}
buttonText = getParameter("BUTTONTEXT");
if (buttonText == null) {
buttonText = "Click here to bring up a " + windowClass;
}
windowTitle = getParameter("WINDOWTITLE");
if (windowTitle == null) {
windowTitle = windowClass;
}
String windowWidthString = getParameter("WINDOWWIDTH");
if (windowWidthString != null) {
try {
requestedWidth = Integer.parseInt(windowWidthString);
} catch (NumberFormatException e) {
//Use default width.
}
}
String windowHeightString = getParameter("WINDOWHEIGHT");
if (windowHeightString != null) {
try {
requestedHeight = Integer.parseInt(windowHeightString);
} catch (NumberFormatException e) {
//Use default height.
}
}
Dar Información sobre los Parámetros
Ahora que hemos proporcionado todos estos bonitos parámetros al usuario, necesitamos
ayudarle a configurar los valores correctamente. Por supuesto, la documentación de
nuestro applet debería describir cada parámetro y darle ejemplos al usuario de como
utilizarlos. Nuestro trabajo no se acaba aquí, creo. También deberíamos implementar el
método getParameterInfo para que devuelva información sobre los parámetros de
nuestro applet. Los navegadores pueden usar esta información para ayudar al usuario a
seleccionar los valores de estos parámetros de nuestro applet.
Abajo tenemos un ejemplo de implementación de un método getParameterInfo. Este
ejemplo es de un applet maravillosamente flexible que proporciona 13 parámetros para
que el usuario personalice una animación:
public String[][] getParameterInfo() {
String[][] info = {
// Parameter Name
{"imagesource",
{"startup",
{"background",
background"},
{"startimage",
{"endimage",
{"namepattern",
names"},
{"pause",
{"pauses",
{"repeat",
{"positions",
{"soundsource",
{"soundtrack",
{"sounds",
};
return info;
}
Kind of Value
"URL",
"URL",
"URL",
Description
"a directory"},
"displayed at startup"},
"displayed as
"int",
"int",
"URL",
"start index"},
"end index"},
"used to generate indexed
"int",
"ints",
"boolean",
"coordinates",
"URL",
"URL",
"URLs",
"milliseconds"},
"milliseconds"},
"repeat or not"},
"path"},
"audio directory"},
"background music"},
"audio samples"},
Como puedes ver, el método getParameterInfo debe devolver un array de tres -arrays de String. En cada array primero va el nombre del parámetro, luego una
indicación del tipo de valor que necesita el applet para ese parámetro y por último el
texto que describe el funcionamiento de ese parámetro.
o
Usar la Etiqueta APPLET
Esta sección nos cuenta todo lo que debemos saber sobre el uso de la etiqueta
<APPLET>. Empieza mostrando la forma más simple de la etiqueta. Y luego explica las
adicciones más comunes a la forma simple. La etiqueta <PARAM>, alterna código HTML
y texto, el atributo CODEBASE, y el atributo ARCHIVE. Para ver una descripción de la
etiqueta <APPLET>, puedes ir a la página La Etiqueta <APPLET>.
Ya deberíamos haber visto la forma más simple de la etiqueta <APPLET>.
<APPLET CODE=AppletSubclass.class WIDTH=anInt HEIGHT=anInt>
</APPLET>
Esta etiqueta le dice al navegador que cargue el applet cuya subclase Applet se llama
AppletSubclass, mostrándolo en un área de la anchura y altura especificada.
Especificar Parámetros
Algunos applets permiten al usuario personalizar la configuración del applet con
parámetros, como se describe en Definir y Usar Parámetros de Applet. Por ejemplo,
AppletButton (un applet usado a lo largo de este tutorial para proporcionar un botón
que trae una ventana) permite al usuario seleccionar el texto del botón especificando el
valor de un parámetro llamado BUTTONTEXT.
El usuario especifica el valor del parámetro usando una etiqueta <PARAM>. Esta etiqueta
debería aparecer justo después de la etiqueta <APPLET> para que afecte al applet.
<APPLET CODE=AppletSubclass.class WIDTH=anInt HEIGHT=anInt>
<PARAM NAME=parameter1Name VALUE=aValue>
<PARAM NAME=parameter2Name VALUE=anotherValue>
</APPLET>
Aquí hay un ejemplo de la etiqueta <PARAM>:
<APPLET CODE="Animator.class" WIDTH=460 HEIGHT=160>
<PARAM NAME="imageSource" VALUE="images/Beans">
<PARAM NAME="backgroundColor" VALUE="0xc0c0c0">
<PARAM NAME="endImage" VALUE=10>
<PARAM NAME="soundSource" VALUE="audio">
<PARAM NAME="soundtrack" VALUE="spacemusic.au">
<PARAM NAME="sounds"
VALUE="1.au|2.au|3.au|4.au|5.au|6.au|7.au|8au|9.au|0.au">
<PARAM NAME="pause" VALUE=200>
. . .
</APPLET>
Especificar Código HTML Alternativo y Texto
Observa los puntos suspensivos (". . .") en el ejemplo anterior. ¿Qué ha dejado fuera el
ejemplo? Ha omitido código HTML alternativo -- código HTML interpretado sólo por
los navegadores que no entienden la etiqueta <APPLET>. El código HTML alternativo es
cualquier texto que aparezca entre las etiquetas <APPLET> y </APPLET>, después de
cualquier etiqueta <PARAM>. Los navegadores compatibles con Java ignoran este código
HTML alternativo.
Para especificar texto alternativo a los navegadores compatibles Java y otros
navegadores que entiendan la etiqueta <APPLET>, usamos el atributo ALT. Si el
navegador no puede mostrar el applet por alguna razón, puede mostrar el texto ALT del
applet.
Aquí está el código HTML completo para el ejemplo Animator mostrado
anteriormente.
<APPLET CODE="Animator.class" WIDTH=460 HEIGHT=160
ALT="If you could run this applet, you'd see some animation">
<PARAM NAME="imageSource" VALUE="images/Beans">
<PARAM NAME="backgroundColor" VALUE="0xc0c0c0">
<PARAM NAME="endImage" VALUE=10>
<PARAM NAME="soundSource" VALUE="audio">
<PARAM NAME="soundtrack" VALUE="spacemusic.au">
<PARAM NAME="sounds"
VALUE="1.au|2.au|3.au|4.au|5.au|6.au|7.au|8au|9.au|0.au">
<PARAM NAME="pause" VALUE=200>
Your browser is completely ignoring the &lt;APPLET&gt; tag!
</APPLET>
Un applet que no entienda la etiqueta <APPLET> ignorará todo el código HTML anterior
excepto la línea que empieza con "Your". Un navegador que entienda la etiqueta
<APPLET>
ignorará todo lo de esa línea. Si el navegador no puede ejecutar el applet,
podría mostrar el texto de ALT.
Especificar el Directorio del Applet
Por defecto, un navegador busca una clase del applet y los ficheros de archivo en el
mismo directorio del fichero HTML que tiene la etiqueta <APPLET>. (Si la clase del
applet está en un paquete, entonces el navegador usa el nombre del paquete para
construir un directorio debajo del directorio del fichero HTML). Sin embargo, algunas
veces, es útil poner el applet en algún otro lugar. Podemos usar el atributo CODEBASE
para decirle al navegador en qué directorio está localizado el applet.
<APPLET CODE=AppletSubclass.class CODEBASE=aURL
WIDTH=anInt HEIGHT=anInt>
</APPLET>
Si aURL es una URL relativa, entonces se interpreta en relación a la localización del
documento HTML. Haciendo aURL una URL absoluta, podemos cargar un applet desde
casi cualquier sitio -- incluso desde otro servidor HTTP.
Este tutorial usa frecuentemente CODEBASE="someDirectory/", ya que agrupa los
ejemplos de cada lección en subdirectorios. Por ejemplo, aquí tenemos la etiqueta
<APPLET> que incluye el applet Simple en El Ciclo de Vida de un Applet.
<APPLET CODE=Simple.class CODEBASE="example/"
WIDTH=500 HEIGHT=20>
</APPLET>
La siguiente figura muestra la localización del fichero class, en relación al fichero
HTML, cuando CODEBASE se selecciona como "example/".
La siguiente figura muestra dónde podría estar la clase del applet si especificamos una
URL absoluta para el valor de CODEBASE.
Combinar ficheros de Applets en un Sólo Archivo
Si nuestro applet tiene más de un fichero, deberíamos considerar el proporcionar un sólo
archivo que empaquete los ficheros del applet en un fichero. Si los ficheros de archivo
tienen sentido o no para nuestro applet depende de varios factores, incluyendo el tamaño
del applet, consideraciones de rendimiento, y el entorno que esperamos que tengan sus
usuarios.
Los ficheros de archivo reducen el tiempo de descarga total del applet. La mayoría del
tiempo ahorrado viene de reducir el número de conexiones HTTP que el navegador
debe realizar. Cada conexión HTTP tarda varios segundos en empezar. Esto significa
que para un applet multi-fichero, el tiempo de conexión puede empeorar el tiempo de
transferencia. Además podemos reducir el tiempo de transferencia comprimiendo los
ficheros en un fichero archivo.
Si especificamos uno o más ficheros archivo, entonces el navegador busca los ficheros
archivo en el mismo directorio en el que debería buscar el fichero class del applet.
Luego el navegador busca los ficheros class del applet dentro del fichero de archivo. Si
un fichero no está en el archivo, el navegador tratará de cargarlo como si el fichero de
archivo no estuviera presente.
El formato de fichero de Archivo Java, llamado JAR, se presentó en el JDK 1.1 y se
basa en el formato de fichero ZIP. Especificamos ficheros JAR usando el atributo
ARCHIVE de la etiqueta <APPLET>. Podemos especificar varios ficheros de archivo
separándolos por comas.
<APPLET CODE="AppletSubclass.class" ARCHIVE="file1, file2"
WIDTH=anInt HEIGHT=anInt>
</APPLET>
Desafortunadamente, no todos los navegadores entienen el mismo formato de archivo, o
usan el mismo código HTML para especificar el archivo del applet. Para crear archivos
JAR puedes ver la página Ficheros JAR.
Otros Atributos de la Etiqueta <APPLET>
Esta sección no ha explicado todos los atributos de la etiqueta <APPLET>. Otros
atributos -- que podrían parecer familiares, ya que la etiqueta HTML <IMG> los usa -incluyendo ALIGN, VSPACE, y HSPACE. La etiqueta <APPLET> también nos pemite cargar
un applet serializado (grabado) especificando el atributo OBJECT en lugar de especificar
el fichero Class con CODE. Finalmente, podemos ponerle un nombre a nuestro applet con
el atributo NAME. Para una descripción detallada de la etiqueta <APPLET>, puedes ver la
página: La Etiqueta <APPLET>.
Consideraciones Prácticas para Escribir Applets
Las dos primeras secciones de este tutor explicaron todo el API específico de Applet.
Sin embargo, la mayoría de los applets tratan con muchos APIs que no son específicos
de los applets. Esta sección nos ofrece unos apuntes sobre la utilización de los API de
Java, cubriendo las áreas que afectan a la relación entre los applets y los navegadores.
Restricciones de Seguridad lista las restricciones de seguridad que tienen los applets no
firmados. También describe algunas formas de evitar estar restricciones.
Crear un Interface de Usuario explica los elementos de un interface de usuario de un
Applet. Nos ofrece información para crear un GUI y crear salida de depuración usando
los streams de salida estándar y de error.
Obtener Propiedades del Sistema explica las propiedades del sistema que un applet
puede obtener para informarse sobre su entorno. Incluye un applet de ejemplo que
muestra las diez propiedades que un applet puede obtener. También lista algunas de las
propiedades que un applet no puede leer.
Threads en Applets explica los problemas de usar threads en applets. Un thread -algunas veces llamado contexto de ejecución o un proceso de peso ligero -- es un único
flujo de control secuencial dentro de un proceso. Incluso el applet más simple, se
ejecuta en varios threads, aunque no siempre sea aparente. Muchos applets crean y usan
sus propios threads para poder ejcutarse correctamente sin afectar al rendimiento del
navegador o de otros applets.
Tabajar con una Aplicación del Lado-del-Servidor muestra cómo incluso los applets no
firmados pueden usar código de red para comunicarse con otros programas que se
ejecutan en el host desde el que vinieron.
Restricciones de Seguridad
Uno de los principales objetivos del entorno Java es hacer que los usuarios de
navegadores se sientan seguros cuando ejecutan cualquier applet. Para alcanzar este
objetivo, se ha empezado de forma conservadora restringiendo capacidades, quizás más
de las necesarias. Cuando el tiempo pase, los applets probablemente tendrán más
habilidades.
Está página nos cuenta las restricciones actuales de los applets, desde el punto de vista
de cómo afectan al diseño de applets. Frequently Asked Questions - Applet Security
Todo visualizador de applets tiene un objeto SecurityManager que chequea las
violaciones de seguridad de los applets. Cuando un SecurityManager detecta una
violación, crea y lanza un objeto SecurityException. Generalmetne, el constructor de
la SecurityException imprime un mensaje de aviso en la salida estándar. Un applet
puede capturar las SecurityExceptions y reaccionar de la forma apropiada, como
avisar al usuario y saltar a una forma "segura" (pero menos ideal) de realizar la tarea.
Algunos visualizadores de applets ocultan algunas SecurityExceptions, para que el
applet nunca obtenga la SecurityException. Por ejemplo, la implementación del
Applet Viewer del JDK de los métodos getApplet y getApplets de AppletContext
simplemente capturan e ignoran cualquier SecurityExceptions. El usuario puede ver
los mensajes de error en la salida estándar, pero el applet obtiene un resultado válido
desde los métodos. Esto tiene sentido, ya que desde getApplets debería ser posible
volver cualquier applet válido que encuentre, incluso si encuentra unos inválidos. (El
Applet Viewer considera un applet válido si fue cargado desde el mismo host que el
applet que llamó a getApplets.)
Los applets tienen las siguientes restricciones:
Los Applets no pueden cargar librerías o definir métodos nativos.
Los Applets sólo pueden usar su propio código Java y el API Java que
proporciona el visualizador. Como mínimo, todo applet debe proporcionar
acceso al API definido en los paquetes java.*.
Normalmente un applet no puede leer o escribir ficheros en el host en el que se está
ejecutando.
El AppletViewer del JDK permite algunas excepciones a esta regla especificadas
por el usuario, pero por ejemplo Netscape Navigator 2.0, no lo hace. Los applets
en cualquier visualizador pueden leer ficheros especificados con URLs
completas, en lugar de con nombres de ficheros. Un atajo para no tener que
escribir ficheros es tener un applet que re-envíe datos a una aplicación en el
servidor del que vino. Esta aplicación puede escribir los datos en ficheros de su
propio host. Puedes ver la página Trabajar con una Aplicación del Lado-delServidor para más ejemplos.
Un applet no puede hacer conexiones de red excepto con el host del que vino.
El atajo para esta restriccion es hacer que el applet funcione con una aplicación
en el host del que vino. La aplicación puede hacer sus propias conexiones a
cualquier lugar de la red. Puedes ver más ejemplos en la página Usar un
Servidor para Esquivar las Restricciones de Seguridad.
Un applet no puede arrancar ningún programa en el host en el que se está
ejecutando.
De nuevo, un applet puede trabajar con una aplicación en lado del servidor para
evitar esto.
Un applet no puede leer ciertas propiedades del sistema.
Puedes encontrar más información en la página Leer Propiedades del Sistema.
Las ventanas que muestran los applets tienen un aspecto distinto a las que
muestran las aplicaciones.
Las ventanas de los Applets tienen algún texto de aviso y una barra coloreada o
una imagen. Esto ayuda al usuario a distinguir las ventanas de los applets de
aquellas de las aplicaciones verdaderas. Las siguientes figuras muestran un
ventana traída por un programa que se puede ejecutar tanto un applet como una
aplicación. La primera figura muestra el aspecto de la ventana cuando el
programa se ejecuta como una aplicación sobre la plataforma Solaris. La
segunda imagen muestra la ventana cuando el programa se ejecuta como un
applet dentro del navegador Netscape Navigator 2.0 de Solaris.
Como puedes ver, la ventana del applet tiene un aviso.
Construir un Interface de Usuario
La mayoría de los applets tiene un entorno gráfico de usuario (GUI). Esta una
consecuencia natural del echo de que todo applet aparece dentro de una ventana de un
navegador. Como la clase Applet es una subclase de la clase Panel del AWT, y así
participa en los modelos de eventos y de dibujo del AWT, crear un GUI de applet es
casi tan sencillo como crear un GUI de una aplicación -- realmente más sencillo, ya que
la ventana del applet (la ventana del navegador) ya existe.
Además de su interface gráfico, un applet puede tener otros tipos de interfaces,
dependiendo del tipo de información que necesite o entregue. Algunos applets ejecutan
sonidos, para dar feedback al usuario o para proporcionar ambiente. Los applets pueden
obtener la información de configuración del usuario a través de los parámetros que el
applet define. Para dar información de texto al usuario, un applet puede usar su GUI,
mostrar cadenas cortas de estado (para texto no crucial) o mostrarlo en los streams de
salida o error estándar (para propósitos de depuración).
Par información sobre los sonidos, los parámetros y las cadenas de estado, puedes ver la
página Aprovecharse del API Applet. El resto de esta sección describe los siguientes
tópicos, en lo relativo a los applets:


Crear un GUI
Mostrar Diagnósticos en los Streams de Salida y Error Estándar
Usar el AWT para crear un Interface de Usuario
Esta página explica algunas cosas que son particulares a los GUIs de los Applets.
Un Applet es un Panel.
Como Applet es una subclase de la clase Panel del AWT, los applets pueden
contener otros Components, como puede hacerlo un Panel. Applet hereda de
Panel su controlador de distribución por defecto. FlowLayout. Al igual que
Panels (y sus Components), Applet participa en el árbol de eventos y dibujos
del AWT.
Los applets aparecen en ventanas de navegador pre-existentes.
Esto tiene dos implicaciones. Primero, al contrario que las aplicaciones basadas
en GUI, los applets no tienen que crear su ventana para mostrarse a sí mismos.
Pueden hacerlo, si tienen una buena razón, pero normalmente se muestran dentro
de la ventana del navegador. Segundo, dependiendo de la implementación del
navegador, los componentes del applet podrían no mostrarse a menos que el
applet llame al método validate después de añadir cada componente.
Afortunadamente, llamar a validate no puede herir a nadie.
El color de fondo del applet podría no corresponder con el color de la página.
Por defecto, los applets tienen un color de fondo gris claro. Sin embargo, las
páginas HTML, pueden tener otros colores de fondo o pueden usar patrones. Si
el diseñador del applet y el de página no son cuidadosos, el color de fondo del
applet diferente puede causar un desastre en la página o crear un parpadeo
notable cuando el applet se dibuje. Una solución es definir un parámetro que
especifique el color de fondo del applet. La subclase de Applet puede usar el
método setBackground de Component para poner el color de fondo
especificado por el usuario. Usando el parámetro del color de fondo, el
diseñador de la página puede elegir un color de fondo del applet que vaya bien
con los colores del applet.
Todo applet tiene un tamaño pre-determinado, especificado por el usuario.
Como la etiqueta <APPLET> requiere que se especifiquen la anchura y altura del
applet, y como los navegadores no necesariamente permiten que los applets se
redimensionen, éstos deben hacerse con una cantidad de espacio fija, que podría
no ser la ideal. Incluso si la cantidad de espacio es la ideal para una plataforma,
las partes epecificas de la plataforma (como los botones) podrían requerir un
espacio diferente en otra plataforma. Podemos compensar esto recomendando a
las páginas que incluyan un poco más de espacio que el necesario, y usando
distribuciones flexibles, como las clases GridBagLayout y BorderLayout
proporcionadas por el AWT, que adaptan bien el espacio extra.
Los Applets cargan imágenes usando los métodos Applet getImage.
La clase Applet proporciona una forma conveniente de getImage que nos
permite especificar una URL base como argumento, seguida por un segundo
argumento que especifica la localización del fichero, en relación a la URL base.
Los métodos Applet getCodeBase y getDocumentBase proporcionan las
URLs base para la mayoría de los usos de los applets.
Las clases Applet (y frecuentemente los ficheros de datos que utilizan) se cargan a
través de la red, lo que podría ser lento.
Los applets pueden hacer varias cosas para reducir el tiempo de arranque
percibido. La subclase Applet puede ser una clase pequeña que muestre
inmediatamente un mensaje de estado. Si algunas clases de applets o datos no se
usan de la forma correcta, el applet puede precargar las clases o los datos en un
thread de segundo plano.
Mostrás Diagnósticos por los Streams de Salida Estándar y de
Error
Mostrar diagnósticos por la salida estándar puede ser una herramienta de mucho valor
cuando estamos depurando un applet. Otras veces que veremos mensajes en la salida
estándar será cuando ocurra un excepción no capturada en el applet. Los applets
también tiene la opción de usar el stream de error estándar.
Dónde se muestran las salidas estándar y de error varia, dependiendo de cómo esté
implementado el visualizador de applets, la plataforma en la que se esté ejecutando, y
(algunas veces) cómo arrancamos el navegador o visualizador. Por ejemplo, cuando
lanzamos el ApplerViewer en una ventana Shell de UNIX, los strings mostrados en la
salida estándar y de error aparecen en esa ventana shell, a menos que re-dirijamos la
salida. Cuando llamamos el AppletViewer desde un menú X-windows, la salida
estándar y de error van a la ventana de consola. Por otro lado, Netscape Navigator 2.0,
siempre muestra la salida estándar y de error en la Consola Java, que está disponible
desde el menú "Opciones".
Lso applets muestran el stream de salida estándar usando System.out.print(String)
y System.out.println(String). Mostrar la salida en el stream de error es similar,
excepto que especificamos System.err en lugar de System.out. Aquí tenemos un
ejemplo:
//Where instance variables are declared:
boolean DEBUG = true;
. . .
//Later, when we want to print some status:
if (DEBUG) {
System.out.println("Called someMethod(" + x + "," + y + ")");
}
Nota:
Mostrar texto por los streams de salida y de error estándar es relativamente lento. Si
tenemos problemas relacionados con el tiempo, imprimir mensajes en cualquiera de
estos streams podría no ser muy útil.
Debemos asegurarnos de desactivar toda la salida de depurado antes de liberar nuestro
applet.
Obtener Propiedades del Sistema
Para encontrar algo sobre el entorno de trabajo actual, los applets pueden leer
propiedades del sistema. Las propiedades de sistema son parejas clave/valor que
contienen información sobre el sistema operativo bajo el que el applet se está
ejecutando.
Los applets pueden leer algunas, pero no todas, las propiedades de sistemas. Esta página
lista las propiedades del sistema que Netscape Navigator 2.0 y el Applet Viewer
permiten leer, seguido por una lista propiedades que los applets no pueden leer.
Propiedades de Sistema que los Applets Pueden Leer
Los applets pueden leer las siguientes propiedades del sistema:
Clave
Significado
"file.separator"
Separador de fichero (por ejemplo, "/")
"java.class.version"
Número de versión de la clase Java
"java.vendor"
Strings Específico del Vendedor de Java
"java.vendor.url"
URL del Vendedor de Java
"java.version"
Número de Versión de Java
"line.separator"
Separador de Líneas
"os.arch"
Arquitectura del Sistema Operativo
"os.name"
Nombre del Sistema Operativo
"path.separator"
Separador de Path (por ejmplo, ":")
Para leer una propiedad del sistema desde dentro de un applet, usamos el método
getProperty de la clase System. Por ejemplo:
String newline = System.getProperty("line.separator");
El siguiente applet lee todas las propiedades que están disponibles para los applets:
Pulsa sobre la imagen para ejecutar el applet...
Podemos encontrar el código fuente (que es el mismo tanto para 1.0 como para 1.1) en:
GetOpenProperties.java.
Propiedades del Sistema Prohibidas
Por razones de seguridad, los navegadores o los visualizadores de applets no permiten
que los applets lean las siguientes propiedades:
Clave
Significado
"java.class.path"
CLASSPATH de Java
"java.home"
Directorio de la Instalación de Java
"user.dir"
Directorio de trabajo actual del usuario
"user.home"
Directorio Home del usuario
"user.name"
Nombre de Cuenta del usuario
Threads en Applets
Todo applet se puede ejecutar en varios threads. Los métodos de dibujo del applet
(paint y update) siempre son llamados desde el thread de dibujo y manejo de eventos
del AWT. Los threads de los métodos de eventos principales -- init, start, stop, y
destroy -- son llamados desdes la aplicación en la que se está ejecutando el applet.
Pero la aplicación no los llama desde el thread de dibujo y manejo de eventos del AWT.
Muchos navegadores asignan un thread por cada applet que hay en la página, usando
este thread para todas las llamadas a los métodos de eventos principales del applet.
Algunos navegadores asignan un grupo de threads para cada applet, para que sea más
sencillo matar a todos lo threads que pertenecen a un applet en particular. En cualquier
caso, no está garantizado que cada thread que crea alguno de los métodos de eventos
principales del applet pertenezca al mismo grupo de threads.
En la página de ejemplo hay dos applets PrintThread. PrintThread es una versión
modificada de SimpleApplet que imprime el thread y el grupo de threads desde los que
son llamados sus métodos init, start, stop, destroy, y update. (Realmente, debido
a un bug en Netscape Navigator 2.0 para Windows 95/NT, los applet no implementan
update. Si no estás usando un PC que esté ejecutando Netscape Navigator 2.0, deberías
poder ejecutar el ejemplo real.) Aquí está el código recortado, y para el ejemplo
más interesante. Como es habitual, para ver la salida de los métodos como destroy
que son llamados durante la descarga, necesitamos mirar la salida estándar. Puedes ver
la página Mostrar Diagnósiticos en los Streams de Salida y Error Estándars para obtener
más información sobre ellos.
Pulsa sobre la imagen para ejecutar el applet...
Nota:
Como algunos viejos navegadores no soportan 1.1, el applet anterior es una versión 1.0
(aquí está el código 1.0; y aquí está el código 1.1). Para ejecutar la versión 1.1 del applet
puedes ir a la página example-1dot1/PrintThread.html.
Entonces, ¿por qué necesitaría un applet crear y usar sus propios threads? Imagina un
applet que realiza alguna inicialización que consume mucho tiempo -- cargar imágenes,
por ejemplo -- en su método init. El thread que llama a init no puede hacer nada
hasta que init retorne. En algunos navegadores, esto podría significar que no se pueda
mostrar el applet ni nada hasta que él haya finalizado su propia incialización. Entonces
si el applet está en la parte superior de la página, por ejemplo, no aparecerá nada en la
página hasta el applet haya terminado de inicializarse.
Incluso en navegadores que crean un thread separado para cada applet, tiene sentido
poner cualquier tarea que consuma tiempo dentro de un thread creado por el applet, para
que el applet pueda realizar otras tareas mientras espera que las tareas que consumen
mucho tiempo se completen.
Regla del Pulgar:
Si un applet realiza una tarea que consume mucho tiempo, debería crear y usar su
propio thread para realizar esa tarea
Normalmente los applets realizan dos tipos de tareas que consumen mucho tiempo. Las
tareas que se realizan una sóla vez y las tareas que se realizan repetidamente. La página
siguiente nos ofrece ejemplos de ambas.
Threads en Applets: Ejemplo
Esta página no explica el código básico de los threads. Para aprender sobre la
implementación de threads Java puedes ir al tutorial Threads en Java: Hacer Dos o Más
Cosas a la Vez.
Usar un Thread para Realizar Tareas Repetitivas
Un applet que realiza la misma tarea una y otra vez normalmente debería tener un
thread con un bucle while (o do...while) que realice la tarea. Un ejemplo típico es un
applet que realiza animación, como un juego. Los applets de animación necesitan
repintarse a intervalos regulares. Otro ejemplo es un applet que lee datos suministrados
por una aplicación del lado del servidor. (Puedes ver ejemplos en la página Usar un
Servidor para Evitar las Restricciones de Seguridad).
Normalmente se crean los threads para tareas repetitivas en el método start del Applet.
Crearlos aquí hace más sencillo que el applet pare el thread cuando el usuario abandona
la página. Todo lo que necesitamos hacer es implementar el método stop para que pare
el thread del applet. Cuando un usuario retorna a la página del applet, se llama de nuevo
al método start, y el applet puede crear otra vez su thread para realizar la tarea
repetitiva.
Abajo está la implementación de los métodos start y stop que hace el applet
AnimatorApplet. (Aquí está el código fuente completo).
public void start() {
if (frozen) {
//Do nothing. The user has requested that we
//stop changing the image.
} else {
//Start animating!
if (animatorThread == null) {
animatorThread = new Thread(this);
}
animatorThread.start();
}
}
public void stop() {
animatorThread = null;
}
El this de new Thread(this) indica que el applet proporciona el cuerpo del thread.
Hace esto implementando el interface java.lang Runnable, que requiere que el applet
proporcione un método run que realiza el cuerpo del thread. Explicaremos el método
run de AnimatorApplet un poco más tarde.
Observa que en ningún lugar de la clase AnimatorApplet se llama al método Thread
stop. Esto es porque llamar a este método es como lanzar el thread por encima de
nuestra cabeza. Es una forma drástica de hacer que un thread pare lo que está haciendo.
En su lugar, podemos escribir el método run del thread para que el thread salga
cuidadosamente cuando lo queramos eliminar. Esta eliminación viene en la forma de
seleccionar a null un ejemplar de variable del tipo Thread.
En AnimatorApplet, este ejemplar se llama animatorThread. El método start lo
selecciona para referirse al objeto Thread recien creado. Cuando el applet necesita
eliminar el thread, selecciona animatorThread a null. Esto elimina el thread no
marcándolo para el recolector de basura, puede ser recolectado mientras es ejecutable -sino que al inicio del bucle el thread comprueba animatorThread, continuando o
saliendo dependiendo del valor de animatorThread. Aquí está el código relevante:
public void run() {
. . .
while (Thread.currentThread() == animatorThread) {
...//Display a frame of animation and then sleep.
}
}
Si animatorThread se refiere al mismo thread que está en ejecución actualmente, el
thread continua ejecutándose. Si, por otro lado, animatorThread es null, el thread sale.
Si animatorThread se refiere a otro thread, entonces ocurre una condición de
competición. start ha sido llamado tan pronto después de stop (o este thread a tardado
mucho tiempo en terminar su bucle) que start ha creado otro thread antes de que éste
haya llegado al bucle while. Cualquiera que sea la causa de la condición de
competición, este thread debe salir.
Usar un Thread para Realizar Inicializaciones de un Sóla Vez
Si nuestro applet necesita realizar alguna tarea de inicialización que puede tardar
mucho, deberíamos considerar la implementación de la inicialización en un thread. Por
ejemplo, cualquier cosa que requiera hacer conexiones de red se debería hacer
generalmente en un thread de segundo plano. Afortunadamente, la carga de imágenes
GIF y JPEG se hace automáticamente en segundo plano usando threads de los que no
tenemos que preocuparnos.
Pero desafortunadamente, la carga de sonidos no está garantizada que se haga en
segundo plano. En las implementaciones actuales, los métodos Applet getAudioClip
no retornan hasta que han cargado los datos de audio. Como resultado, si queremos
precargar sonidos, podríamos querer crear uno o más threads para hacerlo.
Usar un thread para realizar una inicialización de una sola vez para un appelt es una
variante del clásico escenario productor/consumidor. El thread que realiza la tarea es el
productor, y el applet es el consumidor.
El ejemplo SoundExample crea tres clases:



El productor SoundLoader, una subclase de Thread.
El consumidor SoundExample, una subclase de Applet.
El objeto alamcen SoundList, una subclase de Hashtable.
Para más información sobre SoundExample, puedes ir a la página Ejecutar Sonidos.
Trabajar con Aplicaciones del Lado del Servidor
Los Applets, al igual que otros programas Java, pueden utilizar el API definido en el
paquete java.net para comunicarse a través de la red. La única diferencia es que, por
razones de seguridad, el único host con el que se puede comunicar el applet es con su
host de origen.
Nota:
Dependiendo del entorno de red, un applet se carga en, y depende del navegador en el
que se está ejecutando, un applet podría no ser capaz de comunicarse con su host de
origen. Por ejemplo, los navegadores que se ejecutan sobre host dentro de firewalls
frecuentemente no pueden obtener mucha información del mundo fuera del firewall.
Como resultado, algunos navegadores podrían no permitir que el applet se comunique
con un host fuera del firewall.
Es fácil encontrar desde qué host vino un applet. Usando el método Applet
getCodeBase y el método java.net.URL getHost, de esta forma:
String host = getCodeBase().getHost();
Una vez que tenemos el nombre del host correcto, podemos usar todo el código de red
que se documenta en el tutorial Trabajo en Red.
Nota:
No todos los navegadores soportan todo el código de red. Por ejemplo, una amplia
variedad de navegadores compatibles con Java no soportan postear a una URL.
Un Sencillo Applet Cliente de Red
Aquí hay un ejemplo de implementación de un applet que es un cliente de red.
Usar un Servidor para Evitar las Restricciones de Seguridad
Aquí hay un ejemplo de implemetación de un servidor para evitar las restricciones de
seguridad de los applets.
Un Sencillo Applet Cliente de una Red
Aquí está el código fuente de un applet cliente de red. El cliente se ha modificado para
comunicarse con el host del que vino el applet y para tener un bucle para poder obtener
tantas citas como querramos. Podemos ejecutar el applet incluyéndolo en una página
con el siguiente código HTML:
<APPLET CODE=QuoteClientApplet.class WIDTH=500 HEIGHT=100>
</APPLET>
Aquí hay un enlace a una página que contiene el código HTML anterior. Salvando esta
página a un fichero en nuestro servidor local HTTP, podemos usarla para comunicarnos
con la aplicación del lado del servidor que se está ejecutando en el servidor HTTP.
También debemos tener la forma compilada del applet en el mismo directorio.
Antes de que el applet pueda obtener citas, necesitamos ejecutar el servidor en el host
del que viene el applet. Entonces necesitamos apuntar el número de puerto por el que el
servidor está escuchando. Despúes introducimos este número de puerto en el applet, éste
se comunicará con el servidor y podrá obtener citas de una línea. Abajo tenemos las
instrucciones detalladas, seguidas por una imagen del applet en acción:
1. Compilamos QuoteServer.java y QuoteServerThread.java. Aquí hay un
fichero de texto (one-liners.txt) que debería estar en el mismo directorio que los
ficheros class resultantes.
2. En el ordenador que sirve el fichero class del applet (a través de HTTP),
llamamos al intérprete Java sobre la clase QuoteServer. Por ejemplo, si estámos
viendo la página del applet con la URL http://mymachine/quoteApplet.html,
necesitamos ejecutar el servidor en el host llamado mymachine.
3. Registrar el número de puerto que muestra el servidor de citas.
4. Introducir este número en el campo de texto del applet.
5. Pulsar el botón Send para pedirle una cita al servidor. Ahora deberíamos ver
aparecer una cita en el área de texto del applet.
Aquí tenemos una imagen del applet en acción:
Utilizar un Servidor para Evitar las Restricciones de Seguridad
Como explica la sección Restricciones de Seguridad, los applets están sujetos a
demasiadas restricciones de seguridad. Por ejemplo, no pueden realizar I/O de ficheros,
no pueden hacer conexiones de red, excepto con su host original, y no pueden arrancar
programas.
Una forma de evitar estas restricciones es usar una aplicación de servidor que se ejecute
en el host del applet. El servidor no podrá evitar todas las restricciones del applet, pero
puede hacer posibles algunas cosas más. Por ejemplo, un servidor no podrá grabar
ficheros en el host en el que se está ejecutando el applet, pero si podrá grabarlos en el
host del que el applet es originario.
Esta página crea un ejemplo de un servidor que permite a dos applets comunicarse. Los
applets no tienen que estar ejecutándose en la misma página, ni el mismo navegador, ni
incluso en el mismo ordenador. Mientras que los applets sean originarios del mismo
ordenador, se pueden comunicar a través del servidor que se está ejecutando en el
ordenador originador. Los ejemplos usan sockets, que están documentados en Todo
Sobre los Sockets.
Aquí están los ficheros fuente:
TalkClientApplet.java
El fichero fuente para los applets clientes. (ambos applets son ejemplares de la
misma clase; aquí estña la versión 1.0.) Después de compilarlo podremos
ejecutarlo incluyendolo en una página HTML con esta etiqueta
<APPLET CODE=TalkClientApplet.class WIDTH=550 HEIGHT=200>
</applet>
Aquí hay un enlace a una página que incluye el código HTML anterior. Después
de grabar está página en nuestro servidor HTTP local, podemos usarlo para
comunicarnos con el servidor.
TalkServer.java
y TalkServerThread.java
Los ficheros fuente para el servidor (las versiones 1.0 de estos ficheros están en
example/TalkServer.java y example/TalkServerThread.java. Después de
compilar los dos ficheros, podemos ejecutar el servidor en el host que servirá los
applets llamando al intérprete Java sobre la clase TalkServer.
Las instrucciones para ejecutar el servidor son las mismas que para el ejemplo anterior.
Ejecutamos el servidor sobre el host que servirá los applet, anotando el número de
puerto al que los applets debe dirigirse. Luego inicializamos ambos applets (que pueden
estár ejecutándose en diferentes máquinas) para que hablen por el número de puerto del
servidor. Después de que se haya completado la inicialización, tecleamos algo en cada
applet y pulsamos Return para enviar el mensaje al otro applet.
Aquí está el servidor en acción:
www% java TalkServer
TalkServer listening on rendezvous port: 36567
Aquí tenemos dos imágenes de los applets en acción:
o
Finalizar un Applet
Antes de Liberar Nuestro Applet
No debemos liberar nuestro applet antes de asegurarnos de que cumple las reglas de esta
página
El Applet Pefectamente Finalizado
Antes de Liberar Nuestro Applet cubre las cosas aburridas y altamente visibles que un
applet no debería hacer. Está página lista unas pocas cosas más que un applet
perfectamente finalizado si debería hacer.
Antes de Desplegar un Applet
Stop!
antes de permitir que todo el mundo conozca nuestro applet, debemos responder si a las
siguientes preguntas:
1. ¿Hemos elimiando o desactivado todas las salidas de depuración?
Las salidas de depuración (generalmente creadas con System.out.println),
son útiles para nosotros pero pueden resultar confusas para los usuarios. Si
necesitamos dar feedback textual al usuario, podemos hacerlo en el área de
display del applet o en el área de estado de la parte inferior de la ventana. La
información sobre el área de estado está en Mostrar Cadenas Cortas de Estado.
2. ¿Se para el Applet cuando sale de la pantalla?
La mayoría de los applets no deberían usar recursos de CPU cuando el
navegador está minimizado o mostrando otra página que no contiene el applet.
Si nuestro applet no lanza ningún thread explícitamente, entonces está bien.
Si nuestro applet lanza algún thread, a menos que tengamos una muy buena
excusa para no hacerlo, deberíamos implementar el método stop para que pare y
destruya (seleccionándolos a null) los threads que hayamos lanzado. Para ver un
ejemplo de implementación de este método, puedes ver Threads en Applets:
Ejemplos.
3. Si el applet hace algo que podría ser aburrido (u odioso) -- ejecutar sonidos
o animaciones, por ejemplo -- ¿Tiene el usuario alguna forma de parar
dichos comportamientos?
Debemos cuidar de nuestros usuarios. Démosles una forma de parar el applet,
sin dejar la página. En un applet que de otra forma no respondería a las
pulsaciones del ratón, podemos hacer esto implementando el método mouseDown
para hacer que una pulsación del ratón suspenda o re-arranque el thread odioso.
Por ejemplo:
boolean frozen = false; //an instance variable
public boolean mouseDown(Event e, int x, int y) {
if (frozen) {
frozen = false;
start();
} else {
frozen = true;
stop();
}
return true;
}
El Applet Perfectamente Finalizado
Esta página nos cuenta otras formas de hacer el trato con nuestros applets lo más
placentero posible.
Debemos hacer nuestros applets tan flexibles como sea posible.
Podemos definir parámetros que permitan que el applet se pueda ejecutar en
distintas situaciones sin tener que reescribirlo. Para más información puedes ver
Definir y Usar Parámetros de Applet.
Implementar el método getParameterInfo.
Implementar este método ahora podría hacer nuestro applet más fácil de
personalizar en el futuro. Actualmente ningún navegador usa este método. Sin
embargo, esperamos que pronto los navegadores usen este método para ayudar a
generar el GUI que permita al usuario seleccionar interactivamente los valores
de los parámetros. Para ver cómo se implementa el método getParameterInfo
puedes ver la página Dar Información sobre los Parámetros.
Implementar el método getAppletInfo.
Este método devuelve un texto corto que describe el applet. Aunque ningún
navegador usa actualmente este método, esperamos que lo hagan en el futuro.
Aquí tenemos un ejemplo de implementación de getAppletInfo.
public String getAppletInfo() {
return "GetApplets by Kathy Walrath";
}
Problemas con los Appelts (y sus Soluciones)
Esta sección cubre algunos de los problema más comunes que podríamos encontrar
cuando escribimos applets Java. Después de cada problema hay una lista de posibles
soluciones.
El AppletViewer dice que no hay una etiqueta <APPLET> en la página
HTML, pero si que existe.

Chequea si tienes una etiqueta de cierre del applet. </APPLET>.
He recompilado mi Applet, pero el navegador no muestra la nueva
versión, incluso aunque le digo que la recargue.


En muchos visualizadores de applets (incluyendo los navegadores) la recarga no
es posible. Esto es por lo que recomendamos que sólo uses el AppletViewer del
JDK llamándolo cada vez que modifiques el applet.
Si obtienes una vieja versión del applet, hagas lo que hagas, asegúrate de que no
tienes una vieja copia del applet en un directorio dentro del CLASSPATH.
El color gris claro del fondo de mi applet hace que parpadee
cuando se dibuja en una página de diferente color.

Necesitas seleccionar un color de fondo para que el applet funcione bien con el
color de la página: Puedes ver más detalles en la página Usar el AWT para Crear
un GUI.
El método getImage de Applet no funciona.

Asegurate de llamar a getImage desde el método init o desde un método
llamado después de init. El método getImage no funciona cuando se le llama
desde un constructor.
Ahora que he copiado el fichero class del applet en mi servidor
HTTP, el applet no funciona




¿Define tu applet más de una clase? Si es así asegurate de que los ficheros class
de cada clase están en el servidor HTTP. Inlcuso si todas las clases están
definidas en un sólo fichero fuente, el compilador produce un fichero class por
cada clase.
¿Has copiado todos los ficheros de datos para tu applet -- ficheros de imágenes y
sonidos, por ejemplo -- al servidor?
Asegurate de los ficheros de clases y los ficheros de datos pueden ser leídos por
todo el mundo.
Asegurate de que los ficheros de clases del applet y los ficheros de datos no se
corrompieron durante la transferencia. Una fuente común de problemas es usar
el modo ASCII del FTP (en vez del modo BINARY) para transferir ficheros.
No puedo hacer que mi applet funcione. El navegador muestra una
ClassCastException.

Si tu applet tiene varias clases, ¿has especifiado la clase correcta (una subclase
de Applet) en el atributo CODE de la etiqueta APPLET?