Applets Java

Applets Java
Autor: Daniel Rodríguez Herrera
Introducción
o Appletviewer
o Programación orientada a eventos
Introducción
ES NECESARIO SABER JAVA
Un applet es una pequeña aplicación accesible en un servidor Internet, que se transporta por la red, se instala
automáticamente y se ejecuta in situ como parte de un documento web (definición de Patrick Naughton). Dado
que Java es multiplataforma y los applets son soportados por ambos navegadores, su uso se ha popularizado
bastante.
Los applets tienen, sin embargo, un problema que impide que se utilicen más habitualmente. Este problema
consiste en que, al igual que sucede con las imágenes, cuando colocamos un applet en una página web
debemos definir un rectángulo de un tamaño determinado donde permanecerá el mismo, no pudiendo actuar
fuera de sus márgenes.
Appletviewer
Podemos utilizar un navegador web como Explorer, Netscape o HotJava para ver nuestros applets,
especialmente cuando los queremos incluir dentro de una página web ya construida. Sin embargo, mientras
programemos el applet, será recomendable utilizar el programa que viene incluido en el JDK para probarlos.
El appletviewer (nombre francamente explicativo) recibe como parámetro una página HTML y nos muestra el
applet incluido en la misma en acción.
Para utilizarlo, por lo tanto, debemos saber como incluir applets en una página HTML. El applet que
desarrollaremos en el siguiente capítulo utiliza el siguiente código:
AdiosMundo.html
<HTML>
<BODY>
<APPLET CODE="AdiosMundo.class" WIDTH="200"
HEIGHT="70">
</APPLET>
</BODY>
</HTML>
Aparte de las etiquetas que marcan el comienzo y el fin del documento HTML y del cuerpo del mismo vemos
la etiqueta APPLET, que es la encargada de llamar a estas pequeñas aplicaciones. Vemos que el
parámetro CODE define la clase resultante de compilar el applet y que los parámetros WIDTH y
HEIGHT definen el tamaño del rectángulo donde se va a meter el mismo.
Si guardamos el archivo anterior como AdiosMundo.html, para ver el applet deberíamos ejecutar:
appletviewer AdiosMundo.html
Programación orientada a eventos
Si ya conoces Java, sin duda sabes de qué va eso de programación orientada a objetos. Sin embargo, y partir
de ahora, deberemos comprender también en qué consiste el paradigma de programación orientada a
eventos, pues la programación de applets responde también a dicho paradigma.
Cuando creamos un programa tradicional, de esos que se ejecutan desde la línea de comandos, el programa
asume que es lo único que se está ejecutando y que no tiene porqué interactuar con un entorno más grande.
De modo que empieza a ejecutarse y termina, pudiendo ver el programador el hilo de ejecución que va a
seguir sin ningún problema. En el caso particular de Java, la aplicació n comienza cuando empieza el código
del método main y termina cuando llegamos al final de dicho método.
En cambio, si situamos un programa dentro de un entorno mayor, como puede ser una página web o un
entorno multitarea como Windows o X-Windows lo que sucede es que el que se encarga de ejecutar las
aplicaciones es dicho entorno. Y dado que son entornos donde pasan más cosas que la ejecución de nuestro
programa, es necesario que éste no se ejecute de principio a fin, chupando toda la capacidad de proceso de
ordenador.
Es entonces cuando entra en cancha este paradigma. La aplicación no se ejecuta de principio a fin, sino que
lo hace en respuesta a mensajes que le manda el entorno en el que se ejecuta. Estos mensajes se envían
cuando suceden eventos que el entorno piensa que afectan a la aplicación. Por ejemplo, cuando el ratón pasa
por encima de la misma, cuando hay que redibujarla porque hemos cerrado una ventana que tenía encima,
etc..
Los applets funcionan de esa manera. Disponen de muchos métodos que podemos sobreescribir y que se
ejecutan al crearse el applet, al dejar de estar visible, cuando vuelve a estarlo, cuando el ratón pasa por
encima suyo, cuando hay que redibujarlo, etc..
Nuestro primer applet
Nuestro primer applet
Vamos a crear nuestro primer applet, casi equivalente al típico "Hola, mundo" de toda la vida:
AdiosMundo.java
/**
* Applet AdiosMundo
*
* <APPLET CODE="AdiosMundo.class" WIDTH="200"
HEIGHT="70"></APPLET>
*/
import java.applet.Applet;
import java.awt.*;
public class AdiosMundo extends Applet {

public void paint(Graphics g) {
g.drawString("Adios, mundo cruel",20,20);
}
}
Lo grabamos cono AdiosMundo.java y ejecutamos el appletviewer con el siguiente

comando:
appletviewer AdiosMundo.java
Esto parece contradecirse con lo explicado en el tema anterior. ¿No teníamos que llamar a una página HTML
que tuviera la etiqueta APPLET correspondiente? Bueno, sí. Lo que sucede es que appletviewer ignora
cualquier cosa que no sea una etiqueta APPLET, de modo que podemos incluirla en un comentario en
nuestro código fuente y así nos ahorramos tener que escribir una página HTML por cada ejemplo que
veamos. Vamos ahora a examinar el código paso a paso:
import java.awt.*;
En todos nuestro applets deberemos, como mínimo, incluir estas dos sentencias de importación. En la primera
importamos la clase Applet, de la cual derivaremos nuestros applets. La segunda permite importar las
clases de la librería AWT, que nos permitirán dibujar en el rectángulo asignado al applet.
public class AdiosMundo extends Applet {

}
Nuestros applet siempre van a ser clases derivadas de Applet, pues en esta clase y en sus clases padre
se definen los métodos que deberemos sobreescribir para que nuestros applets respondan a los eventos
generados desde el navegador.

}
Este es el método que debemos sobreescribir para dibujar en el rectángulo asignado a nuestro applet. Recibe
un parámetro que es una referencia a una instancia de tipo Graphics. Esta clase permite definir lo que
se suele denominar lienzo (o Canvas). El lienzo es precisamente ese rectángulo del que estamos hablando
todo el rato.

La clase Graphics dispone de muchos métodos para dibujar en el lienzo. Éste, concretamente, nos permite
dibujar un texto en la posición que queramos. En este caso el texto se pintará 20 pixels a la derecha del borde
izquierdo de la pantalla y otros 20 más abajo del borde de arriba.
Ciclo de vida de un applet
Ciclo de vida de un applet
Como hemos visto, un applet se ejecuta en una página web y ese entorno en el que está va a determinar el
ciclo de vida del mismo. La clase Applet dispone de varios métodos sin código dentro a los que llama en
diversas fases de su ciclo de vida (al crearse el applet, al redibujarse, al destruirse...). Si deseamos que
nuestro applet haga cosas especiales en esos momentos deberemos sobreescribir esos métodos. Son éstos:
void init()
Este método se llama al crearse el applet y sólo se ejecuta esa vez. Se suele utilizar para inicializar
variables globales.
void start()
Se llama cuando hay que activar el applet. Esto sucede cuando el applet se ve en la pantalla. Se
suele utilizar para comenzar las actividades de applet, ya que en general éste debe estar visible en la
pantalla para poder realizar su función.
void stop()
Es el inverso del anterior. Es llamado cuando el applet deja de estar visible. Se suele utilizar para
interrumpir las actividades activadas en start().
void destroy()
Método llamado al destruirse el applet. Normalmente no se suele sobreescribir, ya que la destrucción
del applet conlleva la destrucción de todo lo que se ha creado en él. Puede ser útil para mostrar una
ventana de confirmación que pregunte al usuario si de verdad debe cargárselo.
void repaint()
Este método no debería ser sobrecargado y es llamado cuando se necesita redibujar el applet.
Podemos llamarlo nosotros desde nuestro código. Llama a update(Graphics).
void update(Graphics)
Llamado por repaint() cuando se necesita actualizar el applet. Su implementación borra el
rectángulo y llama a paint() para volver a pintarlo.
void paint(Graphics)
Método en el que se dibuja el applet y el cual deberemos sobreescribir para poder dibujar lo que
nosotros deseemos..
void print(Graphics)
Equivalente a paint() pero es llamado cuando se va a imprimir el contenido del applet.
El siguiente ejemplo conviene observarlo desde un navegador e ir viendo los distintos mensajes que nos
muestra el applet, para comprender cuando son llamados los métodos:
CicloDeVida.java
/**
* Applet CicloDeVida
*
* <APPLET CODE="CicloDeVida.class" WIDTH="100" HEIGHT="400"></APPLET>
*/
import java.awt.Graphics;
public class CicloDeVida extends Applet {

String mensajes;
public void init() {
mensajes = "Inicializando. ";
}
public void start() {
escribirMensaje("Método start. ");
}
public void stop() {
escribirMensaje("Método stop. ");
}
public void destroy() {
escribirMensaje("Destruyendo Applet. ");
}
void escribirMensaje(String nuevoMensaje) {
mensajes += nuevoMensaje;
repaint();
}
g.drawString(mensajes, 5, 15);
}
}
Etiqueta APPLET
o Paso de parámetros
Etiqueta APPLET
La etiqueta APPLET presenta varios parámetros, de los cuales sólo es obligatorio poner los ya
comentados CODE, WIDTH y HEIGHT. Son los siguientes:
CODE
Nombre completo (incluyendo extensión) del fichero que contiene el applet.
WIDTH
Anchura del rectángulo donde se ejecutará el applet.
HEIGHT
Altura del rectángulo donde se ejecutará el applet.
CODEBASE
Dirección donde está el fichero .class que contiene al applet. Es necesario ponerlo cuando el applet
se encuentra en un directorio distinto al de la página desde la que se le llama, ya que CODE no
puede contener directorios, sólo el nombre del fichero.
ALT
Algunos navegadores comprenden la etiqueta APPLET pero no pueden mostrar applets. Esto es
debido a no tener instalada la máquina virtual Java o a que son navegadores en modo texto. En ese
caso mostrarán el contenido de este parámetro en lugar del applet.
Hay alguno más, pero de poca importancia.
Paso de parámetros
Entre <APPLET> y </APPLET> podremos colocar etiquetas PARAM que nos permitirán pasar
parámetros al applet. Tienen dos atributos:
VALUE
Nombre del parámetro.
NAME
Valor del parámetro.
Podemos obtener esos valores por medio del método getParameter(String), como vemos
en el siguiente ejemplo:
MostrarMensaje.java
/**
* Applet MostrarMensaje
*
* <APPLET CODE="MostrarMensaje.class" WIDTH="200"
HEIGHT="70">
* <PARAM NAME="Mensaje" VALUE="Mi mensaje propio">
* </APPLET>
*/
import java.awt.*;
public class MostrarMensaje extends Applet {

String mensaje;
mensaje = getParameter("Mensaje");
}
g.drawString(mensaje,20,20);
}
}
Hay que destacar que Java no distingue entre mayúsculas y minúsculas en cuanto al nombre de los
parámetros.
En muchos casos, el usuario puede que no incluya parámetros que consideramos necesarios o que escriba
mal el nombre de un parámetro. En ese caso, la llamada a getParameter() nos devolverá
null. Debemos tener cuidado con esto, ya que nos pueden saltar excepciones por esta clase de cosas.
Así pues, el código correcto de init() será:

mensaje = getParameter("Mensaje");
if (mensaje==null)
mensaje = "Mensaje por defecto";
}
De este modo, si nos equivocamos en la etiqueta PARAM, nos mostrará un mensaje y no lanzará ninguna
excepción.
Clase Graphics
o Métodos de dibujo
o Clase Color
o Manejo de imágenes
Clase Graphics
La clase Graphics dispone de más métodos aparte de drawString, que nos permitirán dibujar figuras
e imágenes.
Métodos de dibujo
Mientras no se especifique, consideraremos que todos los parámetros son enteros:

drawString(String texto,x,y)
Escribe un texto a partir de las coordenadas (x,y).
drawLine(x1,y1,x2,y2)
Dibuja una línea entre las coordenadas (x1,y1) y (x2,y2).
drawRect(x,y,ancho,alto)
fillRect(x,y,ancho,alto)
clearRect(x,y,ancho.alto)
Son tres métodos encargados de dibujar, rellenar y limpiar, respectivamente, un rectángulo cuya
esquina superior izquierda está en las coordenadas (x,y) y tienen el ancho y alto especificados.
drawRoundRect(x,y,ancho,alto,anchoArco,altoArco)
fillRoundRect(x,y,ancho,alto,anchoArco,altoArco)
Equivalentes a los anteriores, pero con las esquinas redondeadas. La forma y tamaño de dichas
esquinas viene dada por los dos últimos parámetros.
draw3DRect(x,y,ancho,alto,boolean elevado)
fill3DRect(x,y,ancho,alto,boolean elevado)
Equivalentes a los primeros, pero dibujan un borde para dar la sensación de que está elevado o
hundido (dependiendo del valor del último parámetro).
drawOval(x,y,ancho,alto)
fillOval(x,y,ancho,alto)
Dibujan una elipse con esquina izquierda superior en (x,y) y el ancho y alto especificados. Si son
iguales dibujará un círculo.
drawArc(x,y,ancho,alto,anguloInicio,anguloArco)
fillArc(x,y,ancho,alto,anguloInicio,anguloArco)
Dibuja una arco cuyo primer vértice está en (x,y) y el segundo en (x+ancho,y+alto). La forma del
mismo vendrá dado por los dos últimos parámetros.
drawPolygon(int[] coordenadasX,int[] coordenadasY,numCoordenadas)
fillPolygon(int[] coordenadasX,int[] coordenadasY,numCoordenadas)
Dibuja un polígono cerrado del número de puntos especificado en el último parámetro.
copyArea(xOrigen,yOrigen,ancho,alto,xDest,yDest)
Copia el área cuya esquina superior izquierda está en (xOrigen,yOrigen) y de ancho y alto
especificados a la zona que comienza en (xDest, yDest).
Por ejemplo, podemos dibujar lo siguiente:
Figurines.java
/**
* Applet Figurines
*
* <APPLET CODE="Figurines.class" WIDTH="200"
*/
import java.awt.*;
public class Figurines extends Applet {

g.fillRoundRect(10,30,50,20,10,10);
g.draw3DRect(100,30,50,20,true);
}
}
Clase Color
Ahora ya sabemos como dibujar, sin embargo todo nos sale en un aburrido blanco y negro... Graphics
almacena internamente el color con el que pinta todo, que por defecto es negro. Para poder cambiar dicho
color deberemos utilizar el método setColor(), que recibe un único parámetro de tipo Color.
La clase Color dispone de varias propiedades estáticas que contienen los colores más comunes; son
Color.black (negro), Color.blue (añil), Color.cyan (azul),
Color.darkGray (gris claro), Color.gray (gris), Color.green (verde),
Color.lightGray (verde claro), Color.magenta (magenta), Color.orange
(naranja), Color.pink (rosa), Color.red (rojo), Color.white (blanco) y
Color.yellow (amarillo). Pero también se pueden crear instancias de color por medio de
constructores para definir colores menos comunes. Por ejemplo:
Color c = new Color(int rojo, int verde, int azul)

El color creado tendrá las cantidades de rojo, verde y azul indicadas, las cuales deberán estar en un
rango que va de 0 a 255.
Color c = new Color(int rojo, int verde, int azul, int alfa)
Idéntico al anterior, pero añade un canal alfa que indica el grado de transparencia. Sólo funciona con
el JDK 1.2.
Cambiando el ejemplo anterior:
FigurinesColor.java
/**
* Applet FigurinesColor
*
* <APPLET CODE="FigurinesColor.class" WIDTH="200"
*/
import java.awt.*;
public class FigurinesColor extends Applet {

g.setColor(Color.green);
g.fillRoundRect(10,30,50,20,10,10);
g.setColor(new Color(30,40,50,100));
g.fill3DRect(50,40,50,20,true);
}
}
Manejo de imágenes
Aún cuando podemos hacer cosas chulas con figuras, no estaría de más poder hacer cosas con imágenes,
que son bastante más espectaculares. Para hacerlo deberemos utilizaremos el siguiente método:
drawImage( Image img,int x,int y,ImageObserver

observador )
Vemos que necesitamos un objeto Image y otro ImageObserver y de esas cosas no sabemos
todavía... No vamos a ver estos objetos muy a fondo. ImageObserver es un interfaz (que un
antepasado de Applet implementa) que nos ofrece información sobre la imagen según la imagen se
carga de la red. Por otro lado, Image es un objeto que representa a la imagen. Normalmente crearemos
un objeto Image por medio del método de Applet getImage():
Image img = getImage(URL base, String fichero)

Asigna la imagen contenida en la URL donde se encuentre el fichero que contiene la imagen que
queremos presentar y el nombre de ese fichero.
Normalmente obtendremos esa dirección a partir de la página donde esté la página HTML o nuestro applet.
Para averiguarlo disponemos de dos métodos en la clase Applet:
URL getDocumentBase()
Devuelve la URL donde está la página HTML (excluyendo el nombre del fichero).
URL getCodeBase()
Devuelve la URL donde está el applet (excluyendo el nombre del fichero).
Si deseamos obtener una URL distinta deberemos importar esa clase (java.net.URL) y crear uno
pasándole una cadena como parámetro al constructor conteniendo la URL.
Normalmente, se realiza el getImage() en el método init() del applet, ya que en el momento

en que ejecutemos este método comenzará la carga de imágenes desde Internet y eso conviene hacerlo
cuanto antes. Para mostrar la imagen se utiliza el método paint(), al igual que hemos hecho para
pintar cosas. Por ejemplo, suponiendo que tengamos un fichero llamado home.jpg:
Grafico.java
/**
* Applet Grafico
*
* <APPLET CODE="Grafico.class" WIDTH="200"
*/
import java.awt.*;
public class Grafico extends Applet {

Image img;
img = getImage(getDocumentBase(), "home.jpg");
}
g.drawImage(img,x,y,this);
}
}
Ejecución multihilo en applets
Ejecución multihilo en applets
Hasta ahora sólo disponíamos de un hilo de ejecución. Es decir, en nuestros programas sólo se ejecuta una
cosa al tiempo. Si deseamos que se ejecuten varias cosas a la vez o simplemente deseamos disponer de una
manera precisa de controlar la ejecución de parte de nuestro programa dependiendo del tiempo,
necesitaremos que nuestro applet realice una ejecución multihilo.
El concepto de multitarea es diferente al de multihilo. El primero se suele aplicar a la ejecución concurrente de

programas distintos, ya que para que exista multitarea se exige que cada proceso ejecutándose disponga de
su propio espacio en la memoria. En el segundo caso, en cambio, todos los hilos que se ejecutan
concurrentemente disponen del mismo espacio de memoria.
Pero no vamos a escribir un tratado filosófico sobre las diversas formas de programación concurrente. Lo
mejor que podemos hacer es explicarlo sobre un ejemplo. El ejemplo siguiente es una modificación del applet
MostrarMensaje, realizado anteriormente, que realiza un scroll lateral del texto, que aparece por la
derecha y desaparece por la izquierda. El código nuevo que concierne a la ejecución multihilo está en negrita
para facilitar su identificación:
Rotacion.java
/**
* Applet MostrarCadena
*
* <APPLET CODE="MostrarCadena.class" WIDTH="200"
HEIGHT="70">
* <PARAM NAME="Cadena" VALUE="Esto sí que es
chulo">
* </APPLET>
*/
import java.awt.*;
public class MostrarCadena extends Applet implements

Runnable {
String mensaje;
int lugar;
Thread hilo = null;
mensaje = getParameter("cadena");
if (mensaje==null)
lugar = getBounds().width;
}
if (hilo==null) {
hilo = new Thread(this);
hilo.start();
}
}
hilo = null;
}
g.drawString(mensaje,lugar,20);
}
public void run() {
while (hilo!=null && hilo.isAlive()) {
lugar -= 1;
repaint();
try {
hilo.sleep(10);
}
catch (InterruptedException e) {} // No hacemos
nada
}
}
}
Lo primero es asegurarnos que nuestro applet implementa el interfaz Runnable, necesario para el
soporte de threads, o hilos de ejecución. Después declaramos un objeto de tipo Thread, es decir, hilo, y
lo igualamos a null. En el método start(), que es donde debe "estart" todo el código de
inicialización, creamos el hilo y lo arrancamos llamando a su método start(). En stop(), por el
contrario, lo paramos.
El método run() es nuevo y es consecuencia de la implementación del interfaz Runnable. Cuando

creamos un hilo de ejecución, como hemos hecho en start(), el hilo recién creado siempre comienza
su vida útil ejecutando el método run(). Así pues, aquí estará el código del hilo. Comenzamos
preguntando si existe nuestro hilo (hilo!=null) y si está ejecutandose (isAlive).
Luego mueve el texto un poco a la izquierda, repinta, y se obliga a sí mismo a dejar de ejecutarse durante 10
milisegundos por medio del método sleep(). Transcurrido ese tiempo seguirá su ejecución por el mismo
sitio donde la dejó (de ahí que sea necesario el while).
Indicar por último que es obligatorio capturar la excepción InterruptedException para poder
llamar al método sleep(). En caso contrario el compilador se queja. Así pues, lo hacemos, aunque no
especifiquemos ningún código en caso de que se lance dicha excepción. Esto ocurrirá en casos muy
excepcionales, por lo que no debemos preocuparnos.
Técnica Double-buffering
Técnica Double-buffering
Ejecutando el ejemplo del capítulo anterior, podemos observar un parpadeo mientras el texto avanza hacia la
izquierda. Esto es debido al modo que tiene Java de actualizar la imagen que vemos del applet.
Cuando llamamos al método repaint(), éste se encarga de llamar a update(), el cual borra lo
que haya en el applet y llama a paint() para pintarlo de nuevo. Y todo eso lo contemplan nuestros ojos.
El parpadeo es debido a que nuestro ojo se da cuenta de que hemos borrado la pantalla y que tardamos cierto
tiempo en escribir de nuevo el texto.
Para remediarlo existe un técnica llamada double-buffering. Esta técnica no es exclusiva de Java, pues por
ejemplo muchos de los juegos que utilizamos la implementan, o incluso utilicen técnicas más complicadas.
Este método consiste en construir una pantalla virtual, que no vemos pero que existe en la memoria del
ordenador, y pintar en ella lo que necesitemos mostrar para volcarla a la pantalla real cuando lo necesitemos.
Eso elimina nuestros dos problemas. Primero, no borramos nunca la pantalla, sino que la sustituimos, por lo
que la retina no aprecia que se quede en blanco en ningún momento. Segundo, el volcado es un proceso muy
rápido, por lo que no se pueden apreciar que la pantalla virtual se ha volcado sólo un cachito pero otro no
como sucedía cuando dibujábamos directamente.
Para implementar esta técnica, deberemos tener en cuenta que Graphics es una clase abstracta, por lo
que no podemos utilizarla para crear esa pantalla virtual. En cambio, utilizaremos Image, que dispone de
un método que nos será muy útil en este caso:
Graphics img.getGraphics()
Este método creará un lienzo a partir de una imagen, con las mismas dimensiones que ésta.
También utilizaremos el método de Applet llamado createImage(anchura,

altura) que crea una imagen en blanco del tamaño especificado. Así pues, vamos a modificar nuestro
famoso ejemplo, ennegreciendo de nuevo el código nuevo que interviene en la implementación en Java de la
técnica double-buffering:
MostrarCadena.java
/**
*
HEIGHT="70">
chulo">
* </APPLET>
*/
import java.awt.*;

Runnable {
String mensaje;
int lugar, ancho, alto;
Thread hilo = null;
Image buffer;
Graphics pantallaVirtual;
if (mensaje==null)
ancho = getBounds().width;
alto = getBounds().height;
lugar = ancho;
buffer = createImage(ancho, alto);
pantallaVirtual = buffer.getGraphics();
}
if (hilo==null) {
hilo.start();
}
}
hilo = null;
}
g.drawString(mensaje,lugar,20);
}
public void update(Graphics g) {
Color colorTemporal = pantallaVirtual.getColor();
pantallaVirtual.setColor(Color.white);
pantallaVirtual.fillRect(0, 0, ancho, alto);
pantallaVirtual.setColor(colorTemporal);
paint(pantallaVirtual);
g.drawImage(buffer, 0, 0, this);
}
public void run() {
lugar -= 1;
repaint();
try {
hilo.sleep(10);
}
catch (InterruptedException e) { // No hacemos
nada
}
}
}
}
Inicializamos los dos nuevos objetos necesarios para implementar esta técnica en el método init()
utilizando como tamaño de la imagen y su lienzo asociado el del applet. Este tamaño lo averiguamos por
medio de una llamada a getBounds().
El proceso de implementar la técnica se realiza en la sobreescritura del método update(). Este método
recibe como parámetro el lienzo correspondiente al rectángulo que ocupa el applet en la pantalla. Sin
embargo, lo que hace es limpiar el lienzo de la pantalla virtual y llama a paint utilizando como parámetro este
último lienzo, por lo que paint() dibuja en la pantalla virtual. Por último, vuelca el buffer en la pantalla
real.
Esto último es posible debido a que buffer y pantallaVirtual son referencias que apuntan a objetos que en
realidad representan lo mismo. De modo que todo lo que hagamos al lienzo pantallaVirtual se ve reflejado en
la imagen buffer y viceversa.
Eventos
Eventos
La interacción con el usuario se obtiene en Java por medio de eventos, como ya fue explicado. Cuando
sucede un evento que afecta al applet, la máquina virtual de Java ejecuta un método que se llama controlador
de eventos. En principio esos métodos no tienen nada, por lo que deberemos sobreescribirlos en función de
nuestras necesidades. Esos métodos son:
boolean mouseDown(Event, int, int)

Llamado cuando pulsamos un botón del ratón; los parámetros segundo y tercero contienen la
posición del ratón cuando ocurrió el evento, mientras que el primero en un objeto que contiene
información adicional sobre el mismo.
boolean mouseUp(Event, int, int)
Llamado cuando soltamos el botón del ratón después de haberlo pulsado.
boolean mouseMove (Event, int, int)
Llamado cuando movemos el ratón.
boolean mouseDrag (Event, int, int)
Llamado cuando movemos el ratón con un botón pulsado.
boolean mouseEnter (Event, int, int)
Llamado cuando el ratón entra en el applet.
boolean mouseExit (Event, int, int)
Llamado cuando el ratón abandona el applet.
boolean keyDown(Event,int)
Llamado cuando se pulsa una tecla. El argumento entero indica cuál.
boolean keyUp(Event, int)
Llamado cuando se suelta una tecla.
Como ejemplo, podemos hacer un ojo que sigue al ratón:
Ojo.java
/**
* Applet Ojo
*
* <APPLET CODE="Ojo.class" WIDTH="300" HEIGHT="300">
chulo">
* </APPLET>
*/
import java.awt.*;
public class Ojo extends Applet {

int ancho, alto, anchoOjo, altoOjo, anchoPupila,
altoPupila;
int xOjo, yOjo, xPupila, yPupila, xActual, yActual;
Image buffer;
anchoOjo = ancho / 2;
altoOjo = alto / 2;
anchoPupila = anchoOjo / 2;
altoPupila = altoOjo / 2;
xOjo = anchoOjo - anchoPupila;
yOjo = altoOjo - altoPupila;
xPupila = xOjo + anchoPupila/2;
yPupila = yOjo + altoPupila/2;
xActual = xPupila;
yActual = yPupila;
}
g.setColor(Color.yellow);
g.fillOval(xOjo, yOjo, anchoOjo, altoOjo);
g.setColor(Color.black);
g.fillOval(xActual, yActual, anchoPupila,
altoPupila);
}
}
public boolean mouseMove(Event evt, int x, int y) {
xActual = (xPupila*21 + x*8)/32;
yActual = (yPupila*21 + y*8)/32;
repaint();
return true;
}
}
El controlador de evento mouseMove se ejecuta cuando el ratón se mueve por encima del applet. Es en
ese momento cuando se modifica la situación de la pupila del ojo, siguiendo al puntero del ratón. La "formula",
la verdad, está hallada a ojo, cosa que me pareció muy natural en este caso. Además, hacerlo bien requeriría
que nos metieramos en asuntos trigonométricos, y son asuntos estos muy peliagudos.
Clase MediaTracker
Clase MediaTracker
Para poder controlar mejor el viaje que hacen por la red los archivos gráficos, deberemos recurrir a la clase
MediaTracker. Esta clase nos permite saber cuando se han descargado los gráficos y si lo han
hecho bien o con errores.
Primero crearemos un objeto:
MediaTracker tracker = new MediaTracker(this);

Este constructor toma como parámetro el componente donde se van a dibujar las imágenes. Puesto que un
applet es un componente, utilizaremos this como parámetro. Dispondremos entonces de los siguientes
métodos:
void tracker.addImage( Image img,int id )

Este es el método esencial, pues especifica que la imagen sea "espiada" con
MediaTracker. Le asigna un número de identificación, que puede ser compartido por varias
imágenes.
boolean tracker.checkAll()
boolean tracker.checkAll(boolean load)
Comprueba todas las imágenes, devolviendo false si aún no se han descargado y true en
caso contrario (incluso cuando se han descargado con fallos). Si aún no ha comenzado la descarga
de alguna imagen y ponemos load a true, comenzará a descargarlas en ese mismo instante.
boolean tracker.checkID(int id)
boolean tracker.checkID(int id,boolean load)
Idéntico al anterior, pero comprueba sólo las imágenes cuyo identificador sea igual a id.
void tracker.waitForAll()
Obliga al hilo actual a esperar a que se carguen todas las imágenes.
void tracker.waitForID(int id)
Obliga al hilo actual a esperar a que se carguen todas las imágenes del grupo id.
boolean tracker.isErrorAny()
Indica si se ha producido algún error en la descarga de alguna imagen.
boolean tracker.isErrorID(int id)
Indica si se ha producido algún error en la descarga de alguna imagen.
Existen más, pero en general son otras formas de hacer lo mismo. Vamos a ver un ejemplo, una animación
gráfica. Para ello cargaremos cada uno de los gráficos, esperaremos a que estén disponibles, y finalmente los
mostraremos:
MostrarAnimacion.java
/**
* Applet MostrarAnimacion
*
* <APPLET CODE="MostrarAnimacion.class" WIDTH="56"
HEIGHT="60">
* </APPLET>
*/
import java.awt.*;
public class MostrarAnimacion extends Applet

implements Runnable {
int imgActual = 0;
Thread hilo = null;
Image[] img;
MediaTracker tracker;
tracker = new MediaTracker(this);
img = new Image[18];
for (int i=0; i<=17; i++) {
img[i] = getImage(getDocumentBase(), "tierra" +
(i+1) + ".gif");
tracker.addImage(img[i], 0);
}
}
if (hilo==null) {
hilo.start();
}
}
hilo = null;
}
if (checkAll())
g.drawImage(img[imgActual],0,0,this);
else {
g.drawString("Cargando",10,10);
g.drawString("gráficos",10,30);
}
}
public void run() {
try {
repaint();
tracker.waitForAll();
}
catch (InterruptedException e) {}
imgActual++;
if (imgActual >= img.length) imgActual = 0;
repaint();
try {
hilo.sleep(50);
}
}
}
paint(g);
}
}
Creamos un hilo de ejecución nuevo para que nuestra animación sea fluida y suavecita. El método run(),
no obstante, lo primero que hace es esperar hasta que se carguen las animaciones; paint() mientras
tanto escribirá el texto "Cargando gráficos". Una vez que se hayan terminado de cargar las imágenes, el hilo
se encarga de mostrar un fotograma cada 50 milisegundos.
Sonido
Sonido
En Java existe una manera (tampoco muy precisa, pero mucho mejor que las que ofrece Javascript o HTML)
de hacer funcionar ficheros de sonido. Para ello utilizaremos el interfaz AudioClip:
AudioClip sonido = getAudioClip(getDocumentBase(),

"musica.au");
Con esto cargaremos el sonido que esté en el fichero "musica.au". Para hacer algo con él disponemos de tres
métodos:
Sonido.play()
Toca el fichero, aunque sólo una vez.
Sonido.loop()
Toca el fichero indefinidamente.
Sonido.stop()
Para la reproducción del sonido.
Aquí no disponemos de un MediaTracker para comprobar si se ha terminado de cargar o no.

Afortunadamente, la variable sonido será igual a null hasta que finalice la carga del fichero. De
modo que estaremos todo el rato comprobando si esa variable tiene dicho valor, y cuando no sea así
tocaremos un poco de música:
Suena.java
/**
* Applet Suena
*
* <APPLET CODE="Suena.class" WIDTH="56" HEIGHT="60">
* </APPLET>
*/
import java.awt.*;
public class MostrarAnimacion extends Applet

implements Runnable {
AudioClip sonido;
Thread hilo = null;
sonido = getAudioClip(getDocumentBase(),
"musica.au");
}
if (hilo==null) {
hilo.start();
}
}
hilo = null;
}
public void run() {
if (sonido != null) {
sonido.loop();
hilo = null;
}
try {
hilo.sleep(1);
}
}
}
}
Clase FontMetrics
Clase FontMetrics
Vamos a ver cómo averiguar datos sobre el tipo de letra que se está utilizando en nuestro applet,
principalmente para poder situarlo dentro del applet con mayor precisión.
FontMetrics fm = getFontMetrics(getFont());
La clase FontMetrics aporta información sobre las dimensiones del tipo de letra. Dispone de
muchos métodos, pero normalmente usaremos sólo dos:
int fm.getHeight()
Devuelve la altura en pixels de un carácter del tipo de letra actual.
int fm.stringWidth(String)
Devuelve el ancho en pixels de una cadena escrito con el tipo de letra actual.
Nos aprovecharemos de estas cositas para hacer que nuestro applet con el texto desplazándose coloque el
texto en el centro del applet y nos vuelva a mostrar el mismo por la derecha cuando salga por la izquierda:
MostrarCadena.java
/**
*
HEIGHT="70">
chulo">
* </APPLET>
*/
import java.awt.*;

Runnable {
String mensaje;
int lugar, ancho, alto, anchoMensaje, ,altoMensaje;
Thread hilo = null;
Image buffer;
if (mensaje==null)
lugar = ancho;
anchoMensaje =
getFontMetrics().stringWidth(mensaje);
altoMensaje =
(getFontMetrics().getHeight()+alto)/2;
}
if (hilo==null) {
hilo.start();
}
}
hilo = null;
}
g.drawString(mensaje,lugar,altoMensaje);
}
}
public void run() {
while (hilo.isAlive()) {
lugar --;
if (lugar < (-anchoMensaje))
lugar = ancho;
repaint();
try {
hilo.sleep(10);
}
catch (InterruptedException e) { // No hacemos
nada
}
}
}
}
Documentación
Documentación
En muchas ocasiones, se distribuyen los applets haciendo públicos sólo los ficheros .class. En ese caso, es
muy posible que el usuario se encuentre con dichos ficheros sin tener una idea muy clara de la utilidad del
applet o de sus parámetros (ni siquiera de qué parámetros son éstos). Para informar de ello al usuario
disponemos de dos métodos que deberemos sobreescribir:
String getAppletInfo()
Devuelve una cadena que identifique el applet.
String[][] getParameterInfo()
Devuelve un array bidimensional, donde la primera dimensión es el número de parámetros y la
segunda es 3. Cada parámetro dispone, por tanto, de tres cadenas para detallar su información: la
primera indica el nombre del mismo, la segunda su rango de valores y la tercera su utilidad.
Como ejemplo, vamos a añadir estos dos métodos en nuestro applet MostrarCadena. Luego, desde el menú
del appletviewer, elegiremos la opción Info para ver el resultado:
public String getAppletInfo() {

return "Applet MostrarCadena, por Daniel Rodriguez
Herrera";
}
public String[][] getParameterInfo() {
String[][] pInfo = return pInfo;
}

Applets Java

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Applets Java

Загружено:

Авторское право:

Доступные форматы

Applets Java

Autor: Daniel Rodríguez Herrera

ES NECESARIO SABER JAVA

Nuestro primer applet

Nuestro primer applet

public class AdiosMundo extends Applet {

Lo grabamos cono AdiosMundo.java y ejecutamos el appletviewer con el siguiente

public class AdiosMundo extends Applet {

public void paint(Graphics g) {

g.drawString("Adios, mundo cruel",20,20);

Ciclo de vida de un applet

Ciclo de vida de un applet

public class CicloDeVida extends Applet {

Hay alguno más, pero de poca importancia.

public class MostrarMensaje extends Applet {

public void init() {

Mientras no se especifique, consideraremos que todos los parámetros son enteros:

Por ejemplo, podemos dibujar lo siguiente:

public class Figurines extends Applet {

Color c = new Color(int rojo, int verde, int azul)

Cambiando el ejemplo anterior:

public class FigurinesColor extends Applet {

drawImage( Image img,int x,int y,ImageObserver

Image img = getImage(URL base, String fichero)

Normalmente, se realiza el getImage() en el método init() del applet, ya que en el momento

public class Grafico extends Applet {

Ejecución multihilo en applets

Ejecución multihilo en applets

El concepto de multitarea es diferente al de multihilo. El primero se suele aplicar a la ejecución concurrente de

public class MostrarCadena extends Applet implements

El método run() es nuevo y es consecuencia de la implementación del interfaz Runnable. Cuando

También utilizaremos el método de Applet llamado createImage(anchura,

public class MostrarCadena extends Applet implements

boolean mouseDown(Event, int, int)

Como ejemplo, podemos hacer un ojo que sigue al ratón:

public class Ojo extends Applet {

Primero crearemos un objeto:

MediaTracker tracker = new MediaTracker(this);

void tracker.addImage( Image img,int id )

public class MostrarAnimacion extends Applet

AudioClip sonido = getAudioClip(getDocumentBase(),

Aquí no disponemos de un MediaTracker para comprobar si se ha terminado de cargar o no.

public class MostrarAnimacion extends Applet

public class MostrarCadena extends Applet implements

public String getAppletInfo() {

Вам также может понравиться