Un Toque de Historia:

Java nace y da sus primeros pasos en 1991 formando parte de un proyecto de desarrollo de
soporte software para electrónica de consumo ( frigoríficos, lavadoras... ), llevado a cabo por un
equipo de SUN llamado Green Team. Este primer enfoque le da a Java una de sus más
interesantes características: La potabilidad, dado que Java tenia que funcionar en numerosos
tipos de CPUs, y por tanto se pensó para ser independiente de la plataforma sobre la que
funcione. Esta característica es muy posiblemente la que ha permitido a Java convertirse
actualmente en el lenguaje por excelencia para la creación de aplicaciones en Internet.
Este salto de Java para convertirse en un lenguaje de programación para computadores se da
definitivamente en 1995 cuando en la versión 2 del navegador web netscape se incluye un
interprete para este lenguaje, produciendo de este modo una auténtica revolución en Internet.
Con este nuevo enfoque Java sigue creciendo y saca su versión 1.1 en 1997 con muchas mejoras
y adaptaciones, fruto de una revisión sustancial del lenguaje. Java 1.2 aparece a finales de 1998 y
más tarde se rebautizará como Java

Que es JAVA 2?
Sun describe a Java como "simple, orientado a objetos, distribuido, interpretado, robusto, seguro,
de arquitectura neutra, portable, de altas prestaciones, multitarea y dinámico".
Aparte de ser estas características la lógica lista de piropos que un padre siempre daría a uno de
sus hijos mas aplicados, efectivamente describen bastante bien a Java.
Java 2 es la tercera versión importante del lenguaje de programación Java. Parte de la versión 1.1
sin introducirle cambios sustanciales, simplemente ampliándolo.
Java presenta muchas características que lo diferencian de lenguajes similares como C++,
empezando por las posibilidades de ejecución.
Básicamente un programa en Java puede ejecutarse como:
• Stand Alone: Aplicación independiente.
• Applet: Una aplicación especial que se ejecuta en el navegador del cliente.
• Servlet: Una aplicación especial sin Interfaz que se ejecuta en servidor.
Por otro lado un desarrollo en Java nunca empieza desde cero. Java implementa consigo un gran
número de clases, incluidas gratuitamente en su entorno de desarrollo, para realizar muy variadas
tareas que permiten al desarrollador centrarse en las características más inherentes a su proyecto.
Sun distribuye gratuitamente desde su página web, el entorno de desarrollo Java llamado
indistintamente con estas siglas: JDK, SDK o J2SE. Este paquete incluye como hemos dicho las
clases incluidas ya en java, es decir el API de Java. También incluye el compilador de Java y lo
que permite a Java funcionar en nuestro ordenador: el JRE (Java Runtime Enviroment).
El JRE incluye los elementos necesarios para hacer funcionar programas java en nuestro
ordenador. Principalmente nos instala la Maquina Virtual de Java y los plugins necesarios para
el/los navegador/es instalados en nuestro sistema. El JRE también se puede descargar
independientemente del entorno de desarrollo, pues se distribuye en un paquete llamado J2RE.
¿Y que es la Máquina Virtual de Java? Pues bien, como hemos comentado antes, Java está
pensado para ser independiente de la arquitectura sobre la que funcione y la manera que tiene
Java para conseguirlo es a través de la emulación de una máquina software sobre la que
funcionan los programas compilados con Java.
Es decir, un programa compilado con Java no tiene código comprensible por ningún procesador,
ese código solo lo entiende la Máquina virtual de Java y lo traduce a código que si pueda ser
comprensible por el procesador sobre el que funciona y además lo puede hacer funcionar sobre el
sistema operativo sobre el que está instalada. Por tanto lo único dependiente del Hardware es la
máquina virtual, pues tiene que conocer lo que tiene por debajo para llevar a cabo la traducción,
pero los programas en Java siempre pueden funcionar sobre una maquina virtual esté donde esté
instalada.

Introducción:
Java tiene como todos los lenguajes de programación sus propias características para describir
algoritmos, es decir sus propios fundamentos del lenguaje. Este manual no pretende ser una
descripción exhaustiva de todos los modos en que podemos "expresarnos" en este lenguaje, sino
una base para poder ir creando nuestros pequeños programas. Creo que es mucho mas útil
empezar a programar puesto que se aprenden mejor estas cosas cuando tenemos que resolver
algún problema durante nuestro trabajo.
Para introducir simplemente destacar que Java tiene una sintaxis muy similar a la de C++ por lo
que los programadores que vengan desde este lenguaje se sentirán muy cómodos en él.
2. Comentarios:
Hay tres tipos de comentarios en Java:
// Este es un comentario de una sola línea
/* Este es un comentario de una o más líneas */
/** Este es un comentario de documentación */

3. Identificadores:
Un identificador es un "nombre" que nos permite dirigirnos específicamente a una de las
entidades propias del lenguaje, es decir, son los nombres que podemos ponerles a nuestros/as
variables, métodos, clases, interfaces y objetos.
La única restricción en la formación de identificadores es que tienen que comenzar por letra,
subrayado o por el signo '$', pudiéndoles seguir después letras o números. Hay que tener en
cuenta que en Java como en otros muchos lenguajes de programación se distinguen las
mayúsculas y las minúsculas.
Hay una serie de normas muy recomendables para crear identificadores en Java: En Java es
habitual escribir todos los identificadores en minúscula teniendo en cuenta las siguientes
excepciones:
1. Si en un identificador queremos incluir un nombre compuesto se pone el primer nombre entero
en minúscula y el resto con la primera letra en mayúscula y el resto en minúscula. Por ejemplo:
miNuevaVariable = 3;
2. Los identificadores de clases e interfaces siempre empiezan en mayúscula siguiendo la
anterior norma en caso de tratarse de un nombre compuesto. Por ejemplo:

MiNuevaClase();
3. Los nombres de variables finales ( las mas habitualmente llamadas "constantes") se escriben
íntegramente en mayúscula. Por ejemplo: "PI"
Otra restricción muy importante y evidente a la hora de elegir identificador por ejemplo para una
variable es no coincidir con ciertas palabras restringidas que tiene el lenguaje, estas son:
abstract continue for new switch boolean default goto null synchronized
break do if package this byte double implements private threadsafe
byvalue else import protected throw case extends instanceof public transient
catch false int return true char final interface short try
class finally long static void const float native super while
4. Tipos Primitivos:
Como tipos primitivos entendemos aquellos tipos de información mas usuales y básicos. Son los
habituales de otros lenguajes de programación. Te describo algún dato a tener en cuenta en cada
tipo.
• Boolean: No es un valor numérico, solo admite los valores true o false.
• Char: Usa el código UNICODE y ocupa cada carácter 16 bits.
• Enteros: Difieren en las precisiones y pueden ser positivos o negativos.
• Byte: 1 byte.
• Short: 2 bytes.
• Int: 4 bytes.
• Long: 8 bytes.
• Reales en punto flotante: igual que los enteros también difieren en las precisiones y
pueden ser positivos o negativos.
• Float: 4 bytes.
• Double: 8 bytes.
5. Variables:
Ahora que tenemos las piezas necesarias ( identificadores y tipos ) podemos definir variables en
Java. Una variable referenciará siempre a un tipo primitivo de Java o a cualquier otro objeto
creado en nuestro programa. Veamos algunas declaraciones:
Int a ; // declaración de una variable 'a'
//inicializada a 0 (valor por defecto).
Int b = 8; // declaración de una variable 'b' inicializada a 8.
NombreClase referencia; // declaración de una variable 'referencia' preparada //para llevar un
objeto de la clase 'NombreClase'.
NombreClase referencia2; // lo mismo que en la variable anterior.
Referencia = new NombreClase; // se crea un nuevo objeto de la clase
//'NombreClase',y es asignado a la variable
//'Referencia'
Referencia2 = referencia; // Ahora también 'referencia2' tiene el mismo
// objeto a su cargo que 'referencia'
Una vez tenemos un poco de idea de como declarar variables en Java, tenemos que tener en
cuenta desde que sitios de nuestro programa podemos acceder a ellas, es lo que llamamos ámbito
de la variable.
Básicamente la norma es que la variable tiene validez dentro del bloque encerrado entre llaves
donde ha sido declarada, ya sea dentro de una función o de por ejemplo una sentencia 'if'.
Veamos un ejemplo con un pequeño programita en java.
public class AmbitoVariables {
public static void main(String[] args) {
if (true) {
int y=5;
}
System.out.println(y);
}
}
Si intentamos ejecutar este código el compilador nos dará un error diciéndonos que la variable y
no está definida puesto que la hemos declarado en un bloque distinto de donde la pretendemos
utilizar.
Hay mas normas de ámbito respecto a las variables miembro de una clase. Para acceder a ellas
depende si en la clase está declarada como 'public' o como 'private'. Las variables declaradas en
una clase como 'public' se acceden directamente a través de 'NombreClase.nombreVariable'. En
caso de una variable 'private' solo podemos utilizarla mediante los métodos de esa clase.
Por otro lado desde la declaración de cualquier función propia de una clase podemos acceder a
las variables internas de esa clase directamente.
Ya incluiré mas normas de ámbito cuando veamos el concepto de herencia en siguientes
capitulos de la programación en Java. Este tutorial acaba con el siguiente punto en el que vemos
los operadores.
Operadores Aritméticos: Los habituales

• Suma + .
• Resta - .
• Multiplicación * .
• División / .
• Resto de la División % .
Operadores de Asignación: El principal es '=' pero hay más operadores de asignación con
distintas funciones que explicamos brevemente ahora.
• '+=' : op1 += op2 à op1 = op1 + op2
• '-=' : op1 -= op2 à op1 = op1 - op2
• '*=' : op1 *= op2 à op1 = op1 * op2
• '/=' : op1 /= op2 à op1 = op1 / op2
• '%=' : op1 %= op2 à op1 = op1 % op2
Operadores Unarios: El mas (+) y el menos (-). Para cambiar el signo del operando.
Operador Instanceof: Nos permite saber si un objeto pertenece a una clase o no.
• NombreObjeto instanceof NombreClase
Operadores Incrementales: Son los operadores que nos permiten incrementar las variables en
una unidad. Se pueden usar delante y detrás de la variable dependiendo de lo que queramos, es
decir, si queremos que incremente o viceversa antes de utilizar o lo contrario.
• '++'
• '--'
Operadores Relacionales: Permiten comparar variables según relación de igualdad/desigualdad
o relacción mayor/menor. Devuelven siempre un valor boolean.
• '>': Mayor que
• '<': Menor que
• '==': Iguales
• '¡=': Distintos
• '>=': Mayor o igual que
• '<=': Menor o igual que
Operadores Lógicos: Nos permiten construir expresiones lógicas.
• '&&' : devuelve true si ambos operandos son true.
• '||' : devuelve true si alguno de los operandos son true.
 • '!' : Niega el operando que se le pasa.
• '&' : devuelve true si ambos operandos son true, evaluándolos ambos.
• '|' : devuelve true uno de los operandos es true, evaluándolos ambos.
Operador de concatenación con cadena de caracteres '+':
• Por Ejemplo: System.out.println("El total es"+ result +"unidades");
Operadores que actúan a nivel de bits: Son mucho menos utilizados por eso los explicamos
mas por encima.
• '>>': desplazamiento a la derecha de los bits del operando
• '<<': desplazamiento a la izquierda de los bits de operando
• '&': operador and a nivel de bit.
• '|': operador or a nivel de bit
Descripción de las estructuras de programación, de tipo bifurcación o toma de decisiones,
en Java.
Se tratan de las mismas estructuras que pueden encontrarse en cualquier otro lenguaje, si sabes
ya programar ten en cuenta que lo único que necesitas aprender es la sintaxis y eso se consigue
mucho mejor programando así que puedes pasar por alto este punto.
Bifurcaciones: Permiten ejecutar código en función de una expresión evaluada
Bifurcaciones if:
Tienen las siguientes posibilidades en su sintaxis:
if (ExpresionBooleana){conjuntoDeSentencias}
if (ExpresionBooleana) {conjuntoDeSentencias}
else {conjuntoAlternativo}

if (ExpresionBooleana) {conjuntoDeSentencias}
else if {conjuntoAlternativo}
else if {conjuntoAlternativo2}

Ejemplos:
if (i == 5){ System.out.println(" i vale 5 ");}
else {System.out.println("i no vale 5");}
if (i == 5){ System.out.println(" i vale 5 ");}
else if (i < 5){System.out.println("i es menor que 5");}
else if (i > 5){System.out.println("i es mayor que 5");}

Bifurcaciones switch
Son las que permiten realizar varias acciones distintas dependiendo del estado de una variable.
Switch (Expresion){
Case valor1: conjuntoDeSentencias;
break;
Case valor2: SentenciasAlternativas;
break;
Case valor3: SentenciasAlternativas2;
break;
Case valor4: SentenciasAlternativas3;
break;
}
La sentencia 'break' detrás de cada opción de case sirve para que no evalue el resto de opciones
sino que se salga directamente del 'Switch', asi que dependiendo de lo que quieras hacer la
pondrás o no.

Ejemplos:

switch (i) {
case '1': System.out.println( "i contiene un 1");
case '2': System.out.println( "i contiene un 2");
case '3': System.out.println( "i contiene un 3");
}
Vemos los bucles for, while y do while, junto con otras estructuras de programación como
break, continue y return.
Los bucles se utilizan para ejecutar un conjunto de instrucciones varias veces basándose siempre
en una condición que decidirá si se sigue repitiendo o no. Veamos los tipos que hay.

Bucle While

while (expresion) {sentencias}

Las instrucciones dentro de las llaves se ejecutan mientras la expresión sea verdadera.
i=5;
while ( i > 0 ) {i --;}
// las llaves aquí se podían haber omitido, puesto
// que solo hay una sentencia.
System.out.println("Ahora i vale 0");

Bucle For

Es un bucle más "fijo", permite ejecutar el conjunto de sentencias un numero determinado de

veces fijado al principio del bucle y funciona por tanto como un contador. Su expresión general
seria como la que sigue:
for (inicialización, expresionBooleana, incremento) {conjuntoDeSentencias;}

for (int i= 0; i <10; i++){ System.out.println("el valor de i es: " + i); }

Este ejemplo nos mostraría por la pantalla diez líneas diciéndonos el valor creciente de 'i' de cero
a nueve.

Bucle do while
Es igual al bucle while anteriormente visto, solo que ahora se evalúa la expresión al final del
bucle, por lo que ese conjunto de sentencias se ejecuta al menos una vez:
i=5;
do
{i --;} // las llaves aquí se pueden omitir puesto
while ( i > 0 ) // que solo hay una sentencia.
Este ejemplo similar al anterior para el bucle while se diferencia en que ejecuta una vez mas las
sentencias en su cuerpo puesto que comprueba la condición posteriormente.
Sentencias Break, Continue y Return

Antes hemos hablado de la sentencia Break con las bifurcaciones switch. Pues bien, esta
sentencia tiene un valor mas amplio. La sentencia break nos permite salirnos del bloque de
sentencias (encerrado entre llaves) o el bucle que estamos ejecutando, sin ejecutar las sentencias
que resten para el final o las restantes iteraciones del bucle. Por ejemplo:
i=5;
do{
i --;
if (i == 3) break;
} while ( i > 0 )
// En este ejemplo cuando i tenga el valor 3
// se abandonará el bucle.
La sentencia Continue solo es válida para bucles, sirve para no ejecutar las sentencias que restan
para la finalización de una iteración de ese bucle, continuando después con las siguientes
iteraciones del bucle. Por ejemplo:
i=5;
do{
if (i == 3) continue; i --;
}while ( i > 0 ) // En este ejemplo cuando i tenga el valor 3
// se abandonará la iteración y por tanto el
// bucle no tendrá fin puesto que no se
// ejecutaría la sentencia de decremento.
Tanto la sentencia continue como break se pueden utilizar con etiquetas para poder discriminar
los bucles que quieren afectar en caso de que se encuentren en un bucle anidado. Por ejemplo:

Bucle1:
for (int i=0; i<10; i++){
bucle2:
for (int j=0; i<10; j++){
if (j==5) {break bucle2;}
}
} // cuando j llega a 5 el bucle2 deja de
// ejecutarse hasta la siguiente iteracion
// del bloque1
Por último vemos la sentencia return. Esta sentencia nos permite finalizar también un conjunto
de sentencias, con la peculiaridad esta vez de que también finaliza el método o función que en el
que se encuentre. En el caso de que queramos devolver un valor desde esa función o método lo
debemos poner a continuación de return. Por ejemplo:

void funcionEjemplo(){
int i=0;
while (i < 100){ //esta absurda función nos devuelve
i++; //al llamarla el valor 100 como has
} //podido comprobar
return i;
}
Bloque Try – Catch – Finally
Se trata de unas sentencias de control relacionadas con el tratamiento de excepciones, no tiene
nada que ver con las estructuras de control de bucle, vistas en este artículo, salvo porque es
también una estructura de control. La comentamos a continuación, aunque se verá con ejemplos
más adelante.
El tratamiento de excepciones se utiliza para detectar errores cuando se ejecutan nuestros
programas y tratarlos del modo que nosotros queramos. Los errores cazados por un sistema de
tratamiento de excepciones no bloquean el programa y el manejo de excepciones nos permite
hacer cosas cuando esos errores ocurren.
Por ahora solo es bueno que sepas que existen, ya las veremos en otro momento.

Vemos lo que son las clases, cómo crearlas y algunos detalles adicionales de su uso.

En si, y como he comentado anteriormente en el Manual de Java, las clases marcan la estructura
básica de un programa tanto en Java como en la programación orientada a objetos en general.

Una clase es el producto de enfocar la programación a los datos más que a las funciones. Por
tanto una clase es una colección de datos y además para operar con ellos una serie de funciones
propias de la clase. Veamos por ejemplo la clase "Fichas" definida anteriormente, su único dato
es "el color" y la única operación que permite es saber el color de la ficha en cualquier momento.
Eso permite un acceso restrictivo a los datos según la función de los mismos. En este caso la
clase es así basándose en la vida misma: No creo que nadie haya cambiado el color de una ficha
jugando a las "cuatro en raya" y en caso positivo no tendría muy buenas intenciones al hacerlo.
Además de este método básico de protección de los datos, Java permite algunos más que vemos
ahora mismo.

Cuando declaramos una clase lo primero que ponemos es la cabecera:

public class Fichas { (cuerpo de la clase) }
La primera palabra nos proporciona la posibilidad de dar permisos de accesos a nuestra clase, los
permisos son los siguientes:
• "Public": Una clase "public" es accesible desde cualquier otra clase, no obstante para
que esto suceda debe ser primero accesible el "package" de esa clase "public". Para que
un "package" sea accesible debe de estar en el directorio que señala la variable
"CLASSPATH" que definimos al instalar nuestro entorno Java y, claro está, tener
permiso de lectura en ese directorio.
• "Package": Usar este identificador en la cabecera de la clase es opcional, pues es la
opción por defecto en java, es decir, si escribimos:
class Fichas {(Cuerpo de la clase)}

Es lo mismo que si escribimos:

package class Fichas {(Cuerpo de la clase)}
Las clases "package" ( que podemos entender como las que no son "public" ) son accesibles solo
desde su propio package.
Esto es relativo a la accesibilidad de las clases. Más conceptos relativos a la accesibilidad hacen
referencia a las variables internas de una clase que ya comentamos en un capítulo anterior, y a
sus métodos.
En cuanto al nombre de la clase consideraremos varias cosas. Debe de obedecer al convenio de
nombres de Java y coincidir con el nombre del fichero ".java" en el que se guardará la clase.
Lo normal es que cada clase vaya incluida en un único fichero pero claro está, nos puede
interesar por algún motivo meter varias clases en un único fichero. En este caso solo puede haber
una clase public que es la que dará el nombre a dicho fichero. En caso de que no hubiese una
clase public el compilador entenderá que la clase "principal" de ese fichero es la que concuerda
con el nombre del mismo, por lo que evidentemente dos clases con un mismo nombre no son
permitidas en un mismo fichero.
Por último para explicar la estructura de una clase explicaré los elementos habituales en la
definición de su cuerpo.
Primero se suelen declarar, al menos, las variables internas de esa clase y posteriormente se
definen los constructores y los métodos que dispondrá la clase. Lo entenderemos mejor más
adelante
En la definición de constructores y métodos tenemos que tener en cuenta un nuevo concepto de
la programación orientada a objetos. La sobrecarga. La sobrecarga consiste en poder tener varios
métodos o constructores con el mismo nombre dentro de una misma clase y que no hagan las
mismas cosas.
Esto se consigue de una manera muy sencilla, se diferencian entre ellos mediante el número y
tipo de parámetros que reciben. Veamos un ejemplo:
/*tenemos dos métodos que pueden por ejemplo obtener el área de una figura geométrica en
concreto, podrían ser:*/
float obtenerAreaCirculo(Circulo ci){
/* ... */
}
float obtenerAreaCuadrado(Cuadrado cu){
/* ... */
}
/*en Java esto se puede abreviar teniendo dos métodos sobrecargados, por ejemplo: */
float obtenerArea(Circulo ci){
/* ... */
}
float obtenerArea(Cuadrado cu){
/* ... */
}
/*A la hora de ejecutar el método obtenerArea se utilizará el que corresponda al parámetro que se
le pase por cabecera*/

Paquetes de Java
El lenguaje Java proporciona una serie de paquetes que incluyen ventanas, utilidades,
un sistema de entrada/salida general, herramientas y comunicaciones. En la versión
actual del JDK, los paquetes Java que se incluyen son:

java.applet
Este paquete contiene clases diseñadas para usar con applets. Hay una clase Applet y
tres interfaces: AppletContext, AppletStub y AudioClip.
java.awt
El paquete Abstract Windowing Toolkit (awt) contiene clases para generar widgets y
componentes GUI (Interfaz Gráfico de Usuario). Incluye las clases Button, Checkbox,
Choice, Component, Graphics, Menu, Panel, TextArea y TextField.
java.io
El paquete de entrada/salida contiene las clases de acceso a ficheros: FileInputStream
y FileOutputStream.
java.lang
Este paquete incluye las clases del lenguaje Java propiamente dicho: Object, Thread,
Exception, System, Integer, Float, Math, String, etc.
java.net
Este paquete da soporte a las conexiones del protocolo TCP/IP y, además, incluye las
clases Socket, URL y URLConnection.
java.util
Este paquete es una miscelánea de clases útiles para muchas cosas en programación.
Se incluyen, entre otras, Date (fecha), Dictionary (diccionario), Random (números
aleatorios) y Stack (pila FIFO).

2 El Visor de applets de Sun (appletviewer)

El visualizador de applets (appletviewer) es una aplicación que permite ver en
funcionamiento applets, sin necesidad de la utilización de un navegador World-Wide-
Web como HotJava, Microsoft Explorer o Nescape. En adelante, recurriremos muchas
veces a él, ya que el objetivo del tutorial es el lenguaje Java.

Applet
La definición más extendida de applet, muy bien resumida por Patrick Naughton, indica
que 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". Claro que así la definición establece el
entorno (Internet, Web, etc.). En realidad, un applet es una
aplicación pretendidamente corta (nada impide que ocupe
más de un gigabyte, a no ser el pensamiento de que se va a
transportar por la red y una mente sensata) basada en un
formato gráfico sin representación independiente: es decir, se
trata de un elemento a embeber en otras aplicaciones; es un
componente en su sentido estricto.
Un ejemplo en otro ámbito de cosas podría ser el siguiente: Imaginemos una empresa,
que cansada de empezar siempre a codificar desde cero, diseña un formulario con los
datos básicos de una persona (nombre, dirección, etc.). Tal formulario no es un diálogo
por sí mismo, pero se podría integrar en diálogos de clientes, proveedores, empleados,
etc.
El hecho de que se integre estática (embebido en un ejecutable) o dinámicamente
(intérpretes, DLLs, etc.) no afecta en absoluto a la esencia de su comportamiento como
componente con que construir diálogos con sentido autónomo.
Pues bien, así es un applet. Lo que ocurre es que, dado que no existe una base
adecuada para soportar aplicaciones industriales Java en las que insertar nuestras
miniaplicaciones (aunque todo se andará), los applets se han construido
mayoritariamente, y con gran acierto comercial (parece), como pequeñas aplicaciones
interactivas, con movimiento, luces y sonido... en Internet.

Llamadas a Applets con appletviewer

Un applet es una mínima aplicación Java diseñada para ejecutarse en un navegador
Web. Por tanto, no necesita preocuparse por un método main() ni en dónde se realizan
las llamadas. El applet asume que el código se está ejecutando desde dentro de un
navegador.

El appletviewer se asemeja al mínimo navegador. Espera como argumento el nombre

del fichero html que debe cargar, no se le puede pasar directamente un programa Java.
Este fichero html debe contener una marca que especifica el código que cargará el
appletviewer:

<HTML>
<APPLET CODE=HolaMundo.class WIDTH=300 HEIGHT=100>
</APPLET>
</HTML>

El appletviewer crear un espacio de navegación, incluyendo un área gráfica, donde se

ejecutará el applet, entonces llamará a la clase applet apropiada. En el ejemplo
anterior, el appletviewer cargará una clase de nombre HolaMundo y le permitirá trabajar
en su espacio gráfico.

Arquitectura de appletviewer
El appletviewer representa el mínimo interfaz de navegación. En la figura se muestran
los pasos que seguiría appletviewer para presentarnos el resultado de la ejecución del
código de nuestra clase.

Esta es una visión simplificada del appletviewer. La función principal de esta aplicación
es proporcionar al usuario un objeto de tipo Graphics sobre el que dibujar, y varias
funciones para facilitar el uso del objeto Graphics.
Ciclo de vida de un
Applet
Cuando un applet se
carga en el
appletviewer, comienza
su ciclo de vida, que
pasaría por las
siguientes fases:

Se crea una instancia de la clase que controla el applet. En el ejemplo de la figura

anterior, sería la clase HolaMundo.

El applet se incializa.
 El applet comienza a ejecutarse.

El applet empieza a recibir llamadas. Primero recibe una llamada init (inicializar),
seguida de un mensaje start (empezar) y paint (pintar). Estas llamadas pueden ser
recibidas asíncronamente.

4.3 Escribir Applets Java

Para escribir applets Java, hay que utilizar una serie de métodos, algunos de los cuales
ya se hay sumariado al hablar de los métodos del appletviewer, que es el visualizador
de applets de Sun. Incluso para el applet más sencillo necesitaremos varios métodos.
Son los que se usan para arrancar (start) y detener (stop) la ejecución del applet, para
pintar (paint) y actualizar (update) la pantalla y para capturar la información que se
pasa al applet desde el fichero HTML a través de la marca APPLET.

init ( )
Esta función miembro es llamada al crearse el applet. Es llamada sólo una vez. La
clase Applet no hace nada en init(). Las clases derivadas deben sobrecargar este
método para cambiar el tamaño durante su inicialización, y cualquier otra inicialización
de los datos que solamente deba realizarse una vez. Deberían realizarse al menos las
siguientes acciones:

Carga de imágenes y sonido

El resize del applet para que tenga su tamaño correcto
Asignación de valores a las variables globales

Por ejemplo:

public void init() {

if( width < 200 || height < 200 )
resize( 200,200 );
valor_global1 = 0;
valor_global2 = 100;

// cargaremos imágenes en memoria sin mostrarlas

// cargaremos música de fondo en memoria sin reproducirla
}

destroy ( )
Esta función miembro es llamada cuando el applet no se va a usar más. La clase
Applet no hace nada en este método. Las clases derivadas deberían sobrecargarlo
para hacer una limpieza final. Los applet multithread deberán usar destroy() para
"matar" cuanquier thread del applet que quedase activo.
start ( )
Llamada para activar el applet. Esta función miembro es llamada cuando se visita el
applet. La clase Applet no hace nada en este método. Las clases derivadas deberían
sobrecargarlo para comenzar una animación, sonido, etc.

public void start() {

estaDetenido = false;
// comenzar la reproducción de la música
musicClip.play();}
También se puede utilizar start() para eliminar cualquier thread que se necesite.
stop ( )
Llamada para detener el applet. Se llama cuando el applet desaparece de la pantalla.
La clase Applet no hace nada en este método. Las clases derivadas deberían
sobrecargarlo para detener la animación, el sonido, etc.
public void stop() {
estaDetenido = true;

if( /* ¿se está reproduciendo música? */ )

musicClip.stop();
}

resize ( int width,int height )

El método init() debería llamar a esta función miembro para establecer el tamaño del
applet. Puede utilizar las variables ancho y alto, pero no es necesario. Cambiar el
tamaño en otro sitio que no sea init() produce un reformateo de todo el documento y no
se recomienda.

En el navegador Netscape, el tamaño del applet es el que se indica en la marca

APPLET del HTML, no hace caso a lo que se indique desde el código Java del applet.

width
Variable entera, su valor es el ancho definido en el parámetro WIDTH de la marca
HTML del APPLET. Por defecto es el ancho del icono.

height
Variable entera, su valor es la altura definida en el parámetro HEIGHT de la marca
HTML del APPLET. Por defecto es la altura del icono. Tanto width como height están
siempre disponibles para que se puede chequear el tamaño del applet.

Podemos retomar el ejemplo de init():

public void init() {

if( width < 200 || height < 200 )
resize( 200,200 );
...
paint( Graphics g )
Se llama cada vez que se necesita refrescar el área de dibujo del applet. La clase
Applet simplemente dibuja una caja con sombreado de tres dimensiones en el área.
Obviamente, la clase derivada debería sobrecargar este método para representar algo
inteligente en la pantalla.

Para repintar toda la pantalla cuando llega un evento Paint, se pide el rectángulo sobre
el que se va a aplicar paint() y si es más pequeño que el tamaño real del applet se
invoca a repaint(), que como va a hacer un update(), se actualizará toda la pantalla.
Podemos utilizar paint() para imprimir nuestro mensaje de bienvenida:

void public paint( Graphics g ) {

g.drawString( "Hola Java!",25,25 );
// Dibujaremos la imágenes que necesitemos
}

update( Graphics g )
Esta es la función que se llama realmente cuando se necesita actualizar la pantalla. La
clase Applet simplemente limpia el área y llama al método paint(). Esta funcionalidad es
suficiente en la mayoría de los casos. De cualquier forma, las clases derivadas pueden
sustituir esta funcionalidad para sus propósitos.

Podemos, por ejemplo, utilizar update() para modificar selectivamente partes del área
gráfica sin tener que pintar el área completa:

public void update( Graphics g ) {

if( estaActualizado )
{
g.clear(); // garantiza la pantalla limpia
repaint(); // podemos usar el método padre: super.update()
}
else
// Información adicional
g.drawString( "Otra información",25,50 );
}

repaint()
A esta función se la debería llamar cuando el applet necesite ser repintado. No debería
sobrecargarse, sino dejar que Java repinte completamente el contenido del applet.

Al llamar a repaint(), sin parámetros, internamente se llama a update() que borrará el

rectángulo sobre el que se redibujará y luego se llama a paint(). Como a repaint() se le
pueden pasar parámetros, se puede modificar el rectángulo a repintar.

getParameter ( String attr )

Este método carga los valores parados al applet vía la marca APPLET de HTML. El
argumento String es el nombre del parámetro que se quiere obtener. Devuelve el valor
que se le haya asignado al parámetro; en caso de que no se le haya asignado ninguno,
devolverá null.
Para usar getParameter(), se define una cadena genérica. Una vez que se ha
capturado el parámetro, se utilizan métodos de cadena o de números para convertir el
valor obtenido al tipo adecuado.

public void init() {

String pv;

pv = getParameter( "velocidad" );
if( pv == null )
velocidad = 10;
else
velocidad = Integer.parseInt( pv );
}

getDocumentBase ( )
Indica la ruta http, o el directorio del disco, de donde se ha recogido la página HTML
que contiene el applet, es decir, el lugar donde está la hoja en todo Internet o en el
disco.
getCodeBase ( )
Indica la ruta http, o el directorio del disco, de donde se ha cargado el código bytecode
que forma el applet, es decir, el lugar donde está el fichero .class en todo Internet o en
el disco.
print ( Graphics g )
Para imprimir en impresora, al igual que paint() se puede utilizar print(), que pintará en
la impresora el mapa de bits del dibujo.