LenProg F08

Fascículo
Lenguaje de
Programación
Semestre 2
Lenguaje de programación
Lenguaje de
programación Semestre 2
Tabla de contenido Página
Introducción 1
Conceptos previos 2
Mapa conceptual Fascículo 8 2
Logros 3
¿Qué es un Applet? 3
Appletviewer 8
Ciclo de vida de un Applet 10
Etiqueta APPLET y paso de parámetros 12
Clase Graphics y métodos de dibujo de primitivas 15
Eventos 20
Actividad de trabajo colaborativo 23
Resumen 24
Bibliografía recomendada 25
Seguimiento al autoaprendizaje 27
Anexo 29
Créditos: 3
Tipo de asignatura: Teórica – Práctico
Semestre 2
Copyright©2008 FUNDICIÓN UNIVERSITARIA SAN MARTÍN

Facultad de Universidad Abierta y a Distancia,
“Educación a Través de Escenarios Múltiples”
Bogotá, D.C.
Prohibida la reproducción total o parcial sin autorización

por escrito del Presidente de la Fundación.
La redacción de este fascículo estuvo a cargo de

JAIME ALBERTO GUTIERREZ
Docente tutor – Programa de Ingeniería de Sistemas a Distancia.
Sede Bogotá, D.C.
Orientación a cargo de;

ESPERANZA MARTINEZ G.
Directora Nacional de Material Educativo.
Diseño gráfico y diagramación a cargo de

SANTIAGO BECERRA SÁENZ
ORLANDO DÍAZ CÁRDENAS
Impreso en: GRÁFICAS SAN MARTÍN

Calle 61A No. 14-18 - Tels.: 2350298 - 2359825
Bogotá, D.C., Febrero de 2010
Lenguaje de
programación Semestre 2
Lenguaje de programación 1
Introducción
Uno de los grandes elementos que ha caracterizado la popularización de
la Plataforma Java de Sun Microsystems durante los últimos años ha sido
la posibilidad de poder desarrollar dentro de sus componentes, herra-
mientas o piezas que sean capaces de ejecutarse en entornos de Internet.
Esto no solo ha hecho ha Java realmente merecedora del título de alta
abanderada de la portabilidad, el cual es uno de sus principios rectores,
sino que ha permitido que los usuarios puedan familiarizarse de forma muy
adecuada con el uso de los recursos implementados con dicha plataforma.
Un ejemplo claro de esto, lo encontramos en los chats de Internet. Dichas
herramientas de mensajería y comunicación que han unido a miles de
personas alrededor del mundo, comenzaron a implementarse en sus
primeras etapas bajo Java y lo siguen haciendo aún y se convirtieron en
mecanismos de interacción donde el usuario a través de su diálogo con
este tipo de aplicaciones podía sacar a la luz la funcionalidad de los
métodos y propiedades de este tipo de componente ejecutable.
El objetivo de este fascículo es aprender el fundamento del desarrollo de

los Applets, los cuales son aplicaciones especiales diseñadas con un
propósito específico de correr en entornos gráficos y facilitar al usuario el
despliegue de información a partir del uso no solo de cadenas de texto y
mensajes, sino también de primitivas que permiten el dibujo de objetos y
además, como vimos en nuestros fascículos anteriores, el uso de los
controles de la API Swing para el diseño de formularios, tales como
mencionábamos, similares o muy parecidos, a los que por ejemplo, usan
ciertos salones de chat en Internet. Igualmente, gracias al desarrollo de
Applet es posible crear programas que realicen funciones de trazado de
figuras, diseño de formas y demás elementos, que pueden ser de gran
utilidad para comprender los principios de las interfaces gráficas así como
Fascículo No. 8 Lenguaje de

Semestre 2 programación
del diseño de especificaciones funcionales para programas de cálculo,

ingeniería, dibujo y aplicables a muchos campos del conocimiento.
Conceptos Previos
Como en todos nuestros previos fascículos, hemos hecho un especial
énfasis en la importancia de tener muy claros los conceptos de desarrollo
de clases, atributos y métodos. Igualmente, es importante haber estudiado
y hecho énfasis en los elementos que forman la base de las interfaces
gráficas de usuario, puesto que los conceptos de estas se entrecruzan con
el desarrollo de Applets para realizar aplicaciones más gráficas que
permiten el desarrollo de la interactividad con el usuario y el
aprovechamiento de los métodos de la API de este componente de Sun
Microsystems.
Mapa conceptual Fascículo 8
Fascículo No. 8
Lenguajede
programación
2 Semestre 2
Logros
Al finalizar el estudio de este fascículo el estudiante estará en capacidad de:
. Entender que es un Applet y cuál es la diferencia fundamental entre apli-

caciones Java básicas y Applets Java embebibles en HTML.
. Diseñar los componentes principales de un Applet y comprenderá cual es la
diferencia entre el canvas y la actualización gráfica del mismo.
. Comprender como extender la clase Applet, sobreescribir sus métodos y ela-
borar aplicaciones que permitan la interacción entre los métodos de
procesamiento del Applet y el usuario.
. Emplear las principales herramientas primitivas del pincel para diseñar for-
mas en el Applet y reconocer con facilidad el sistema de Coordenadas
manejado en los Applets como herramientas para la programación de este
tipo de aplicaciones.
¿Qué es un Applet?
Al iniciarse el proceso de desarrollo de aplicaciones con Java, se carac-
terizaron al principios dos tipos de programas básicos (Los programas de
consola que permitían visualizar el funcionamiento de las clases, pero que
ofrecían una interfaz de usuario prácticamente inexistente, y donde los
procesos de entrada y salida de datos se realizaban vía esa consola a
través de métodos como System.in.read() y System.out.println(). Por otro
lado, y consciente de la necesidad de poseer un espacio gráfico que
permitiese desarrollar aplicaciones con mayor nivel de interactividad para
el usuario, Sun creó el concepto de Applet como mecanismo para facilitar
la construcción de ese tipo de soluciones. Dada la necesidad de garantizar
la portabilidad entre sistemas operativos (principio funcional de la
plataforma Java), el objetivo de los Applets es permitir que las aplicaciones
corran dentro de un contenedor externo (por lo general una página Web
escrita en el lenguaje HTML).
A diferencia de un programa, un Applet no puede ejecutarse de manera

independiente, ofrece información gráfica y a veces interactúa con el
usuario, típicamente carece de sesión y tiene privilegios de seguridad
Fascículo No. 8
Semestre 2 3 Lenguaje de
programación
restringidos. Un Applet normalmente lleva a cabo una función muy espe-

cífica que carece de uso independiente. Un Java Applet es un código
JAVA que carece de un método main, por eso se utiliza principalmente
para el trabajo de páginas web, ya que es un pequeño programa que es
utilizado en una página HTML y representado por una pequeña pantalla
gráfica dentro de ésta.
Por otra parte, la diferencia entre una aplicación JAVA y un Applet radica
en cómo se ejecutan. Para cargar una aplicación JAVA se utiliza el
intérprete de JAVA (pcGRASP de Auburn University, Visual J++ de
Microsoft, Forte de Sun de Visual Café, Eclipse IDE, etc.). En cambio, un
Applet se puede cargar y ejecutar desde cualquier explorador que soporte
JAVA (Netscape, Internet Explorer, Mozilla Firefox, Opera, etc.).
Figura 1
Ejecución de un Applet Java dentro de un navegador Web HTML
El proceso de construcción de un Applet sigue la misma filosofía de una

aplicación Java, pero con la diferencia de que el código fuente de la clase
de un Applet no implementa un método main para disparar la ejecución del
componente dentro del entorno de desarrollo y posteriormente en un
navegador HTML. Para ello, la clase base utiliza el concepto de herencia,
Fascículo No. 8
Lenguajede
programación
4 Semestre 2
donde cada Applet escrito por el desarrollador está heredando los

métodos de la clase genérica java.Applet.Applet y sobreescribiendo (de
acuerdo a las necesidades del Applet que vayamos a desarrollar) todos los
métodos heredados de la superclase Applet y que permiten la definición
del componente, sus elementos y su funcionalidad como nueva aplicación
independiente.
A continuación observemos la estructura básica de un Applet Java:
package Appletssimples;
//Importaciones
import java.Applet.Applet;
import java.awt.*;
/**
* @author Ingeniero Jaime Alberto Gutiérrez Mejía
* Fundación Universitaria San Martín
* Programa de Ingeniería de Sistemas
* Facultad de Universidad Abierta y a Distancia
*
* UNIDAD VIII: APPLETS Y APLICACIONES
* EN NAVEGADORES WEB *
*
* Clase Java para implementar un Applet que imprime
* una cadena de caracteres definida por el usuario
*/
public class AppletImpresion extends Applet
{
/*******************************************/
//Atributos de la clase
private static final long serialVersionUID = 9L;
private String cadenaImprimir;
private Font fuente;
private Color colorFuente;
//Datos para mostrar el cálculo de una operación
//sobre el canvas del Applet
private int n1;
private int n2;
private int resultado;
/*******************************************/
//Constructor de la clase
public AppletImpresion() throws HeadlessException
{
// TODO Auto-generated constructor stub
}
/*******************************************/
//Heredando de Applet, debo sobreescribir los metodos
public void init()
{
//Establezco la fuente y el color de la fuente
fuente = new Font("monospaced",Font.BOLD,26);
Fascículo No. 8
programación
cadenaImprimir = "Ejemplo de un Applet Java";

colorFuente = Color.GREEN;
//Definimos el fondo del canvas
setBackground(Color.RED);
//Definimos su tamaño
setSize(800,600);
}
//Metodo para forzar la actualizacion del Applet

public void paint (Graphics g)
{
//El objeto graphics establece un patron para pintar
//sobre el canvas del Applet
//Mejoremos la presentacion del Applet
g.setFont(fuente);
g.setColor(colorFuente);
//Pintamos
g.drawString(cadenaImprimir,25,40);
//Ejecuto los metodos de logica del Applet

//Damos valores a los atributos
this.n1 = 23;
this.n2 = 1004;
//Obtenemos el resultado
this.resultado = sumarValoresApplet(this.n1,this.n2);
//Definimos el color
//Imprimimos el resultado de la suma en el canvas
g.setColor(Color.BLUE);
g.drawString(String.valueOf(this.resultado),25,200);
}
/*******************************************/
//Metodos de logica para el Applet
public int sumarValoresApplet (int n1, int n2)
{
int resultado = 0;
resultado = n1 + n2;
return (resultado);
}
/*******************************************/
}//Fin de la clase Applet
Como podemos observar en el código, todo Applet al igual que cualquier

clase que implemente una aplicación está formada por una serie de
atributos que definen los elementos de información a manejar por el Applet
y una serie de métodos que el programador puede escribir para manipular
la lógica de negocio de la solución. No obstante, dado que el Applet
funciona sobre una superficie gráfica, la cual se denomina canvas, debe
existir una forma de actualizar la información en ella, por lo que el Applet
Fascículo No. 8
Lenguajede
programación
6 Semestre 2
que escribamos debe sobreescribir tres métodos claves en la definición de

su estructura:
a) Método paint: Dicho método se encarga de forzar el refresco de la

superficie del canvas, con el objetivo de desplegar las primitivas del
objeto gráfico encargado de la actualización del mismo. Esto quiere
decir que cada vez que ocurre un proceso de interacción del usuario
con el canvas, como dar clic sobre él o usar el teclado para ingresar
caracteres, el método debe encargarse de forzar el repintado de la
superficie y mostrar los cambios que se hayan presentado.
b) Método init: Cumple la función de inicializar el canvas del Applet en el

momento en que este es desplegado. A semejanza de un método
constructor, su responsabilidad está en definir todos los parámetros de
arranque que el Applet debe tener en el momento de su inicialización y
garantizar que los recursos estén listos para que el usuario pueda
interactuar con él.
c) Método repaint(): Es un método que no es necesario sobreescribir,

pero que debe establecerse en cualquier método de lógica de negocio
del Applet que involucre un proceso de actualización de datos sobre la
superficie del canvas. Una vez el método se ejecute, el método repaint
se invoca para forzar el redibujado de todos los objetos gráficos,
cadenas de caracteres, primitivas de dibujo o controles de formulario,
que en ese momento estén presentes y que hayan sido instanciados y
preconfigurados desde las instrucciones del método init().
8.1
1. Desarrolle un Applet Java que permita la impresión de un párrafo de

texto. Utilice un String [] para almacenar las líneas del párrafo, de
manera que pueda utilizar una estructura de repetición para (for) o
while para descargar en el método paint el contenido del String []
Fascículo No. 8
programación
utilizando la primitiva de trazado drawString que acabamos de ver en

el ejemplo anterior.
2. Desarrolle un Applet Java que imprima las operaciones básicas
(suma, resta, producto y cociente) de dos valores numéricos y que
muestre la raíz cuadrada, el logaritmo en base 10 y la potenciación
de ab y ba, donde a y b, son los números de las operaciones
solicitadas en esta aplicación. Cree un método para cada operación
de cálculo aritmético e invóquelo en la definición del método paint
para este Applet solicitado.
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. Dicha
herramienta permite la depuración de los Applets y visualizar su fun-
cionamiento antes del despliegue de la aplicación final dentro de uno de
los navegadores anteriormente citados. El objetivo del Appletviewer es el
de facilitar que el desarrollador pueda revisar el Applet antes de su
despliegue final en el contenedor Web y probarlo en la funcionalidad de
todos sus métodos.
Figura 3
Herramienta de ejecución y depuración de Applets Java Appletviewer
Como se observa en la siguiente figura, el Applet que se visualiza

despliega dos cadenas de caracteres, la primera, un valor estático que se
define en el código de una de las variables de instancia de la clase
Fascículo No. 8
Lenguajede
programación
8 Semestre 2
AppletImpresion.java. La segunda cadena de caracteres que se imprime,

muestra el resultado de un cálculo generado por el método
sumarValoresApplet que se despliega como la última función
implementada dentro del código del método.
Figura 4
Vista de un Applet en ejecución sobre el Appletviewer de Java
El Appletviewer igualmente permite controlar el despliegue de nuevas

instancias del Applet, reiniciarlo cuando este comienza a presentar
problemas de ejecución o clonar el objeto de instancia del Applet actual
(algo muy útil cuando se tiene que verificar el funcionamiento de varios
procesos del usuario en el momento de ejecutar la aplicación). También
gracias a él es posible resetear el Applet cuando este deja de funcionar y
detener su operación para corregir errores en el él y lanzarlo nuevamente a
su despliegue.
Figura 5
Opciones de administración del Appletviewer para el control de los Applets en ejecución
Fascículo No. 8
programación
Ciclo de vida de un Applet

A diferencia de una aplicación estándar que deja de ejecutarse en el
momento que finaliza la última instrucción de su método main, un Applet
tiene un ciclo de vida algo diferente. El siguiente diagrama de estados
ilustra su funcionamiento básico:
Figura 6
Ciclo de vida de un Applet Java
Cada círculo representa una fase en el ciclo de vida de la Applet. Las

flechas representan transiciones y el texto representa la acción que causa
la transición. Cada fase está marcada con una invocación a un método del
Applet Java:
a) Método init(): Como se había mencionado su función es crear la

instancia base del Applet generado y ejecutar todas las instrucciones
para que el canvas se pueda ejecutar apropiadamente.
b) Método start(): Se encarga de inicializar el proceso de interacción del
usuario con el Applet. Básicamente su función es la de facilitar la
respuesta del Applet ante los eventos de interacción del usuario con el
navegador (restaurar el navegador, actualizarlo, minimizarlo,
maximizarlo, etc. El método se conjuga con el uso de threads (hilos de
ejecución) para permitir que puedan ejecutarse subprocesos dentro del
Applet principal.
c) Método stop(): Se invoca para detener el Applet de manera tal que ya
Fascículo No. 8
Lenguajede
programación
10 Semestre 2
no se puedan ejecutar más sus funciones. El método stop detiene el

Applet y hace que los eventos y funciones de actualización ya no
puedan ejecutarse más.
d) Método destroy(): Se encarga de liberar los recursos que el Applet
esté utilizando en dicho momento. Dicho método es invocado por el
cargador de clases de la máquina virtual, cuando del Applet detecta que
el contenedor que lo anida (la página Web en el navegador HTML se
cierra automáticamente).
El proceso se ilustra gráficamente a continuación:
Figura 7
Carga del Applet en el contenedor HTML (método init())
Figura 8
Ejecución del método start() al redimensionar el contenedor del Applet
Cuando un navegador carga una página Web que contiene un Applet,

suele mostrar en su parte inferior un mensaje como:
initializing... starting...
Fascículo No. 8
programación
Esto indica que el Applet, se está cargando:
1. Una instancia de la clase Applet es creada.

2. El Applet es iniciado, mediante su método init().
3. El Applet empieza a ejecutarse, mediante su método start(). Cuando el
usuario se encuentra con una página Web, que contiene una Applet y
salta a otra página, entonces el Applet se detiene invocando a su
método stop(). Si el usuario retorna a la página donde reside el Applet,
ésta vuelve a ejecutarse nuevamente invocando a su método start().
4. Cuando el usuario sale del navegador el Applet tiene un tiempo para
finalizar su ejecución y hacer una limpieza final, mediante el método
destroy(). El garbage collector de la máquina virtual elimina la instancia
y libera cualquier recurso y objeto que estuviera siendo utilizado por el
Applet en ese momento, liberando memoria para otras aplicaciones.
Etiqueta APPLET y paso de parámetros

Con la evolución del lenguaje HTML, como lenguaje para la construcción y
definición de documentos hipervinculados para la World Wide Web
(telaraña mundial de la información), se hizo necesario agregar mucha más
interactividad al desarrollo de las aplicaciones construidas para el entorno
mundial de Internet. La aparición de Java como plataforma tecnológica de
desarrollo para el despliegue de aplicaciones hizo necesario que el World
Wide Web Consortium (W3C) insertara en la especificación del lenguaje
una etiqueta (tag) especial para la inclusión de los Applets Java. Su
estructura es la siguiente:
<APPLET code="ClaseAppletJava.class" width="ancho"

heigth="alto"></APPLET>
Donde el parámetro code le indica al navegador que debe cargar en el

browser una instancia del JRE local instalado en el equipo de la máquina
Fascículo No. 8
Lenguajede
programación
12 Semestre 2
cliente donde el Applet intenta ser desplegado. Esto hace que el submotor
de procesamiento Java configurado en el equipo local suba el class loader
(cargador de clases) de la máquina virtual y la copia del Applet que es
descargada al cache del equipo cliente, se ejecute localmente en dicho
navegador, brindando al usuario la sensación de que la aplicación se
ejecuta nativamente en su propia computadora. Los parámetros width
(ancho) y heigth (alto), le indican al navegador la cantidad de espacio que
debe asignar para que el componente Java se despliegue en la página
Web. Dichos valores no deben confundirse con los parámetros del
método Java setSize(ancho,alto) visto en el método init del Applet, puesto
que dichos valores establecen el tamaño para el canvas, por lo que si los
valores de la etiqueta son más pequeños que los del método setSize, se
perderá gran parte de la superficie del canvas en el momento del des-
pliegue del Applet sobre el contenedor Web (página HTML).
Dada la capacidad de desarrollar otros componentes, que en lugar de ser

beneficiosos, podrían ser nocivos como los troyanos y los spywares, que
igualmente son aplicaciones programadas, los navegadores Web más
modernos siempre restringen la ejecución de cualquier tipo de código,
incluyendo el de Sun Microsystems, por lo que al intentar cargar el Applet,
se despliega una advertencia de seguridad, como se muestra a conti-
nuación:
Figura 9
Advertencia de seguridad desplegada por el intento de cargar una aplicación Java (Applet) dentro de un navegador como el
Microsoft Internet Explorer
Fascículo No. 8
programación
En muchas ocasiones, se hace necesario que el Applet, por cuestiones

tanto de diseño como de seguridad, lea ciertos valores desde la página
Web que lo contiene, con el fin de cargar parámetros de configuración que
permitan el despliegue de la aplicación. Para poder hacer esto, se hace
necesario incluir unos tags (etiquetas) HTML adicionales que le indiquen al
Applet que debe hacer en el método init (como por ejemplo, el tamaño, el
ancho, el alto, el color o la lectura de algún valor necesario para la
ejecución de un método de lógica de negocio incluido en el código del
Applet o en objetos Java que complemente su implementación). Para
hacer esto, el código HTML del contenedo Web debe contener las
siguientes etiquetas:
<APPLET code="ClaseAppletJava.class" width="1024" heigth="768">

<param name="alto" value="1024"/>
<param name="ancho" value="768"/>
<param name="numeropuntos" value="30"/>
</APPLET>
Dichos valores deben establecerse mediante el parámetro de tag (etiqueta)

llamado param y debe contener dos valores: Un nombre (name) que
indica el nombre del parámetro y un valor (value), que debe establecerse
entre comillas y que puede ser una cadena de caracteres, un valor
numérico o cualquier dato que deba ser recuperado por el método init en
el momento de la instanciación del Applet. Como hemos observado en
otros fascículos, dicho valor es tratado en todos los casos como un dato
de tipo String, por lo que si se quiere enviar un valor numérico al Applet
desde un parámetro, en el código del Applet dicho valor debe ser
transformado en su correspondiente valor numérico por el método de
turno asociado (parseDouble, parseInt, parseLong, etc.).
En el ejemplo anterior, observamos tres parámetros que definirían el alto y

el ancho (para el método setSize) y un parámetro de lógica de negocio
que denominaríamos numeropuntos, que sería utilizado por el Applet para
Fascículo No. 8
Lenguajede
programación
14 Semestre 2
procesar uno de sus métodos de operación. Esto significaría, por lo tanto,

que en el método init debemos encontrar las siguientes instrucciones Java
para procesar los datos direccionados por el contenedor Web HTML:
//Sobreescritura de los métodos de la Clase Applet
//Init (): Define el tamaño y el color de fondo del canvas
public void init()
{
try
{
//Leemos los parámetros del HTML
valorAlto = getParameter("alto");
valorAncho = getParameter("ancho");
numeroPuntosArranque = getParameter("numeropuntos");
if (valorAlto != null && valorAncho != null &&

numeroPuntosArranque != null)
{
alto = Integer.parseInt(valorAlto);
ancho = Integer.parseInt(valorAncho);
numeroPuntos =
Integer.parseInt(numeroPuntosArranque);
}
else
{
alto = 800;
ancho = 600;
numeroPuntos = 50;
}
//Tamaño del canvas
PUNTOSMAXIMOS = numeroPuntos;
puntosx = new int[PUNTOSMAXIMOS];
puntosy = new int[PUNTOSMAXIMOS];
setSize(alto,ancho);
//Establecemos el color de fondo en en canvas

setBackground(Color.red);
}
catch (Exception errorInit)

{
JOptionPane.showMessageDialog(null,"No se puede cargar el
color de fondo. Applet no inicializable: " + errorInit.toString());
errorInit.printStackTrace();
System.exit(0);
}
}//Fin del init
En el momento de instanciar el Applet, los valores serán leídos desde la página

HTML, convertidos a sus correspondientes valores numéricos gracias al método
Fascículo No. 8
programación
parseInt del objeto Integer y pasados como parámetros por valor a los métodos
que hacen uso de ellos, tal como en el caso de la instanciación del arreglo de
enteros del ejemplo para el número máximo de puntos que dicho vector debe
contener y los valores enteros requeridos por setSize para definir desde el
momento de la carga, el tamaño del canvas para el nuevo Applet.
Clase Graphics y métodos de dibujo de primitivas

Como se ha observado, el proceso de actualización de la superficie del canvas
necesita ser instanciado en tiempo de ejecución, puesto que cada cambio
aplicado al Applet debe verse reflejado mediante el redibujado de la totalidad de
los objetos presentes en el canvas. Dado esto, vemos que la clase Applet crea-
da por nosotros debe permitir la sobreescritura del método paint, el cual recibe
como parámetro un objeto de la clase Graphics. Dicho objeto, es fundamen-
talmente el “lápiz” que permite el trazado de las imágenes, figuras y demás
elementos alfanuméricos como cadenas de caracteres, que desean ser puestos
en la superficie del canvas. Entre sus principales métodos, encontramos:
a) drawString( string s,x,y ): Permite dibujar una cadena de caracteres

establecida en el parámetro s y en las coordenadas indicadas por los
valores enteros x e y.
Figura 10
Primitiva drawString()
b) drawLine( x1,y1,x2,y2 ): Permite trazar una línea recta por las

coordenadas definidas por los parámetros (x1,y1: Punto inicial y
x2,y2: Punto final).
Figura 11
Primitiva drawLine()
Fascículo No. 8
Lenguajede
programación
16 Semestre 2
c) drawRect( x,y,ancho,alto ): Traza un rectángulo definido por el punto

inicial establecido en x,y y de dimensiones (ancho y alto)).
Figura12
Primitiva drawRect()
d) fillRect( x,y,ancho,alto ): Trabaja igual que el método anterior, con la

diferencia de que rellena de un color el rectángulo trazado.
Figura13
Primitiva fillRect()
e) drawFillOval( x,y,ancho,alto ): Permite trazar una circunferencia o un

óvalo, cuyo centro está indicado por las coordenadas x,y y de radio
definido por los parámetros ancho y alto. Si ancho y algo son iguales
se traza un círculo. Si son diferentes, un óvalo.
Figura 14
Primitiva drawFillOval()
f) drawFillArc( x,y,ancho,alto,anguloInicio,anguloArco): Permite trazar

un arco establecido por los parámetros del método, sin completar una
elipse o una circunferencia completa.
Fascículo No. 8
programación
Figura 15
Primitiva drawFillArc()
g) drawPolygon( int[] puntosX,int[] puntosY[],numPuntos ): Permite

trazar un polígono establecido por los vectores de números enteros int[]
puntosX e int [] puntosY y el total de puntos definidos en el parámetro
numPuntos. Si dicho número es diferente a la de longitud del vector de
puntos, se genera una excepción de Graphics que impide el trazado del
polígono.
Figura 16
Primitiva drawPolygon()
h) fillPolygon( int[] puntosX,int[] puntosY[],numPuntos ): Es similar al

método anterior, con la diferencia de que el polígono trazado se rellena
de un color previamente establecido para el lápiz.
Figura 17
Primitiva fillPolygon()
El siguiente Applet muestra la implementación del uso de la primitiva de

dibujo drawOval, mediante la definición de un Applet que también se
encarga de reaccionar ante los eventos del usuario. Por ahora, nos
concentraremos en la definición del uso de la primitiva de dibujado del
lápiz (Graphics G) y procederemos después a revisar con más detalle el
tema de los eventos bajo los Applets Java, que observaremos se manejan
de manera idéntica a como se han tratado en las clases Java para la
Fascículo No. 8
Lenguajede
programación
18 Semestre 2
implementación de controles Swing

(Ver anexo no. VII – Implementación de la clase de manejo de eventos del ratón puntos locos).
Este código nos permite desplegar un Applet que reacciona a los eventos
de pulsación del click izquierdo del ratón, pintando un punto (círculo)
sobre las coordenadas capturadas en la superficie del canvas del Applet.
Figura 18
Applet Puntos Locos
8.1
1. Tomando como base, el Applet de los puntos locos, desarrolle un

método que permita calcular las distancias entre puntos adyacentes,
con el fin de definir el área del polígono que circunscriban dichos
puntos. Es decir, si se traza un cuadrado, un pentágono o un
hexágono con dichos puntos, el método debe recorrer los arreglos
de posiciones en x e y, y obtener las distancias entre punto y punto.
Desarrolle otro método que sume todas las distancias, e indique el
valor final del perímetro de la figura inscrita en los puntos trazados. A
medida que se trace cada punto, la cadena que imprime el perímetro
debe irse actualizando.
2. Desarrolle un Applet Java que permita el despliegue de tres figuras

geométricas (un triángulo, un círculo y un rectángulo). Sobre la
misma superficie del cambas y tomando como base las medidas
establecidas por los límites de los parámetros de cada figura, se
debe imprimir respectivamente de cada figura, sus siguientes valores
de medición:
Triángulo Área y Perímetro
Círculo Área y Longitud de la circunferencia
Rectángulo Área, Perímetro y Semiperímetro
Fascículo No. 8
programación
Eventos
Al igual que como observamos en los dos fascículos anteriores, los objetos
gráficos deben tener la capacidad de responder a los eventos del usuario.
En el Applet del ejemplo anterior, observamos que cada vez que hacemos
click izquierdo sobre la superficie del canvas del Applet, se dispara un
evento que obliga al recorrido del vector de puntos tanto en x como en y al
repintado de una serie de puntos sobre las coordenadas donde fue hecho
el click, mediante el uso del método fillOval. El objetivo en este apartado,
es analizar como los componentes Swing de las ventanas estándar de una
aplicación JSE (Java Standard Edition) pueden ser instanciados dentro de
la superficie del canvas e igual, a como vimos en los diálogos JFrame y
JPanel, poder asociar a los contenedores y los controles, escuchadores de
eventos que permitan agregar mayor nivel de interactividad del usuario al
Applet, con el objeto de hacerl o mucho más dinámico.
En primer lugar, hay que tener en cuenta, que para poder realizar este
proceso, es necesario organizar, como en los JFrames, contenedores
sobre el canvas con el fin de poder distribuir la superficie de pintado del
Applet. Si tomamos el ejemplo de los puntos locos, pensemos en modificar
el código de esta aplicación para permitir que el usuario además de pintar
los puntos, pueda también generar un polígono a partir del vector de
puntos almacenados en el Applet. Si observamos la parametrización del
método drawPolygon, observamos que este recibe como argumentos dos
arreglos (el de posiciones tanto en x como en y, así como el número total
de puntos almacenados, variables que ya están presentes como variables
de instancia o atributos en nuestra clase de los puntos locos.
Consideremos que ahora queremos es que ocurra un evento de que

cuando algo se pulse (como un botón por ejemplo), se trace automática-
mente el polígono. Retomando nuestros conceptos de eventos vistos en
Fascículo No. 8
Lenguajede
programación
20 Semestre 2
Swing, la esencia estaría en implementar un botón sobre el canvas,

asociarle un escuchador de evento y crear un método que cuando el botón
sea pulsado, haga que en el método paint se trace el polígono con la
primitiva de dibujo asociada al objeto gráfico Graphics (nuestro lápiz en el
Applet). Tomando estas premisas en el diseño de nuestra aplicación, con-
virtamos ahora el puntos locos en la clase EditorPoligonos.java, e inclu-
yamos adicionalmente en el método de inicialización (init()), la inclusión del
layout a aplicar sobre la superficie del canvas para poder distribuir los
controles y garantizar que los botones necesarios acompañarán a la
superficie de dibujado que ya hemos empleado previamente.
(Ver anexo no. VIII – Implementación del editor gráfico).
Como se puede observar en la implementación, el proceso de dibujado o

no dibujado de los objetos es controlado por una serie de variables
booleanas que se emplean como centinelas para indicarle al método paint
qué debe y qué no debe hacer. Cada vez que se pulsa un botón, auto-
máticamente se establecen los estados de dichas variables, haciendo que
cuando dichos métodos se evalúen en el método de refresco del pintado
del Applet (paint), se defina que se debe hacer con la actualización de la
superficie del canvas. Obsérvese igualmente que cuando se pulsa el botón
Borrar Polígono, lo que se hace es jugar simplemente con el concepto de
lógica y aritmética de colores.
Dado que la superficie del canvas siempre es blanca, para eliminar

cualquier conjunto de puntos previamente trazado y un polígono que haya
sido dibujado, basta con cambiar el color del lápiz al mismo color del
fondo (background) del canvas, y se repinta la misma figura, generando en
el canvas el efecto de que la figura ha sido borrada. Al borrarla, se
restituye el color del lápiz nuevamente a negro para que el usuario pueda
iniciar una nueva ronda de puntos y decidir cuándo pinta el siguiente
polígono.
Fascículo No. 8
programación
Por otro lado, también es posible hacer interactuar el teclado con la super-
ficie del canvas del Applet, mediante la implementación y sobreescritura
del método keyDown del Applet. Dicho método, así como mouseDown
actúa sobre las pulsaciones o clicks del ratón, permite controlar la
interacción con el buffer de escritura del teclado de la computadora,
facilitando la captura de los caracteres ASCII digitados por el usuario. El
siguiente Applet, denominado PalabrasApplet, implementa en dicho
método la captura de las teclas cursoras del teclado, lo que permite mover
los caracteres de la palabra escrita hacia cualquier nueva posición en la
superficie del canvas, indicada por el desplazamiento cada 5 pixeles de las
teclas de dirección del teclado. Si no se pulsa ninguna de estas teclas, el
método captura los demás caracteres del teclado y los almacena en una
variable de tipo String, generando mediante la primitiva drawString la
impresión (como si fuese una máquina de escribir) de la cadena que el
usuario vaya generando a medida que va digitando caracteres de entrada.
Figura 19
Clase PuntosLoco.java convertida en EditorPoligonos.java para permitir el dibujado de una primitiva (drawPolygon()), a partir de
la construcción de una GUI, un manejador de eventos y una redefinición del método paint.
El siguiente código del Applet lo ilustra mucho mejor

(Ver anexo no. VIII – Implementación del applet para el manejo del ratón palabrasapplet):
Fascículo No. 8
Lenguajede
programación
22 Semestre 2
Figura 20
Funcionamiento del Applet PalabrasApplet.java
Así se obtiene un Applet que permite la digitación, además de la

interacción producida por los efectos de repintado de las primitivas
contenidas en el objeto Graphics del componente creado.
En grupos de trabajo, preparen la siguiente implementación bajo Java, utilizando

los conceptos vistos de orientación a objetos y de desarrollo de Applets vistos en
este fascículo:
a) Modifique la clase PalabrasApplet.java, para que una vez el usuario haya

ingresado una cadena de caracteres y haya hecho clic sobre la superficie del
canvas del Applet, ese se encargue de codificar cada letra del alfabeto con su
respectivo código ASCII. Es decir, si el usuario escribe Jaime, el Applet pinta
sobre el canvas la secuencia de códigos ASCII de cada letra de dicha cadena
como 74 97 105 109 101. Si se ingresa la palabra San Martín, el Applet genera
83 97 110 32 77 97 114 116 237 110.
b) Desarrolle un Applet Java que implemente tres botones y un cuadro de texto

(Textbox) en la superficie del canvas y que se encargue de implementar, cada
uno de ellos, las siguientes funcionalidades:
Botón pintar cuadrado. Al pulsarlo debe llamar la primitiva fillRect y pintar de

forma aleatoria la cantidad de cuadrados especificados por el valor digitado en el
textbox. Los colores de cada cuadrado deben ser igualmente aleatorios (Utilice la
función random del paquete Math para generar los valores de las coordendas y
parámetros solicitados por el método de pintado de paralelogramos del objeto
Graphics.
Botón Borrar. Al pulsarlo, todas las figuras que estén pintadas en la superficie del
Applet, deben desaparecer automáticamente. Tome como base la
implementación de EditorPoligonos.java para realizar dicha implementación.
Fascículo No. 8
programación
Botón Pintar línea. Utilizando la base del Applet puntos locos, defina que al
pulsar este botón, el canvas debe mostrar una línea recta trazada entre dos
puntos que previamente hayan sido seleccionados en la superficie del canvas e
indicados debidamente sobre dicha superficie, a través del uso de la primitiva
drawFillOval, tal como actualmente lo hace el Applet de los puntos locos.
Como observamos en este fascículo, la estructuración de los Applets Java

permite la creación de aplicaciones donde los conceptos de programación
que hemos venido trabajando en fascículos previos cobran toda su fuerza,
revitalizados adicionalmente por el hecho fundamental de la correcta
aplicación de un proceso de modelamiento de las soluciones, de análisis
lógico de los problemas y finalmente de uso de las estructuras de
programación (ciclos, decisiones, etc.) como herramientas fundamentales
para la correcta construcción de soluciones informáticas.
Como vimos, la aplicación de los métodos de lógica de negocio, asocia-

dos al uso del concepto de herencia de la sobreescritura de los métodos
de la clase Applet, permite que el desarrollador construya sus propios
Applets, donde los conceptos de geometría, distribución, uso de las
primitivas y aplicación de la correcta parametrización de los métodos del
objeto Graphics permite la creación de aplicaciones visuales ricas y que
faciliten la simulación o el despliegue de procesos que no pueden reali-
zarse en aplicaciones Java Standard de consola o de aquellas que usan el
componente de entrada y salida JOptionPane. Adicionalmente, la capa-
cidad de integrar los componentes de Swing a la superficie del canvas,
muestra sin lugar a duda la riqueza de la interoperabilidad de los diversos
componentes ofrecidos por todas las APIS del lenguaje de programación
Java.
Fascículo No. 8
Lenguajede
programación
24 Semestre 2
Queda en el reto de los desarrolladores, el de crear nuevos objetos que

utilizando los conceptos de herencia, encapsulamiento y polimorfismo de
métodos permitan generar aplicaciones que respondan a un proceso
riguroso de diseño, que faciliten la construcción de soluciones a la medida
y lo más importante, que apliquen el buen paradigma de la programación
orientada a objetos como una herramienta funcional y crítica en la
definición de soluciones que satisfagan los requerimientos de los usuarios
finales y que sigan las buenas prácticas de diseño de aplicaciones
computacionales.
 Villalobos S., J. A., & Casallas G., R. (2006). FUNDAMENTOS DE

PROGRAMACIÓN - APRENDIZAJE ACTIVO BASADO EN CASOS.
México, D.F.: PEARSON, Prentice Hall.
 Deitel, H. M., & Deitel, P. J. (2004). CÓMO PROGRAMAR EN JAVA.
México, D.F.: PEARSON EDUCATION.
 Format, E. C. (1999). Java Enterprise In A Nutshell. New York.
Fascículo No. 8
programación
Fascículo No. 8
Lenguajede
programación
26 Semestre 2
Seguimientoal autoaprendizaje
Lenguaje de Programación - Fascículo No. 8

Nombre_______________________________________________________
Apellidos ________________________________ Fecha: _________________
Ciudad___________________________________Semestre: _______________
1) Desarrolle un Applet Java que permita la impresión de las tablas de

multiplicar de un valor previamente establecido en un parámetro del código
HTML que debe contener el valor sobre el cual quiere hacerse la tabla de
multiplicar. El Applet debe correr, tal como lo muestra la siguiente figura:
El parámetro en la página HTML que contenga al Applet debe ser:
<param name=”valorlimite” value=”10”>
2) Desarrolle un Applet Java que permita ilustrar la fecha actual del computador,
tal como lo hace el reloj del Sistema Operativo. Cuando el Applet se ejecute,
debe mostrar la fecha en el siguiente formato:
Hoy es Lunes, 09 de Noviembre de 2009 y son las 6:30:00 P.M.
3) Construya un Applet Java que utilizando el evento de manejo del teclado

permita capturar un valor numérico. Una vez el usuario haya hecho click con
el botón izquierdo del ratón, el programa debe mostrar la impresión en el
canvas de la suma del número con 100, la resta del número con 50, la
multiplicación del producto con 20 y la división del número con 2. Si el
Fascículo No. 8
programación
número ingresado es 0, en lugar de aparecer un error de división, debe

aparecer el mensaje “ERROR – DIVISIÓN POR CERO”. Utilice una excepción
aritmética como vimos en fascículos anteriores para controlar el error.
Fascículo No. 8
Lenguajede
programación
28 Semestre 2
Anexo
Implementación de la clase de manejo de eventos del ratón
puntos locos
package Appletsgraficos;
//Importaciones
import java.awt.Graphics;
import java.awt.Color;
import java.awt.Event;
import javax.swing.JOptionPane;
/**
*
*
* Tema: Manejo del ratón en Applets Java
* Este Applet permite pintar hasta 50 puntos
* sobre la superficie del canvas y cuando ya no
* puede hacerlo más, informa al usuario de dicha ocurrencia
*
*/
public class PuntosLocos extends Applet
{
/************************************************/
//Atributos de la Clase
//Número máximo de puntos permitidos
private final int PUNTOSMAXIMOS = 50;
//Arreglos para almacenar los puntos
private int [] puntosx = new int [PUNTOSMAXIMOS];
private int [] puntosy = new int [PUNTOSMAXIMOS];
//Contador de puntos
private int puntosactuales = 0;
/************************************************/
public PuntosLocos()
{
}

public void init()
{
try
{
setSize(800,600);
Fascículo No. 8
programación
//Establecemos el color de fondo en en canvas

setBackground(Color.red);
}

{
JOptionPane.showMessageDialog(null,"No se puede
cargar el color de fondo. Applet no inicializable: " +
errorInit.toString());
System.exit(0);
}
}//Fin del init
//Método para manejar el evento de control del raton

/**
* @arg evt Evento de pulsación del clic izquierdo
* @arg int x (Coordenada en x de donde se dio clic)
* @arg int y (Coordenada en y de donde se dio clic)
* */
public boolean mouseDown (Event evt, int x, int y)
{
boolean Estado = false;
try
{
if (puntosactuales < PUNTOSMAXIMOS)
{
//Agregamos el punto actual al vector de
//puntos
agregarPunto (x,y);
Estado = true;
}
else
{
JOptionPane.showMessageDialog(null,
"Demasiados puntos para pintar");
Estado = false;
}
catch (Exception errorMouseDown)

{
JOptionPane.showMessageDialog(null,"No se puede
operar el ratón: " + errorMouseDown.toString());
errorMouseDown.printStackTrace();
return (false);
}
return (Estado);
}//Fin del método
//Método para agregar un Nuevo Punto

public void agregarPunto (int x, int y)
{
Fascículo No. 8
Lenguajede
programación
30 Semestre 2
try
{
puntosx[puntosactuales] = x;
puntosy[puntosactuales] = y;
puntosactuales++;
//Repintamos
repaint();
}
catch (Exception erroragregarPunto)

{
JOptionPane.showMessageDialog(null,"No se pueden
agregar más puntos: " + erroragregarPunto.toString());
erroragregarPunto.printStackTrace();
}
}//Fin de agregar Punto
//Método para refrescar el Applet

{
try
{
g.setColor(Color.blue);
//Recorremos los vectores de puntos en x y y y
//pintamos
//los puntos en el canvas
for (int i = 0; i < puntosactuales; i++)
{
//USO DEL MÉTODO DE PINTADO DEL
//CANVAS
g.fillOval(puntosx[i] - 10, puntosy[i] - 10, 20,20);
}//fin del for
}
catch (Exception errorPaint)

{
JOptionPane.showMessageDialog(null,"Error en el
refresco del Applet: "+ errorPaint.toString());
errorPaint.printStackTrace();
}
}//Fin del paint
/************************************************/
/************************************************/
}//Fin del Applet
IMPLEMENTACIÓN DEL EDITOR GRÁFICO
package Appletsgraficos;
//Importaciones
import java.awt.Button;
import java.awt.Graphics;
import java.awt.Color;
import java.awt.Event;
import java.awt.event.*;
Fascículo No. 8
programación
/**
*
*
* Clase para implementar un editor gráfico
* que permite trazar un polígono a partir
* de un conjunto de puntos establecidos por el usuario
* y regenerar dicho polígono ante el evento
* de la pulsación de un botón. Igualmente
* el Applet permite limpiarlo cuando el usuario pulsa el botón borrar
*/
public class EditorPoligonos extends Applet implements ActionListener
{//Inicio de la clase
/************************************************/
//Variables de estado para indicar cuando pintar, rellenar o borrar
//el polígono
private boolean pintarPoligono;
private boolean pintarPoligonoLleno;
private boolean borrarPoligono;
//Número máximo de puntos permitidos

private final int PUNTOSMAXIMOS = 50;
//Arreglos para almacenar los puntos

private int [] puntosx = new int [PUNTOSMAXIMOS];
private int [] puntosy = new int [PUNTOSMAXIMOS];
//Contador de puntos
private int puntosactuales = 0;
//Botones de evento para el usuario

private Button botonPintar;
private Button botonPintarLleno;
private Button botonBorrar;
/************************************************/
public EditorPoligonos()
{
}
/************************************************/
//y los botones de operación
public void init()
{
Fascículo No. 8
Lenguajede
programación
32 Semestre 2
try
{
//Definimos el tamaño del canvas
setSize(800,600);
//Definimos el color de fondo para el Applet
setBackground(Color.WHITE);
//Establecemos los botones para las acciones

botonPintar = new Button ("Pintar Polígono");
//Agregamos el manejador de eventos
add(botonPintar);
botonPintar.addActionListener(this);
botonBorrar = new Button ("Borrar Polígono");

add(botonBorrar);
botonBorrar.addActionListener(this);
botonPintarLleno = new Button ("Pintar Polígono Relleno");

add(botonPintarLleno);
botonPintarLleno.addActionListener(this);
}//Fin del try

{
JOptionPane.showMessageDialog(null,"No se puede cargar el
color de fondo. Applet no inicializable: " + errorInit.toString());
System.exit(0);
}
}//Fin del init
/************************************************/
//Método para manejar el evento de control del raton
/**
* @arg evt Evento de pulsación del clic izquierdo
* @arg int x (Coordenada en x de donde se dio clic)
* @arg int y (Coordenada en y de donde se dio clic)
* */
public boolean mouseDown (Event evt, int x, int y)
{
try
{
if (puntosactuales < PUNTOSMAXIMOS)
{
//Agregamos el punto actual al vector de puntos
agregarPunto (x,y);
Estado = true;
}
else
{
JOptionPane.showMessageDialog(null,
"Demasiados puntos para pintar");
Fascículo No. 8
programación
Estado = false;
}
}//Fin del try
catch (Exception errorMouseDown)

{
JOptionPane.showMessageDialog(null,"No se puede operar el ratón: " +
errorMouseDown.toString());
errorMouseDown.printStackTrace();
return (false);
}
return (Estado);
}//Fin del método
/************************************************/
/************************************************/
/************************************************/
//Método para agregar un Nuevo Punto
public void agregarPunto (int x, int y)
{
try
{
puntosx[puntosactuales] = x;
puntosy[puntosactuales] = y;
puntosactuales++;
//Repintamos
repaint();
}
catch (Exception erroragregarPunto)

{
JOptionPane.showMessageDialog(null,"No se pueden
agregar más puntos: " + erroragregarPunto.toString());
erroragregarPunto.printStackTrace();
}
}//Fin de agregar Punto
/************************************************/
//Método para refrescar el Applet
//En este método establecemos el estado de la pulsación
//de los botones y definimos si se pinta o no el polígono
{
int i = 0;
try
{
System.out.println("Pintar poligono: " + pintarPoligono);
System.out.println("Borrar poligono: " + borrarPoligono);
//1. Verificamos si se debe pintar o no el polígono

if (pintarPoligono == true)
{
g.setColor(Color.BLACK);
//Pintamos los puntos
for (i = 0; i < puntosactuales; i++)
Fascículo No. 8
Lenguajede
programación
34 Semestre 2
{
}
//Pintamos el polígono
g.drawPolygon(puntosx, puntosy, puntosactuales);
}
else
if (pintarPoligonoLleno == true)
{
//Pintamos los puntos
{
}
g.fillPolygon(puntosx, puntosy, puntosactuales);
}
else
{
//Seguimos pintando puntos
{
}
}
//Verificamos si se va a borrar
if (borrarPoligono == true)
{
//Definimos el color blanco para los puntos
g.setColor(Color.WHITE);
{
}
g.setColor(Color.WHITE);
g.drawPolygon(puntosx, puntosy, puntosactuales);
//Limpiamos el arreglo
for (i = 0; i < PUNTOSMAXIMOS; i++)
{
puntosx[i] = 0;
puntosy[i] = 0;
}
puntosactuales = 0;
borrarPoligono = false;
}
}//Fin del try
catch (Exception errorPaint)

{
Fascículo No. 8
programación
JOptionPane.showMessageDialog(null,"Error en el refresco
del Applet: "+ errorPaint.toString());
errorPaint.printStackTrace();
}
}//Fin del paint
/************************************************/
//Método para capturar el evento de pintado
public void actionPerformed(ActionEvent e)
{
try
{
//Verificamos si se va a pintar
if (e.getSource() == botonPintar)
{
//Establecemos la variable para pintar el polígono
pintarPoligono = true;
System.out.println ("Entre al boton pintar");
}
if (e.getSource() == botonPintarLleno)
{
pintarPoligonoLleno = true;
System.out.println ("Entre al boton pintar lleno");
}
//Verificamos si se va a borrar
if (e.getSource() == botonBorrar)
{
borrarPoligono = true;
pintarPoligono = false;
pintarPoligonoLleno = false;
System.out.println ("Entre al boton borrar");
}
//Repintamos
repaint();
}//Fin del try
catch (Exception errorEventoBoton)

{
JOptionPane.showMessageDialog(null,"Error en el botón: " +
errorEventoBoton.toString());
errorEventoBoton.printStackTrace();
}
}
}//Fin de la clase
IMPLEMENTACIÓN DEL APPLET PARA EL MANEJO DEL RATÓN PALABRASAPPLET
package Appletssimples;
//Importaciones
Fascículo No. 8
Lenguajede
programación
36 Semestre 2
import java.awt.*;
/**
*
*
* Clase Java para implementar un Applet que imprime
* una cadena de caracteres, a medida que el usuario
* digita caracteres sobre la superficie del canvas
*/
public class PalabrasApplet extends Applet
{
/*******************************************/
/*******************************************/
/*******************************************/
//Atributos de la clase
//Caracter digitado por el usuario
private char teclaActual;
//Posición del cursor del teclado en el canvas en el eje x
private int posicionx;
//Posición del cursor del teclado en el canvas en el eje y
private int posiciony;
//Palabra construida a partir de la digitación de los caracteres
private String palabra;
/*******************************************/
//Constructor
public PalabrasApplet()
{
}
/*******************************************/
//Sobreescritura de los métodos de la clase
public void init ()
{
try
{
//Fondo blanco y fuente Helvética
setSize(800,600);
//Obtenemos las dimensiones de la pantalla
posicionx = (Container.WIDTH/2) + 50;
//posicionx = (size().width/2) - 8;
posiciony = (Container.HEIGHT/2) + 50;
setBackground(Color.white);
setFont(new Font("Helvetica",Font.BOLD,36));
//Palabra en limpio
palabra = "";
}
Fascículo No. 8
programación
{
JOptionPane.showMessageDialog(null,"Error en el init: " +
errorInit.toString());
}
}//fin del init
/*******************************************/
//Método para manejar el teclado (pulsación de una tecla)
public boolean keyDown (Event evt, int tecla)
{
//Switch para controlar que tecla se presionó

try
{
Estado = true;
switch (tecla)
{
//Flecha hacia abajo
case Event.DOWN:
posiciony += 5;
break;
//Flecha hacia arriba:

case Event.UP:
posiciony -= 5;
break;
//Flecha hacia la izquierda

case Event.LEFT:
posicionx -= 5;
break;
//Flecha hacia la derecha

case Event.RIGHT:
posicionx += 5;
break;
case Event.BACK_SPACE:
String palabraAnterior = "";
char caracter = '\0';
for (int i = 0; i < palabra.length()-1; i++)
{
caracter = palabra.charAt(i);
palabraAnterior += caracter;
}
palabra = palabraAnterior;
break;
default:
teclaActual = (char)tecla;
palabra += teclaActual;
break;
}//Fin del switch
Fascículo No. 8
Lenguajede
programación
38 Semestre 2
//Refrescamos la impresión de la tecla en el canvas

repaint();
}//fin del try
catch (Exception errorKeyDown)

{
JOptionPane.showMessageDialog(null,"Error en el teclado: " +
errorKeyDown.toString());
errorKeyDown.printStackTrace();
return (false);
}
return (Estado);
}//Fin del manejo del teclado
/*******************************************/
//Método para pintar
{
try
{
if (teclaActual != 0)
{
//Pintamos la tecla
g.setColor(Color.blue);
g.drawString(palabra,posicionx,posiciony);
}
}
catch (Exception errorGraphics)

{
JOptionPane.showMessageDialog(null,"Error en el método
gráfico de pintado: " + errorGraphics.toString());
errorGraphics.printStackTrace();
}
}
/*******************************************/
}//Fin del Applet
Fascículo No. 8
programación

LenProg F08

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

LenProg F08

Cargado por

Copyright:

Formatos disponibles

Fascículo

Tabla de contenido Página

Copyright©2008 FUNDICIÓN UNIVERSITARIA SAN MARTÍN

Prohibida la reproducción total o parcial sin autorización

La redacción de este fascículo estuvo a cargo de

Orientación a cargo de;

Diseño gráfico y diagramación a cargo de

Impreso en: GRÁFICAS SAN MARTÍN

El objetivo de este fascículo es aprender el fundamento del desarrollo de

Fascículo No. 8 Lenguaje de

del diseño de especificaciones funcionales para programas de cálculo,

Mapa conceptual Fascículo 8

Al finalizar el estudio de este fascículo el estudiante estará en capacidad de:

. Entender que es un Applet y cuál es la diferencia fundamental entre apli-

A diferencia de un programa, un Applet no puede ejecutarse de manera

restringidos. Un Applet normalmente lleva a cabo una función muy espe-

El proceso de construcción de un Applet sigue la misma filosofía de una

donde cada Applet escrito por el desarrollador está heredando los

A continuación observemos la estructura básica de un Applet Java:

cadenaImprimir = "Ejemplo de un Applet Java";

//Metodo para forzar la actualizacion del Applet

//Ejecuto los metodos de logica del Applet

Como podemos observar en el código, todo Applet al igual que cualquier

que escribamos debe sobreescribir tres métodos claves en la definición de

a) Método paint: Dicho método se encarga de forzar el refresco de la

b) Método init: Cumple la función de inicializar el canvas del Applet en el

c) Método repaint(): Es un método que no es necesario sobreescribir,

1. Desarrolle un Applet Java que permita la impresión de un párrafo de

utilizando la primitiva de trazado drawString que acabamos de ver en

Como se observa en la siguiente figura, el Applet que se visualiza

AppletImpresion.java. La segunda cadena de caracteres que se imprime,

El Appletviewer igualmente permite controlar el despliegue de nuevas

Ciclo de vida de un Applet

Cada círculo representa una fase en el ciclo de vida de la Applet. Las

a) Método init(): Como se había mencionado su función es crear la

no se puedan ejecutar más sus funciones. El método stop detiene el

El proceso se ilustra gráficamente a continuación:

Cuando un navegador carga una página Web que contiene un Applet,

Esto indica que el Applet, se está cargando:

1. Una instancia de la clase Applet es creada.

Etiqueta APPLET y paso de parámetros

<APPLET code="ClaseAppletJava.class" width="ancho"

Donde el parámetro code le indica al navegador que debe cargar en el

Dada la capacidad de desarrollar otros componentes, que en lugar de ser

En muchas ocasiones, se hace necesario que el Applet, por cuestiones

<APPLET code="ClaseAppletJava.class" width="1024" heigth="768">

Dichos valores deben establecerse mediante el parámetro de tag (etiqueta)

En el ejemplo anterior, observamos tres parámetros que definirían el alto y

procesar uno de sus métodos de operación. Esto significaría, por lo tanto,

if (valorAlto != null && valorAncho != null &&

//Establecemos el color de fondo en en canvas

catch (Exception errorInit)

En el momento de instanciar el Applet, los valores serán leídos desde la página

Clase Graphics y métodos de dibujo de primitivas

a) drawString( string s,x,y ): Permite dibujar una cadena de caracteres

b) drawLine( x1,y1,x2,y2 ): Permite trazar una línea recta por las

c) drawRect( x,y,ancho,alto ): Traza un rectángulo definido por el punto

d) fillRect( x,y,ancho,alto ): Trabaja igual que el método anterior, con la

e) drawFillOval( x,y,ancho,alto ): Permite trazar una circunferencia o un

f) drawFillArc( x,y,ancho,alto,anguloInicio,anguloArco): Permite trazar

g) drawPolygon( int[] puntosX,int[] puntosY[],numPuntos ): Permite

h) fillPolygon( int[] puntosX,int[] puntosY[],numPuntos ): Es similar al

El siguiente Applet muestra la implementación del uso de la primitiva de