Download Untitled - Mi clase en linea

ÍNDICE
1. Introducción a Java .............................................................................................................1
1.1 Desarrollo y evolución 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 programación..............................................................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 Introducción a las clases y objetos .............................................................................13
2.2 Los objetos son instancias de una clase.....................................................................15
2.3 Usando los métodos de los objetos ............................................................................17
2.4 Creación de un objeto.................................................................................................18
2.5 Definición de un constructor .......................................................................................19
2.6 Múltiples constructores ...............................................................................................20
2.7 Sobrecarga de métodos .............................................................................................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 métodos........................................................................................26
3.4 Definición de nuevos datos y métodos en subclases ..................................................27
3.5 La palabra reservada super para métodos 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 página del applet..................................................30
4.1.3 Cerrando el navegador........................................................................................31
4.2 Métodos básicos de la clase applet ............................................................................31
4.3 Programando interfaces gráficas ................................................................................32
5. Programación de interfaz gráfica de usuarios ...................................................................35
5.1 Jerarquía 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 Introducción ................................................................................................................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 conexión de base de datos....................................................61
6.2.3 Usando comandos básicos de SQL ....................................................................62
BIBLIOGRAFÍA .....................................................................................................................67
Anexo A. La referencia this ...................................................................................................68
Anexo B. El modificador static...............................................................................................71
Anexo C. La etiqueta APPLET ..............................................................................................73
Páginas para Internet con Java
1. INTRODUCCIÓN A JAVA
El desarrollo de aplicaciones de computadoras ha evolucionado desde sus orígenes de manera
constante, al igual que las herramientas con las que se generan. En los últimos años ha sido
evidente el auge en la utilización del lenguaje Java, como una alternativa real y funcional para el
desarrollo de aplicaciones estándares o en línea, con las ventajas que ofrece la Programación
Orientada a Objetos (POO).
En el presente capítulo se analizarán los orígenes de Java, así como su descripción general; y
por último se dará una breve explicación de cómo instalar el JDK (Java Development Kit) para
comenzar a programar.
1.1 Desarrollo y evolución de Java
Java surge en el año de 1993 en los laboratorios de SUN Microsystems, como resultado de una
investigación encaminada a solucionar los problemas relacionados con la programación de
componentes para artículos electrodomésticos. La problemática que SUN tenía, 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 diseño y/o funcionamiento. El
lenguaje de programación que habían utilizado hasta ese momento era C.
Teniendo en cuenta las necesidades concretas de programación, tales como la reutilización de
código, el desarrollo de aplicaciones para varias plataformas y el menor tiempo de capacitación
para la generación de nuevas aplicaciones con el nuevo esquema, entre otros, se determinó la
creación de un nuevo lenguaje. Dicho lenguaje fue posteriormente conocido como Java.
Entre las principales características 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 características 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 deberán ser
diseñadas 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 programación orientada a objetos radica en los conceptos de clase y objeto. Una
clase describe las características y comportamientos de un tipo especial de objetos. En la
1
Alejandro Talavera Rosales
práctica, 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 gráfico, programación 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 múltiple. 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 más clases. Java sólo contempla la
herencia simple debido a las implicaciones de la herencia múltiple. La herencia es un
mecanismo que permite la reutilización de código.
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 diseñaron 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
fácilmente migradas al nuevo lenguaje. Por estas razones, se eligió como modelo al lenguaje C,
pero se eliminaron varias de las características 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 más peso los conceptos de la
programación orientada a objetos.
1.4 Java es interpretado
Las aplicaciones desarrolladas con Java requieren de un intérprete para su ejecución. Los
programas se compilan para generar un programa que correrá una máquina “virtual”. Esta
máquina, en términos reales no existe como un componente físico, de hecho, el intérprete debe
implementar la máquina virtual de Java (JVM – Java Virtual Machine).
En el caso de los navegadores de Web, Netscape Navigator® y HotJava Browser™, cuentan
con intérpretes 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
correrán en una máquina virtual, es decir, no están diseñadas para una plataforma en particular.
Esta característica 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 intérprete.
2
Páginas para Internet con Java
La manera tradicional de generar programas implica, que a partir de un código fuente, un
compilador genera el correspondiente programa para la plataforma en que se compila; es decir,
un compilador que fue diseñado para una PC sólo genera programas que se ejecutarán en una
PC. La figura 1 resume esta forma de producir programas.
Figura 1. Compilación tradicional.
Con Java, este concepto cambia radicalmente. Se requiere nuevamente de un código fuente,
pero el compilador de manera independiente a la plataforma en que se utiliza, generará un
código intermedio (en este caso conocido como Java Byte Code). El código intermedio es,
finalmente, ejecutado por un intérprete de Java. Tanto el compilador como el intérprete
dependen de la plataforma en particular del cliente, pero no así el código intermedio. La figura 2
muestra este nuevo concepto.
Figura 2. Generación del Java Byte Code.
3
Alejandro Talavera Rosales
1.6 Java es multithread
La programación 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
instrucción se ejecuta por completo antes de continuar con otra, en cambio, en la programación
multithread, una instrucción (o conjunto de ellas) pueden ejecutarse simultáneamente sin que
con esto interfieran necesariamente en la ejecución de las demás.
1.7 Programas elaborados con Java
Con Java, se pueden hacer una amplia variedad de programas, pero para que los propósitos 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 intérprete. El intérprete está diseñado
para correr en una plataforma en particular y recibe como parámetro el programa de Java,
además de los parámetros propios del programa en particular.
Las aplicaciones pueden ser de distinta índole, desde simples programas como los mostrados
en la figura 3.
Figura 3. Aplicación de Java en MS-DOS.
En estos ejemplos, las aplicaciones fueron muy simples y sólo requirieron del intérprete para
sus ejecuciones. En este caso en particular, se utilizó el intérprete para Windows 32-bits,
incluido en el JDK que se explicará en la siguiente sección.
4
Páginas para Internet con Java
En el ejemplo de la figura 4, se muestra una aplicación que recupera la información de una
base de datos1, obviamente necesitó de más elementos para ejecutarlo. Se requirió la
instalación de los controladores de la base datos para Java, además de la configuración de la
red y del servidor mSQL.
Figura 4. Aplicación con conexión a una base de datos.
Ahora bien, las aplicaciones aquí mostradas sólo tienen una interfaz ASCII, pero se pueden
desarrollar aplicaciones gráficas.
1.7.2 Applets
Los applets son un tipo especial de aplicación. 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 página HTML, como la que se muestra en la
figura 5.
Cabe señalar 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 información la
envía de regreso al navegador en forma de una página HTML. Un applet, por su parte, se aloja
en un servidor junto con la página que le hace referencia. Cuando dicha página se carga
también lo hace el applet, una vez cargado en el navegador, éste comienza a ejecutarse
utilizando ahora los recursos del equipo cliente.
1
La base de datos utilizada aquí fue mSQL 2.0.7
2
CGI es un programa que es activado a través de un navegador.
5
Alejandro Talavera Rosales
Figura 5. Applet en un navegador.
Por las características propias de los applets, tienen una serie de limitaciones con respecto a
las aplicaciones. Como se nota, los applets están 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 máquina local, sólo 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 capítulos posteriores, pueden crearse applets
como interfaces gráficas para la manipulación 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.
6
Páginas para Internet con Java
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 sección se abordará el tema de las herramientas de
desarrollo de Java.
1.8 El JDK y otras herramientas de programación
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 intérprete y
otras herramientas básicas. 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:
7
Alejandro Talavera Rosales
• 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 información 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 instalación.
2. Ejecutar los programas de instalación, 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 página 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 líneas 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 instalación.
Para el JDK 1.2, J2SDK 1.3.x y J2SDK1.4, sólo hay que agregar la siguiente línea al
Autoexec:bat
SET PATH=C:\JDK1.2\bin;%PATH%
Donde C:\JDK1.2.1 es el directorio de instalación.
•
Si se instala en un equipo con sistema operativo UNIX, se sugiere agregar las dos
siguientes líneas al archivo fuente del shell en cuestión.
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 instalación. Para el caso de un Bash
Shell, la configuración sería 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
3
Para el caso de otras herramientas, es necesario revisar la documentación e instrucciones que ofrecen sus autores.
8
Páginas para Internet con Java
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 gráfico de trabajo funcional y
eficiente. Es decir, el código 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 gráficas y con una amplia biblioteca de clases y soluciones de integración 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 edición, compilación, depurado y definición.
•
Plantillas para construcción 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 edición sobre el código
directo y la segunda con herramientas y componentes gráficos. La figura 8 muestra el ambiente
general de trabajo de JavaWorkShop:
Figura 8.
9
Alejandro Talavera Rosales
Para mayor información, se recomienda al lector consultar la página:
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 código 100%
Java. Incluye además una amplia biblioteca de componentes para aplicaciones concretas:
conexión a bases de datos, comunicación vía red y generación rápida y confiable de elementos
gráficos.
Figura 9.
Para mayor información, se recomienda al lector consultar la página:
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 capítulos siguientes puedan ser
compilados y ejecutados por el lector, esta sección le ofrece el primer código a compilar y ejecutar,
donde se hará uso de las herramientas básicas de SUN: JDK o J2SDK. Para la compilación y
ejecución 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 programación. 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
Páginas para Internet con Java
caso permitirá comprobar la correcta instalación de las herramientas de desarrollo y la definición
de las variables de ambiente requeridas.
Como primer paso escriba el siguiente código 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 gráfico Windows.
•
Microsoft® Word, en el ambiente gráfico Windows. Al guardar el archivo utilice la opción
de texto plano.
•
EditPLus Text Editor ®, en el ambiente gráfico de Windows.
•
VI, en Unix.
•
PICO, en Unix.
•
ED, en Unix.
•
EMACS, en Unix.
Se debe tener cuidado de respetar las mayúsculas y las minúsculas con las que se escribe el
código fuente, ya que Java es un lenguaje sensible a mayúsculas y minúsculas. Esta regla se
aplica tanto para el código 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
Alejandro Talavera Rosales
Cuando no se genera error alguno, origina un segundo archivo que tiene el mismo nombre que
el del código fuente, pero la extensión es .class. Este último archivo es el correspondiente al
Java Byte Code.
En caso de que hubiera un error de sintaxis en el código fuente, el compilador marcará el error
correspondiente. La figura 11 muestra el caso en que se compila el código anterior, pero se
omite el punto y coma al final de la línea: System.out.println (“Hola Mundo!!!” ). Cabe señalar
que si existe algún error en la compilación no se genera el archivo .class.
Figura 11.
En caso de no existir algún error en la compilación del código fuente, se utiliza el programa
Java para ejecutar el programa, y como parámetro el nombre del archivo .class sin esta
extensión, ya que automáticamente el programa busca dicho archivo. La figura 12 muestra la
ejecución 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 instalación, a fin de detectar la
causa por la que no se compile y/o ejecute este programa.
En los siguientes capítulos se presentarán más códigos fuente, y las reglas que se deben seguir
para escribir correctamente programas usando el lenguaje de programación Java.
12
Páginas para Internet con Java
2. CLASES Y OBJETOS EN JAVA
2.1 Introducción a las clases y objetos
Una clase es una colección de datos y métodos que operan sobre dichos datos. Los datos y los
métodos, tomados juntos, usualmente sirven para definir el contenido y capacidades de algún
tipo de objeto. Analizando esta definición, 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 métodos 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 círculos mediante una clase, y se hace un análisis
rápidamente, los datos de un objeto Círculo pueden ser las coordenadas (x, y) de su centro y la
longitud de su radio r. Ahora bien, hay un número de acciones que pueden ser desempeñadas
por cualquier círculo tales como calcular su circunferencia, calcular su área, verificar si un
punto del plano cartesiano pertenece o no al círculo, entre otras más.
Con todos los elementos descritos hasta el momento para esta clase de objetos, se utiliza el
Diagrama de Clases de la notación de UML (Unified Modeling Language) para simplificar el
análisis de la clase Circulo4. La regla correspondiente indica que una clase se representará en
un rectángulo divido en tres secciones, cada una de las cuales presentan la siguiente
información: nombre de la clase, listado de datos y listado de métodos. La figura 1 muestra
dicha representación de la clase Circulo.
Circulo
x : double
y : double
r : double
area() : double
circunferencia() : double
Figura 1. Clase Circulo.
Es decir, la representación anterior indica que las variables: x, y y r son del tipo double5. Los
métodos de area() y circunferencia() regresan valores de tipo double los cuales se calculan con
base en los datos anteriores.
Cabe señalar que esta representación de clases es independiente del lenguaje, por lo que se le
indica al lector no confundir la representación con UML y la implementación de la clase con el
lenguaje de programación Java.
4
La palabra Circulo no presenta acentos, ya que para definir nombres de identificadores, variables y métodos sólo se
pueden utilizar letras y números, nunca caracteres especiales.
5
El tipo de dato double está definido en Java y representa números de punto flotante de doble precisión.
13
Alejandro Talavera Rosales
Si bien una clase nos da la idea en conjunto de un grupo de objetos, cada objeto círculo es
diferente de los demás, ya que a cada uno de ellos cuenta con su propio conjunto de datos
(variables), y su conjunto métodos (funciones).
Para traducir esta especificación a un código 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 extensión será ‘.java’. En otras palabras, el nombre del
archivo correspondiente al código 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
mayúsculas, ya que Java es un lenguaje sensible a mayúsculas y minúsculas.
El primer paso para especificar una clase en Java es la siguiente:
public class Circulo
{
}
Las palabras reservadas public class, al inicio del código, indican el alcance y en sí la
declaración de una clase. En este caso particular del código el nombre de dicha clase es
Circulo. Entre las dos llaves, una que abre y otra que cierra, se especifican los datos y métodos
de la clase.
Los datos que se han definido son: x, y y r, todas ellas de tipo double. A continuación se
presenta la definición de estas variables en el código.
public class Circulo
{
public double x, y;
public double r;
}
La declaración de variables en Java sigue básicamente las mismas reglas que las del lenguaje
C, es decir, primero el tipo de dato y después la lista de variables. Optativamente una misma
declaración puede ser utilizada para más 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 métodos de los objetos de esta clase. Los métodos que se han
presentado devuelven datos numéricos de tipo double. La implementación del método area() se
inicia con la especificación de la siguiente forma:
public double area()
{
}
La palabra reservada double en este caso indica que el método regresará una expresión
numérica de dicho tipo. El método area() regresará el valor de la fórmula: Π x r2. Para tal efecto,
se utilizará la siguiente versión de la fórmula: 3.14159 * r * r.
La palabra reservada para indicar que se regresa un valor es return, seguida de la expresión a
evaluarse. El siguiente código muestra la implementación completa del método area().
14
Páginas para Internet con Java
public double area()
{
return 3.14159 * r * r;
}
Un análisis similar para el método circunferencia() producirá el siguiente código.
public double circunferencia()
{
return 2 * 3.14159 * r;
}
El ejemplo 1 muestra el código completo de la implementación de la clase Circulo.
public class Circulo
{
public double x, y;
public double r;
public double area()
{
return 3.14159 * r * r;
}
public double circunferencia()
{
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
métodos: circunferencia( ) y area( ). En la siguiente sección se presenta al lector cómo 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
dinámicamente. Esto es casi siempre utilizando la palabra reservada new como se muestra a
continuación:
15
Alejandro Talavera Rosales
Circulo c;
c = new Circulo();
Con la última línea 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 creación y la asignación de valores hasta aquí presentados, el código del
ejemplo 2 muestra el uso del método main para la clase Circulo.
public class Circulo
{
public double x, y;
public double r;
public double area()
{
return 3.14159 * r * r;
}
public double circunferencia()
{
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 código anterior.
16
Páginas para Internet con Java
Figura 2.
2.3 Usando los métodos de los objetos
Los métodos de un objeto, como se explicó anteriormente, definen las acciones que un objeto
puede llevar a acabo. Para utilizar los métodos de un objeto, usamos la misma técnica que para
asignar colores a los datos de un objeto:
Circulo c = new Circulo();
double a;
c.r = 2.5;
a = c.area();
En este último ejemplo se asignó el valor del método area( ) a la variable a. Observe la última
línea. No se escribió a = area(); sino: a = c.area();
Esto se debe a que se utilizó la programación “Orientada a Objetos”; aquí el objeto es el centro
de atención y no así la llamada del método. Esto es probablemente la más simple e importante
característica del paradigma orientado a objetos.
Note que no se pasó ningún argumento a c.area(). El objeto sobre el que se está operando, c,
se encuentra implícito en la sintaxis. Observe de nuevo el ejemplo 1: notará lo mismo en la
definición del método area() - no toma argumentos. Esta implícito en el lenguaje, que un método
opera sobre una instancia de la clase de la cual es definido. De este modo el método area()
puede utilizar libremente el campo r de la clase - es claro que esta refiriéndose al radio de
cualquier instancia Circulo que invoca el método.
¿Qué es lo que pasa aquí? ¿Cómo puede saber un método, que no toma ningún parámetro,
sobre que dato operar? En efecto, el método area() simula tener un argumento, y se define con
un argumento implícito que no se muestra en la declaración del mismo. El argumento implícito
es llamado this, y se refiere a “este objeto” - el objeto Circulo del cual el método se invoco. this
es frecuentemente llamado la referencia “this”.
El argumento implícito this, no se muestra en la declaración del método, ya que usualmente no
es necesario - donde quiera un método en Java puede accesar los campos en su clase.
El código de un método constructor de la clase Circulo se muestra en el ejemplo 3:
public Circulo(double a, double b, double c) {
x = a;
17
Alejandro Talavera Rosales
y = b;
r = c;
}
Ejemplo 3.
En este caso, el método constructor inicializa los campos de datos del objeto que se está
creando. Este método 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 explícitamente cuando se quiere poner en claro que un método
accesa sus propias variables y/o métodos. Por ejemplo, se puede re-escribir el método area()
de la siguiente forma:
public double area() {return 3.14159 * this.r * this.r;}
En un método tan sencillo como éste, no es necesario ser explícito. Sin embargo, en casos más
complicados, parece que utilizar un this explícito incrementa la claridad del código aunque no
sea estrictamente necesario.
2.4 Creación de un objeto
Se examinará de nuevo, la forma en que se creó un objeto de la clase Circulo:
Circulo c = new Circulo();
¿Qué significan los paréntesis? Una llamada de función. Toda clase en Java tiene al menos un
método constructor6. El propósito de todo constructor es el de llevar a cabo el proceso de
inicialización requerido para un nuevo objeto. Como no se definió de forma explícita un
constructor para la clase Circulo, Java da un constructor por omisión que no toma argumentos
ni efectúa una inicialización particular.
Esta es la forma en que funciona el mecanismo de creación de objetos:
1. La palabra reservada new crea una nueva instancia dinámica de la clase; esto es, asigna el
objeto nuevo.
2. Se llama al método constructor.
6
Los métodos constructores tiene el mismo nombre que el de la clase que los define.
18
Páginas para Internet con Java
3. Se pasa explícitamente el objeto nuevo y se pasan explícitamente los argumentos
especificados entre los paréntesis.
2.5 Definición de un constructor
Si se desea que los objetos de la clase Circulo no se construyan con base en la forma por
omisión, 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 sección anterior.
public class Circulo {
public double x, y, r;
//El método 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, obtendría algo como el siguiente código:
Circulo c = new Circulo();
c.x = 1.1414;
c.y = -1.0;
c.r = .25;
Mientras que con el nuevo constructor, la inicialización 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 método constructor es siempre el mismo que el de la clase.
• El valor de retorno del método es implícitamente 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 implícitamente; un constructor no debe usar una declaración return
para regresar algún valor.
19
Alejandro Talavera Rosales
2.6 Múltiples constructores
Existen ocasiones en que se requiere de inicializar un objeto de varias formas, dependiendo de
lo que resulte más práctico en algún momento determinado. En el ejemplo 6 se muestra la
declaración 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 parámetros. En la siguiente sección se hace un análisis de estas implicaciones.
2.7 Sobrecarga de métodos
Con el último ejemplo surge la siguiente pregunta: ¿Cómo es posible que estos métodos se
llamen iguales y el compilador pueda distinguirlos? La respuesta es simple, todo se debe a la
disposición de los siguientes elementos: el nombre del método, el número de parámetros, el
tipo y la posición de los parámetros. Esta cualidad se denomina sobrecarga de métodos y no es
exclusiva de los métodos constructores.
Cuando se llama a un método y hay más de uno con el mismo nombre, el compilador
automáticamente selecciona uno que se ajuste con los tipos de datos de los argumentos que le
hayan pasado.
Resumiendo, al hecho de definir métodos con el mismo nombre y distintos tipos de argumentos
se denomina Sobrecarga de método.
2.8 Subclases y herencia
La clase Circulo que se definió, representa una buena abstracción de la figura matemática que
modela. Pero supóngase que se desea dibujarla en pantalla, por ejemplo, para lo cual será
necesario una nueva clase, podría ser CirculoGrafico, que tiene toda la funcionalidad de
Circulo, además de poderse dibujar.
Puede definirse la clase CirculoGrafico de la siguiente forma:
20
Páginas para Internet con Java
public class CirculoGrafico
{
public Circulo c; // Círculo matemático
public double area() { return c.area(); }
public double circunferencia () { return c.circunferencia(); }
public Color exterior, relleno;
public void dibujar(DibujarVentana dw) { /* Código */ }
}
Esta forma de hacerlo funciona, pero involucró la definición de elementos que ya existían. Hay
una mejor opción.
En Java es posible definir CirculoGrafico como una extensión o subclase de Circulo. El ejemplo
7 muestra la definición 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
Alejandro Talavera Rosales
3. LA HERENCIA
Hablando de manera general, los objetos están definidos en términos 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 velocípedo, con sólo decirle que es una bicicleta, sabría entonces que
tiene dos llantas, un juego de manubrio y de pedales.
Los sistemas de programación orientados a objetos toman esto de forma similar y permiten que las
clases sean definidas en términos de otras clases. Por ejemplo, las bicicletas de montaña, 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 montaña, de carreras y dobles.
Cada subclase hereda las cualidades (en la forma de declaraciones de variables) de la
superclase. Las bicicletas de montaña, de carrera y dobles comparten las mismas cualidades:
cadencia, velocidad y la forma. También, cada subclase hereda métodos de la superclase. Las
bicicletas de montaña, 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é habría que señalar en esto? Las subclases pueden agregar variables y
métodos para aquellos heredados de la superclase. Las bicicletas dobles tienen dos asientos y
dos pares de manubrios; algunas bicicletas de montaña tienen un conjunto extra de engranajes
de radio menor.
Las subclases pueden también sobre-escribir los métodos heredados y proveer
implementaciones específicas para esos métodos. Por ejemplo, si tuviera una bicicleta de
montaña con un conjunto extra de engranes, podría sobre-escribir el método
"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 programación orientados a objetos, la herencia puede ser simple o
múltiple. La herencia simple permite al programador definir nuevas clases a partir de una, y sólo
una clase existente. Por el contrario, la herencia múltiple permite al programador definir nuevas
clases a partir de una o más al mismo tiempo. En el caso particular de Java, sus diseñadores
optaron por el manejo de la herencia simple, permitiendo que el manejo de la herencia sea fácil
de incorporar y de entender.
La herencia en Java se maneja con el uso de la palabra reservada extends, en la definición de
la clase. Supóngase que se define la clase A con todos sus datos y métodos por completo.
Ahora supóngase que se pretende crear la clase B como subclase de A. Lo que se debe hacer es
agregar a la declaración de la clase B la expresión "extends A", como se muestra en el ejemplo 1.
public class A
{
...................
}
22
Páginas para Internet con Java
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 declaración de la clase, y así sucesivamente. Esta relación 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 raíz (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
Alejandro Talavera Rosales
Cuando se declara una clase sin definir explícitamente 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 capítulo, 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
Páginas para Internet con Java
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 sólo declarar que ésta es una subclase de Rectangulo.
Pero como también se explicó, dicha funcionalidad puede ser modificada según las
necesidades concretas de la nueva clase.
En el caso de los constructores existe una regla de funcionamiento, sólo el método constructor
por omisión se hereda tal cual como se definió en la superclase. Esto excluye a los demás
constructores que se hayan declarado. ¿Cómo resolver este problema? Existen dos respuestas
a esta pregunta, la primera consistirá en volver a escribir los métodos constructores. Lo anterior
resulta de lo más inconveniente, ya que no se reutilizaría el código ya compilado y probado. El
segundo método 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 métodos de la superclase. En el
caso de los constructores, ésta tiene la siguiente forma:
super(param1, param2, ...);
Además, el uso de super para ejecutar constructores sólo se puede hacer desde un constructor
de una clase heredada y debe ser la primera línea del método.
Para la clase Cuadrado del ejemplo 5, se tendrá que añadir el método 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 geométrica, 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 omisión. Una solución sería la que se muestra en el
ejemplo 7, en la cual, primero se crea el 'rectángulo', y después se verifica si los lados tienen la
misma longitud, en caso de no ser así se ajustan las coordenadas.
25
Alejandro Talavera Rosales
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 métodos constructores proporcionarán
objetos Cuadrado de manera confiable.
Ahora bien, se podría pensar en modificar otros métodos de la clase para ajustarlos a la forma
en que se está definiendo los métodos area( ) y perimetro( ). Para ver un poco más lo anterior,
se recurrirá a la sobre-escritura de métodos que se explica en la siguiente sección.
3.3 Sobre-escritura de métodos
Se denomina sobre-escritura de métodos a la capacidad de volver a definir los métodos que un
objeto ha heredado. Como se vio en la sección anterior, es posible modificar los métodos
constructores, pero aún más, se puede modificar cualquier método que la clase haya heredado.
Retomando el caso de la clase Cuadrado, los métodos area( ) y perimetro( )se pueden
simplificar de su versión 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 actúa como si se escribiera la clase por primera vez
dentro de la clase.
26
Páginas para Internet con Java
3.4 Definición de nuevos datos y métodos en subclases
Cuando se define una subclase a partir de otra, se pueden agregar nuevos elementos, los
cuales funcionarán 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
métodos de A, además 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 métodos, es decir,
se pueden incorporar nuevos métodos 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 métodos, o bien, las clases modifican
los métodos que heredaron, la llamada a éstos se va escalando a las superclases de la
siguiente forma: primero se busca si en la definición de la clase actual se tiene declarado el
método invocado, de ser así, se ejecuta este método. En caso contrario se busca en la
definición de la superclase y efectúa el mismo análisis. Esto continua sucesivamente hasta
llegar a la raíz de herencia, en el caso de Java la clase Object. Si en este nivel no se encuentra
la definición del método, el compilador marcará un error.
3.5 La palabra reservada super para métodos no constructores
Con estos mecanismos puede utilizarse el método tal y como lo venia haciendo la superclase.
Supóngase que la clase B hereda el método area( ) de la clase A, como se muestra en el
ejemplo 10.
public class A{
*******
public double area()
{ return 3.14259; }
*******
}
class B extends A{
********
}
Ejemplo 10.
27
Alejandro Talavera Rosales
También se supondrá, que para la clase B, se necesita sobre-escribir el método area( ). Al
modificar directamente el método, é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 definición que heredó
de forma intacta dado un valor verdadero, o bien, ejecute una nueva especificación si el valor es
falso. Una opción nuevamente sería la de escribir de nuevo la especificación del método. La
solución más práctica es el uso de la palabra super, ahora para métodos no constructores.
Su utilización es simple, piense que super representa a un objeto de la superclase, entonces
vuelva a utilizar la notación de punto de la siguiente forma:
super.método(arg1, arg2, ...)
Para este caso, puede usar algo como lo que se muestra en el ejemplo 11.
double area( ) {
if(<condición>) {
super.area( );
}
else {
//Nuevo código
*************
}
}
Ejemplo 11.
28
Páginas para Internet con Java
4. APPLETS
Como se ha mencionado, existe otro tipo de aplicación 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 más claro el concepto de un applet, se retomará el ejemplo que está funcionando en
la dirección http://www.unam.mx/Temas/, el cual ofrece una opción de búsqueda por teclado a
la manera de las ayudas de Windows. Ver figura 1.
Figura 1.
Cuando un navegador (con capacidad de ejecución de applets) carga una página que tiene
asociado un applet, ocurren varias cosas. Lo primero es la verificación de que el applet que se pide
cargar no contenga código "peligroso", es decir, que no pueda recuperar información del equipo
local, como la lista de directorios y archivos, o en su caso la alteración 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 sección.
4.1 Ciclo de vida de un applet
4.1.1 Cargar el applet
Cuando se carga un applet, se efectúan las siguientes operaciones:
• Una instancia de la clase de control del applet se crea.
• El applet se inicializa.
29
Alejandro Talavera Rosales
• 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 rectángulo alrededor del área de despliegue del
Applet.
g.drawRect(0, 0, size().width - 1, size().height - 1);
//Dibuja la cadena actual dentro del rectángulo
g.drawString(buffer.toString(), 5, 15);
}
}
Ejemplo 1.
4.1.2 Cambiando y regresando a la página del applet
Cuando los usuarios cambian de página, esto es, van a otra página, el applet puede pararse.
Caso contrario, cuando el usuario regresa a la página, 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
Páginas para Internet con Java
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 Métodos básicos de la clase applet
Los applets son clases ya definidas, lo único que se debe hacer es sobre-escribir los métodos
que ya se definieron para su funcionamiento. El ejemplo 2 muestra un resumen con los
métodos básicos 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 métodos que allí aparecen, responden a eventos específicos. A continuación se da una
breve explicación del funcionamiento de cada uno de estos métodos.
init() –
Sirve para inicializar al applet. Este método se ejecuta sólo después de que el applet
se ha cargado.
start() –
Este método sirve para comenzar la ejecución del applet, se ejecuta después de que
se ha inicializado el applet, o bien, cuando se regresa a la página del applet.
stop() -- Detiene la ejecución del applet. Este método se ejecuta cuando los usuarios dejan la
página del applet, o bien, cuando se cierra el navegador.
destroy()-
Se ejecuta después de que se detiene el applet, ya que el navegador se cierra.
31
Alejandro Talavera Rosales
Cabe mencionar, que los applets no requieren sobre-escribir todos y cada uno de los métodos
definidos para los mismos. En el ejemplo 3 se muestra el código fuente de un applet muy
sencillo, donde sólo se requirió la modificación del método paint()7.
import java.applet.Applet;
import java.awt.Graphics;
public class HolaMundo extends Applet {
public void paint(Graphics g) {
g.drawString("Hola Mundo!!!", 40, 20);
}
}
Ejemplo 3.
El método init() cumple de alguna manera la función de un constructor, ya que sólo se ejecuta
inmediatamente después 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 operación después de su inicialización será necesario sobreescribir el método start(). El método start(), a la vez que activa al applet, desarrolla el trabajo del
mismo; también pone en funcionamiento uno o más threads para desarrollar el trabajo. Por el
momento sólo se dará importancia al primer punto. El método stop() se ha definido para detener
la ejecución del applet. El método destroy() es raramente utilizado ya que el método stop()
efectúa todo lo necesario para detener la ejecución del applet. Sin embargo, destroy() está
disponible para aquellos applets que requieran procesos adicionales antes de terminar la
ejecución del applet.
4.3 Programando interfaces gráficas
La programación de interfaces gráficas no es exclusiva de los applets. Elementos tales como
botones, cajas de texto, despliegue de gráficas y demás, pueden incluirse en cualquier tipo de
programa con Java, ya sea aplicación o applet.
Para incluir componentes gráficos, 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.
7
Este método se describirá más adelante.
32
Páginas para Internet con Java
Figura 2.
Para el caso de los applets, todos estos elementos que conformarán la interfaz gráfica
(botones, cajas de texto, etc.), se van agregando en el método init().
Supóngase que se desea una interfaz como la que se muestra en la figura 3.
Figura 3.
El código asociado a este applet sería el que se muestra en el ejemplo 3.
import java.awt.*;
import java.applet.Applet;
public class Interfaz01 extends Applet
{
Label lb1, lb2, lb3;
33
Alejandro Talavera Rosales
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
Páginas para Internet con Java
5. PROGRAMACIÓN DE INTERFAZ GRÁFICA DE USUARIOS
El objetivo de una interfaz gráfica de usuario es la de facilitar la interacción de un programa o
sistema con sus usuarios finales. Si bien el éxito de una interfaz gráfica de usuario depende en
gran parte de un estudio a fondo de los aspectos ergonómicos adecuados para los programas,
no es el objetivo de este manual el proporcionar guías al respecto.
Una interfaz proporciona al usuario un conjunto de elementos gráficos para que éste pueda
operar, insertar, desplegar y manipular información desde y para el programa. En otras palabras
una interfaz gráfica 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 gráficos que podemos apreciar en la figura 1, y otros más, forman
parte del paquete java.awt.
Figura 1.
Otro aspecto importante, ligado a los componentes, es la generación de eventos. Un evento es
el resultado de la interacción de un usuario con alguno de los componentes de la interfaz
gráfica, por ejemplo, un usuario genera un evento al activar un botón, o bien al abrir o cerrar
una ventana.
El concepto de AWT o Abstract Window Toolkit sólo engloba los componentes gráficos, la parte
de programación de eventos está contenida en el paquete java.awt.event8. En el presente
capítulo, se presentan al lector, los distintos objetos definidos en Java para el uso de
componentes gráficos.
8
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
Alejandro Talavera Rosales
5.1 Jerarquía de objetos del AWT
A partir de la versión del JDK 1.1, se ha dado una mayor atención y flexibilidad a los elementos y
objetos para la programación e incorporación de elementos gráficos. El paquete AWT contiene
todos los componentes gráficos para incluirlos en la programación. Existe una jerarquía de herencia
que relaciona todos los elementos gráficos. La figura 2 muestra dicha jerarquía.
Figura 2.
La base de la herencia sigue siendo la case Object, pero la clase Component se toma como la
raíz de la herencia de todos los componentes gráficos 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 también son abstractas.
Las diferentes clases de la jerarquía del AWT se presentarán una por una, mostrando su
representación gráfica, sus propiedades y los métodos más útiles para su programación.
5.1.1 Clase Component
Como se mencionaba, la clase es abstracta por lo que no pueden tenerse objetos de esta clase.
Su propósito es establecer un patrón de diseño y funcionalidad de los componentes gráficos en
general.
Los objetos Component tienen definidos métodos que permiten la recuperación de información
relativa a ellos, además de los métodos que manipulan su aspecto final. Al ser la raíz de
herencia de los componentes gráficos, todos los métodos que este objeto tenga, los tendrán
definidos las distintas subclases de éste.
Los métodos de recuperación de información más 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
Páginas para Internet con Java
getWidth()
getX()
int
Int
getY()
int
isEnabled()
boolean
isVisible()
bolean
getSize()
Dimension
Regresa el valor del ancho del componente.
Regresa el valor de la posición con respecto al eje
X del componente.
Regresa el valor de la posición 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 tamaño del componente.
Los métodos más importantes de manipulación de información 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 posición del componente.
Establece las dimensiones del componente.
Actualiza la vista del componente.
5.1.2 Clase Button
Los objetos Button proporcionan la implementación de botones para una interfaz gráfica. Un
botón 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 botón sin etiqueta.
• Button( String ) : construye un botón con una etiqueta específica.
Los siguientes, son los ejemplos de la definición y creación 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
Alejandro Talavera Rosales
Los métodos de recuperación de información más 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
botón.
Regresa un String que representa la
etiqueta del botón.
Los métodos más importantes de manipulación de información 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 botón.
setLabel()
void
Establece la etiqueta del botón con el
String de parámetro.
5.1.3 Clase Checkbox
La clase Checkbox proporciona cajas de selección, 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 selección sin etiqueta.
• Checkbox(String) : crea una caja de selección con una etiqueta específica.
• Checkbox(String, boolean): crea una caja de selección con una etiqueta y un estado
específicos.
• Checkbox(String, boolean, CheckboxGroup): crea una caja de selección con una etiqueta
y un estado específicos, además de especificar un grupo al que pertenece.
• Checkbox(String, CheckboxGroup, boolean): crea una caja de selección con una etiqueta
y un estado específicos, además de especificar un grupo al que pertenece.
Los dos primeros constructores permiten varios de ellos sin que tengan relación unos de otros. Las
dos últimas opciones sirven para generar lo que se conoce como radios, es decir, varias opciones
pero sólo se puede seleccionar una a la vez, tal como se muestra en la figura 5.
38
Páginas para Internet con Java
Figura 5.
El siguiente código muestra la definición y creación 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 código muestra la definición y creación de cajas de opciones de una selección a la
vez, usando los dos últimos constructores. La figura 2 corresponde a este código:
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 métodos de recuperación de información más 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 opción.
Regresa el String de la etiqueta de la caja
de opción.
Regresa el valor del estado de la caja: true
o false.
Los métodos más importantes de manipulación de información 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 opción.
Asigna el valor del estado de una caja de
opción.
Alejandro Talavera Rosales
5.1.4 Clase Label
Los objetos de la clase Label se utilizan para colocar etiquetas en una interfaz gráfica. Las
etiquetas pueden ser insertadas cuando es necesario mostrar alguna información 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 vacía.
•
Label(String): construye una etiqueta con un texto justificado a la izquierda.
•
Label(String, int): construye una etiqueta con un texto y justificado según el valor del
segundo parámetro.
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 código muestra la definición y creación de etiquetas usando los constructores
anteriores. La figura 7 muestra el resultado del código.
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
Páginas para Internet con Java
Figura 7.
Los métodos de recuperación de información más importantes son los que se listan en la
siguiente tabla:
Nombre
getAlignment()
getText()
Tipo de retorno
int
String
Uso
Regresa el valor de alineación de la etiqueta.
Regresa el String que corresponde a la etiqueta
Los métodos más importantes de manipulación de información y aspecto de un Label son los
que se presentan en la siguiente tabla:
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 gráfico, 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 métodos add, los cuales permiten la inserción de
otros componentes gráficos en ellos. La siguiente tabla muestra las distintas versiones del
método add.
Método
Add(Component)
add(Component, int)
add(String, Component)
Uso
Agrega el componente al final del contenedor.
Agrega el componente al contenedor en la posición dada
por el segundo parámetro.
Agrega el componente al contenedor con un String que se
le asocia.
41
Alejandro Talavera Rosales
La representación gráfica y el uso de cada contenedor depende del objeto y su función de
operación. La figura 9 muestra la representación gráfica 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 representación gráfica, 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 tamaño ni en su posición.
Los objetos de la clase Frame representan ventanas de la interfaz gráfica de la plataforma
donde se despliega. Tienen barra de título 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 información por este medio. Una clase
derivada es FileDialog para desplegar ventanas de archivos, y buscar archivos en la máquina
local.
Se principiará con los objetos de la clase Frame para la inserción de elementos, ya que
representan la base de desarrollo de una interfaz gráfica.
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 título, botones de maximizar, minimizar y de cerrar, las
cuales son completamente funcionales, salvo la operación de cerrar. Es decir las ventanas en
AWT no cuentan con la opción de cerrar, a pesar de presentar el correspondiente botón.
Los constructores de la clase Frame son los siguientes:
•
Frame ( ): construye una ventana de sistema que inicialmente está oculta. No presentará
título alguno.
•
Frame ( String ): construye una ventana de sistema que inicialmente está oculta. El título
que presentará es el asociado al String, que se manda como parámetro.
42
Páginas para Internet con Java
El siguiente código muestra la definición y creación 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 especificación de los
constructores. Para visualizar las ventanas que se crean, se utiliza el método setVisible (bolean)
heredado de Component, de la siguiente forma:
f1.setVisible( true );
La figura 10 muestra el resultado de esta última operación. La ventana se despliega sin
dimensiones y ubicada en la esquina superior derecha.
Figura 10.
Los métodos para la recuperación de información más importantes de la clase Frame son los
que se presentan en la siguiente tabla:
Nombre
getTitle()
Tipo de retorno
String
isResizable()
boolean
setCursor(Cursor)
Void
Uso
Regresa el String que representa el título de la
ventana.
Indica si el usuario puede cambiar el tamaño 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 combinación de teclas CTRL + C. Por otra parte se pueden usar los métodos
setSize (nt, int) y setLocation (int, int) heredados de Componet, para establecer el tamaño y
ubicación de la ventana respectivamente. El siguiente código muestra un programa completo
usando estos métodos, 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
Alejandro Talavera Rosales
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 excepción 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 después indicar su inserción.
Para Insertar un componente, ya sea Button o Label, en un frame, por ejemplo, se deben utilizar
los métodos add heredados de Container. El siguiente código muestra el uso de las
operaciones de inserción 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.setLocation ( 50, 50 );
f.setSize ( 300, 150 );
f.setVisible ( true );
}
}
Es decir, primero se crea el componente a insertar:
Label l = new Label ( “Etiqueta” );
Y después se inserta en la ventana:
f.add ( l );
La figura 12 muestra la ventana con una etiqueta ya insertada.
44
Páginas para Internet con Java
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ú sólo puede incluirse en un objeto de la clase Frame. Para asignar una barra
de menú, es necesario entender la relación de la clase de objetos MenuBar con otras clases
que ayudan a implementar esta opción, las cuales son:
•
MenuItem : cada opción de un menú es representada por un objeto de esta clase.
•
CheckboxMenuItem: cada opción de un menú que sólo sirve para ser marcada. Es una
subclase de MenuItem.
•
Menu: cada uno de los menús que se presentan sobre la barra. Es una subclase de
MenuItem.
•
MenuBar: es la implementación de la barra de menú.
La figura 14 muestra la representación gráfica de los objetos anteriores.
45
Alejandro Talavera Rosales
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 opción 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 continuación:
1. Crear un objeto de la clase MenuBar.
Los objetos de la clase MenuBar cuentan con un constructor por omisión y sólo basta con
crearlo. El siguiente código ejemplifica esta operación.
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 menús: Archivo y Edición. El siguiente
código ejemplifica estas definiciones.
Menu m1 = new Menu ( "Archivo" );
Menu m2 = new Menu ( "Edición" );
3. Por cada opción 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 crearán
tres objetos de la clase MenuItem con sus títulos indicados en sus respectivos constructores.
Una vez creados se agregarán al primer menú, es decir, a m1. El siguiente código 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
Páginas para Internet con Java
m1.add ( mi_02 );
m1.add ( "-" );
m1.add ( mi_03 );
La línea 6 de este código muestra la forma para añadir una línea separadora entre los menús.
Este procedimiento es el mismo para el menú Edición.
4. Agregar los objetos de la clase Menu al objeto MenuBar.
Ya que se cuenta con los menús completos, éstos deben ser agregados al objeto MenuBar del
punto 1. El siguiente código 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
código.
f.setMenuBar ( mb );
El código completo de este ejemplo se muestra a continuación:
import java.awt.*;
public class Menus
{
public static void main(String[] args)
{
Frame f = new Frame ( "Ventana con menus" );
f.setLocation ( 100, 100 );
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 ( "Edición" );
MenuItem mi_04 = new MenuItem ( "Copiar" );
MenuItem mi_05 = new MenuItem ( "Cortar" );
47
Alejandro Talavera Rosales
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 );
f.setVisible ( true );
}
}
5.2 Manejo de eventos
El problema que aún prevalece en las interfaces hasta aquí presentadas es que se carece de la
programación requerida para que funcione como se pretende lo haga. Por ejemplo, supóngase
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 botón Copiar.
Figura 15.
El código 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.setLocation ( 100, 100 );
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
Páginas para Internet con Java
f.add ( etiqueta1 );
f.add ( texto1 );
f.add ( etiqueta2 );
f.add ( texto2 );
f.add ( bt );
f.setVisible ( true );
}
}
Sin embargo, se carece de la programación para que el texto se copie.
A fin de implementar dicha programación, en el código anterior se requiere entender cómo
funcionan los componentes cuando son utilizados por alguna persona. Resulta fácil intuir que la
programación no puede estipularse de forma lineal, ya que la interacción del usuario no es
uniforme. De aquí que se defina el concepto de evento.
Un evento resulta de la interacción del usuario con algún elemento de la interfaz. Por ejemplo,
en un botón, un evento es activarlo; en una ventana, por su parte, un evento sería minimizarla.
La idea es que cada operación interactiva de cualquier componente gráfico, representa un
evento del mismo.
Cada lenguaje de programación define la programación de eventos según su estructura y
paradigma que implemente, en el caso particular de Java los eventos son también clases de
objetos. En Java existen dos modelos de manejo de eventos, pero en este manual sólo 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 gráficas con otros lenguajes, seguramente se ha
encontrado que los elementos gráficos manejan los eventos que producen, es decir, cada
componente tiene el conjunto de líneas asociadas a un evento dado. En el modelo
delegacional, el manejo de eventos se distribuye en tres partes:
• Componentes gráficos.
• Eventos.
• Listeners.
Los cuales se explican a continuación.
Componentes
Son todos aquellos elementos con los cuales puede interaccionar el usuario en una interfaz
gráfica, como por ejemplo botones, ventanas, cajas de texto, entre otros. Su objetivo no es el de
responder con algún código, sino más bien generar eventos.
49
Alejandro Talavera Rosales
Eventos
Cada que el usuario utiliza algún componente gráfico, el sistema genera automáticamente un
objeto que los representa. Dichos objetos representan los eventos que el usuario generó al
interaccionar con un componente. Con ellos puede recuperarse información 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 parámetro los eventos generados por los componentes. Los listeners se agrupan
en el paquete java.awt.event.
En términos generales, se puede resumir que los componentes gráficos tienen la tarea de crear
objetos que representan eventos producidos por los usuarios. Cabe señalar que un mismo
componente puede generar más de una clase distinta de eventos. La figura 16 muestra un
resumen de los componentes más 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 botón 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 botón, y en el momento en que se produzca, llevar a cabo alguna
programación. 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
Páginas para Internet con Java
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 patrón de funcionalidad de alguna clase que quiera
seguirlo. En una interfaz se presenta una lista de firmas de métodos, los cuales deberán ser
implementados por alguna clase que así lo requiera. En dicha lista no se especifican cuerpos de
programación, sólo encabezados. Este mecanismo no sólo es útil en la programación de
eventos, pero no se presentarán más casos en este manual.
51
Alejandro Talavera Rosales
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, sólo que implemente la interfaz ActionListener. La especificación de la interfaz se
muestra en la figura 19.
Figura 19.
ActionListener sólo especifica un solo método actionPerformed(ActionEvent ae ), con lo que una
clase que la implemente deberá tener obligatoriamente dicho método. Por ejemplo, defina la
clase EscuchaBoton como se muestra en la figura 20.
Figura 20
La indicación 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 declaración de escribirá después 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 botón
que se utilizará será el referido por la variable bt. Para efectuar dicho registro, todo componente
cuenta con un método addXXXListener( XXXListener ) para tal efecto, los objetos de la clase
Button tienen el método addActionListener ( ActionListener ). La figura 21 muestra el registro de
un objeto de la clase Escucha botón.
Figura 21.
Es importante señalar que se necesita un objeto de la clase EscuchaBotón para registrarlo.
Entonces cada vez que se utiliza el botón aparece el mensaje “XXX” en la pantalla de MS-DOS,
tal como se muestra en la figura 22.
52
Páginas para Internet con Java
Figura 22
Algo interesante de esta técnica es, que un componente puede registrar más de un listener.
Para apreciar este hecho, defina una nueva clase que implemente ActionListener, tal y como se
muestra en la figura 23.
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 método 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
Alejandro Talavera Rosales
Más aún, 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 automáticamente. Esto se debe a
que no hay ningún 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 métodos que tienen
que ser incluidos.
Figura 26.
El registro de un objeto de esta clase lo efectuará una ventana con el método
addWindowListener() como se muestra en la figura 27. El efecto del manejo de eventos se
muestra en la figura 28.
Figura 27.
54
Páginas para Internet con Java
Figura 28.
Una clase que permita que la ventana se cierre automáticamente 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 automáticamente.
55
Alejandro Talavera Rosales
6. JDBC
6.1 Introducción
El desarrollo de aplicaciones con conexión a bases de datos es uno de los principales tipos de
programas que pueden ser desarrollados con el lenguaje de programación Java. Java cuenta
con el API JDBC™ para la manipulación de información en bases de datos, utilizando para ello
el estándar SQL (Structured Query Language). Cabe mencionar que el API JDBC™ no es la
abreviatura de algún concepto o tecnología, pero frecuentemente se le asocia el término Java
DataBase Connectivity (Conectividad de Base de Datos de Java).
Este API define una serie de clases e interfaces que establecen un estándar tanto para
herramientas de desarrollo como para bases de datos. Dicho estándar 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 envío de sentencias
de SQL a casi cualquier base de datos relacional, además de que es posible manipular los
datos de respuesta a dicha sentencia. Con esto podemos desarrollar aplicaciones que permiten
el establecimiento de servicios en línea 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 básicas de los programas que
utilizan el JDBC, las cuales se listan a continuación:
1. Cargar el controlador.
2. Establecer una conexión 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
Páginas para Internet con Java
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 vía un controlador y puede soportar múltiples controladores
de conexión 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 métodos 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 utilización:
•
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 están divididos en las siguientes categorías:
1. Controlador JDBC–ODBC bridge: proporciona acceso vía 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 más 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
Alejandro Talavera Rosales
2. Controlador Native-API partly-Java: un controlador, basado en la tecnología 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 algún 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 específico que se utilice depende enteramente del vendedor. En general,
esta es la alternativa más flexible del JDBC. Es probable que todos vendedores de esta
solución proporcionarán los productos adecuados para el desarrollo de Intranets. Ver figura 3.
Figura 3.
58
Páginas para Internet con Java
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, solución práctica 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 desarrollarán 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 visión general de lo qué es el JDBC con algunas de sus características, se hará
uso de éste con un controlador tipo 1. El controlador JDBC-ODBC bridge no requiere ser
instalado ya que la distribución del JDK lo tiene incluido.
6.2.1 Instalando y configurando una base de datos con ODBC
Para configurar el recurso de ODBC, se seguirán los siguientes pasos:
1. Inicie la aplicación 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
Alejandro Talavera Rosales
Figura 5.
2. Seleccione el botón 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. Después de esto aparecerá la ventana
de la figura 7.
60
Páginas para Internet con Java
Figura 7.
4. Cree una nueva base de datos con el botón Create y asigne el nombre de un archivo con
extensión .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 conexión de base de datos
Lo primero que se requiere para utilizar el JDBC es establecer una conexión a la base de datos.
Esto es un procedimiento de dos pasos. Se debe cargar el controlador del JDBC y entonces
establecer la conexión. Cargar un controlador de JDBC es muy simple, sólo toma una línea de
código.
La siguiente línea muestra como cargar el controlador:
Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
Cuando se llama al método Class.forName( ), se crea una instancia del controlador que registra
el DriverManager.
61
Alejandro Talavera Rosales
Después de que se cargó el controlador, para establecer una conexión, se llama al método
estático DriverManager.getConnection( ), el cual regresa una conexión a la base. La firma de
este último método es la siguiente:
public static synchronized Connection getConnection(String url,
String user, String password) throws SQLException
El primer parámetro es el URL que señala 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 sección anterior, el URL queda como jdbc:odbc:PruebaODBC. Los otros dos
parámetros se explican por sí solos.
El siguiente código es un ejemplo para establecer una conexión a esta base de datos:
Connection con = DriverManager.getConnection(“jdbc:odbc:PruebaODBC”,”alex”,”alex123”);
6.2.3 Usando comandos básicos de SQL
Una vez que se cuenta con una conexión a la base de datos, debe crearse un objeto de la clase
Statement. Para crear dicho objeto se debe utilizar el método Connection.createStatement( ).
Este último, como objeto Statement del JDBC, se utilizará para enviar sentencias de SQL a la
base de datos.
La siguiente línea muestra cómo 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 utilizarán 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 conexión 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
Páginas para Internet con Java
"(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 conexión
con.close();
}
}
catch(SQLException sqle)
{
System.err.println(sqle.getMessage());
}
}
}
public static void main(String arg[]) {
CreateTableApp cta = new CreateTableApp();
cta.createTable();
}
}
Ejemplo 2.
Ahora, centre su atención en las siguientes líneas:
// Creando un Statement
Statement stmt = con.createStatement();
// 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 conexión, se creó un objeto Statement. Para efectuar la creación de la tabla se llama
al método Statement.executeUpdate(), cuya firma se muestra a continuación:
public int executeUpdate(String sql) throws SQLException
Este método se usa para todo tipo de transacciones de actualización 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 aplicación usada para insertar datos en ellas.
63
Alejandro Talavera Rosales
import java.sql.*;
public class InsertDataApp{
public InsertDataApp() {
}
public void insertData() {
Connection con = null;
try {
// Cargando el controlador
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
// Estableciendo la conexión con la Base de datos
con = DriverManager.getConnection("jdbc:odbc:PruebaODBC","","");
// Creando un Statement
Statement stmt = con.createStatement();
// Uso del Statement creado para insertar datos a la tabla titulos
stmt.executeUpdate("INSERT INTO titulos " +
"VALUES (0, 'Estudio de ecuaciones', 2)");
stmt.executeUpdate("INSERT INTO titulos " +
"VALUES (1, 'TOO: Ejemplos y casos practicos', 4)");
stmt.executeUpdate("INSERT INTO titulos " +
"VALUES (2, 'Analisis de mercados', 10)");
stmt.executeUpdate("INSERT INTO titulos " +
"VALUES (3, 'Generadores y alternadores', 3)");
stmt.executeUpdate("INSERT INTO titulos " +
"VALUES (4, 'Tanques y compresoras Diesel', 2)");
}
catch(SQLException sqle) {
System.err.println(sqle.getMessage());
}
catch(ClassNotFoundException cnfe) {
System.err.println(cnfe.getMessage());
}
finally {
try
{
if(con != null)
{
// Cerrar la conexión
con.close();
}
}
catch(SQLException sqle)
{
System.err.println(sqle.getMessage());
}
64
Páginas para Internet con Java
}
}
public static void main(String arg[]) {
InsertDataApp ida = new InsertDataApp();
ida.insertData();
}
}
Ejemplo 3.
La aplicación InsertDataApp usa el mismo método que se utilizó para crear tablas. El único
cambio se efectuó en la cadena SQL que se le pasó al método, usando una sentencia INSERT
de SQL en su lugar.
Realizando consultas a una tabla
La instrucción más utilizada del SQL es el SELECT. Dicha instrucción da la posibilidad de
explorar el contenido de las tablas en una base de datos. En el ejemplo 4 se muestra una
aplicación que con los datos que contiene la tabla titulos.
import java.sql.*;
public class SelectDataApp{
public SelectDataApp() {
}
public void selectData( ) {
Connection con = null;
try {
// Cargando el controlador
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
// Estableciendo la conexión con la Base de datos
con = DriverManager.getConnection("jdbc:odbc:PruebaODBC","","");
// Creando un Statement
Statement stmt = con.createStatement();
// 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
Alejandro Talavera Rosales
}
catch(SQLException sqle) {
System.err.println(sqle.getMessage());
}
catch(ClassNotFoundException cnfe) {
System.err.println(cnfe.getMessage());
}
finally {
try {
if(con != null)
{
// Cerrar la conexión
con.close();
}
}
catch(SQLException sqle) {
System.err.println(sqle.getMessage());
}
}
}
public static void main(String arg[]) {
SelectDataApp cta = new SelectDataApp();
cta.selectData();
}
}
Ejemplo 4.
Para efectuar una consulta se vuelve a utilizar el objeto Statement como se venía llevando a
cabo en los ejemplos anteriores. La diferencia es el uso de un nuevo método executeQuery().
Su firma es la siguiente:
public ResultSet executeQuery(String sql) throws SQLException
Como se puede apreciar, el método devuelve un objeto ResultSet , el cual regresa una
colección de renglones, resultado de la consulta. El método ResultSet.next() regresa un
boolean que indica si existe todavía una columna como resultado de la consulta efectuada. El
método ResultSet.getString() regresa la versión de cadena de un campo dado, que se le pasa
como parámetro.
El resultado de esta aplicación puede apreciarse en la figura 9.
Figura 9.
66
Páginas para Internet con Java
BIBLIOGRAFÍA
• Effective Java Programming Language Guide.
Joshua Bloch.
Addison Wesley Professional.
1ª edición, junio de 2001.
ISBN: 0201310058
• Java in a Nutshell, Fourth Edition.
David Flanagan.
O'Reilly & Associates
4ª edición, marzo de 2002.
ISBN: 0596002831
• Sams Teach Yourself Java 2 Platform in 21 Days, Professional Reference Edition.
Laura Lemay, Rogers Cadenhead.
Editorial Sams.
Edición de CD-ROM, enero de 1999.
ISBN: 067231438X
67
Alejandro Talavera Rosales
ANEXO A. LA REFERENCIA THIS
Java utiliza referencias
Como se observó en el Capítulo II, this es una referencia dinámica al objeto que está
ejecutando un método en particular, para lo cual véase el siguiente código:
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 colección de datos y métodos que operan sobre esos datos.
Los datos y los métodos, en conjunto, generalmente sirven para definir los contenidos y las
capacidades de algún tipo de objeto. En este caso el método area( ) manipula directamente los
datos de un objeto Circulo (¡cuál 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 código como el que se muestra a continuación:
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 código:
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 Capítulo II. Por tanto se retomará el
ejemplo A1.
68
Páginas para Internet con Java
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 están en capacidad para manipular los datos de cada uno de
objetos a los que hacen referencia respectivamente, por ejemplo, cada objeto puede ejecutar el
método área, como se muestra en el ejemplo A.4:
c.area();
d.area();
Ejemplo A.4
La pregunta será entonces la siguiente: ¿Cómo sabe el método 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 método.
Recuerde que en la Programación Orientada a Objetos primero están los objetos como la base
del desarrollo de aplicaciones, y éstas manipulan los datos de esos objetos. Ahora vea cómo
funcionan los objetos.
Los objetos, cuando se crean, manipulan y utilizan los datos y métodos 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 métodos. Esto pasa
igual con d.
69
Alejandro Talavera Rosales
Figura A. 1.
Conteste por fin la pregunta. Como cada objeto de la clase Circulo tiene su propio juego de
métodos, éstos tratarán de manipular los datos del propio objeto, no los de otros. Así, cuando a
través de la referencia d ejecuta el método area( ), se utiliza el dato r del mismo objeto, lo
mismo que con c.
70
Páginas para Internet con Java
ANEXO B. EL MODIFICADOR STATIC
Variables estáticas de una clase
Primero se definirá la clase Circulo como se muestra en el ejemplo 1:
public class Circulo
{
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 sólo una variable, la cual está
asociada a la clase. El efecto es que una variable declarada como static existe sólo una vez a
pesar del número 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
círculo. Esto podría servir para conocer el número de objetos creados en un momento dado.
9
Entiéndase la palabra "instancia" como sinónimo de objeto.
71
Alejandro Talavera Rosales
Utilizando las variables de clase
Como se definió, las variables de clases están 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 sería de la siguiente forma:
Circulo.cir_cread
Lo anterior sirve para imprimir en pantalla el número de círculos creados hasta un momento
dado, la sintaxis correspondiente sería:
System.out.println("El número de círculos creados es de: " + Circulo.cir_cread);
72
Páginas para Internet con Java
ANEXO C. LA ETIQUETA APPLET
Aquí se muestra un ejemplo de la utilización de la etiqueta APPLET:
<applet code="MiApplet.class" width=100 height=140></applet>
Lo anterior indica al navegador que cargue el applet cuyo código compilado es 'MiApplet.class'
(en el mismo nivel de directorio que el documento HTML actual), y fija el tamaño inicial del
applet a 100 pixeles de largo y 140 de alto.
A continuación, se presenta un ejemplo más 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 vería el texto 'bailando'
en lugar de este párrafo.
<hr>
</applet>
Este código indica al navegador que cargue el applet cuyo código compilado esté en el URL
http://java.sun.com/applets/applets/NervousText/NervousText.class , fija el tamaño inicial del
applet a 400 x 75 pixeles. El navegador debe también asignar el valor "Bienvenido a HotJava!"
al atributo "text" (el cual define el texto que este applet desplegará). Si la página es vista por un
navegador que no puede ejecutar applets, el navegador ignorará las etiquetas APPLET y
PARAM, desplegando solamente el código HTML entre las etiquetas <PARAM> y </APPLET>.
A continuación, 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. ¿Algún 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 también contener la referencia a la imagen cuyo nombre es test.gif.
73
Alejandro Talavera Rosales
A continuación, se muestra la sintaxis completa de la etiqueta TAG. Los elementos requeridos
están en negritas. Los elementos que se deben especificar están en itálicas.
<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>
<PARAM NAME = appletAttribute2 VALUE = valor>
...
alternateHTML
</APPLET>
CODE, CODEBASE y los demás son atributos de la etiqueta APPLET; ellos dan al navegador
información acerca del applet. Los únicos atributos requeridos con CODE, WIDTH y HEIGHT.
Cada atributo es descrito a continuación.
CODEBASE = codebaseURL
Este atributo opcional especifica la base URL del Applet -- el directorio que contiene los códigos
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 más archivos que contienen clases y otros recursos que
serán "pre-cargados". Las clases son cargadas usando una instancia de un AppletClassLoader con
el CODEBASE dado. Los archivos en archiveList están separados por ",".
Nota: en JDK 1.1, múltiples etiquetas APPLET con el mismo CODEBASE comparten la misma
instancia de un ClassLoader. Esto es utilizado por algún código cliente para implementar la
comunicación entre applets. Futuros JDK "pueden" proporcionar otros mecanismos para la
comunicación entre applets.
CODE = appletFile
74
Páginas para Internet con Java
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 representación seriada de un applet. El
applet se definirá en serie. El método init() no será invocado; pero su método start() si lo hará.
CODE u OBJECT deberán estar presentes.
ALT = alternateText
Este atributo opcional especifica cualquier texto que será desplegado, si el navegador no
entiende la etiqueta APPLET, pero no se ejecutarán 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 página encontrar y comunicarse con los demás.
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 diálogo 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 número 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 = appletAttribute1 VALUE = valor>
<PARAM NAME = appletAttribute2 VALUE = valor> . . .
Con esta etiqueta se especifica un atributo específico del applet. Los applets recuperan estos
atributos con el método getParameter().
75
UNIVERSIDAD NACIONAL AUTÓNOMA DE
MÉXICO
DR. JUAN RAMÓN DE LA FUENTE
Rector
LIC. ENRIQUE DEL VAL BLANCO
Secretario General
MTRO. DANIEL BARRERA PÉREZ
Secretario Administrativo
LIC. ARMANDO LABRA MANJARREZ
Secretario de Planeación y Reforma Universitaria
DRA. ELVIA ARCELIA QUINTANA ADRIANO
Abogada General
DIRECCIÓN GENERAL DE SERVICIOS DE
CÓMPUTO ACADÉMICO
DR. ALEJANDRO PISANTY BARUCH
Director General
MAT. CARMEN BRAVO CHAVESTE
Directora de Cómputo para la Docencia
LIC. ROSARIO ORTIZ OSORNIO
Subdirectora de Planeación Académica
ACT. FABIÁN ROMO ZAMUDIO
Subdirector de Tecnología para la Educación
ING. SERGIO ALVA ARGUINZONIZ
Coordinador del Centro Mascarones
LIC. ALEJANDRINA SAN JUAN REYES
Coordinadora del Centro de Extensión en
Cómputo y Telecomunicaciones Nuevo León
LIC. CECILIA MEDINA NAVARRO
Coordinadora del Centro Coapa de Extensión
en Cómputo y Telecomunicaciones
QUIM. LAURA MATA MONTIEL
Coordinadora de Infraestructura y Soporte Tecnológico
ACADEMIA DE LENGUAJES DE PROGRAMACIÓN
Revisión Técnica
LIC. MARIANA CELORIO SUÁREZ CORONAS
Subdirectora de Comunicación
DG TOÑA ZIMERMAN SONABEND
Jefa del Departamento de Diseño
LIC. MARTHA PATRICIA GARCÍA MORALES
Edición y corrección de estilo
DG EPRIN VARAS GABRELIAN
Diseño de portada
Guías y textos de cómputo.
Páginas para Internet con Java.
Abril de 2003.