Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Lenguaje de
Programación
Semestre 2
Lenguaje de programación
Lenguaje de
programación Semestre 2
Lenguaje de programación
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
Lenguaje de programación
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.
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.
Fascículo No. 8
Lenguajede
programación
2 Semestre 2
Lenguaje de programación
Logros
¿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).
Fascículo No. 8
Semestre 2 3 Lenguaje de
programación
Lenguaje de programación
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
Fascículo No. 8
Lenguajede
programación
4 Semestre 2
Lenguaje de programación
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
Semestre 2 5 Lenguaje de
programación
Lenguaje de programación
//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
Fascículo No. 8
Lenguajede
programación
6 Semestre 2
Lenguaje de programación
8.1
Fascículo No. 8
Semestre 2 7 Lenguaje de
programación
Lenguaje de programación
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
Fascículo No. 8
Lenguajede
programación
8 Semestre 2
Lenguaje de programación
Figura 4
Vista de un Applet en ejecución sobre el Appletviewer de Java
Figura 5
Opciones de administración del Appletviewer para el control de los Applets en ejecución
Fascículo No. 8
Semestre 2 9 Lenguaje de
programación
Lenguaje de programación
Figura 6
Ciclo de vida de un Applet Java
Fascículo No. 8
Lenguajede
programación
10 Semestre 2
Lenguaje de programació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
initializing... starting...
Fascículo No. 8
Semestre 2 11 Lenguaje de
programación
Lenguaje de programación
Fascículo No. 8
Lenguajede
programación
12 Semestre 2
Lenguaje de programación
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).
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
Semestre 2 13 Lenguaje de
programación
Lenguaje de programación
Fascículo No. 8
Lenguajede
programación
14 Semestre 2
Lenguaje de programación
try
{
//Leemos los parámetros del HTML
valorAlto = getParameter("alto");
valorAncho = getParameter("ancho");
numeroPuntosArranque = getParameter("numeropuntos");
PUNTOSMAXIMOS = numeroPuntos;
puntosx = new int[PUNTOSMAXIMOS];
puntosy = new int[PUNTOSMAXIMOS];
setSize(alto,ancho);
Fascículo No. 8
Semestre 2 15 Lenguaje de
programación
Lenguaje de 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.
Figura 10
Primitiva drawString()
Figura 11
Primitiva drawLine()
Fascículo No. 8
Lenguajede
programación
16 Semestre 2
Lenguaje de programación
Figura12
Primitiva drawRect()
Figura13
Primitiva fillRect()
Figura 14
Primitiva drawFillOval()
Fascículo No. 8
Semestre 2 17 Lenguaje de
programación
Lenguaje de programación
Figura 15
Primitiva drawFillArc()
Figura 16
Primitiva drawPolygon()
Figura 17
Primitiva fillPolygon()
Fascículo No. 8
Lenguajede
programación
18 Semestre 2
Lenguaje de programación
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
Fascículo No. 8
Semestre 2 19 Lenguaje de
programación
Lenguaje de 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.
Fascículo No. 8
Lenguajede
programación
20 Semestre 2
Lenguaje de programación
Fascículo No. 8
Semestre 2 21 Lenguaje de
programación
Lenguaje de 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.
Fascículo No. 8
Lenguajede
programación
22 Semestre 2
Lenguaje de programación
Figura 20
Funcionamiento del Applet PalabrasApplet.java
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
Semestre 2 23 Lenguaje de
programación
Lenguaje de 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.
Fascículo No. 8
Lenguajede
programación
24 Semestre 2
Lenguaje de programación
Fascículo No. 8
Semestre 2 25 Lenguaje de
programación
Lenguaje de programación
Fascículo No. 8
Lenguajede
programación
26 Semestre 2
Lenguaje de programación
Seguimientoal autoaprendizaje
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:
Fascículo No. 8
Semestre 2 27 Lenguaje de
programación
Lenguaje de programación
Fascículo No. 8
Lenguajede
programación
28 Semestre 2
Lenguaje de programación
Anexo
Implementación de la clase de manejo de eventos del ratón
puntos locos
package Appletsgraficos;
//Importaciones
import java.Applet.Applet;
import java.awt.Graphics;
import java.awt.Color;
import java.awt.Event;
import javax.swing.JOptionPane;
/**
* @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 *
*
* 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
{
/************************************************/
private static final long serialVersionUID = 14L;
//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;
/************************************************/
//Constructor de la clase
public PuntosLocos()
{
}
Fascículo No. 8
Semestre 2 29 Lenguaje de
programación
Lenguaje de programación
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;
}
return (Estado);
}//Fin del método
Fascículo No. 8
Lenguajede
programación
30 Semestre 2
Lenguaje de programación
try
{
puntosx[puntosactuales] = x;
puntosy[puntosactuales] = y;
puntosactuales++;
//Repintamos
repaint();
}
package Appletsgraficos;
//Importaciones
import java.Applet.Applet;
import java.awt.Button;
import java.awt.Graphics;
import java.awt.Color;
import java.awt.Event;
import java.awt.event.*;
Fascículo No. 8
Semestre 2 31 Lenguaje de
programación
Lenguaje de programación
import javax.swing.JOptionPane;
/**
* @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 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
/************************************************/
private static final long serialVersionUID = 12L;
//Atributos 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;
//Contador de puntos
private int puntosactuales = 0;
/************************************************/
//Constructor de la clase
public EditorPoligonos()
{
}
/************************************************/
//Sobreescritura de los métodos de la Clase Applet
//Init (): Define el tamaño y el color de fondo del canvas
//y los botones de operación
public void init()
{
Fascículo No. 8
Lenguajede
programación
32 Semestre 2
Lenguaje de programación
try
{
//Definimos el tamaño del canvas
//Tamaño del canvas
setSize(800,600);
//Definimos el color de fondo para el Applet
setBackground(Color.WHITE);
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
Semestre 2 33 Lenguaje de
programación
Lenguaje de programación
Estado = false;
}
}//Fin del try
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();
}
/************************************************/
//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
public void paint (Graphics g)
{
int i = 0;
try
{
System.out.println("Pintar poligono: " + pintarPoligono);
System.out.println("Borrar poligono: " + borrarPoligono);
Fascículo No. 8
Lenguajede
programación
34 Semestre 2
Lenguaje de programación
{
g.fillOval(puntosx[i] - 10, puntosy[i] - 10, 20,20);
}
//Pintamos el polígono
g.drawPolygon(puntosx, puntosy, puntosactuales);
}
else
if (pintarPoligonoLleno == true)
{
g.setColor(Color.BLACK);
//Pintamos los puntos
for (i = 0; i < puntosactuales; i++)
{
g.fillOval(puntosx[i] - 10, puntosy[i] - 10, 20,20);
}
//Pintamos el polígono
g.fillPolygon(puntosx, puntosy, puntosactuales);
}
else
{
g.setColor(Color.BLACK);
//Seguimos pintando puntos
for (i = 0; i < puntosactuales; i++)
{
g.fillOval(puntosx[i] - 10, puntosy[i] - 10, 20,20);
}
}
//Verificamos si se va a borrar
if (borrarPoligono == true)
{
//Definimos el color blanco para los puntos
g.setColor(Color.WHITE);
for (i = 0; i < puntosactuales; i++)
{
g.fillOval(puntosx[i] - 10, puntosy[i] - 10, 20,20);
}
//Pintamos el polígono
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
Fascículo No. 8
Semestre 2 35 Lenguaje de
programación
Lenguaje de 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
package Appletssimples;
//Importaciones
import java.Applet.Applet;
Fascículo No. 8
Lenguajede
programación
36 Semestre 2
Lenguaje de programación
import java.awt.*;
import javax.swing.JOptionPane;
/**
* @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, a medida que el usuario
* digita caracteres sobre la superficie del canvas
*/
public class PalabrasApplet extends Applet
{
/*******************************************/
/*******************************************/
/*******************************************/
//Atributos de la clase
private static final long serialVersionUID = 10L;
//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
Semestre 2 37 Lenguaje de
programación
Lenguaje de programación
{
JOptionPane.showMessageDialog(null,"Error en el init: " +
errorInit.toString());
errorInit.printStackTrace();
}
}//fin del init
/*******************************************/
//Método para manejar el teclado (pulsación de una tecla)
public boolean keyDown (Event evt, int tecla)
{
boolean Estado = false;
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
Lenguaje de programación
return (Estado);
}//Fin del manejo del teclado
/*******************************************/
//Método para pintar
public void paint (Graphics g)
{
try
{
if (teclaActual != 0)
{
//Pintamos la tecla
g.setColor(Color.blue);
g.drawString(palabra,posicionx,posiciony);
}
}
Fascículo No. 8
Semestre 2 39 Lenguaje de
programación