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

Í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

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

Alejandro Talavera Rosales

2

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.


3

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.


4

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.


5

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.


6

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.


7

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:


8

• 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.


9

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.


10

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


11

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.


12

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.


13

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.

Circulox : doubley : doubler : double

area() : doublecircunferencia() : 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.


14

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().


15


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;


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:


16

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.


17

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;


18

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.


19

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.


20

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:


21

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.


22

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 { ................... }


23

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.


24

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.


25

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.


26

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.


27

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.


28

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.


29

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.


30

• 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.


31

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.


32

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 sobre-escribir 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.


33

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;


34

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.


35

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.


36

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 Tipo de retorno Uso getHeight() int Regresa el valor de la altura del componente.


37

getWidth() int Regresa el valor del ancho del componente. getX() Int Regresa el valor de la posición con respecto al eje

X del componente. getY() int Regresa el valor de la posición con respecto al eje

X del componente. isEnabled() boolean El valor de retorno indica si el componente está

activado (true) o no (false). isVisible() bolean El valor de retorno indica si el componente está

visible (true) o no (false). getSize() Dimension 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 Tipo de retorno Uso paint(Graphics) void Pinta el componente.

repaint() void Repinta el componente. repaint(long) void Repinta el componente cada cierto tiempo en

milisegundos. setBackground(Color) void Establece un color de fondo. setEnabled(boolean) void Modifica su estado de disponibilidad: true o false setLocation(int,int) void Establece la posición del componente.

setSize(int,int) void Establece las dimensiones del componente. update(Graphics) void 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.


38

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 Tipo de retorno Uso getActionCommand() String Regresa el String asociado al evento del

botón. getLabel() String 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 Tipo de retorno Uso setActionCommand(String) void 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.


39

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 Tipo de retorno Uso getCheckboxGroup() CheckboxGroup Regresa una referencia al grupo

correspondiente de la caja de opción. getLabel( ) String Regresa el String de la etiqueta de la caja

de opción. getState( ) bolean 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 Tipo de retorno

Uso

setCheckboxGroup(CheckboxGroup) void Asigna el grupo a la caja. setLabel(String) void Asigna una etiqueta a la caja de opción. setState(bolean) void Asigna el valor del estado de una caja de

opción.


40

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 );


41

Figura 7.

Los métodos de recuperación de información más importantes son los que se listan en la siguiente tabla:

Nombre Tipo de retorno Uso getAlignment() int Regresa el valor de alineación de la etiqueta.

getText() String 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 Tipo de retorno Uso setAlignment(int) void Asigna el valor del alineamiento. setText(String) void 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 Uso Add(Component) Agrega el componente al final del contenedor.

add(Component, int) Agrega el componente al contenedor en la posición dada por el segundo parámetro.

add(String, Component) Agrega el componente al contenedor con un String que se le asocia.


42

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.


43

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 Tipo de retorno Uso getTitle() String Regresa el String que representa el título de la

ventana. isResizable() boolean Indica si el usuario puede cambiar el tamaño de la

ventana. setCursor(Cursor) Void 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 ); } }


44

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.


45

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.


46

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 );


47

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" );


48

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" );


49

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.


50

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.


51

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.


52

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.


53

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.


54

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.


55

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.


56

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.


57

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.


58

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.


59

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.


60

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.


61

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.


62

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 " +


63

"(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.


64

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()); }


65

} } 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();


66

} 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.


67

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


68

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.


69

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.


70

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.


71

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.


72

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);


73

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.


74

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>


. . .

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


75

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 = appletAttribute2 VALUE = valor> . . .

Con esta etiqueta se especifica un atributo específico del applet. Los applets recuperan estos atributos con el método getParameter().

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.

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

Documents

Transcript of Programación Para Internet. Java ( DGSCA. UNAM )