Programación para Internet. Java (DGSCA. UNAM)

NDICE
1. Introduccin a Java .............................................................................................................1

1.1 Desarrollo y evolucin de Java .....................................................................................1
1.2 Java es orientado a objetos ..........................................................................................1
1.3 La sintaxis de Java es similar a la de C ........................................................................2
1.4 Java es interpretado .....................................................................................................2
1.5 Java es multiplataforma ................................................................................................2
1.6 Java es multithread.......................................................................................................4
1.7 Programas elaborados con Java ..................................................................................4
1.7.1 Aplicaciones..........................................................................................................4
1.7.2 Applets..................................................................................................................5
1.8 El JDK y otras herramientas de programacin..............................................................7
1.8.1 JDK o J2SDK ........................................................................................................7
1.8.2 Java Work Shop....................................................................................................9
1.8.3 Visual Caf..........................................................................................................10
1.9 Compilando el programa HolaMundo..........................................................................10
2. Clases y objetos en Java ..................................................................................................13
2.1 Introduccin a las clases y objetos .............................................................................13
2.2 Los objetos son instancias de una clase.....................................................................15
2.3 Usando los mtodos de los objetos ............................................................................17
2.4 Creacin de un objeto.................................................................................................18
2.5 Definicin de un constructor .......................................................................................19
2.6 Mltiples constructores ...............................................................................................20
2.7 Sobrecarga de mtodos .............................................................................................20
2.8 Subclases y herencia..................................................................................................20
3. La herencia .......................................................................................................................22
3.1 Manejo de herencia con Java .....................................................................................22
3.2 La palabra reservada super para constructores ..........................................................25
3.3 Sobre-escritura de mtodos........................................................................................26
3.4 Definicin de nuevos datos y mtodos en subclases ..................................................27
3.5 La palabra reservada super para mtodos no constructores ......................................27
4. Applets..............................................................................................................................29
4.1 Ciclo de vida de un applet...........................................................................................29
4.1.1 Cargar el applet...................................................................................................29
4.1.2 Cambiando y regresando a la pgina del applet..................................................30
4.1.3 Cerrando el navegador........................................................................................31
4.2 Mtodos bsicos de la clase applet ............................................................................31
4.3 Programando interfaces grficas ................................................................................32
5. Programacin de interfaz grfica de usuarios ...................................................................35
5.1 Jerarqua de objetos del AWT ....................................................................................36
5.1.1 Clase Component ...............................................................................................36
5.1.2 Clase Button .......................................................................................................37
5.1.3 Clase Checkbox ..................................................................................................38
5.1.4 Clase Label .........................................................................................................40
5.1.5 Clase Container ..................................................................................................41
5.1.6 Clase Frame .......................................................................................................42
5.1.7 La clase MenuBar y otros objetos relacionados ..................................................45
5.2 Manejo de eventos .....................................................................................................48
5.2.1 Modelo delegacional ...........................................................................................49
6. JDBC ................................................................................................................................56
6.1 Introduccin ................................................................................................................56
6.1.1 Operaciones de un programa que utiliza el JDBC ...............................................56
6.1.2 Componentes del JDBC......................................................................................57
6.1.3 Tipos de controladores de JDBC.........................................................................57
6.2 Uso del controlador JDBC-ODBC bridge ....................................................................59
6.2.1 Instalando y configurando una base de datos con ODBC ...................................59
6.2.2 Estableciendo una conexin de base de datos....................................................61
6.2.3 Usando comandos bsicos de SQL ....................................................................62
BIBLIOGRAFA .....................................................................................................................67
Anexo A. La referencia this ...................................................................................................68
Anexo B. El modificador static...............................................................................................71
Anexo C. La etiqueta APPLET ..............................................................................................73
Pginas para Internet con Java
1. INTRODUCCIN A JAVA
El desarrollo de aplicaciones de computadoras ha evolucionado desde sus orgenes de manera
constante, al igual que las herramientas con las que se generan. En los ltimos aos ha sido
evidente el auge en la utilizacin del lenguaje Java, como una alternativa real y funcional para el
desarrollo de aplicaciones estndares o en lnea, con las ventajas que ofrece la Programacin
Orientada a Objetos (POO).
En el presente captulo se analizarn los orgenes de Java, as como su descripcin general; y
por ltimo se dar una breve explicacin de cmo instalar el JDK (Java Development Kit) para
comenzar a programar.
1.1 Desarrollo y evolucin de Java

Java surge en el ao de 1993 en los laboratorios de SUN Microsystems, como resultado de una
investigacin encaminada a solucionar los problemas relacionados con la programacin de
componentes para artculos electrodomsticos. La problemtica que SUN tena, era la de no
contar con una herramienta que les permitiera re-programar de manera eficiente sus
componentes a fin de adaptarlos a las nuevas necesidades de diseo y/o funcionamiento. El
lenguaje de programacin que haban utilizado hasta ese momento era C.
Teniendo en cuenta las necesidades concretas de programacin, tales como la reutilizacin de
cdigo, el desarrollo de aplicaciones para varias plataformas y el menor tiempo de capacitacin
para la generacin de nuevas aplicaciones con el nuevo esquema, entre otros, se determin la
creacin de un nuevo lenguaje. Dicho lenguaje fue posteriormente conocido como Java.
Entre las principales caractersticas de Java podemos citar las siguientes:
Es un lenguaje orientado a objetos.
Su sintaxis es similar a la de C.
Es interpretado.
Es multiplataforma.
Es multithread.
Estas caractersticas se explican brevemente en las siguientes secciones.
1.2 Java es orientado a objetos

Java es un lenguaje orientado a objetos, esto significa que las aplicaciones debern ser
diseadas para que funcionen como una serie de elementos (objetos) interrelacionados, de tal
forma que sus comportamientos describan el funcionamiento total de las aplicaciones que se
programan.
La base de la programacin orientada a objetos radica en los conceptos de clase y objeto. Una
clase describe las caractersticas y comportamientos de un tipo especial de objetos. En la
Alejandro Talavera Rosales
prctica, los lenguajes orientados a objetos cuentan con una serie de clases ya definidas. En el
caso de Java, existe una amplia variedad de clases (y por consecuencia objetos). Estas clases
definen objetos que pueden ser utilizados para distintas tareas: manejo de archivos, manejo del
ambiente grfico, programacin de aplicaciones de red, entre otros.
Otro concepto importante de la POO es la herencia. Bajo el concepto de herencia es posible
definir nuevos tipos de objetos a partir de los ya existentes. Existen dos tipos de herencia: la
herencia simple y la herencia mltiple. La primera hace referencia a la capacidad para definir
una nueva clase a partir de otra clase y solo una clase. Por su parte en el segundo tipo de
herencia, una clase puede definirse a partir de dos o ms clases. Java slo contempla la
herencia simple debido a las implicaciones de la herencia mltiple. La herencia es un
mecanismo que permite la reutilizacin de cdigo.
En Java, las clases se agrupan para formar lo que se conoce como paquetes. Estos paquetes
pueden ser utilizados en las aplicaciones que se programen.
1.3 La sintaxis de Java es similar a la de C

Los creadores de Java disearon el lenguaje para que su aprendizaje fuera sencillo y requiriera
poco tiempo para comenzar a desarrollar aplicaciones. Otro hecho importante para el desarrollo del
lenguaje, fue el hecho de que necesitaba que las aplicaciones ya generadas pudieran ser
fcilmente migradas al nuevo lenguaje. Por estas razones, se eligi como modelo al lenguaje C,
pero se eliminaron varias de las caractersticas que posee. Por ejemplo, Java no implementa el
control de flujo goto, a pesar de que es una palabra reservada. Las declaraciones de variables,
ciclos y asignaciones permanecen intactas con respecto a C.
En Java se elimina el uso de apuntadores a memoria, lo cual, si bien elimina mucho del
potencial con el que se contaba en C, en Java tienen ms peso los conceptos de la
programacin orientada a objetos.
1.4 Java es interpretado

Las aplicaciones desarrolladas con Java requieren de un intrprete para su ejecucin. Los
programas se compilan para generar un programa que correr una mquina virtual. Esta
mquina, en trminos reales no existe como un componente fsico, de hecho, el intrprete debe
implementar la mquina virtual de Java (JVM Java Virtual Machine).
En el caso de los navegadores de Web, Netscape Navigator y HotJava Browser, cuentan
con intrpretes de Java para aplicaciones desarrolladas con Java.
1.5 Java es multiplataforma

Como se mencion, las aplicaciones de Java se compilan para generar aplicaciones que
corrern en una mquina virtual, es decir, no estn diseadas para una plataforma en particular.
Esta caracterstica permite que las aplicaciones puedan ser generadas en una plataforma y
correr en otra. En ambos casos se deber de contar con los programas apropiados (para cada
plataforma) del compilador e intrprete.
La manera tradicional de generar programas implica, que a partir de un cdigo fuente, un

compilador genera el correspondiente programa para la plataforma en que se compila; es decir,
un compilador que fue diseado para una PC slo genera programas que se ejecutarn en una
PC. La figura 1 resume esta forma de producir programas.
Figura 1. Compilacin tradicional.
Con Java, este concepto cambia radicalmente. Se requiere nuevamente de un cdigo fuente,
pero el compilador de manera independiente a la plataforma en que se utiliza, generar un
cdigo intermedio (en este caso conocido como Java Byte Code). El cdigo intermedio es,
finalmente, ejecutado por un intrprete de Java. Tanto el compilador como el intrprete
dependen de la plataforma en particular del cliente, pero no as el cdigo intermedio. La figura 2
muestra este nuevo concepto.
Figura 2. Generacin del Java Byte Code.
1.6 Java es multithread

La programacin multithread no es un concepto que Java introduzca para el desarrollo de
aplicaciones, si no que al contrario, Java utiliza los sistemas operativos para el desarrollo de
nuevas aplicaciones. El concepto de multithread se refiere a la capacidad de ejecutar en
paralelo varias tareas a la vez a partir de un programa. En un programa tradicional, cada
instruccin se ejecuta por completo antes de continuar con otra, en cambio, en la programacin
multithread, una instruccin (o conjunto de ellas) pueden ejecutarse simultneamente sin que
con esto interfieran necesariamente en la ejecucin de las dems.
1.7 Programas elaborados con Java

Con Java, se pueden hacer una amplia variedad de programas, pero para que los propsitos de
este material sean claros, los programas elaborados con Java se han dividido en los siguientes
dos tipos:
Aplicaciones.
Applets.
1.7.1 Aplicaciones
Las aplicaciones son programas que se ejecutan con un intrprete. El intrprete est diseado
para correr en una plataforma en particular y recibe como parmetro el programa de Java,
adems de los parmetros propios del programa en particular.
Las aplicaciones pueden ser de distinta ndole, desde simples programas como los mostrados
en la figura 3.
Figura 3. Aplicacin de Java en MS-DOS.
En estos ejemplos, las aplicaciones fueron muy simples y slo requirieron del intrprete para
sus ejecuciones. En este caso en particular, se utiliz el intrprete para Windows 32-bits,
incluido en el JDK que se explicar en la siguiente seccin.
En el ejemplo de la figura 4, se muestra una aplicacin que recupera la informacin de una

base de datos1, obviamente necesit de ms elementos para ejecutarlo. Se requiri la
instalacin de los controladores de la base datos para Java, adems de la configuracin de la
red y del servidor mSQL.
Figura 4. Aplicacin con conexin a una base de datos.
Ahora bien, las aplicaciones aqu mostradas slo tienen una interfaz ASCII, pero se pueden
desarrollar aplicaciones grficas.
1.7.2 Applets
Los applets son un tipo especial de aplicacin. Con el auge de las aplicaciones en la Internet,
surge un nuevo tipo de programas desarrollados con Java. El objetivo de los applets es el de
incluir un programa que se ejecuta dentro de una pgina HTML, como la que se muestra en la
figura 5.
Cabe sealar que los applets no se ejecutan del mismo modo que un CGI2. En el caso de un
CGI, el servidor ejecuta el programa con sus recursos, y una vez procesada la informacin la
enva de regreso al navegador en forma de una pgina HTML. Un applet, por su parte, se aloja
en un servidor junto con la pgina que le hace referencia. Cuando dicha pgina se carga
tambin lo hace el applet, una vez cargado en el navegador, ste comienza a ejecutarse
utilizando ahora los recursos del equipo cliente.
La base de datos utilizada aqu fue mSQL 2.0.7
CGI es un programa que es activado a travs de un navegador.
Figura 5. Applet en un navegador.
Por las caractersticas propias de los applets, tienen una serie de limitaciones con respecto a
las aplicaciones. Como se nota, los applets estn pensados para ser distribuidos de forma
inmediata y esto conlleva una serie de implicaciones de seguridad muy fuertes, por ejemplo, un
applet no puede escribir o leer archivos de la mquina local, slo puede acceder a recursos del
equipo servidor.
Aun con estas limitantes, los applets vienen a ser un tipo de programas muy importantes para
los desarrolladores de Java, y como se ver en captulos posteriores, pueden crearse applets
como interfaces grficas para la manipulacin de sistemas de bases de datos. Un ejemplo de
esto ltimo, se presenta en la figura 6.
Figura 6. Applet como interfaz para una base de datos.
Otro ejemplo interesante de las aplicaciones de los applets se tiene en la figura 7, el cual fue
uno de los ganadores de la Java Cup International Award Winner del 97. Dicho applet permite al
usuario efectuar cortes longitudinales sobre el cuerpo humano.
Figura 7. Applet para un proyecto de medicina.
Hasta este momento, se han revisado algunos ejemplos de los programas que se pueden
desarrollar utilizando Java. En la siguiente seccin se abordar el tema de las herramientas de
desarrollo de Java.
1.8 El JDK y otras herramientas de programacin

1.8.1 JDK o J2SDK
SUN Microsystems ofrece de manera gratuita sus herramientas de desarrollo para Java
denominadas JDK (Java Development Kit), J2SDK (Java 2 Standar Edition Kit) y J2EDK
(Java 2 Enterprise Edition Kit), las cuales en general incluyen un compilador, un intrprete y
otras herramientas bsicas. Se cuenta actualmente con las siguientes versiones de estas
herramientas de desarrollo:
JDK 1.0.x y 1.1.x
JDK 1.2.x
J2SDK 1.3.x
J2EDK 1.3.x
J2SDK 1.4.x
J2EDK 1.4.x
Los sistemas operativos para estas herramientas de desarrollo que SUN ofrece, son los
siguientes:
Solaris 2.5 o superior (SPARC e Intel).

Windows 95, 98, Me , NT y XP.
Linux (Red Hat, Slackware, entre otros).
Actualmente existen las versiones de estas herramientas para otros sistemas operativos y
plataformas, tales como HP y Silicon Graphics. Para mayor informacin al respecto se pueden
consultar los sitios de cada fabricante.
Para instalar los Kits de SUN, los pasos son los mismos3:
1. Obtener el software de instalacin.
2. Ejecutar los programas de instalacin, o en su caso, descomprimir los archivos
correspondientes.
3. Configurar variables de ambiente.
Para los pasos 1 y 2 se recomienda al lector consultar la pgina de Java de SUN Microsystems:
http://java.sun.com/
Para el punto 3 tenemos las siguientes consideraciones:
Si se instala en un equipo PC, se sugiere agregar las dos siguientes lneas al archivo
Autoexec.bat para el caso del JDK 1.1 y anteriores:
SET PATH=C:\JDK1.1.7\BIN;%PATH%
SET CLASSPATH= C:\JDK1.1.7\LIB\CLASSES.ZIP;.
Esto es si C:\JDK1.1.7 es el directorio de instalacin.

Para el JDK 1.2, J2SDK 1.3.x y J2SDK1.4, slo hay que agregar la siguiente lnea al
Autoexec:bat
SET PATH=C:\JDK1.2\bin;%PATH%
Donde C:\JDK1.2.1 es el directorio de instalacin.
Si se instala en un equipo con sistema operativo UNIX, se sugiere agregar las dos
siguientes lneas al archivo fuente del shell en cuestin.
SET PATH /usr/local/jdk1.1.7/bin:%PATH%
SET CLASSPATH /usr/local/jdk1.1.7/lib/classes.zip:.
Esto es si /usr/local/jdk1.1.7 es el directorio de instalacin. Para el caso de un Bash

Shell, la configuracin sera la siguiente en el archivo .bash_profile:
SET PATH /usr/local/jdk1.1.7/bin:%PATH%
SET CLASSPATH /usr/local/jdk1.1.7/lib/classes.zip:.
export PATH CLASSPATH
Para el caso de otras herramientas, es necesario revisar la documentacin e instrucciones que ofrecen sus autores.
Una vez configurado el ambiente de trabajo podemos compilar y ejecutar los programas que se
vayan desarrollando. Usar estas herramientas es muy simple, pero representa un gran
problema para el desarrollador ya que carece de un ambiente grfico de trabajo funcional y
eficiente. Es decir, el cdigo fuente de los programas que se escriban, se har con cualquier
editor de texto que produzca archivos ASCII.
Actualmente existen herramientas poderosas para el desarrollo de aplicaciones, y applets de
formas grficas y con una amplia biblioteca de clases y soluciones de integracin inmediata. En
las siguientes secciones se presentan a grandes rasgos algunos de ellos.
1.8.2 Java Work Shop
Esta es una herramienta de desarrollo visual que ofrece SUN Microsystems. El producto incluye:
Interfaz de usuario intuitiva y un conjunto de herramientas para aumentar el desarrollo

productivo durante su ciclo de edicin, compilacin, depurado y definicin.
Plantillas para construccin sencilla y de componentes JavaBeans.
Soporte para el nuevo Java 2 SDK, Standard Edition, v 1.2 (formalmente el JDK 1.2).
El desarrollo de aplicaciones se divide en dos partes. La primera es la edicin sobre el cdigo

directo y la segunda con herramientas y componentes grficos. La figura 8 muestra el ambiente
general de trabajo de JavaWorkShop:
Figura 8.
Para mayor informacin, se recomienda al lector consultar la pgina:

http://www.sun.com/microelectronics/embedded/javaws.html.
1.8.3 Visual Caf
Esta herramienta permite sacar provecho de las plataformas Windows para el desarrollo de
aplicaciones con Java. Visual Caf es una poderosa herramienta que genera cdigo 100%
Java. Incluye adems una amplia biblioteca de componentes para aplicaciones concretas:
conexin a bases de datos, comunicacin va red y generacin rpida y confiable de elementos
grficos.
Figura 9.
Para mayor informacin, se recomienda al lector consultar la pgina:

http://www.webgain.com/Products/VisualCafe_Overview.html
1.9 Compilando el programa HolaMundo

A fin de garantizar que los ejemplos que se presenten en los captulos siguientes puedan ser
compilados y ejecutados por el lector, esta seccin le ofrece el primer cdigo a compilar y ejecutar,
donde se har uso de las herramientas bsicas de SUN: JDK o J2SDK. Para la compilacin y
ejecucin de los programas que aqu se presenten con las diferentes herramientas mostradas u
otras, ser necesario referirse a los manuales y especificaciones del fabricante.
El programa que se presenta es el denominado Hola Mundo, el cual es por excelencia el
primer ejemplo para usarse con un lenguaje de programacin. El objetivo del programa es el de
presentar el texto Hola Mundo!!! en la pantalla. Si bien la utilidad del mismo es nula, en nuestro
10
caso permitir comprobar la correcta instalacin de las herramientas de desarrollo y la definicin

de las variables de ambiente requeridas.
Como primer paso escriba el siguiente cdigo en un archivo llamado: HolaMundo.java, usando
para ello un editor que genere texto plano, es decir, sin formato.
public class HolaMundo
{
public static void main (String args[])

{
System.out.println (Hola Mundo!!! );
}
}
Editores que generan texto plano tenemos los siguientes:
EDIT, en MS-DOS.
Bloc de notas, en el ambiente grfico Windows.
Microsoft Word, en el ambiente grfico Windows. Al guardar el archivo utilice la opcin

de texto plano.
EditPLus Text Editor , en el ambiente grfico de Windows.
VI, en Unix.
PICO, en Unix.
ED, en Unix.
EMACS, en Unix.
Se debe tener cuidado de respetar las maysculas y las minsculas con las que se escribe el
cdigo fuente, ya que Java es un lenguaje sensible a maysculas y minsculas. Esta regla se
aplica tanto para el cdigo fuente como para el nombre del archivo.
Una vez generado el archivo fuente con las especificaciones mencionadas, se procede a
compilarlo con el programa Java, usando como argumento el nombre del archivo. La figura 10
muestra el uso de dicho programa y lista los archivos del directorio.
Figura 10.
11
Cuando no se genera error alguno, origina un segundo archivo que tiene el mismo nombre que
el del cdigo fuente, pero la extensin es .class. Este ltimo archivo es el correspondiente al
Java Byte Code.
En caso de que hubiera un error de sintaxis en el cdigo fuente, el compilador marcar el error
correspondiente. La figura 11 muestra el caso en que se compila el cdigo anterior, pero se
omite el punto y coma al final de la lnea: System.out.println (Hola Mundo!!! ). Cabe sealar
que si existe algn error en la compilacin no se genera el archivo .class.
Figura 11.
En caso de no existir algn error en la compilacin del cdigo fuente, se utiliza el programa
Java para ejecutar el programa, y como parmetro el nombre del archivo .class sin esta
extensin, ya que automticamente el programa busca dicho archivo. La figura 12 muestra la
ejecucin del programa HolaMundo.
Figura 12.
Si este programa se ejecuta en su equipo, puede tener la certeza de que instal correctamente
la herramienta de desarrollo de SUN, y que su ambiente de trabajo est listo para los siguientes
ejemplos. En caso contrario, consulte el archivo README de la instalacin, a fin de detectar la
causa por la que no se compile y/o ejecute este programa.
En los siguientes captulos se presentarn ms cdigos fuente, y las reglas que se deben seguir
para escribir correctamente programas usando el lenguaje de programacin Java.
12
2. CLASES Y OBJETOS EN JAVA

2.1 Introduccin a las clases y objetos
Una clase es una coleccin de datos y mtodos que operan sobre dichos datos. Los datos y los
mtodos, tomados juntos, usualmente sirven para definir el contenido y capacidades de algn
tipo de objeto. Analizando esta definicin, los datos se entienden como el conjunto de variables
asociados a un tipo de objetos y son representados por variables dentro del lenguaje. Por su
parte, los mtodos definen el conjunto de acciones que puede llevar a cabo dichos objetos y
son representados por funciones o procedimientos dentro del lenguaje.
Por ejemplo, si se desea representar a los crculos mediante una clase, y se hace un anlisis
rpidamente, los datos de un objeto Crculo pueden ser las coordenadas (x, y) de su centro y la
longitud de su radio r. Ahora bien, hay un nmero de acciones que pueden ser desempeadas
por cualquier crculo tales como calcular su circunferencia, calcular su rea, verificar si un
punto del plano cartesiano pertenece o no al crculo, entre otras ms.
Con todos los elementos descritos hasta el momento para esta clase de objetos, se utiliza el
Diagrama de Clases de la notacin de UML (Unified Modeling Language) para simplificar el
anlisis de la clase Circulo4. La regla correspondiente indica que una clase se representar en
un rectngulo divido en tres secciones, cada una de las cuales presentan la siguiente
informacin: nombre de la clase, listado de datos y listado de mtodos. La figura 1 muestra
dicha representacin de la clase Circulo.
Circulo
x : double
y : double
r : double
area() : double
circunferencia() : double
Figura 1. Clase Circulo.
Es decir, la representacin anterior indica que las variables: x, y y r son del tipo double5. Los
mtodos de area() y circunferencia() regresan valores de tipo double los cuales se calculan con
base en los datos anteriores.
Cabe sealar que esta representacin de clases es independiente del lenguaje, por lo que se le
indica al lector no confundir la representacin con UML y la implementacin de la clase con el
lenguaje de programacin Java.
La palabra Circulo no presenta acentos, ya que para definir nombres de identificadores, variables y mtodos slo se
pueden utilizar letras y nmeros, nunca caracteres especiales.
El tipo de dato double est definido en Java y representa nmeros de punto flotante de doble precisin.
13
Si bien una clase nos da la idea en conjunto de un grupo de objetos, cada objeto crculo es
diferente de los dems, ya que a cada uno de ellos cuenta con su propio conjunto de datos
(variables), y su conjunto mtodos (funciones).
Para traducir esta especificacin a un cdigo en Java, primero se escribir el archivo fuente con
un editor de texto simple que genere ASCII. El nombre del archivo ser el mismo que el de la
clase que se est especificando y la extensin ser .java. En otras palabras, el nombre del
archivo correspondiente al cdigo fuente de la clase Circulo es: Circulo.java. Note que la
primera letra tanto del nombre de la clase como del archivo fuente se encuentran en
maysculas, ya que Java es un lenguaje sensible a maysculas y minsculas.
El primer paso para especificar una clase en Java es la siguiente:
public class Circulo
{
}
Las palabras reservadas public class, al inicio del cdigo, indican el alcance y en s la
declaracin de una clase. En este caso particular del cdigo el nombre de dicha clase es
Circulo. Entre las dos llaves, una que abre y otra que cierra, se especifican los datos y mtodos
de la clase.
Los datos que se han definido son: x, y y r, todas ellas de tipo double. A continuacin se
presenta la definicin de estas variables en el cdigo.
{
public double x, y;
public double r;
}
La declaracin de variables en Java sigue bsicamente las mismas reglas que las del lenguaje
C, es decir, primero el tipo de dato y despus la lista de variables. Optativamente una misma
declaracin puede ser utilizada para ms de una variable, como con las variables x y y de
nuestro ejemplo. La palabra reservada public en las variables es optativa.
Lo que resta ahora es definir los mtodos de los objetos de esta clase. Los mtodos que se han
presentado devuelven datos numricos de tipo double. La implementacin del mtodo area() se
inicia con la especificacin de la siguiente forma:
public double area()
{
}
La palabra reservada double en este caso indica que el mtodo regresar una expresin
numrica de dicho tipo. El mtodo area() regresar el valor de la frmula: x r2. Para tal efecto,
se utilizar la siguiente versin de la frmula: 3.14159 * r * r.
La palabra reservada para indicar que se regresa un valor es return, seguida de la expresin a
evaluarse. El siguiente cdigo muestra la implementacin completa del mtodo area().
14

{
return 3.14159 * r * r;
}
Un anlisis similar para el mtodo circunferencia() producir el siguiente cdigo.

public double circunferencia()
{
return 2 * 3.14159 * r;
}
El ejemplo 1 muestra el cdigo completo de la implementacin de la clase Circulo.

{
public double x, y;
public double r;
{
return 3.14159 * r * r;
}

{
return 2 * 3.14159 * r;
}
}
Ejemplo 1.
En resumen, lo que se ha definido hasta el momento es la clase Circulo utilizando al lenguaje

Java para tal efecto. As pues, los objetos de esta clase tienen tres datos: x, y y r; y dos
mtodos: circunferencia( ) y area( ). En la siguiente seccin se presenta al lector cmo crear
objetos de esta clase.
2.2 Los objetos son instancias de una clase

Ahora que se ha definido la clase Circulo (al menos inicialmente), se har algo con ella, ya que no
es posible utilizarla por s misma, se requiere un circulo en particular para trabajar con l. Es
necesario una instancia de una clase, es decir, un simple objeto Circulo. Al definir la clase Circulo en
Java, se ha creado un nuevo tipo de dato. Pueden declararse variables de ese tipo:
Circulo c;
Pero esta variable c es simplemente un nombre que hace referencia a un objeto de la clase
Circulo; no es un objeto por s mismo. En Java, todos los objetos deben ser creados
dinmicamente. Esto es casi siempre utilizando la palabra reservada new como se muestra a
continuacin:
15
Circulo c;
c = new Circulo();
Con la ltima lnea se ha originado una instancia de la clase Circulo (es decir, un objeto), y se
ha referenciado con la variable c. Ya que se ha creado tal objeto, es posible usar sus campos
de datos ( x, y y r). La sintaxis ser familiar para los programadores de C:
Circulo c = new Circulo();
c.x = 2.0;
c.y = 2.0;
c.r = 1.0;
En este caso se asignaron los valores de 2.0, 2.0 y 1.0 a las variables x, y y r del objeto que se
cre, respectivamente.
Para verificar la creacin y la asignacin de valores hasta aqu presentados, el cdigo del
ejemplo 2 muestra el uso del mtodo main para la clase Circulo.
{
public double x, y;
public double r;
{
return 3.14159 * r * r;
}
{
return 2 * 3.14159 * r;
}
public static void main ( String args [ ] )
{
Circulo c;
c = new Circulo ( );
c.x = 2.0;
c.y = 2.0;
c.r = 1.0;
System.out.println (c.x );
System.out.println (c.y );
System.out.println (c.r );
}
}
Ejemplo 2.
La figura 2 muestra el resultado del cdigo anterior.
16
Figura 2.
2.3 Usando los mtodos de los objetos

Los mtodos de un objeto, como se explic anteriormente, definen las acciones que un objeto
puede llevar a acabo. Para utilizar los mtodos de un objeto, usamos la misma tcnica que para
asignar colores a los datos de un objeto:
double a;
c.r = 2.5;
a = c.area();
En este ltimo ejemplo se asign el valor del mtodo area( ) a la variable a. Observe la ltima
lnea. No se escribi a = area(); sino: a = c.area();
Esto se debe a que se utiliz la programacin Orientada a Objetos; aqu el objeto es el centro
de atencin y no as la llamada del mtodo. Esto es probablemente la ms simple e importante
caracterstica del paradigma orientado a objetos.
Note que no se pas ningn argumento a c.area(). El objeto sobre el que se est operando, c,
se encuentra implcito en la sintaxis. Observe de nuevo el ejemplo 1: notar lo mismo en la
definicin del mtodo area() - no toma argumentos. Esta implcito en el lenguaje, que un mtodo
opera sobre una instancia de la clase de la cual es definido. De este modo el mtodo area()
puede utilizar libremente el campo r de la clase - es claro que esta refirindose al radio de
cualquier instancia Circulo que invoca el mtodo.
Qu es lo que pasa aqu? Cmo puede saber un mtodo, que no toma ningn parmetro,
sobre que dato operar? En efecto, el mtodo area() simula tener un argumento, y se define con
un argumento implcito que no se muestra en la declaracin del mismo. El argumento implcito
es llamado this, y se refiere a este objeto - el objeto Circulo del cual el mtodo se invoco. this
es frecuentemente llamado la referencia this.
El argumento implcito this, no se muestra en la declaracin del mtodo, ya que usualmente no
es necesario - donde quiera un mtodo en Java puede accesar los campos en su clase.
El cdigo de un mtodo constructor de la clase Circulo se muestra en el ejemplo 3:
public Circulo(double a, double b, double c) {
x = a;
17
y = b;
r = c;
}
Ejemplo 3.
En este caso, el mtodo constructor inicializa los campos de datos del objeto que se est
creando. Este mtodo es equivalente al que se muestra en el ejemplo 4.
public Circulo(double a, double b, double c) {
this.x = a;
this.y = b;
this.r = c;
}
Ejemplo 4.
Cada vez que este ltimo constructor se ejecuta, this hace referencia al objeto que se est
creando en ese instante.
La palabra this se puede usar explcitamente cuando se quiere poner en claro que un mtodo
accesa sus propias variables y/o mtodos. Por ejemplo, se puede re-escribir el mtodo area()
de la siguiente forma:
public double area() {return 3.14159 * this.r * this.r;}
En un mtodo tan sencillo como ste, no es necesario ser explcito. Sin embargo, en casos ms
complicados, parece que utilizar un this explcito incrementa la claridad del cdigo aunque no
sea estrictamente necesario.
2.4 Creacin de un objeto

Se examinar de nuevo, la forma en que se cre un objeto de la clase Circulo:
Qu significan los parntesis? Una llamada de funcin. Toda clase en Java tiene al menos un
mtodo constructor6. El propsito de todo constructor es el de llevar a cabo el proceso de
inicializacin requerido para un nuevo objeto. Como no se defini de forma explcita un
constructor para la clase Circulo, Java da un constructor por omisin que no toma argumentos
ni efecta una inicializacin particular.
Esta es la forma en que funciona el mecanismo de creacin de objetos:
1. La palabra reservada new crea una nueva instancia dinmica de la clase; esto es, asigna el
objeto nuevo.
2. Se llama al mtodo constructor.
Los mtodos constructores tiene el mismo nombre que el de la clase que los define.
18
3. Se pasa explcitamente el objeto nuevo y se pasan explcitamente los argumentos
especificados entre los parntesis.
2.5 Definicin de un constructor

Si se desea que los objetos de la clase Circulo no se construyan con base en la forma por
omisin, en el ejemplo 5 se muestra un constructor que permite especificar los valores iniciales
para el centro y el radio de los nuevos objetos Circulo. El ejemplo ilustra al mismo tiempo el uso
de la palabra reservada this vista en la seccin anterior.
public class Circulo {
public double x, y, r;
//El mtodo constructor
public Circulo(double x, double y, double r) {
this.x = x;
this.y = y;
this.r = r;
}
public double circunferencia( ) {return 2 * 3.14159 * r;}
public double area( ) {return 3.14159 * r * r;}
}
Ejemplo 5.
Ahora, al crear un objeto de la clase Circulo, las variables de dicho objeto ya tienen valores que
les son asignadas desde el constructor.
Si desea el mismo efecto, pero con el constructor anterior, obtendra algo como el siguiente cdigo:
c.x = 1.1414;
c.y = -1.0;
c.r = .25;
Mientras que con el nuevo constructor, la inicializacin de variables se vuelve parte del proceso
para crear el objeto:
Circulo c = new Circulo (1.1414, -1.0, .25);
Existen tres reglas importantes para nombrar a los constructores:
El nombre del mtodo constructor es siempre el mismo que el de la clase.
El valor de retorno del mtodo es implcitamente una instancia de dicha clase. Para
cualquier constructor, el tipo de valor de retorno no se especifica, ni se puede emplear la
palabra reservada void.
El objeto this regresa implcitamente; un constructor no debe usar una declaracin return
para regresar algn valor.
19
2.6 Mltiples constructores

Existen ocasiones en que se requiere de inicializar un objeto de varias formas, dependiendo de
lo que resulte ms prctico en algn momento determinado. En el ejemplo 6 se muestra la
declaracin de varios constructores para la clase Circulo.
public class Circulo {
public double x, y, z;
public Circulo (double x, double y, double r) {
this.x = x; this.y = y; this.r = r;
}
public Circulo(double r) { x = 0.0; y = 0.0; this.r = r;}
public Circulo(Circulo c) { x= c.x; y =c.y; z = c.z;}
public Circulo() { x = 0.0; y = 0.0; r = 1.0; }
public double circunferencia () { return 2 * 3.14159 * r;}
public double area() { return 3.14159 * r * r; }
}
Ejemplo 6.
En este caso se definen tres constructores y todos ellos tienen el mismo nombre aunque
distintos parmetros. En la siguiente seccin se hace un anlisis de estas implicaciones.
2.7 Sobrecarga de mtodos

Con el ltimo ejemplo surge la siguiente pregunta: Cmo es posible que estos mtodos se
llamen iguales y el compilador pueda distinguirlos? La respuesta es simple, todo se debe a la
disposicin de los siguientes elementos: el nombre del mtodo, el nmero de parmetros, el
tipo y la posicin de los parmetros. Esta cualidad se denomina sobrecarga de mtodos y no es
exclusiva de los mtodos constructores.
Cuando se llama a un mtodo y hay ms de uno con el mismo nombre, el compilador
automticamente selecciona uno que se ajuste con los tipos de datos de los argumentos que le
hayan pasado.
Resumiendo, al hecho de definir mtodos con el mismo nombre y distintos tipos de argumentos
se denomina Sobrecarga de mtodo.
2.8 Subclases y herencia

La clase Circulo que se defini, representa una buena abstraccin de la figura matemtica que
modela. Pero supngase que se desea dibujarla en pantalla, por ejemplo, para lo cual ser
necesario una nueva clase, podra ser CirculoGrafico, que tiene toda la funcionalidad de
Circulo, adems de poderse dibujar.
Puede definirse la clase CirculoGrafico de la siguiente forma:
20
public class CirculoGrafico

{
public Circulo c; // Crculo matemtico
public double area() { return c.area(); }
public double circunferencia () { return c.circunferencia(); }
public Color exterior, relleno;
public void dibujar(DibujarVentana dw) { /* Cdigo */ }
}
Esta forma de hacerlo funciona, pero involucr la definicin de elementos que ya existan. Hay
una mejor opcin.
En Java es posible definir CirculoGrafico como una extensin o subclase de Circulo. El ejemplo
7 muestra la definicin de la clase CirculoGrafico como subclase.
public class CirculoGrafico extends Circulo
{
Color exterior, relleno;
public void dibujar(DibujarVentana dw)
{
dw.dibujarCirculo(x, y, r, exterior, relleno);
}
}
Ejemplo 7.
21
3. LA HERENCIA
Hablando de manera general, los objetos estn definidos en trminos de clases. Se sabe lo
bastante sobre un objeto tanto como se conozca la clase de la cual provienen. Por ejemplo, si
desconoce lo qu es un velocpedo, con slo decirle que es una bicicleta, sabra entonces que
tiene dos llantas, un juego de manubrio y de pedales.
Los sistemas de programacin orientados a objetos toman esto de forma similar y permiten que las
clases sean definidas en trminos de otras clases. Por ejemplo, las bicicletas de montaa, las de
carrera y las dobles, todas ellas son subclases de la clase bicicleta. Similarmente, la clase Bicicleta
es la superclase de las bicicletas de montaa, de carreras y dobles.
Cada subclase hereda las cualidades (en la forma de declaraciones de variables) de la
superclase. Las bicicletas de montaa, de carrera y dobles comparten las mismas cualidades:
cadencia, velocidad y la forma. Tambin, cada subclase hereda mtodos de la superclase. Las
bicicletas de montaa, de carreras y dobles comparten algunos comportamientos: frenado y
cambio de velocidades, por ejemplo.
Sin embargo, las subclases no se limitan a las cualidades y comportamiento provisto por sus
superclases. Qu habra que sealar en esto? Las subclases pueden agregar variables y
mtodos para aquellos heredados de la superclase. Las bicicletas dobles tienen dos asientos y
dos pares de manubrios; algunas bicicletas de montaa tienen un conjunto extra de engranajes
de radio menor.
Las subclases pueden tambin sobre-escribir los mtodos heredados y proveer
implementaciones especficas para esos mtodos. Por ejemplo, si tuviera una bicicleta de
montaa con un conjunto extra de engranes, podra sobre-escribir el mtodo
"cambio_de_engranes( )" para que la bicicleta pudiera realmente usar estos nuevos engranajes.
3.1 Manejo de herencia con Java

Dentro de los lenguajes de programacin orientados a objetos, la herencia puede ser simple o
mltiple. La herencia simple permite al programador definir nuevas clases a partir de una, y slo
una clase existente. Por el contrario, la herencia mltiple permite al programador definir nuevas
clases a partir de una o ms al mismo tiempo. En el caso particular de Java, sus diseadores
optaron por el manejo de la herencia simple, permitiendo que el manejo de la herencia sea fcil
de incorporar y de entender.
La herencia en Java se maneja con el uso de la palabra reservada extends, en la definicin de
la clase. Supngase que se define la clase A con todos sus datos y mtodos por completo.
Ahora supngase que se pretende crear la clase B como subclase de A. Lo que se debe hacer es
agregar a la declaracin de la clase B la expresin "extends A", como se muestra en el ejemplo 1.
public class A
{
...................
}
22
public class B extends A

{
...................
}
Ejemplo 1.
Ahora bien, cuando se defina una nueva clase C como subclase de B, se debe agregar
"extends C" a la declaracin de la clase, y as sucesivamente. Esta relacin de herencia
sucesiva da como resultado el denominado rbol de herencia, que se muestra en la figura 1.
Figura 1.
Las clases en Java forman un rbol de herencia con la clase Object como su raz (todas las
clases heredan al menos de la clase Object). Por ejemplo, la clase Applet hereda de Panel, sta
a su vez de la clase Container, que a su vez hereda de Component, y sta finalmente de la
clase Object, tal como se muestra en la figura 2.
Figura 2.
23
Cuando se declara una clase sin definir explcitamente una clase de la cual herede, se asume
que dicha clase heredar su funcionalidad de la clase Object. En otras palabras, los ejemplos 2
y 3 son equivalentes.
public class A
{
***************
}
Ejemplo 2.
public class A entends Object

{
***************
}
Ejemplo 3.
Como se mencion al inicio del captulo, la herencia permite definir nuevas clases a partir de las
ya existentes. En el ejemplo 4 se muestra la clase Rectangulo de la cual se define la clase
Cuadrado del ejemplo 5.
public class Rectangulo {
double x1, y1, x2, y2;
public double area() {
return Math.abs(x1 - x2) * Math.abs(y1 - y2);
}
public double perimetro() {
return (Math.abs(x1 - x2) + Math.abs(y1 - y2)) * 2;
}
public void estado() {
System.out.println(x1);
System.out.println(y1);
System.out.println(x2);
System.out.println(y2);
}
Rectangulo(double x1, double y1, double x2, double y2) {
this.x1 = x1; this.x2 = x2; this.y1 = y1; this.y2 = y2;
}
Rectangulo() {
this(0.0, 0.0, 1.0, 1.0);
}
}
Ejemplo 4.
24
public class Cuadrado extends Rectangulo {

public static void main(String arg[]) {
Cuadrado c = new Cuadrado();
c.estado();
System.out.println("El area es de : " + c.area());
System.out.println("El perimetro es de : " + c.perimetro());
}
}
Ejemplo 5.
En este caso, los objetos de la clase Cuadrado se crean con el mismo constructor de su
superclase, y pueden efectuar las mismas operaciones que los objetos Rectangulo tienen. Esta
funcionalidad se obtiene con slo declarar que sta es una subclase de Rectangulo.
Pero como tambin se explic, dicha funcionalidad puede ser modificada segn las
necesidades concretas de la nueva clase.
En el caso de los constructores existe una regla de funcionamiento, slo el mtodo constructor
por omisin se hereda tal cual como se defini en la superclase. Esto excluye a los dems
constructores que se hayan declarado. Cmo resolver este problema? Existen dos respuestas
a esta pregunta, la primera consistir en volver a escribir los mtodos constructores. Lo anterior
resulta de lo ms inconveniente, ya que no se reutilizara el cdigo ya compilado y probado. El
segundo mtodo es el uso de la palabra reservada super.
3.2 La palabra reservada super para constructores

super permite al programador hacer referencia directa a los mtodos de la superclase. En el
caso de los constructores, sta tiene la siguiente forma:
super(param1, param2, ...);
Adems, el uso de super para ejecutar constructores slo se puede hacer desde un constructor
de una clase heredada y debe ser la primera lnea del mtodo.
Para la clase Cuadrado del ejemplo 5, se tendr que aadir el mtodo constructor
Cuadrado(double,double,double,double) y declararlo como se muestra en el ejemplo 6
public Cuadrado(double x1, double y1, double x2, double y2){
super(x1, y1, x2, y2);
}
Ejemplo 6.
Pero para que esta clase represente a la figura geomtrica, el constructor requiere de
modificarse a fin de garantizar que la longitud de cada lado sea la misma. Note que no se
requiere modificar el constructor por omisin. Una solucin sera la que se muestra en el
ejemplo 7, en la cual, primero se crea el 'rectngulo', y despus se verifica si los lados tienen la
misma longitud, en caso de no ser as se ajustan las coordenadas.
25
public Cuadrado(double x1, double y1, double x2, double y2) {

super(x1, y1, x2, y2);
if(Math.abs(x1 - x2) != Math.abs(y1 - y2))
double d = Math.min(Math.abs(x1 - x2), Math.abs(y1 - y2));

if(x2 > x1) this.x2 = x1 + d;
else
this.x2 = x1 - d;
if(y2 > y1) this.y2 = y1 + d;

else
this.y2 = y1 - d;
}
}
Ejemplo 7.
Con estas modificaciones, puede garantizarse que los mtodos constructores proporcionarn
objetos Cuadrado de manera confiable.
Ahora bien, se podra pensar en modificar otros mtodos de la clase para ajustarlos a la forma
en que se est definiendo los mtodos area( ) y perimetro( ). Para ver un poco ms lo anterior,
se recurrir a la sobre-escritura de mtodos que se explica en la siguiente seccin.
3.3 Sobre-escritura de mtodos

Se denomina sobre-escritura de mtodos a la capacidad de volver a definir los mtodos que un
objeto ha heredado. Como se vio en la seccin anterior, es posible modificar los mtodos
constructores, pero an ms, se puede modificar cualquier mtodo que la clase haya heredado.
Retomando el caso de la clase Cuadrado, los mtodos area( ) y perimetro( )se pueden
simplificar de su versin para la clase Rectangulo, como se muestran en el ejemplo 8.
public double area(){
return Math.pow(Math.abs(x1 - x2),2);
}
public double perimetro(){
return Math.abs(x1 - x2) * 4;
}
Ejemplo 8.
El proceso de sobre-escritura es simple, se acta como si se escribiera la clase por primera vez
dentro de la clase.
26
3.4 Definicin de nuevos datos y mtodos en subclases

Cuando se define una subclase a partir de otra, se pueden agregar nuevos elementos, los
cuales funcionarn junto con los datos ya heredados. Por ejemplo, la clase A define dos
variables enteras x y y como se muestra en el ejemplo 9. La clase B hereda estos datos y
mtodos de A, adems agrega un nuevo dato a estos objetos: z, es decir, los objetos de esta
clase tienen los datos x, y y z. Esto ocurre de la misma forma con los nuevos mtodos, es decir,
se pueden incorporar nuevos mtodos a los ya existentes.
public class A{
int x, y;
*******
}
class B extends A{
int z;
double visor() { ******* }
}
Ejemplo 9.
Ahora bien, conforme se van generando nuevos datos y mtodos, o bien, las clases modifican
los mtodos que heredaron, la llamada a stos se va escalando a las superclases de la
siguiente forma: primero se busca si en la definicin de la clase actual se tiene declarado el
mtodo invocado, de ser as, se ejecuta este mtodo. En caso contrario se busca en la
definicin de la superclase y efecta el mismo anlisis. Esto continua sucesivamente hasta
llegar a la raz de herencia, en el caso de Java la clase Object. Si en este nivel no se encuentra
la definicin del mtodo, el compilador marcar un error.
3.5 La palabra reservada super para mtodos no constructores

Con estos mecanismos puede utilizarse el mtodo tal y como lo venia haciendo la superclase.
Supngase que la clase B hereda el mtodo area( ) de la clase A, como se muestra en el
ejemplo 10.
public class A{
*******
{ return 3.14259; }
*******
}
class B extends A{
********
}
Ejemplo 10.
27
Tambin se supondr, que para la clase B, se necesita sobre-escribir el mtodo area( ). Al

modificar directamente el mtodo, ste se ejecutar cuando un objeto de la clase B lo llame.
Pero puede plantearse que un objeto de la clase B ejecute area( ) con la definicin que hered
de forma intacta dado un valor verdadero, o bien, ejecute una nueva especificacin si el valor es
falso. Una opcin nuevamente sera la de escribir de nuevo la especificacin del mtodo. La
solucin ms prctica es el uso de la palabra super, ahora para mtodos no constructores.
Su utilizacin es simple, piense que super representa a un objeto de la superclase, entonces
vuelva a utilizar la notacin de punto de la siguiente forma:
super.mtodo(arg1, arg2, ...)
Para este caso, puede usar algo como lo que se muestra en el ejemplo 11.
double area( ) {
if(<condicin>) {
super.area( );
}
else {
//Nuevo cdigo
*************
}
}
Ejemplo 11.
28
4. APPLETS
Como se ha mencionado, existe otro tipo de aplicacin que puede programarse con Java
denominados applets. Los applets son programas que se ejecutan dentro de un documento
HTML y que corren con recursos del equipo cliente. Este tipo de programas tienen una serie de
restricciones para el acceso a recursos del equipo local debido a que su objetivo es el
desarrollo de aplicaciones de acceso global.
Para dejar ms claro el concepto de un applet, se retomar el ejemplo que est funcionando en
la direccin http://www.unam.mx/Temas/, el cual ofrece una opcin de bsqueda por teclado a
la manera de las ayudas de Windows. Ver figura 1.
Figura 1.
Cuando un navegador (con capacidad de ejecucin de applets) carga una pgina que tiene
asociado un applet, ocurren varias cosas. Lo primero es la verificacin de que el applet que se pide
cargar no contenga cdigo "peligroso", es decir, que no pueda recuperar informacin del equipo
local, como la lista de directorios y archivos, o en su caso la alteracin de los mismos. Una vez que
se comprueba que lo que se recibe es efectivamente un applet, comienza lo que se denomina el
ciclo de vida de un applet, que se explica en la siguiente seccin.
4.1 Ciclo de vida de un applet

4.1.1 Cargar el applet
Cuando se carga un applet, se efectan las siguientes operaciones:
Una instancia de la clase de control del applet se crea.
El applet se inicializa.
29
El applet comienza a correr.

import java.applet.Applet;
import java.awt.Graphics;
public class Simple extends Applet {
StringBuffer buffer;
public void init() {
buffer = new StringBuffer();
addItem("inicializando... ");
}
public void start() {
addItem("comenzando... ");
}
public void stop() {
addItem("deteniendo... ");
}
public void destroy() {
addItem("descargando...");
}
void addItem(String newWord) {
System.out.println(newWord);
buffer.append(newWord);
repaint();
}
public void paint(Graphics g) {
//Dibuja un rectngulo alrededor del rea de despliegue del
Applet.
g.drawRect(0, 0, size().width - 1, size().height - 1);
//Dibuja la cadena actual dentro del rectngulo
g.drawString(buffer.toString(), 5, 15);
}
}
Ejemplo 1.
4.1.2 Cambiando y regresando a la pgina del applet

Cuando los usuarios cambian de pgina, esto es, van a otra pgina, el applet puede pararse.
Caso contrario, cuando el usuario regresa a la pgina, el applet comienza de nuevo a
ejecutarse. Esto ltimo se repite cada vez que se minimiza y maximiza la ventana donde se est
presentando el applet.
30
4.1.3 Cerrando el navegador

Cuando el usuario cierra el navegador, el applet se detiene y puede ejecutar un proceso final
antes de salir.
Resumen
Un applet reacciona entre otros eventos de las siguientes formas:
Puede inicializarse.
Puede comenzar a correr.
Puede detenerse.
Puede ejecutar un proceso antes de que el applet se destruya.
4.2 Mtodos bsicos de la clase applet

Los applets son clases ya definidas, lo nico que se debe hacer es sobre-escribir los mtodos
que ya se definieron para su funcionamiento. El ejemplo 2 muestra un resumen con los
mtodos bsicos que se modificaron para el applet simple.
public class Simple extends Applet {
...
public void init() { . . . }
public void start() { . . . }
public void stop() { . . . }
public void destroy() { . . . }
...
}
Ejemplo 2.
Los mtodos que all aparecen, responden a eventos especficos. A continuacin se da una
breve explicacin del funcionamiento de cada uno de estos mtodos.
init()
Sirve para inicializar al applet. Este mtodo se ejecuta slo despus de que el applet
se ha cargado.
start()
Este mtodo sirve para comenzar la ejecucin del applet, se ejecuta despus de que
se ha inicializado el applet, o bien, cuando se regresa a la pgina del applet.
stop() -- Detiene la ejecucin del applet. Este mtodo se ejecuta cuando los usuarios dejan la
pgina del applet, o bien, cuando se cierra el navegador.
destroy()-
Se ejecuta despus de que se detiene el applet, ya que el navegador se cierra.
31
Cabe mencionar, que los applets no requieren sobre-escribir todos y cada uno de los mtodos
definidos para los mismos. En el ejemplo 3 se muestra el cdigo fuente de un applet muy
sencillo, donde slo se requiri la modificacin del mtodo paint()7.
import java.awt.Graphics;
public class HolaMundo extends Applet {
public void paint(Graphics g) {
g.drawString("Hola Mundo!!!", 40, 20);
}
}
Ejemplo 3.
El mtodo init() cumple de alguna manera la funcin de un constructor, ya que slo se ejecuta
inmediatamente despus de que el applet se ha cargado. Hay que notar que no se utiliza un
constructor para los applets, esto se debe a que es necesario garantizar el ambiente de trabajo
por completo, lo cual se verifica cuando el applet se carga.
Si el applet debe efectuar alguna operacin despus de su inicializacin ser necesario sobreescribir el mtodo start(). El mtodo start(), a la vez que activa al applet, desarrolla el trabajo del
mismo; tambin pone en funcionamiento uno o ms threads para desarrollar el trabajo. Por el
momento slo se dar importancia al primer punto. El mtodo stop() se ha definido para detener
la ejecucin del applet. El mtodo destroy() es raramente utilizado ya que el mtodo stop()
efecta todo lo necesario para detener la ejecucin del applet. Sin embargo, destroy() est
disponible para aquellos applets que requieran procesos adicionales antes de terminar la
ejecucin del applet.
4.3 Programando interfaces grficas

La programacin de interfaces grficas no es exclusiva de los applets. Elementos tales como
botones, cajas de texto, despliegue de grficas y dems, pueden incluirse en cualquier tipo de
programa con Java, ya sea aplicacin o applet.
Para incluir componentes grficos, es necesario incluir el paquete java.awt. en el programa que se
est generando. La figura 2 muestra algunas de las clases que contiene el paquete java.awt.
Este mtodo se describir ms adelante.
32
Figura 2.
Para el caso de los applets, todos estos elementos que conformarn la interfaz grfica
(botones, cajas de texto, etc.), se van agregando en el mtodo init().
Supngase que se desea una interfaz como la que se muestra en la figura 3.
Figura 3.
El cdigo asociado a este applet sera el que se muestra en el ejemplo 3.

import java.awt.*;
public class Interfaz01 extends Applet
{
Label lb1, lb2, lb3;
33
TextField tf1, tf2;

TextArea ta1;
public void init()

{
lb1 = new Label("Nombre:");
add(lb1);
tf1 = new TextField(20);
add(tf1);
lb2 = new Label("Direccion:");
add(lb2);
tf2 = new TextField(20);
add(tf2);
lb3 = new Label("Comentarios:");
add(lb3);
ta1 = new TextArea("Comentarios", 10, 20);
add(ta1);
}
}
Ejemplo 3.
34
5. PROGRAMACIN DE INTERFAZ GRFICA DE USUARIOS

El objetivo de una interfaz grfica de usuario es la de facilitar la interaccin de un programa o
sistema con sus usuarios finales. Si bien el xito de una interfaz grfica de usuario depende en
gran parte de un estudio a fondo de los aspectos ergonmicos adecuados para los programas,
no es el objetivo de este manual el proporcionar guas al respecto.
Una interfaz proporciona al usuario un conjunto de elementos grficos para que ste pueda
operar, insertar, desplegar y manipular informacin desde y para el programa. En otras palabras
una interfaz grfica de usuario es la cara de nuestro desarrollo ante el usuario. La figura 1
presenta una interfaz de usuario programada en Java.
Cada uno de los elementos grficos que podemos apreciar en la figura 1, y otros ms, forman
parte del paquete java.awt.
Figura 1.
Otro aspecto importante, ligado a los componentes, es la generacin de eventos. Un evento es

el resultado de la interaccin de un usuario con alguno de los componentes de la interfaz
grfica, por ejemplo, un usuario genera un evento al activar un botn, o bien al abrir o cerrar
una ventana.
El concepto de AWT o Abstract Window Toolkit slo engloba los componentes grficos, la parte
de programacin de eventos est contenida en el paquete java.awt.event8. En el presente
captulo, se presentan al lector, los distintos objetos definidos en Java para el uso de
componentes grficos.
El paquete java.awt.event no est contenido en java.awt por lo que las importaciones deben realizarse de manera
separada en cada caso.
35
5.1 Jerarqua de objetos del AWT

A partir de la versin del JDK 1.1, se ha dado una mayor atencin y flexibilidad a los elementos y
objetos para la programacin e incorporacin de elementos grficos. El paquete AWT contiene
todos los componentes grficos para incluirlos en la programacin. Existe una jerarqua de herencia
que relaciona todos los elementos grficos. La figura 2 muestra dicha jerarqua.
Figura 2.
La base de la herencia sigue siendo la case Object, pero la clase Component se toma como la
raz de la herencia de todos los componentes grficos de una interfaz. La clase Component es
definida como abstracta, es decir, no se puede generar objetos de la misma. A diferencia de
Component sus subclases pueden ser instanciadas, salvo las clases Container y
TextComponent que tambin son abstractas.
Las diferentes clases de la jerarqua del AWT se presentarn una por una, mostrando su
representacin grfica, sus propiedades y los mtodos ms tiles para su programacin.
5.1.1 Clase Component
Como se mencionaba, la clase es abstracta por lo que no pueden tenerse objetos de esta clase.
Su propsito es establecer un patrn de diseo y funcionalidad de los componentes grficos en
general.
Los objetos Component tienen definidos mtodos que permiten la recuperacin de informacin
relativa a ellos, adems de los mtodos que manipulan su aspecto final. Al ser la raz de
herencia de los componentes grficos, todos los mtodos que este objeto tenga, los tendrn
definidos las distintas subclases de ste.
Los mtodos de recuperacin de informacin ms importantes son los que se presentan en la
siguiente tabla:
Nombre
getHeight()
Tipo de retorno
int
Uso
Regresa el valor de la altura del componente.
36
getWidth()
getX()
int
Int
getY()
int
isEnabled()
boolean
isVisible()
bolean
getSize()
Dimension
Regresa el valor del ancho del componente.

Regresa el valor de la posicin con respecto al eje
X del componente.
Regresa el valor de la posicin con respecto al eje
X del componente.
El valor de retorno indica si el componente est
activado (true) o no (false).
El valor de retorno indica si el componente est
visible (true) o no (false).
Regresa un objeto de la clase Dimension que
representa el tamao del componente.
Los mtodos ms importantes de manipulacin de informacin y aspecto de un Component son

los que se presentan en la siguiente tabla:
Nombre
paint(Graphics)
repaint()
repaint(long)
Tipo de retorno
void
void
void
setBackground(Color)
setEnabled(boolean)
setLocation(int,int)
setSize(int,int)
update(Graphics)
void
void
void
void
void
Uso
Pinta el componente.
Repinta el componente.
Repinta el componente cada cierto tiempo en
milisegundos.
Establece un color de fondo.
Modifica su estado de disponibilidad: true o false
Establece la posicin del componente.
Establece las dimensiones del componente.
Actualiza la vista del componente.
5.1.2 Clase Button

Los objetos Button proporcionan la implementacin de botones para una interfaz grfica. Un
botn es un componente que se genera un evento cuando el usuario da un clic sobre l. La
clase Button definen dos constructores para estos objetos, los cuales son los siguientes:
Button( ) : construye un botn sin etiqueta.
Button( String ) : construye un botn con una etiqueta especfica.
Los siguientes, son los ejemplos de la definicin y creacin de botones usando los
constructores anteriores:
Button b1 = new Button ( Aceptar );
Button b2 = new Button ( );
La figura 3 muestra estos dos botones dentro de una ventana.
Figura 3.
37
Los mtodos de recuperacin de informacin ms importantes de los objetos Button son los que
se presentan en la siguiente tabla:
Nombre
getActionCommand()
Tipo de retorno
String
getLabel()
String
Uso
Regresa el String asociado al evento del
botn.
Regresa un String que representa la
etiqueta del botn.
Los mtodos ms importantes de manipulacin de informacin y aspecto de un Button son los

que se presentan en la siguiente tabla:
Nombre
setActionCommand(String)
Tipo de retorno
void
Uso
Establece el String asociado a los eventos
del botn.
setLabel()
void
Establece la etiqueta del botn con el

String de parmetro.
5.1.3 Clase Checkbox

La clase Checkbox proporciona cajas de seleccin, las cuales permiten al usuario marcarlas o
no. Si un usuario activa este componente se cambia de estado intercalando dichos estados. La
figura 4 muestra el despliegue de estos componentes.
Figura 4.
Los objetos de esta clase tienen los siguientes constructores:

Checkbox( ) : crea una caja de seleccin sin etiqueta.
Checkbox(String) : crea una caja de seleccin con una etiqueta especfica.
Checkbox(String, boolean): crea una caja de seleccin con una etiqueta y un estado
especficos.
Checkbox(String, boolean, CheckboxGroup): crea una caja de seleccin con una etiqueta
y un estado especficos, adems de especificar un grupo al que pertenece.
Checkbox(String, CheckboxGroup, boolean): crea una caja de seleccin con una etiqueta
y un estado especficos, adems de especificar un grupo al que pertenece.
Los dos primeros constructores permiten varios de ellos sin que tengan relacin unos de otros. Las
dos ltimas opciones sirven para generar lo que se conoce como radios, es decir, varias opciones
pero slo se puede seleccionar una a la vez, tal como se muestra en la figura 5.
38
Figura 5.
El siguiente cdigo muestra la definicin y creacin de cajas de opciones usando los primeros
dos constructores, que corresponden a la figura 4:
Checkbox cb1 = new Checkbox ( );
cb1.setLabel ( "Opcion 1" );
Checkbox cb2 = new Checkbox ( "Opcion 2", false );
Checkbox cb3 = new Checkbox ( "Opcion 3", true );
Checkbox cb4 = new Checkbox ( "Opcion 4", true );
El siguiente cdigo muestra la definicin y creacin de cajas de opciones de una seleccin a la
vez, usando los dos ltimos constructores. La figura 2 corresponde a este cdigo:
CheckboxGroup cbg = new CheckboxGroup ( );
Checkbox cb1 = new Checkbox ( "", cbg, false );
cb1.setLabel ( "Opcion 1" );
Checkbox cb2 = new Checkbox ( "Opcion 2", cbg, false );
Checkbox cb3 = new Checkbox ( "Opcion 3", cbg, true );
Checkbox cb4 = new Checkbox ( "Opcion 4", cbg, false );
Los mtodos de recuperacin de informacin ms importantes son los que se presentan en la
siguiente tabla:
Nombre
getCheckboxGroup()
Tipo de retorno
CheckboxGroup
getLabel( )
String
getState( )
bolean
Uso
Regresa
una
referencia
al
grupo
correspondiente de la caja de opcin.
Regresa el String de la etiqueta de la caja
de opcin.
Regresa el valor del estado de la caja: true
o false.
Los mtodos ms importantes de manipulacin de informacin y aspecto de un Component son

los que se presentan en la siguiente tabla:
Nombre
setCheckboxGroup(CheckboxGroup)
setLabel(String)
setState(bolean)
Tipo de
retorno
void
void
void
39
Uso
Asigna el grupo a la caja.
Asigna una etiqueta a la caja de opcin.
Asigna el valor del estado de una caja de
opcin.
5.1.4 Clase Label

Los objetos de la clase Label se utilizan para colocar etiquetas en una interfaz grfica. Las
etiquetas pueden ser insertadas cuando es necesario mostrar alguna informacin al usuario, o
bien, se utilizan para asignar nombres a los campos de un formulario. La figura 6 indica los
objetos de la clase etiqueta utilizados en la primera interfaz.
Figura 6.
La clase Label define los siguientes constructores:
Label(): construye una etiqueta vaca.
Label(String): construye una etiqueta con un texto justificado a la izquierda.
Label(String, int): construye una etiqueta con un texto y justificado segn el valor del
segundo parmetro.
Para el tercer constructor, los valores enteros que pueden ser utilizados, son las siguientes
constantes definidas en la misma clase: CENTER, LEFT y RIGHT.
El siguiente cdigo muestra la definicin y creacin de etiquetas usando los constructores
anteriores. La figura 7 muestra el resultado del cdigo.
Label lb1 = new Label ( );
lb1.setText ( "Etiqueta 1" );
Label lb2 = new Label ( "Etiqueta 2" );
Label lb3 = new Label ( "Etiqueta 3", Label.CENTER );
Label lb4 = new Label ( "Etiqueta 4", Label.LEFT );
Label lb5 = new Label ( "Etiqueta 5", Label.RIGHT );
40
Figura 7.
Los mtodos de recuperacin de informacin ms importantes son los que se listan en la

siguiente tabla:
Nombre
getAlignment()
getText()
Tipo de retorno
int
String
Uso
Regresa el valor de alineacin de la etiqueta.
Regresa el String que corresponde a la etiqueta
Los mtodos ms importantes de manipulacin de informacin y aspecto de un Label son los

Nombre
setAlignment(int)
setText(String)
Tipo de retorno
void
void
Uso
Asigna el valor del alineamiento.
Asigna la cadena a desplegar la etiqueta.
5.1.5 Clase Container

Un contenedor es un tipo especial de componente grfico, en tanto puede albergar
componentes e incluso otros contenedores, bajo ciertas reglas. La clase Container representa
la base de la herencia de otros, tales como Window, Frame, Dialog y Panel, entre otros. La
figura 8 muestra las relaciones de herencia derivadas de Container.
Figura 8.
Un contenedor cuenta con un conjunto de mtodos add, los cuales permiten la insercin de
otros componentes grficos en ellos. La siguiente tabla muestra las distintas versiones del
mtodo add.
Mtodo
Add(Component)
add(Component, int)
add(String, Component)
Uso
Agrega el componente al final del contenedor.
Agrega el componente al contenedor en la posicin dada
por el segundo parmetro.
Agrega el componente al contenedor con un String que se
le asocia.
41
La representacin grfica y el uso de cada contenedor depende del objeto y su funcin de

operacin. La figura 9 muestra la representacin grfica de los contenedores presentados en la
figura 8.
Figura 9.
La clase Container se defini como abstracta, es decir, no puede ser instanciada. En su lugar se
utilizan las clases derivadas de sta para agregar componentes a estos. Las clases Panel y
ScrollPanel no tienen representacin grfica, pero sirven para agrupar componentes dentro de un
contenedor. La clase Window es un recuadro blanco que se despliega sobre el monitor, los objetos
de esta clase no pueden ser modificados ni en su tamao ni en su posicin.
Los objetos de la clase Frame representan ventanas de la interfaz grfica de la plataforma
donde se despliega. Tienen barra de ttulo y botones para las operaciones de maximizar,
minimizar cerrar y de control.
Los objetos de la clase Dialog representan ventanas de aviso. Su nico fin es el de presentar al
usuario mensajes relativos al sistema, o bien, solicitar informacin por este medio. Una clase
derivada es FileDialog para desplegar ventanas de archivos, y buscar archivos en la mquina
local.
Se principiar con los objetos de la clase Frame para la insercin de elementos, ya que
representan la base de desarrollo de una interfaz grfica.
5.1.6 Clase Frame
Los objetos de esta clase representan ventanas de sistema completamente funcionales, en el
sentido de que contienen una barra de ttulo, botones de maximizar, minimizar y de cerrar, las
cuales son completamente funcionales, salvo la operacin de cerrar. Es decir las ventanas en
AWT no cuentan con la opcin de cerrar, a pesar de presentar el correspondiente botn.
Los constructores de la clase Frame son los siguientes:
Frame ( ): construye una ventana de sistema que inicialmente est oculta. No presentar
ttulo alguno.
Frame ( String ): construye una ventana de sistema que inicialmente est oculta. El ttulo
que presentar es el asociado al String, que se manda como parmetro.
42
El siguiente cdigo muestra la definicin y creacin de ventanas de sistema, usando los

constructores anteriores.
import java.awt.*;
public Ventanas {
public static void main ( String [ ] args ){
Frame f1 = new Frame ( );
Frame f2 = new Frame ( Ventana principal );
}
}
En ambos casos no se desplegar ventana alguna, tal y como lo indica la especificacin de los
constructores. Para visualizar las ventanas que se crean, se utiliza el mtodo setVisible (bolean)
heredado de Component, de la siguiente forma:
f1.setVisible( true );
La figura 10 muestra el resultado de esta ltima operacin. La ventana se despliega sin
dimensiones y ubicada en la esquina superior derecha.
Figura 10.
Los mtodos para la recuperacin de informacin ms importantes de la clase Frame son los
Nombre
getTitle()
Tipo de retorno
String
isResizable()
boolean
setCursor(Cursor)
Void
Uso
Regresa el String que representa el ttulo de la
ventana.
Indica si el usuario puede cambiar el tamao de la
ventana.
Establece el apuntador de mouse a usarse en
esta ventana.
Para cerrar la ventana que se presenta, es necesario activar la ventana de MS-DOS que se
abri y oprimir la combinacin de teclas CTRL + C. Por otra parte se pueden usar los mtodos
setSize (nt, int) y setLocation (int, int) heredados de Componet, para establecer el tamao y
ubicacin de la ventana respectivamente. El siguiente cdigo muestra un programa completo
usando estos mtodos, y la figura 11, su despliegue correspondiente.
import java.awt.*;
public class Ventanas {
public static void main ( String arg [ ] ) {
Frame f = new Frame ( "Ventana principal" );
f.setLocation ( 50, 50 );
f.setSize ( 300, 150 );
f.setVisible ( true );
}
}
43
Figura 11.
Un objeto de la clase Frame cuenta con la capacidad de albergar otros componentes como los
que se han descrito hasta el momento. La nica excepcin es cuando se intenta agregar un
objeto de la clase Window o subclases de sta. Las reglas para insertar componentes a un
contenedor son muy simples en s. Lo primero es crear el componente a insertarse en un
contenedor y despus indicar su insercin.
Para Insertar un componente, ya sea Button o Label, en un frame, por ejemplo, se deben utilizar
los mtodos add heredados de Container. El siguiente cdigo muestra el uso de las
operaciones de insercin de componentes en un frame.
import java.awt.*;
public class Ventanas {
public static void main ( String arg [ ] ) {
Frame f = new Frame ( "Ventana principal" );
Label l = new Label ( Etiqueta );
f.add ( l );
f.setSize ( 300, 150 );
}
}
Es decir, primero se crea el componente a insertar:
Label l = new Label ( Etiqueta );
Y despus se inserta en la ventana:
f.add ( l );
La figura 12 muestra la ventana con una etiqueta ya insertada.
44
Figura 12.
La figura13 muestra el efecto de los constructores de Label vistos anteriormente e insertados en

el frame.
Figura 13.
Ahora bien, el aspecto de la interfaz que se construye depende de dos aspectos fundamentales:
el componente a insertar y el contenedor al que se insertan.
5.1.7 La clase MenuBar y otros objetos relacionados
Una barra de men slo puede incluirse en un objeto de la clase Frame. Para asignar una barra
de men, es necesario entender la relacin de la clase de objetos MenuBar con otras clases
que ayudan a implementar esta opcin, las cuales son:
MenuItem : cada opcin de un men es representada por un objeto de esta clase.
CheckboxMenuItem: cada opcin de un men que slo sirve para ser marcada. Es una
subclase de MenuItem.
Menu: cada uno de los mens que se presentan sobre la barra. Es una subclase de
MenuItem.
MenuBar: es la implementacin de la barra de men.
La figura 14 muestra la representacin grfica de los objetos anteriores.
45
Figura 14.
Para programar la barra de men de la figura 14, tiene que seguir los siguientes pasos,
considerando un objeto de la clase Frame:
1. Crear un objeto de la clase MenuBar.
2. Por cada men en la barra, crear un objeto de la clase Menu.
3. Por cada opcin de un men crear un MenuItem y agregarlo al men correspondiente.
4. Agregar los objetos de la clase Menu al objeto MenuBar.
5. Asignar el MenuBar a la ventana.
Dichos puntos se presentan a continuacin:

1. Crear un objeto de la clase MenuBar.
Los objetos de la clase MenuBar cuentan con un constructor por omisin y slo basta con
crearlo. El siguiente cdigo ejemplifica esta operacin.
MenuBar mb = new MenuBar ( );
2. Por cada men en la barra, crear un objeto de la clase Menu.
En el caso de la interfaz de la figura 14, se tienen dos mens: Archivo y Edicin. El siguiente
cdigo ejemplifica estas definiciones.
Menu m1 = new Menu ( "Archivo" );
Menu m2 = new Menu ( "Edicin" );
3. Por cada opcin de un men, crear un MenuItem, y agregarlo al men correspondiente
Para el men Archivo, se cuenta con tres opciones: Abrir, Cerrar y Salir, por lo que se crearn
tres objetos de la clase MenuItem con sus ttulos indicados en sus respectivos constructores.
Una vez creados se agregarn al primer men, es decir, a m1. El siguiente cdigo ejemplifica
estas operaciones.
MenuItem mi_01 = new MenuItem ( "Abrir" );
MenuItem mi_02 = new MenuItem ( "Cerrar" );
MenuItem mi_03 = new MenuItem ( "Salir" );
m1.add ( mi_01 );
46
m1.add ( mi_02 );
m1.add ( "-" );
m1.add ( mi_03 );
La lnea 6 de este cdigo muestra la forma para aadir una lnea separadora entre los mens.
Este procedimiento es el mismo para el men Edicin.
4. Agregar los objetos de la clase Menu al objeto MenuBar.
Ya que se cuenta con los mens completos, stos deben ser agregados al objeto MenuBar del
punto 1. El siguiente cdigo muestra estas operaciones.
mb.add(m1);
mb.add(m2);
5. Asignar el MenuBar a la ventana.
Finalmente se asigna la barra de men a la ventana, tal y como se muestra en el siguiente
cdigo.
f.setMenuBar ( mb );
El cdigo completo de este ejemplo se muestra a continuacin:
import java.awt.*;
public class Menus
{
public static void main(String[] args)
{
Frame f = new Frame ( "Ventana con menus" );
f.setSize ( 400, 300 );
f.setResizable ( false );
MenuBar mb = new MenuBar ( );
Menu m1 = new Menu ( "Archivo" );
MenuItem mi_01 = new MenuItem ( "Abrir" );
MenuItem mi_02 = new MenuItem ( "Cerrar" );
MenuItem mi_03 = new MenuItem ( "Salir" );
m1.add ( mi_01 );
m1.add ( mi_02 );
m1.add ( "-" );
m1.add ( mi_03 );
Menu m2 = new Menu ( "Edicin" );
MenuItem mi_04 = new MenuItem ( "Copiar" );
MenuItem mi_05 = new MenuItem ( "Cortar" );
47
MenuItem mi_06 = new MenuItem ( "Pegar" );

m2.add ( mi_04 );
m2.add ( mi_05 );
m2.add ( mi_06 );
mb.add(m1);
mb.add(m2);
f.setMenuBar ( mb );
}
}
5.2 Manejo de eventos

El problema que an prevalece en las interfaces hasta aqu presentadas es que se carece de la
programacin requerida para que funcione como se pretende lo haga. Por ejemplo, supngase
que el objetivo de la interfaz de la figura 15, es copiar el texto que se escriba en la primera caja
de texto a la segunda, al utilizar el botn Copiar.
Figura 15.
El cdigo de dicha interfaz es el siguiente:

import java.awt.*;
public class CopiarTextos
{
public static void main(String[] args)
{
Frame f = new Frame ( "Copiar Textos" );
f.setSize ( 400, 100 );
f.setResizable ( false );
f.setLayout ( new GridLayout ( 3, 2 ) );
Label etiqueta1 = new Label ( "Texto 1:" );
Label etiqueta2 = new Label ( "Texto 2:" );
TextField texto1 = new TextField ( );
TextField texto2 = new TextField ( );
Button bt
= new Button ( "Copiar" );
48
f.add ( etiqueta1 );
f.add ( texto1 );
f.add ( etiqueta2 );
f.add ( texto2 );
f.add ( bt );
}
}
Sin embargo, se carece de la programacin para que el texto se copie.
A fin de implementar dicha programacin, en el cdigo anterior se requiere entender cmo
funcionan los componentes cuando son utilizados por alguna persona. Resulta fcil intuir que la
programacin no puede estipularse de forma lineal, ya que la interaccin del usuario no es
uniforme. De aqu que se defina el concepto de evento.
Un evento resulta de la interaccin del usuario con algn elemento de la interfaz. Por ejemplo,
en un botn, un evento es activarlo; en una ventana, por su parte, un evento sera minimizarla.
La idea es que cada operacin interactiva de cualquier componente grfico, representa un
evento del mismo.
Cada lenguaje de programacin define la programacin de eventos segn su estructura y
paradigma que implemente, en el caso particular de Java los eventos son tambin clases de
objetos. En Java existen dos modelos de manejo de eventos, pero en este manual slo se
presenta el modelo delegacional, ya que viene a sustituir por completo al otro.
5.2.1 Modelo delegacional
Si usted ya ha programado interfaces grficas con otros lenguajes, seguramente se ha
encontrado que los elementos grficos manejan los eventos que producen, es decir, cada
componente tiene el conjunto de lneas asociadas a un evento dado. En el modelo
delegacional, el manejo de eventos se distribuye en tres partes:
Componentes grficos.
Eventos.
Listeners.
Los cuales se explican a continuacin.
Componentes
Son todos aquellos elementos con los cuales puede interaccionar el usuario en una interfaz
grfica, como por ejemplo botones, ventanas, cajas de texto, entre otros. Su objetivo no es el de
responder con algn cdigo, sino ms bien generar eventos.
49
Eventos
Cada que el usuario utiliza algn componente grfico, el sistema genera automticamente un
objeto que los representa. Dichos objetos representan los eventos que el usuario gener al
interaccionar con un componente. Con ellos puede recuperarse informacin sobre el evento en
s y de las condiciones en que se gener. Los objetos que representan eventos se agrupan en
el paquete java.awt.event.
Listeners
Son objetos que responden a los eventos generados por los componentes de una interfaz.
Reciben como parmetro los eventos generados por los componentes. Los listeners se agrupan
en el paquete java.awt.event.
En trminos generales, se puede resumir que los componentes grficos tienen la tarea de crear
objetos que representan eventos producidos por los usuarios. Cabe sealar que un mismo
componente puede generar ms de una clase distinta de eventos. La figura 16 muestra un
resumen de los componentes ms comunes y los eventos que producen.
Figura 16
Si bien un componente genera eventos, son los listeners, los que tienen la tarea de procesar
los eventos que los componentes generan. La idea es muy simple, un listener est atento a
que se produzca un tipo de evento a fin de responder al mismo.
Por ejemplo, un botn est representado por objetos de la clase Button, los cuales generan
objetos de la clase ActionEvent, que es cuando un usuario interacciona con l. Se requiere de
un listener para escuchar al botn, y en el momento en que se produzca, llevar a cabo alguna
programacin. Para cada clase de evento se especifica un tipo especial de listener. La figura 17
muestra algunos eventos, y los listeners que se les asocia.
50
Figura 17.
Como regla general, con sus excepciones, para cada clase de evento XXXEvent se asocia el
listener XXXListener, y los listeners en Java son interfaces, tal como se muestra en la figura 18.
Figura 18.
Las interfaces en Java establecen un patrn de funcionalidad de alguna clase que quiera
seguirlo. En una interfaz se presenta una lista de firmas de mtodos, los cuales debern ser
implementados por alguna clase que as lo requiera. En dicha lista no se especifican cuerpos de
programacin, slo encabezados. Este mecanismo no slo es til en la programacin de
eventos, pero no se presentarn ms casos en este manual.
51
Para hacer funcionar los botones de una interfaz, se requiere de un ActionListener, en otras
palabras se requiere una clase que implemente dicha interfaz. No se necesita una clase en
particular, slo que implemente la interfaz ActionListener. La especificacin de la interfaz se
muestra en la figura 19.
Figura 19.
ActionListener slo especifica un solo mtodo actionPerformed(ActionEvent ae ), con lo que una

clase que la implemente deber tener obligatoriamente dicho mtodo. Por ejemplo, defina la
clase EscuchaBoton como se muestra en la figura 20.
Figura 20
La indicacin de que la clase implementa la interfaz, se especifica en el encabezado de la clase con

la palabra reservada implements seguida de la lista de interfaces a implementar. Si la clase hereda
de alguna otra, la declaracin de escribir despus del nombre de la superclase. Hasta este
momento se cuenta con una clase que ya puede escuchar ActionEvents.
El nico paso que hace falta es que el componente registre dicha clase. En este caso, el botn
que se utilizar ser el referido por la variable bt. Para efectuar dicho registro, todo componente
cuenta con un mtodo addXXXListener( XXXListener ) para tal efecto, los objetos de la clase
Button tienen el mtodo addActionListener ( ActionListener ). La figura 21 muestra el registro de
un objeto de la clase Escucha botn.
Figura 21.
Es importante sealar que se necesita un objeto de la clase EscuchaBotn para registrarlo.

Entonces cada vez que se utiliza el botn aparece el mensaje XXX en la pantalla de MS-DOS,
tal como se muestra en la figura 22.
52
Figura 22
Algo interesante de esta tcnica es, que un componente puede registrar ms de un listener.
Para apreciar este hecho, defina una nueva clase que implemente ActionListener, tal y como se
Figura 23.
En este caso, la clase EscuchaBoton2 tiene como cualidad, que para construirla requiere de
dos objetos de la clase TextField, los cuales son utilizados en el mtodo actionPerformed(). Es
decir, cuando un objeto de la clase EscuchaBoton2 detecte un evento, copiar el texto del
primer TextField al segundo. El registro de un objeto de la clase EscuchaBoto sigue las mismas
indicaciones que se presentaron anteriormente, y que se muestra en la figura 24; el efecto del
registro de dos listeners se muestra en la figura 25.
Figura 24.
Figura 25.
53
Ms an, los objetos de la clase TextField generan ActionEvent al dar un enter e ir escribiendo
en ellos. Se deja al lector registrar el objeto referido con la variable texto1 y el objeto
EscuchaBoton2 para ver dicho efecto.
Como el lector habr notado, las ventanas de Java no cierran automticamente. Esto se debe a
que no hay ningn listener registrado por la ventana. En este caso se requerir de un
WindowListener para manejar los eventos de una ventana. La figura 26 muestra la clase
EscuchaVentana que implementa dicha interfaz. En este caso son siete los mtodos que tienen
que ser incluidos.
Figura 26.
El registro de un objeto de esta clase lo efectuar una ventana con el mtodo

addWindowListener() como se muestra en la figura 27. El efecto del manejo de eventos se
Figura 27.
54
Figura 28.
Una clase que permita que la ventana se cierre automticamente es la que se presenta en la
figura 29.
Figura 29.
Se deja al lector registrar un objeto de esta clase para que su ventana cierre automticamente.
55
6. JDBC
6.1 Introduccin
El desarrollo de aplicaciones con conexin a bases de datos es uno de los principales tipos de
programas que pueden ser desarrollados con el lenguaje de programacin Java. Java cuenta
con el API JDBC para la manipulacin de informacin en bases de datos, utilizando para ello
el estndar SQL (Structured Query Language). Cabe mencionar que el API JDBC no es la
abreviatura de algn concepto o tecnologa, pero frecuentemente se le asocia el trmino Java
DataBase Connectivity (Conectividad de Base de Datos de Java).
Este API define una serie de clases e interfaces que establecen un estndar tanto para
herramientas de desarrollo como para bases de datos. Dicho estndar permite el desarrollo de
aplicaciones 100% Pure Java, con la ventaja de que un mismo programa puede manipular una
base de datos ya sea Sybase, Oracle, Informix u otra. El JDBC permite el envo de sentencias
de SQL a casi cualquier base de datos relacional, adems de que es posible manipular los
datos de respuesta a dicha sentencia. Con esto podemos desarrollar aplicaciones que permiten
el establecimiento de servicios en lnea tanto para Intranets como en la Internet.
6.1.1 Operaciones de un programa que utiliza el JDBC
Se puede resumir en cuatro operaciones, al conjunto de acciones bsicas de los programas que
utilizan el JDBC, las cuales se listan a continuacin:
1. Cargar el controlador.
2. Establecer una conexin con la base de datos.
3. Enviar sentencias SQL al manejador de la base de datos.
4. Procesar los resultados de las consultas.
Un ejemplo de dichas operaciones se muestra en el ejemplo 1.

1: Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
2: Connection con =
3: DriverManager.getConnection("jdbc:odbc:PruebaODBC","login","pass");
4:
5: Statement stmt = con.createStatement();
6:
7: ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table1");
8:
9: while (rs.next()) {
10:
int x = getInt("a");
11:
String s = getString("b");
12:
float f = getFloat("c");
13: }
...
Ejemplo 1.
56
Resumiendo, el JDBC define las clases en Java para representar conexiones a bases de
datos, instrucciones SQL, conjuntos de resultados, metadatos de la base de datos, etc. Permite
escribir un programa en el lenguaje Java para enviar comandos de SQL y procesar los
resultados de los mismos.
El API del JDBC se implementa va un controlador y puede soportar mltiples controladores
de conexin a distintas bases de datos. Los controladores de JDBC pueden ser escritos en
Java a fin de que puedan ser integrados como parte de un applet, o bien pueden ser
implementados usando mtodos nativos de las bases de datos para servir de puente con las
bibliotecas de acceso de datos existentes.
6.1.2 Componentes del JDBC
El JDBC incluye tres componentes para su utilizacin:
El administrador del controlador del JDBC, incluido como parte de JDK.
La JDBC driver test suite, disponible en: http://www.javasoft.com/products/jdbc
El controlador JDBC-ODBC bridge, incluido en las versiones de Solaris y Windows del

JDK.
6.1.3 Tipos de controladores de JDBC

Los controladores de JDBC estn divididos en las siguientes categoras:
1. Controlador JDBCODBC bridge: proporciona acceso va los controladores ODBC. Note
qu archivos binarios para ODBC (y en muchos casos los clientes de bases de datos) se
deben cargar en cada equipo cliente que usa este controlador; por lo que esta clase de
controlador es el ms apropiado para una red corporativa, o para aplicaciones del lado del
servidor escritas en Java en una arquitectura de tres capas. Ver figura 1.
Figura 1.
57
2. Controlador Native-API partly-Java: un controlador, basado en la tecnologa de un tercero,

convierte las llamadas del JDBC en llamadas nativas de la base de datos, por ejemplo
Oracle, Sybase, Informix, DB2 u otro DBMS. Note que, al igual que en el anterior tipo, el
controlador requiere de algn programa binario para cargarse en cada equipo cliente. Ver
figura 2.
Figura 2.
3. Controlador JDBC-Net pure Java: un controlador que traduce las llamadas de JDBC en un
protocolo de red independiente del DBMS, el cual es traducido a un protocolo DBMS por un
servidor. Este servidor de red es capaz de conectar a sus clientes a distintas bases de
datos. El protocolo especfico que se utilice depende enteramente del vendedor. En general,
esta es la alternativa ms flexible del JDBC. Es probable que todos vendedores de esta
solucin proporcionarn los productos adecuados para el desarrollo de Intranets. Ver figura 3.
Figura 3.
58
4. Controlador Native-protocol pure Java: un controlador nativo que convierte las llamadas del
JDBC en el protocolo de red usado por la directiva del DBMS. Esto permite una llamada
directa del equipo cliente al servidor del DBMS, solucin prctica para Intranet. Ya que
muchos de estos protocolos son propietarios, los vendedores de stos son los mismos que
los vendedores de los controladores. Ver figura 4.
Figura 4.
En el presente trabajo se desarrollarn aplicaciones con la base de datos Access de Microsoft

utilizando el controlador JDBC-ODBC bridge.
6.2 Uso del controlador JDBC-ODBC bridge

A partir de una visin general de lo qu es el JDBC con algunas de sus caractersticas, se har
uso de ste con un controlador tipo 1. El controlador JDBC-ODBC bridge no requiere ser
instalado ya que la distribucin del JDK lo tiene incluido.
6.2.1 Instalando y configurando una base de datos con ODBC
Para configurar el recurso de ODBC, se seguirn los siguientes pasos:
1. Inicie la aplicacin del administrador de ODBC que se encuentra en el Panel de Control de
Windows, similar a la que se muestra en la figura 5.
59
Figura 5.
2. Seleccione el botn Add para agregar un nuevo recurso de base de datos, por lo que
aparecer la ventana que se muestra en la figura 6.
Figura 6.
3. Seleccione el controlador ODBC Microsoft Access. Despus de esto aparecer la ventana

de la figura 7.
60
Figura 7.
4. Cree una nueva base de datos con el botn Create y asigne el nombre de un archivo con
extensin .mdb en un directorio, para esto utilice la ventana de la figura 8.
Figura 8.
Al final de estos pasos, su base de datos debe estar listada en la ventana original de la figura 6.
6.2.2 Estableciendo una conexin de base de datos
Lo primero que se requiere para utilizar el JDBC es establecer una conexin a la base de datos.
Esto es un procedimiento de dos pasos. Se debe cargar el controlador del JDBC y entonces
establecer la conexin. Cargar un controlador de JDBC es muy simple, slo toma una lnea de
cdigo.
La siguiente lnea muestra como cargar el controlador:
Class.forName(sun.jdbc.odbc.JdbcOdbcDriver);
Cuando se llama al mtodo Class.forName( ), se crea una instancia del controlador que registra
el DriverManager.
61
Despus de que se carg el controlador, para establecer una conexin, se llama al mtodo
esttico DriverManager.getConnection( ), el cual regresa una conexin a la base. La firma de
este ltimo mtodo es la siguiente:
public static synchronized Connection getConnection(String url,
String user, String password) throws SQLException
El primer parmetro es el URL que seala la base de datos. En el caso del JDBC-ODBC bridge
tiene la siguiente estructura: jdbc:odbc:NombreDelRecurso, donde el nombre del recurso es
el nombre de la base de datos que se configur en el administrador del ODBC de Windows. En
el caso de la seccin anterior, el URL queda como jdbc:odbc:PruebaODBC. Los otros dos
parmetros se explican por s solos.
El siguiente cdigo es un ejemplo para establecer una conexin a esta base de datos:
Connection con = DriverManager.getConnection(jdbc:odbc:PruebaODBC,alex,alex123);
6.2.3 Usando comandos bsicos de SQL
Una vez que se cuenta con una conexin a la base de datos, debe crearse un objeto de la clase
Statement. Para crear dicho objeto se debe utilizar el mtodo Connection.createStatement( ).
Este ltimo, como objeto Statement del JDBC, se utilizar para enviar sentencias de SQL a la
base de datos.
La siguiente lnea muestra cmo crear una sentencia:
Statement stmt = con.createStatement( );
Creando tablas
Lo primero por hacer, ser crear las tablas de la base de datos, las cuales se utilizarn para los
ejemplos posteriores. El ejemplo 2 muestra la tarea de crear una tabla.
import java.sql.*;
public class CreateTableApp
{
public void createTable( ) {
Connection con = null;
try {
// Cargando el controlador
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
// Estableciendo la conexin con la Base de datos
con = DriverManager.getConnection("jdbc:odbc:PruebaODBC","","");
// Creando un Statement
Statement stmt = con.createStatement();
// Uso del Statement creado para CREAR la tabla titulos
stmt.executeUpdate("CREATE TABLE titulos " +
62
"(tit_id INTEGER, tit_nombre VARCHAR(50)," +

" cantidad INTEGER)");
}
catch(SQLException sqle) {
System.err.println(sqle.getMessage());
}
catch(ClassNotFoundException cnfe) {
System.err.println(cnfe.getMessage());
}
finally {
try
{
if(con != null)
{
// Cerrar la conexin
con.close();
}
}
catch(SQLException sqle)
{
}
}
}
CreateTableApp cta = new CreateTableApp();
cta.createTable();
}
}
Ejemplo 2.
Ahora, centre su atencin en las siguientes lneas:

// Uso del Statement creado para CREAR la tabla titulos
stmt.executeUpdate("CREATE TABLE titulos " +
"(tit_id INTEGER, tit_nombre VARCHAR(50)," +
" cantidad INTEGER)");
Dada una conexin, se cre un objeto Statement. Para efectuar la creacin de la tabla se llama
al mtodo Statement.executeUpdate(), cuya firma se muestra a continuacin:
public int executeUpdate(String sql) throws SQLException
Este mtodo se usa para todo tipo de transacciones de actualizacin en la base de datos.
Insertando datos en la tabla
Ahora que se tienen las tablas en la base de datos, pueden ponerse datos en ellas. El ejemplo
3 muestra una aplicacin usada para insertar datos en ellas.
63
import java.sql.*;
public class InsertDataApp{
public InsertDataApp() {
}
public void insertData() {
try {
// Uso del Statement creado para insertar datos a la tabla titulos
stmt.executeUpdate("INSERT INTO titulos " +
"VALUES (0, 'Estudio de ecuaciones', 2)");
"VALUES (1, 'TOO: Ejemplos y casos practicos', 4)");
"VALUES (2, 'Analisis de mercados', 10)");
"VALUES (3, 'Generadores y alternadores', 3)");
"VALUES (4, 'Tanques y compresoras Diesel', 2)");
}
}
}
finally {
try
{
if(con != null)
{
con.close();
}
}
catch(SQLException sqle)
{
}
64
}
}
InsertDataApp ida = new InsertDataApp();
ida.insertData();
}
}
Ejemplo 3.
La aplicacin InsertDataApp usa el mismo mtodo que se utiliz para crear tablas. El nico
cambio se efectu en la cadena SQL que se le pas al mtodo, usando una sentencia INSERT
de SQL en su lugar.
Realizando consultas a una tabla
La instruccin ms utilizada del SQL es el SELECT. Dicha instruccin da la posibilidad de
explorar el contenido de las tablas en una base de datos. En el ejemplo 4 se muestra una
aplicacin que con los datos que contiene la tabla titulos.
import java.sql.*;
public class SelectDataApp{
public SelectDataApp() {
}
public void selectData( ) {
try {
// Uso del Statement creado para sleccionar datos de la tabla
// titulos
ResultSet rs = stmt.executeQuery("SELECT * FROM titulos");
// Iterando sobre el objeto ResultSet
while(rs.next()) {
System.out.println("ID: " + rs.getString("tit_id"));
System.out.println("NOMBRE: " + rs.getString("tit_nombre"));
System.out.println("CANTIDAD: " + rs.getString("cantidad")+"\n");
}
// Cerrando ResultSet
rs.close();
65
}
}
}
finally {
try {
if(con != null)
{
con.close();
}
}
}
}
}
SelectDataApp cta = new SelectDataApp();
cta.selectData();
}
}
Ejemplo 4.
Para efectuar una consulta se vuelve a utilizar el objeto Statement como se vena llevando a
cabo en los ejemplos anteriores. La diferencia es el uso de un nuevo mtodo executeQuery().
Su firma es la siguiente:
public ResultSet executeQuery(String sql) throws SQLException
Como se puede apreciar, el mtodo devuelve un objeto ResultSet , el cual regresa una
coleccin de renglones, resultado de la consulta. El mtodo ResultSet.next() regresa un
boolean que indica si existe todava una columna como resultado de la consulta efectuada. El
mtodo ResultSet.getString() regresa la versin de cadena de un campo dado, que se le pasa
como parmetro.
El resultado de esta aplicacin puede apreciarse en la figura 9.
Figura 9.
66
BIBLIOGRAFA
Effective Java Programming Language Guide.
Joshua Bloch.
Addison Wesley Professional.
1 edicin, junio de 2001.
ISBN: 0201310058
Java in a Nutshell, Fourth Edition.
David Flanagan.
O'Reilly & Associates
4 edicin, marzo de 2002.
ISBN: 0596002831
Sams Teach Yourself Java 2 Platform in 21 Days, Professional Reference Edition.
Laura Lemay, Rogers Cadenhead.
Editorial Sams.
Edicin de CD-ROM, enero de 1999.
ISBN: 067231438X
67
ANEXO A. LA REFERENCIA THIS

Java utiliza referencias
Como se observ en el Captulo II, this es una referencia dinmica al objeto que est
ejecutando un mtodo en particular, para lo cual vase el siguiente cdigo:
1. public class Circulo
2. {
3.
double x,y,r;
4.
double area()
5.
{
6.
return 3.14159 * r *r;
7.
}
8. }
Ejemplo A.1
Como se explic, una clase es una coleccin de datos y mtodos que operan sobre esos datos.
Los datos y los mtodos, en conjunto, generalmente sirven para definir los contenidos y las
capacidades de algn tipo de objeto. En este caso el mtodo area( ) manipula directamente los
datos de un objeto Circulo (cul objeto en particular?).
Como se ha analizado, Java es un lenguaje orientado a objetos que los maneja por referencia.
Para crear la referencia se requiere de un cdigo como el que se muestra a continuacin:
Circulo c,d;
Ejemplo A.2
En este caso, c y d pueden hacer referencia a objetos da la clase Circulo. Para esto se requiere
primero crear un objeto de esta clase y pasar la referencia del mismo, como se muestra en el
siguiente fragmento de cdigo:
c = new Circulo();
d = new Circulo();
Ejemplo A.3
Note que c y d ahora tienen una referencia a dos objetos de la clase Circulo de manera
independiente. Es decir, se crearon dos objetos y para cada uno de ellos existe una referencia
propia. Si se asigna el valor de la referencia d a c, los dos hacen referencia al mismo objeto, y
la referencia original de c, se pierde:
c = d;
Pero esto ltimo ya ha sido discutido ampliamente en el Captulo II. Por tanto se retomar el
ejemplo A1.
68
Si se declaran dos referencias a objetos Circulo y son creados los objetos, como se muestra en
los ejemplos A.2 y A.3, c y d estn en capacidad para manipular los datos de cada uno de
objetos a los que hacen referencia respectivamente, por ejemplo, cada objeto puede ejecutar el
mtodo rea, como se muestra en el ejemplo A.4:
c.area();
d.area();
Ejemplo A.4
La pregunta ser entonces la siguiente: Cmo sabe el mtodo area( ) a qu valor de r llamar?
Observe que tanto el objeto al que c hace referencia como al de d tienen el atributo r. La
respuesta es simple: utilizar el valor r del objeto que mand a ejecutar dicho mtodo.
Recuerde que en la Programacin Orientada a Objetos primero estn los objetos como la base
del desarrollo de aplicaciones, y stas manipulan los datos de esos objetos. Ahora vea cmo
funcionan los objetos.
Los objetos, cuando se crean, manipulan y utilizan los datos y mtodos que se definieron para
ellos. Cuando se crean, cada uno de ellos, se les da estos elementos. Observe la figura A.1, c
hace referencia a un objeto Circulo que tiene su propio juego de datos y mtodos. Esto pasa
igual con d.
69
Figura A. 1.
Conteste por fin la pregunta. Como cada objeto de la clase Circulo tiene su propio juego de
mtodos, stos tratarn de manipular los datos del propio objeto, no los de otros. As, cuando a
travs de la referencia d ejecuta el mtodo area( ), se utiliza el dato r del mismo objeto, lo
mismo que con c.
70
ANEXO B. EL MODIFICADOR STATIC

Variables estticas de una clase
Primero se definir la clase Circulo como se muestra en el ejemplo 1:
{
public double x, y, r;
static int cir_cread = 0;
public Circulo(double x, double y, double r)
{
this.x = x; this.y = y; this.r = r;
num_Circulos++;
}
public Circulo( double r)
{ this(0.0, 0.0, r ); }
public Circulo ( Circulo r )
{ this(c.x, c.y, x.r); }
public Circulo()
{ this.(0.0, 0.0, 0.0); }
public double circunferencia() { reutrn 2 * 3.14159 *r; }
public double area() { reutrn 3.14159 *r * r; }
}
Ejemplo 1.
En este ejemplo, la clase Circulo define tres variables de instancia9: x, y y r. Cada instancia de
la clase alberga su propio conjunto de variables, las cuales son ajenas a las de otros objetos.
Sin embargo en algunos casos es necesario contar con variables globales, pero Java no
maneja las variables globales.
Por regla, toda variable debe ser declarada dentro de una clase. Con el uso de la palabra
reservada static se indica que dicha variable es una variable de clase, y no por el contrario una
variable de instancia. Con esto se logra que exista una, y slo una variable, la cual est
asociada a la clase. El efecto es que una variable declarada como static existe slo una vez a
pesar del nmero de instancias que de la clase se hayan creado en un momento dado.
En el presente caso, la variable cir_cread se incrementa en una unidad cada vez que se crea un
crculo. Esto podra servir para conocer el nmero de objetos creados en un momento dado.
Entindase la palabra "instancia" como sinnimo de objeto.
71
Utilizando las variables de clase

Como se defini, las variables de clases estn asociadas a las clases y no a las instancias.
Para utilizar y/o manipular una variable de clase es necesario utilizar la siguiente sintaxis:
Nombre_de_Clase.variable_de_calse
Para el ejemplo, esto sera de la siguiente forma:
Circulo.cir_cread
Lo anterior sirve para imprimir en pantalla el nmero de crculos creados hasta un momento
dado, la sintaxis correspondiente sera:
System.out.println("El nmero de crculos creados es de: " + Circulo.cir_cread);
72
ANEXO C. LA ETIQUETA APPLET

Aqu se muestra un ejemplo de la utilizacin de la etiqueta APPLET:
<applet code="MiApplet.class" width=100 height=140></applet>
Lo anterior indica al navegador que cargue el applet cuyo cdigo compilado es 'MiApplet.class'
(en el mismo nivel de directorio que el documento HTML actual), y fija el tamao inicial del
applet a 100 pixeles de largo y 140 de alto.
A continuacin, se presenta un ejemplo ms complejo del uso de la etiqueta APPLET:
<applet codebase="http://java.sun.com/applets/applets/NervousText"
code="NervousText.class" width=400 height=75>
<param name="text" value="Bienvenido a HotJava!">
<hr>
Si estuviera usando un navegador con capacidad
de Java tal como HotJava vera el texto 'bailando'
en lugar de este prrafo.
<hr>
</applet>
Este cdigo indica al navegador que cargue el applet cuyo cdigo compilado est en el URL
http://java.sun.com/applets/applets/NervousText/NervousText.class , fija el tamao inicial del
applet a 400 x 75 pixeles. El navegador debe tambin asignar el valor "Bienvenido a HotJava!"
al atributo "text" (el cual define el texto que este applet desplegar). Si la pgina es vista por un
navegador que no puede ejecutar applets, el navegador ignorar las etiquetas APPLET y
PARAM, desplegando solamente el cdigo HTML entre las etiquetas <PARAM> y </APPLET>.
A continuacin, se muestra otro ejemplo del uso de la etiqueta APPLET:
<applet code=A21 width=256 height=256 archive="toir.jar">
<param name=img value=test.gif>
<hr>
Necesitamos convertir algunos de estos Applets para usar
archivos. Algn voluntario?
<hr>
</applet>
En este ejemplo la clase del applet es A21. Su Java ByteCode (puede) reside en el archivo
"toir.jar". Este archivo puede tambin contener la referencia a la imagen cuyo nombre es test.gif.
73
A continuacin, se muestra la sintaxis completa de la etiqueta TAG. Los elementos requeridos

estn en negritas. Los elementos que se deben especificar estn en itlicas.
<APPLET
CODEBASE = codebaseURL
ARCHIVE = archiveList
CODE = appletFile...o... OBJECT = serializedApplet
ALT = alternateText
NAME = appletInstanceName
WIDTH = pixels HEIGHT = pixels
ALIGN = alignment
VSPACE = pixels HSPACE = pixels
>
<PARAM NAME = appletAttribute1 VALUE = valor>
...
alternateHTML
</APPLET>
CODE, CODEBASE y los dems son atributos de la etiqueta APPLET; ellos dan al navegador
informacin acerca del applet. Los nicos atributos requeridos con CODE, WIDTH y HEIGHT.
Cada atributo es descrito a continuacin.
CODEBASE = codebaseURL
Este atributo opcional especifica la base URL del Applet -- el directorio que contiene los cdigos
de los applets. Si este atributo no se especifica, entonces el URL del documento se usa como
tal.
ARCHIVE = archiveList
Este atributo es opcional y describe uno o ms archivos que contienen clases y otros recursos que
sern "pre-cargados". Las clases son cargadas usando una instancia de un AppletClassLoader con
el CODEBASE dado. Los archivos en archiveList estn separados por ",".
Nota: en JDK 1.1, mltiples etiquetas APPLET con el mismo CODEBASE comparten la misma
instancia de un ClassLoader. Esto es utilizado por algn cdigo cliente para implementar la
comunicacin entre applets. Futuros JDK "pueden" proporcionar otros mecanismos para la
comunicacin entre applets.
CODE = appletFile
74
Este atributo es requerido y da el nombre del archivo que contiene el applet compilado. Este
archivo es relativo al URL base del applet. No puede ser absoluto. CODE u OBJECT deben
estar presentes.
OBJECT = serializedApplet
Este atributo da el nombre del archivo que contiene una representacin seriada de un applet. El
applet se definir en serie. El mtodo init() no ser invocado; pero su mtodo start() si lo har.
CODE u OBJECT debern estar presentes.
ALT = alternateText
Este atributo opcional especifica cualquier texto que ser desplegado, si el navegador no
entiende la etiqueta APPLET, pero no se ejecutarn los applets de Java.
NAME = appletInstanceName
Este atributo es opcional y especifica un nombre para la instancia del applet, lo cual permite a
los applets de la misma pgina encontrar y comunicarse con los dems.
WIDTH = pixeles HEIGHT = pixeles
Estos atributos son requeridos y dan el ancho y largo (en pixeles) del rea, donde se
desplegar el applet, sin interesar ventanas o cajas de dilogo en que se incluyan.
ALIGN = alignment
Este atributo opcional especifica el alineamiento del applet. Los valores posibles de este
atributo son los mismos que para la etiqueta IMG: left, right, top, texttop, middle, absmiddle,
baseline, bottom, absbottom.
VSPACE = pixeles HSPACE = pixeles
Este atributo es opcional y especifica el nmero de pixeles por arriba y por debajo del applet
(VSPACE), y de cada lado del applet (HSPACE). Son tratados de la misma forma como los
atributos de la etiqueta IMG: VSPACE y HSPACE.
<PARAM NAME = appletAttribute2 VALUE = valor> . . .
Con esta etiqueta se especifica un atributo especfico del applet. Los applets recuperan estos
atributos con el mtodo getParameter().
75
UNIVERSIDAD NACIONAL AUTNOMA DE

MXICO
DR. JUAN RAMN DE LA FUENTE
Rector
LIC. ENRIQUE DEL VAL BLANCO
Secretario General
MTRO. DANIEL BARRERA PREZ
Secretario Administrativo
LIC. ARMANDO LABRA MANJARREZ
Secretario de Planeacin y Reforma Universitaria
DRA. ELVIA ARCELIA QUINTANA ADRIANO
Abogada General
DIRECCIN GENERAL DE SERVICIOS DE

CMPUTO ACADMICO
DR. ALEJANDRO PISANTY BARUCH
Director General
MAT. CARMEN BRAVO CHAVESTE
Directora de Cmputo para la Docencia
LIC. ROSARIO ORTIZ OSORNIO
Subdirectora de Planeacin Acadmica
ACT. FABIN ROMO ZAMUDIO
Subdirector de Tecnologa para la Educacin
ING. SERGIO ALVA ARGUINZONIZ
Coordinador del Centro Mascarones
LIC. ALEJANDRINA SAN JUAN REYES
Coordinadora del Centro de Extensin en
Cmputo y Telecomunicaciones Nuevo Len
LIC. CECILIA MEDINA NAVARRO
Coordinadora del Centro Coapa de Extensin
en Cmputo y Telecomunicaciones
QUIM. LAURA MATA MONTIEL
Coordinadora de Infraestructura y Soporte Tecnolgico
ACADEMIA DE LENGUAJES DE PROGRAMACIN
Revisin Tcnica
LIC. MARIANA CELORIO SUREZ CORONAS
Subdirectora de Comunicacin
DG TOA ZIMERMAN SONABEND
Jefa del Departamento de Diseo
LIC. MARTHA PATRICIA GARCA MORALES
Edicin y correccin de estilo
DG EPRIN VARAS GABRELIAN
Diseo de portada
Guas y textos de cmputo.

Pginas para Internet con Java.
Abril de 2003.

Programación para Internet. Java (DGSCA. UNAM)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programación para Internet. Java (DGSCA. UNAM)

Uploaded by

Copyright:

Available Formats

NDICE

1. Introduccin a Java .............................................................................................................1

Pginas para Internet con Java

1.1 Desarrollo y evolucin de Java

1.2 Java es orientado a objetos

Alejandro Talavera Rosales

1.3 La sintaxis de Java es similar a la de C

1.4 Java es interpretado

1.5 Java es multiplataforma

Pginas para Internet con Java

La manera tradicional de generar programas implica, que a partir de un cdigo fuente, un

Figura 1. Compilacin tradicional.

Figura 2. Generacin del Java Byte Code.

Alejandro Talavera Rosales

1.6 Java es multithread

1.7 Programas elaborados con Java

Figura 3. Aplicacin de Java en MS-DOS.

Pginas para Internet con Java

En el ejemplo de la figura 4, se muestra una aplicacin que recupera la informacin de una

Figura 4. Aplicacin con conexin a una base de datos.

La base de datos utilizada aqu fue mSQL 2.0.7

CGI es un programa que es activado a travs de un navegador.

Alejandro Talavera Rosales

Figura 5. Applet en un navegador.

Figura 6. Applet como interfaz para una base de datos.

Pginas para Internet con Java

Figura 7. Applet para un proyecto de medicina.

1.8 El JDK y otras herramientas de programacin

Alejandro Talavera Rosales

Solaris 2.5 o superior (SPARC e Intel).

Esto es si C:\JDK1.1.7 es el directorio de instalacin.

Donde C:\JDK1.2.1 es el directorio de instalacin.

Esto es si /usr/local/jdk1.1.7 es el directorio de instalacin. Para el caso de un Bash

Pginas para Internet con Java

Interfaz de usuario intuitiva y un conjunto de herramientas para aumentar el desarrollo

Plantillas para construccin sencilla y de componentes JavaBeans.

El desarrollo de aplicaciones se divide en dos partes. La primera es la edicin sobre el cdigo

Alejandro Talavera Rosales

Para mayor informacin, se recomienda al lector consultar la pgina:

Para mayor informacin, se recomienda al lector consultar la pgina:

1.9 Compilando el programa HolaMundo

Pginas para Internet con Java

caso permitir comprobar la correcta instalacin de las herramientas de desarrollo y la definicin

public static void main (String args[])

Editores que generan texto plano tenemos los siguientes:

Bloc de notas, en el ambiente grfico Windows.

Microsoft Word, en el ambiente grfico Windows. Al guardar el archivo utilice la opcin

EditPLus Text Editor , en el ambiente grfico de Windows.

Alejandro Talavera Rosales

Pginas para Internet con Java

2. CLASES Y OBJETOS EN JAVA

Figura 1. Clase Circulo.

Alejandro Talavera Rosales

Pginas para Internet con Java

public double area()

Un anlisis similar para el mtodo circunferencia() producir el siguiente cdigo.

El ejemplo 1 muestra el cdigo completo de la implementacin de la clase Circulo.

public double circunferencia()

En resumen, lo que se ha definido hasta el momento es la clase Circulo utilizando al lenguaje

2.2 Los objetos son instancias de una clase

Alejandro Talavera Rosales

La figura 2 muestra el resultado del cdigo anterior.

Pginas para Internet con Java