Manual+Java+UML+Básico

INSTITUTO DE TECNOLOGÍA Y COMPUTACIÓN

MANUAL de JAVA y UML Básico

2006

CESAR ROJAS MORAGA RELATOR

2

Índice Introducción .............................................................................................................................3 CAPITULO 1: INTRODUCCION ..............................................................................................4

Introducción...........................................................................................................................5 Aspectos Históricos ...............................................................................................................6 ¿Qué es Java?.........................................................................................................................8 Evolución de las Versiones de Java .......................................................................................9

CAPITULO 2: PROGRAMACION ORIENTADA A OBJETOS...............................................10 Principios de la Orientación a Objetos ................................................................................11

CAPITULO 3: ELEMENTOS DEL LENGUAJE JAVA .............................................................13 Errores de Programación .....................................................................................................14 Edición, Compilación y Ejecución de Programas ...............................................................16 Elementos Básicos ...............................................................................................................21 Control de Flujo ...................................................................................................................28 Control de Excepciones .......................................................................................................29 Try – Throw – Throws - Catch - Finally ............................................................................32

CAPITULO 4: PROGRAMACION ORIENTADA A OBJETOS CON JAVA............................34 Abstracción (Aplicado)........................................................................................................35 Encapsulamiento (Aplicado) ...............................................................................................36 Herencia (Aplicado).............................................................................................................37 Polimorfismo (Aplicado) .....................................................................................................40

CAPITULO 5: INTRODUCCIÓN A UML ...............................................................................43 CAPITULO 6: PAQUETES DE JAVA......................................................................................44

Introducción.........................................................................................................................45 Paquetes y Directorios .........................................................................................................46

CAPITULO 7: MANEJO DE ARCHIVO EN JAVA..................................................................53 Introducción.........................................................................................................................54 Flujos ...................................................................................................................................55 Jerarquía de Clases ..............................................................................................................56 FileInputStream y FileOutputStream...................................................................................57 Ejemplo Introductorio FileInputStream...............................................................................58 Ejemplo Introductorio FileOutputStream............................................................................60 Ejemplo Introductorio FileReader .......................................................................................61 Ejemplo Introductorio FileWriter ........................................................................................62

CAPITULO 8: APPLETS.........................................................................................................64 Introducción a los Applets de Java ......................................................................................65 Applets .................................................................................................................................66

CAPITULO 9: INTERFASES GRÁFICAS DE USUARIO EN JAVA.......................................74 Eventos ..............................................................................................................................110 La Clase Event ...................................................................................................................111

3

Introducción Java se ha convertido hoy en día en uno de los lenguajes de programación más importantes, sobre el cual se están desarrollando aplicaciones de variadas índoles, como por ejemplo, aplicaciones Web, aplicaciones para dispositivos electrónicos, incluso para proyectos de robótica avanzada. El enfoque que tiene el curso es dar una capacitación en el lenguaje en sí, demostrando que la programación orientación a objeto es fácil de entender mientras se programe y se trabaje directamente en el código.

4

MANUAL DE JAVA

CAPITULO 1: INTRODUCCION

5

Introducción El lenguaje de programación que utiliza Java es netamente orientado a objeto, el nivel sintáctico es muy similar a C y C++. Contiene clases que pueden manipular los tipos de variables de manera fácil, además posee un control del flujo de fácil manejo. A continuación presentaremos la Historia y comenzaremos a entrar en profundidad en el lenguaje Java.

6

Aspectos Históricos Hace ya muchos años, por allá por fines de los 60, Martin Richards desarrollo un lenguaje de programación denominado “BCPL”, el cual estaba orientado principalmente para la programación de Sistemas Operativos y compiladores. En 1970, Kem Thomson presentaba su lenguaje, denominado “B”, en el cual se escribieron las primeras líneas del sistema operativo UNIX, este lenguaje fue desarrollado en los laboratorios AT&T DELL Laboratorios en un computador DEC PDP-7. En los mismos laboratorios, en 1972, pero en un computador DEC PDP-11, Dennos Ritchie desarrolla “C”, lenguaje que incorpora a los lenguajes BCPL y C, obteniendo lo mejor de ambos, es así como “C” comienza a ser pilar fundamental en la programación del código fuente de UNIX. Para 1978, la editora Prentice Hall, publica el libro “The C Programming Languaje”, libro que ha sido el más vendido en la historia de los libros informáticos, con ésta fama, C se convierte en el lenguaje preferido para desarrollar aplicaciones y diferentes tipos de sistemas y programas, el problema surge porque C es de “open source”, por lo tanto existieron tantas versiones como aplicaciones, que prontamente se hicieron incompatibles entre ellas, es por esto que en 1983, se realiza una congregación, denominada la X3J11, bajo la supervisión de la ANSI, en donde se comienzan a desarrollar las referencias del lenguaje, para que los desarrolladores tengan a que atenerse para no perder el estándar. Es así como para el año 1989 es aprobado el estándar de C, bajo el nombre de ANSI/ISO 9899:1990. Por el año 1980, Bjarne Stroustrup, comienza a incluir dentro de la programación estructurada de C, una nueva e interesante capacidad, la orientación a objeto, dando como resultado la versión avanzada de C, conocida como C++, ésta versión es un Híbrido, pues permite desarrollar de manera estructurada como en C y también de manera orientada a objeto, es decir con clases. Dentro de las grandes empresas desarrolladoras de tecnología, se encontraba Sun Microsystem, la cual tenía a su haber el sistema operativo Solaris y también la Arquitectura SPARC. Ésta empresa financia a comienzos de los 90 un proyecto denominado GREEN, bajo el mando de James Gosling, el proyecto tenía como meta desarrollar tecnología para el manejo de los dispositivos electrónicos nuevos que aparecerían en el mercado, pues Sun esperaba obtener grandes proyectos, y con ellos, obtener ventaja de la gran expansión tecnológica que vendría con los dispositivos electrónicos.

7

James Goblin y su equipo, desarrollaron un lenguaje de programación que denominaron “OAK” que significa Roble en Inglés, pues se cuenta que desde su ventana en las oficinas de Sun Microsystem, él puede ver un roble que esta en el patio. El problema surge por que ya existía una empresa con un lenguaje denominado “OAK”, con lo cual el equipo de James Goblin debió cambiar el nombre de su lenguaje de programación. La historia cuenta que le denominaron JAVA por el café que tomaban a la hora de descanso durante el desarrollo del lenguaje, otra teoría cuenta que es por el café que le servían a Goblin y su equipo en una cafetería cercana a las oficinas de Sun Microsystem. El tema principal es que la gran explosión de dispositivos electrónicos que esperaba la Sun nunca existió, además que parte de los proyectos que esperaban fueron otorgados a otras empresas, por lo cual se vio gravemente afectado el proyecto GREEN, a tal punto de ser casi clausurado. Pero Goblin no se vería disminuido por lo sucedido, así que, con astucia, volcaron JAVA al desarrollo de aplicaciones Web, debido a que a comienzos de los 90, la WWW alcanzó niveles de desarrollo insospechados, es así como en 1995, Sun Microsystem, presenta al mundo su primera versión de JAVA, la versión 1.0, maravillando al mundo con el dinamismo que le otorgaba a las estáticas páginas Web predominantes en esos años. Nace así, una de las tecnologías más admiradas y venerada de los últimos años, además que la explosión de los dispositivos electrónicos llegó con el tiempo, JAVA ha comenzado a ocupar espacios que ningún otro lenguaje lo había logrado. Permaneciendo así en Celulares, Pocket PC, Palms, Robots, Servidores Web, etc.

8

¿Qué es Java? El significado de Java, tal y como se le conoce en al actualidad, es el de un lenguaje de programación y un entorno para ejecución de programas escritos en lenguaje Java. Al contrario de los compiladores normales que convierten el código fuente a instrucciones a nivel de máquina, el compilador traduce el código fuente Java a Bytecode, instrucciones que son interpretadas por una Máquina Virtual de Java, conocida como la JVM (Java Virtual Machine). Java se ha convertido en el lenguaje de programación de Internet por excelencia, debido a que trata de resolver problemas de Internet con contenidos de Internet.

• En la actualidad, el contenido de la WWW es pasivo y estático. • La entrega (Delivery) del contenido WWW es dependiente de la configuración

de cada navegador Web de usuario. Para el mundo Web, Java es una tecnología facilitadota que permite crear paginas Web que se entregaran de manera consistente a todos los usuarios con un navegador habilitado para java y con independencia de a plataforma hardware que se este utilizando. Toda esta maravilla la permite la JVM y se explica en este gráfico a continuación.

En ésta figura, cuando una maquina se conecta a un servidor, éste le transfiere el código nativo de java al computador del usuario para que la maquina virtual lo ejecute en el navegador del mismo, indistintamente el hardware que posea el computador del usuario. Actualmente, para cada Sistema Operativo, existe una Maquina Virtual para descargar, además que Java es un Kit de Desarrollo gratis, el cual se puede descargar desde la página de sus creadores y dueños, www.sun.com/java/.

Computador Local Sistema Operativo Navegador Java Máquina Virtual Java

Computador Servidor (Host) Código Nativo Java

Código Fuente

9

Evolución de las Versiones de Java Existen dos grandes especificaciones actualmente en entorno Java: J2EE Está orientada a al desarrollo de aplicaciones de propósito empresarial o para servidores y son numerosos los grandes fabricantes (IBM, Nokia, Motorola, Hewtlett-Packard…) que lo soportan con especificaciones comunes. Actualmente J2EE se ha convertido en un autentico estándar, reconocido por la industria. J2ME Es un nuevo estándar para dispositivos inalámbricos (móviles, de bolsillo o de mano (handhelds)) que requieren una integración en dispositivos con poco espacio físico y memoria de trabajo. La versión J2SDK, es un Kit de Desarrollo Estándar, el cual permite comenzar a desarrollar aplicaciones de aprendizaje previo al desarrollo profesional de aplicaciones en J2EE. Versiones La versión original de Java que se comercializó y se expandió rápidamente fue la 1.0, posteriormente aparece la 1.1, que para muchos fue un salto bastante importante dentro del desarrollo de las capacidades del lenguaje, salto que no se representaba con un aumento de un dígito. Posteriormente la versión 2, con sus diferentes kit de desarrollo, ha servido para asentar la eficiencia y calidad de Java. Se puede considerar que Sun ha lanzado al mercado seis versiones importantes del lenguaje Java: Java 1.0 1995, pequeña versión centrada en la Web, disponible

uniformemente para todos los navegadores Web populares. Java 1.1 1997, mejora la interfaz de usuario, manipulación de eventos o

sucesos, reescrito totalmente, y una tecnología de componentes denominada JavaBeans.

Java 2 con SDK 1.2

1998, versión ampliada significativamente, incluye una nueva interfaz gráfica de usuario, conectividad a bases de datos y muchas otras mejoras.

Java 2 con SDK 1.3

2000, añade características notables como multimedia mejorada, más accesibilidad y compilación más rápida.

Java 2 con SDK 1.4

2001, introduce la posibilidad de trabajar con XML

Java 2 con SDK 1.5

10

MANUAL DE JAVA

CAPITULO 2: PROGRAMACION ORIENTADA A OBJETOS

11

Principios de la Orientación a Objetos Todos los programas de computadora constan de dos elementos: código y datos. Sin embargo, un programa se puede organizar conceptualmente alrededor de su código o alrededor de sus datos. Existen dos paradigmas que controlan el modo en que se construye un programa. Los programas que se escriben alrededor de “lo que esta sucediendo” (paradigma procedimental u orientado a procesos); este enfoque caracteriza un programa como una serie de etapas lineales, es decir, código. El otro enfoque dice que los programas se pueden escribir alrededor de “quien está siendo afectado” (paradigma orientado a objetos). Este paradigma es la base de Java. La Programación Orientada a Objeto (de ahora en adelante POO), está en el núcleo de Java. De hecho, todos los programas en Java son orientados a objetos. La idea principal de un sistema orientado a objetos es un conjunto de objetos que interactúan entre sí y que están organizados en clases. Todos los lenguajes de POO proporcionan mecanismos que ayudan a implementar el modelo orientado a objetos. Estos principios o propiedades fundamentales son: abstracción, encapsulamiento, herencia y polimorfismo. Abstracción:

• Es un elemento fundamental de la POO • Las personas gestionamos la complejidad a través de la abstracción.

o Por ejemplo, las personas andamos en un auto sin importar como este trabaja internamente, sabemos conducirlo, pero muchas veces no nos importa como funciona su motor, el aire acondicionado, los freso, la caja de cambio etc., solo nos importa el auto como un todo.

• La abstracción es el proceso de capturar los detalles fundamentales de un objeto mientras se suprimen o ignoran los detalles.

o Por ejemplo, si tenemos que ir de un sitio A a un sitio B en el vehículo del ejemplo anterior, no nos vamos a concentrar en como funciona el motor o las partes tecnológicas del auto, solo nos vamos a concentrar en acelerar, virar a la derecha o izquierda por el camino, nada más.

• La noción de abstracción entraña la descomposición de un sistema complejo o complicado en sus partes más fundamentales y describir estas partes en un lenguaje sencillo y preciso.

• La abstracción se puede presentar como un Tipo Abstracto de Dato (TAD), lo que quiere decir que es un modelo matemático de una estructura de dato que especifica el tipo de dato almacenado, las operaciones soportadas pro ellos y tipos de los parámetros de las operaciones.

• Un TAD especifica qué hace cada operación, pero no cómo lo hace. • En Java, un TAD se puede expresar como una interfaz que normalmente es

una lista de declaraciones de métodos.

12

Encapsulamiento

• Es sinónimo de ocultación de información. • Es el proceso de ocultar todos los detalles de un objeto que no contribuyen a

sus características esenciales. • El usuario de un objeto nunca necesitará conocer el interior de una clase. • Como ventaja, el encapsulamiento proporciona al programador libertad en la

implementación de los detalles de un sistema. La única restricción que tendrá el programador es mantener la interfaz abstracta que ven los usuarios externos.

• Encapsulamiento, desde un punto de vista más técnico, es el mecanismo que enlaza juntos código y los datos que los manipulan y los mantienen seguros de interfaces externas y mal uso.

• Se puede pensar en encapsulamiento, como el envoltorio que encierra al código y a los datos.

• En Java, los fundamentos de la encapsulación están en la clase. Una clase define la estructura y el comportamiento (datos y código) que se compartirá por un conjunto de objetos.

• Cuando se crea una clase, se especifica el código y los datos que constituyen esa clase, a estos elementos se les llama miembros de la clase. Estos miembros pueden ser públicos o privados dentro de la misma clase. Así que comúnmente se utilizan métodos públicos para manipular los datos de la clase que son privados.

Herencia

• Herencia es el proceso mediante el cual un objeto adquiere las propiedades de otro objeto. Por ejemplo, un pastor alemán es parte de la clase perro, y a su vez es parte de la clase mamífero, que a su vez es de la clase animal.

• Sin el uso de la herencia, el objeto necesitaría definir todas las características nuevamente. Sin embargo, usando herencia, un objeto solo necesita definir aquellas cualidades que lo hace único dentro de la clase.

• Las nuevas clases pueden heredar atributos generales de su clase padre o clase base, también denominada superclase.

• Muchas personas ven en la naturaleza como un conjunto de objetos están

relacionados entre sí de manera jerárquica. • En la POO se pueden derivar o extender nuevas clases de otras clases

existentes. Esta propiedad se denomina herencia.

Animal

Mamífero

Perro

13

• La herencia es un concepto poderos de Java. De hecho cada clase que se define en Java se hereda de una clase existente, bien explicita o implícitamente.

Polimorfismo

• Proviene del griego polymorphos, que significa “muchas formas” • En la práctica, es la propiedad que permite enviar el mismo mensaje a

objetos de diferentes clases (totalmente diferentes). Del mismo modo cada objeto responde a ese mensaje de manera distinta, dependiendo de su implementación.

• El polimorfismo como sobrecarga (en Java) ocurre cuando una clase X tiene múltiples métodos con el mismo nombre, cada uno de ellos con una signatura distinta, por ejemplo.

o public double getDistancia() o public double getDistancia(double x, double y) En este caso, tenemos dos métodos con el mismo nombre, pero con argumentos distintos.

• La signatura de un método es una combinación de nombre y tipo de argumentos de un método.

• El polimorfismo se aplica sólo a métodos que tienen la misma signatura pero están definidos en clases diferentes.

• Herencia, polimorfismo y sobrecarga de métodos soportan el desarrollo de software reutilizable.

MANUAL DE JAVA

CAPITULO 3: ELEMENTOS DEL LENGUAJE JAVA

14

Errores de Programación Los errores de programación son inevitables, incluso para programadores experimentados. El proceso de corregir un error (bug en inglés) se denomina depuración (debugging) del programa. Cuando se detecta un error en Java, se visualiza un mensaje de error que devuelve la posible causa del error. Desgraciadamente los errores no siempre se detectan y los mensajes de error no siempre son fáciles de interpretar. El ciclo de Editar-Compilar-Ejecutar junto con la depuración paso a paso de los errores observados y fijados en los programas se pueden observar en la siguiente figura.

Los mensajes de error que produce el compilador no siempre ayudan a encontrar los errores. Una mezcla de las advertencias del compilador, manual de instrucciones y sobre todo la experiencia del programador, serán quienes proporcionen el conocimiento suficiente para llegar a depurar programas con éxito. Existen tres tipos de errores: errores de compilación (sintaxis), errores de ejecución y errores lógicos. Errores de Compilación

• Este tipo de errores ocurren cuando el código viola un o más reglas gramaticales de Java.

• Estos errores los detecta el compilador. • Ejemplo: utilizar una variable que no se ha definido previamente.

Errores de Ejecución

Editar y crear un nuevo archivo .java

Compilar Editar y corregir errores de compilación

Ejecutar Programa Editar para corregir o ampliar

Errores

No existen errores

15

• Este tipo de errores aparecen cuando el sistema termina de forma anormal y que se detectan y visualizan durante la ejecución del programa.

• Un error de ejecución se produce cuando el usuario instruye a la computadora para que ejecute una operación no válida.

• Ejemplo: realizar una división por cero. • Un error de entrada ocurre cuando el usuario introduce un valor de entrada

imprevisto que el programa no puede manejar. • Ejemplo: si el programa espera un número y el usuario ingresa una cadena

de caracteres. Errores Lógicos

• Los errores lógicos ocurren cuando un programa realiza un algoritmo incorrecto y no ejecuta la operación que estaba prevista.

• Son complicados de detectar, pues no se avisan como los errores de compilación, además pueden no producir un término anormal del programa.

• Generalmente se detectan cuando se observan los valores de salida del programa.

16

Edición, Compilación y Ejecución de Programas Los programas escritos en java, pueden ser editados desde cualquier editor de texto, y ejecutados desde una línea de comandos cualquiera, a continuación presentaré un ejemplo sencillo de nuestro primer programa en Java. Primeramente, editamos el texto en Java y lo guardamos como Holamundo.java. class Holamundo{ static public void main(String [] args){ System.out.println("Hola mundo, este es el primer ejemplo en java"); } } Posteriormente a esta edición, preparamos las variables de entorno para poder compilar nuestro programa y ejecutarlo en cualquier directorio en el que se encuentre; NOTA: al utilizar algún editor, sea este Netbeans, JCreator, Eclipse, Visual age, etc, no es necesario realizar el paso que explicaré a continuación debido a que los editores por lo general encuentran la ruta al JDK de manera automática, por ende, nos permiten a través de botones, realizar la compilación y ejecución de nuestros programas. Para ello, obtenemos las propiedades de Mi PC

17

Chiqueamos en la pestaña de “Opciones avanzadas” y presionamos en el botón de “Variables de Entorno”

18

Esta ventana nos permite editar las variables que permanecerán en el entorno de Windows, permitiéndonos así utilizarlas desde cualquier directorio en nuestro computador. Seleccionamos la variable Path y chiqueamos en “Nueva”

Ingresamos el nombre de la variable como “java” y como valor de la variable, ponemos la dirección de la carpeta “bin” en el JDK de Java.

19

La ventana nos quedaría de la siguiente forma, posteriormente aceptamos

y volvemos a aceptar en la ventana de propiedades de Mi PC, con esto, podremos compilar nuestro archivo Holamundo.java.

Si revisamos el directorio veremos que solo esta nuestro archivo Holamundo.java, ahora procederé a compilar el archivo con el comando “javac”.

20

Si volvemos a revisar nuestro directorio, observaremos que el compilador de java genera un archivo en bytecode, este archivo se crea como Holamundo.class.

Para ejecutar nuestro archivo en bytecode con la Maquina Virtual de Java, lo hacemos con el comando “java”.

Lo que realizamos se explica en este gráfico: Esto nos demuestra que Java es multiplataforma, ya que su JVM ejecuta su Bytecode en cualquier máquina en la cual este instalada.

Holamundo.java

Javac Holamundo.java

Holamundo.class (en Bytecode)

Java Holamundo (Otra Maquina y S.O.)

Java Holamundo (Windows)

Java Holamundo (Solaris)

21

Elementos Básicos Comentarios Los comentarios en Java se pueden anotar de dos maneras: //comentario de una sola línea /* Comentario de un bloque */ Palabras Reservadas Las palabras reservadas son palabras que tiene un determinado significado para el compilador y no pueden ser utilizadas para otros fines. Por ejemplo la palabra “import” le indica al compilador que se necesita realizar una importación. El listado de las palabras reservadas de Java se presenta a continuación:

Modificadores Existen palabras reservadas que Java denomina “Modificadores”, las cuales especifican las propiedades de los datos, métodos y clases. Por ejemplo: public, private, static, final, abstract, protected Public: Modificador que permite visualizar las variables y métodos desde cualquier otro paquete de clases o clase. Private: Modificador que impide visualizar las variables o métodos desde otras clases y paquetes, solo se pueden manipular las variables o métodos con este modificador dentro de la misma clase. Static: Modificador que indica que las variable so métodos declarados, permanecerán estáticos bajo la misma clase, es decir que si tengo una variable declarada de manera estática, y es modificada, se modificará a todos los miembros de la clase. Final: Modificador que declara constantes

22

Abstract: Modificador que declara clases y métodos que se declaran de manera abstracta. Protected: Modificador que permite a miembros de una misma clase o paquete a obtener la variables y métodos declarados como protegidos, pero las clases que se encuentran fuera del paquete, no podrán acceder a las variables y métodos protegidos. Sentencias Una sentencia representa una acción o una secuencia de acciones, cada sentencia termina con un punto y coma (“;”), ejemplos de sentencias: int c=0; System.out.println (“Hola mundo”); Bloques Un bloque es una estructura de programa que agrupa sentencias. Los bloques comienzan con una llave de apertura ({) y cierran con una llave de cierre (}), por ejemplo: if (a<34){ System.out.println(“menor que 34”); }

23

Control de Flujo Los controles de flujo cuentan de dos partes, bifurcaciones y bucles, todo lenguaje de programación debe contenerlos, debido a que son claves al momento de administrar la ejecución de un programa. A continuación veremos como se definen ambos en Java.

• Bifurcaciones o if – else if – else Esta bifurcación permite realizar las preguntas de SI esta condición ocurre, O SI esta otra condición ocurre, ENTONCES haga lo siguiente. Un ejemplo de su utilización lo demuestro a continuación:

Donde la salida de este programa es la siguiente

24

o switch - case Esta bifurcación permite hacer selecciones de casos para hacer más rápido la bifurcación, a continuación presentaré un ejemplo de este comando.

Y la salida de este programa es la siguiente:

25

• Bucles o while El while tiene como traducción “mientras”, y funciona de la siguiente manera, mientras la condición se cumpla, el bloque se ejecuta. Para entender de mejor manera el funcionamiento del bucle while, veamos este ejemplo a continuación.

Que tiene la siguiente salida.

o for El ciclo for, no permite realizar un ciclo gracias a que existe un condición que debe cumplirse, esta condición va de la mano de un número entero que se debe declarar dentro del for, y que puede ir creciendo o disminuyendo. La estructura del for es la siguiente for (número ; condición ; incremento o decremento){ Bloque… }

26

A continuación veremos un ejemplo aclarador del uso del for.

Este ejemplo nos entrega la siguiente salida.

27

Clases La clase es la construcción fundamental de Java, la cual constituye una plantilla o modelo para fabricar objetos. Un programa consta de una o más clases y cada una de ellas puede contener declaraciones de datos y métodos. Cada archivo de clase se compila en un archivo de Bytecode con la extensión .class. NOTA: Las clases serán explicadas en un capítulo aparte. Métodos Un método es una colección de sentencias que realizan una serie de operaciones determinadas. Por ejemplo: System.out.println(“Bienvenido a mi Ejemplo”); Es un método que visualiza un mensaje en el monitor o consola. El método “main”: Cada aplicación de Java debe tener un método main declarado por el programador que defina don de comienza el flujo del programa. El método main tendrá siempre una sintaxis similar a esta: static public void main (String [] args){ //… sentencias; } NOTA: Los métodos se explicarán más adelante. Tipos Primitivos de Datos Los tipos primitivos de datos o variables de Java con aquellas variables sencillas que contienen los tipos de información más habituales, valores boléanos, caracteres y valores numéricos o de punto flotante. A continuación se presentan los ocho tipos primitivos de variables.

28

Control de Flujo Para crear programas en Java hay que tener en cuenta que toda implementación que se realice se efectuará encapsulada en una clase. Un programa aplicación fuente en Java se podría considerar formado por las siguientes partes:

• Una sentencia de Paquete (package) que también puede ser omitida. • Una, ninguna o varias sentencias de importación (import). • Una serie de comentarios ubicados en cualquier parte del

programa.(//comentario) • Declaraciones de las clases deseadas, puede no haber ninguna.(class) • Una declaración de clase pública (public class).

A su vez una declaración de clase comenzará con al sentencia (class) y podrá contener.

• Declaraciones de variables de la clase (estáticas). • Declaraciones de variables de instancia • Definiciones de constructores. • Definiciones de métodos.

Dado que una clase es un modelo y las instancias son los objetos de esa clase, a las variables de instancia se les denomina así porque cada objeto contendrá una copia de dichas variables, de forma que los datos de una objeto se encontrarán separados de los de otro objeto, utilizándose los métodos para la modificación de los valores de las variables de instancia.

29

Control de Excepciones Según se van complicando los programas, cada vez es más difícil construirlos con robustez. Una excepción es una condición anormal quien interrumpe el flujo lógico de un programa. Hay varios casos donde nos podemos encontrar con este tipo de situaciones, como por ejemplo:

• No existe el archivo que queremos abrir. • Se ha perdido el archivo class que se quiere cargar o bien no cuenta con el

formato adecuado. • No existe el otro extremo de la conexión de una red. • Uno de los operadores no se encuentra dentro del rango legal para dicha

operación o método. Por ejemplo, el tamaño correspondiente al índice de un array no puede ser superior al de la propia matriz y el divisor de una operación no puede ser igual a cero.

Modelo Básico Java sigue la sintaxis que usan los controladores de excepciones en C++. En primer lugar, intentaremos ejecutar un bloque de declaraciones. Si aparece una condición anormal, algo lanzará una excepción que podremos capturar con el controlador adecuado. Además, puede haber un bloque de declaraciones que queremos ejecutar (independientemente de que se den o no excepciones). Siempre será mejor lanzar una excepción que cerrar el programa abruptamente, por lo menos esta comprobado que el impacto que produce el cierre anormal del programa en un usuario, a ver un mensaje de error, es mucho más fuerte. Dentro de los programas básicos que hemos desarrollado esta el típico programa que recibe datos desde el teclado, a continuación utilizaremos el mismo programa para demostrar cuando se lanza una excepción al convertir una cadena a un int.

30

import java.io.*; class Error{ static public void main(String [] args){ InputStreamReader isr= new InputStreamReader(System.in); BufferedReader in= new BufferedReader(isr); System.out.print("Ingrese un numero: "); String cadena= in.readLine(); int numero= Integer.parseInt(cadena); //producirá un error si no System.out.println("Fin del Programa"); // ingresamos un numero } } Si procedemos a compilar este código fuente, nos presentará un mensaje de error de compilación que nos dice que una excepción puede ser lanzada, es decir, que las excepciones posibles no están siendo soportadas, estas deben ser contenidas o deberán ser lanzadas, concepto que veremos más adelante.

Para solucionar este problema de compilación, podemos instalar una throws IOException después del método main de la siguiente manera. import java.io.*; class Error{ static public void main(String [] args)throws IOException{ InputStreamReader isr= new InputStreamReader(System.in); BufferedReader in= new BufferedReader(isr); System.out.print("Ingrese un numero: "); String cadena= in.readLine(); int numero= Integer.parseInt(cadena); //producirá un error si no System.out.println("Fin del Programa");// ingresamos un numero } }

31

Procedemos a compilar y a ejecutar

Deberíamos ingresar un número, pero que sucede si ingresamos una cadena de texto normal, se producirá un error de transformación, el cual se explica en un mensaje a continuación

Este mensaje de ejecución que se explica en la imagen anterior, dice que ha ocurrido una excepción en el hilo “main”, y el error es de tipo java.lang.NumberFormatException para la cadena de entrada “cesar”. Para solucionar este problema explicaré el mecanismo de manejo de excepciones. El modelo de un mecanismo de excepciones consta, fundamentalmente, de cinco nuevas palabras reservadas, try, throw, throws catch, y finally.

• try, un bloque para detectar excepciones • catch, un manejador para captura excepciones de los bloques try. • throw, una excepción para levantar (raise) excepciones. • throws, indica las excepciones que se pueden elevar de un método. • finally, bloque, opcional, situado después de los catch de un try.

32

Try – Throw – Throws - Catch - Finally Iniciemos la explicación con el siguiente código: Archivo Error2.java import java.io.*; class Error2{ static public void main (String [] args){ try{ lanzar_excepcion(); }catch(IOException provocado){ System.out.println("Excepcion capturada"); }catch (Exception e){ //hacemos algo si viene otro tipo de excepción }finally{ System.out.println("Ejecución de bloque finally"); } } static public void lanzar_excepcion()throws Exception{ //provocamos un lanzamiento con throw throw new IOException(); } } Compilemos y ejecutemos este código

Explicaré a continuación cada una de las líneas del código para que se entienda que hacen las palabras reservadas que están involucradas en el control de excepciones.

33

• Se importa import java.io.*; para poder utilizar el error de entrada y salida. • Se crea un bloque try el cual puede capturar excepciones de cualquier tipo

dentro de su bloque de declaración. • Se emplea la palabra catch, la cual permite capturar las excepciones que se

produzcan en el bloque try. Inicialmente programamos que se capturara una excepción de tipo IOException (excepción de entrada y salida). Posteriormente utilizamos otro catch para posibles excepciones de otro tipo que no tuviéramos previstas, esto lo hice más que nada para demostrar que uno puede utilizar cuantos bloques catch desee, según la cantidad de excepciones que uno espere obtener de un bloque.

• Se utiliza la cláusula finally para demostrar su uso, esta cláusula puede ser utilizada para volver a levantar o estabilizar el sistema después de una excepción. Como podemos apreciar, en el interprete de comandos, primero se capturo el excepción y luego se ejecutó el bloque finally.

• Por último escribimos un método lanzar_excepcion(), el cual levanta un nuevo error de tipo IOException.

34

MANUAL DE JAVA

CAPITULO 4: PROGRAMACION ORIENTADA A OBJETOS CON JAVA

35

Abstracción (Aplicado) Como comentamos anteriormente, la abstracción nos permite capturar lo más importante de un objeto, sin importar como funciona, aplicaremos esto de la siguiente manera, daré un objeto y comenzaremos a abstraerlo, para así conocer la aplicación de abstracción en la POO. Objeto: Punto bidimensional

• Una Punto tiene una coordenada x y una coordenada y; (x, y) (atributos) • A una Línea se le puede calcular la Distancia del punto al centro del eje

v (x2+y2), se puede pedir el valor de x, y (métodos) Vamos a programar lo siguiente, en un diagrama de clases de UML se vería así:

X

Y

(x,y)

(0,0)

v (x2+y2)

36

Encapsulamiento (Aplicado) El encapsulamiento es la capacidad que tiene el programador en dejar todo lo abstraído en una clase, protegiendo los datos y los métodos que desee sean privados, y dejando los métodos esenciales como públicos para que otras clases o sistemas las puedan utilizar. Continuando con el ejemplo del punto, vamos a programar el diagrama de clases en UML que dejamos pendiente en el paso anterior. Archivo Punto2d.java class Punto2d{ //atributos private double x; private double y; //Constructor public Punto2d(double x, double y){ this.x= x; this.y= y; } //metodo public double getDistancia(){ return Math.sqrt((x*x)+(y*y)); } public double getX(){ return x; } public double getY(){ return y; } } Como podemos observar, los atributos de la clase, son declarados como privados, por lo tanto no se puede acceder a ellos desde otra clase, al menos que se consulten los métodos “get”, getX() y getY(), a esto se le denomina en parte encapsulamiento, porque el termino encapsulamiento en sí, se explica en la capacidad de generar una estructura o un molde con características similares para las instancias que se generen en esta. A modo de ejemplo, todos las instancias de la clase Punto2d que se generen, tendrán, gracias a la encapsulación, dos atributos, que son x e y, y los tres métodos, getDistancia(), getX() y getY().

37

Herencia (Aplicado) La herencia, como se explicó anteriormente, es la capacidad de traspasar las características de una clase padre a una clase hija, esto nos permite ahorrar líneas de código y reutilizar el software diseñado anteriormente. A continuación, expondré un ejemplo de Herencia en código fuente de Java. Utilizaremos la siguiente abstracción: Un punto puede ser definido en un plano de tres dimensiones, para ello, el punto va a tener una coordenada x, una y y una z, además la distancia de un punto de tres dimensiones se calcula de la siguiente forma v (x2+y2+z2). Por lo tanto, también podemos escribir los métodos, getDistancia(), getX(), getY() y crearemos el getZ(). La idea es heredar las características de la clase Punto2d y agregar los nuevos atributos y métodos a la clase Punto3d. El diagrama de clase de Punto3d quedaría de la siguiente manera:

En donde la flecha que une las dos clases representa que la clase Punto3d es subclase de la clase Punto2d, es decir hereda las características de la clase Punto2d.

38

Como se ve esto en código, de la siguiente manera. Archivo Punto3d.java class Punto3d extends Punto2d{ //atributos private double z; //constructor public Punto3d(double x, double y, double z){ super(x,y); this.z= z; } //metodos public double getDistancia(){ double x2= Math.pow(super.getX(),2); double y2= Math.pow(super.getY(),2); double z2= z*z; return Math.sqrt(x2+y2+z2); } public double getX(){ return super.getX(); } public double getY(){ return super.getY(); } public double getZ(){ return z; } } La palabra clase “extends” es la que indica que vamos a heredar de la clase Punto2d. Dentro del método getDistancia(), se utiliza una función de la clase Math que nos permite elevar a potencia un valor (Math.pow). Además utilizamos otra función de la clase Math, que nos permite obtener la raíz cuadrada de un número (Math.sqrt). La palabra clase super, es la que nos permite acceder a las variables y métodos de la superclase, en este caso a Punto2d. Como sabemos que no podemos acceder a la variable x directamente, es decir utilizando el siguiente código: public double getX(){

return super.x; }

39

Éste código nos marcará una excepción, la cual nos indicará que estamos haciendo referencia a una variable de tipo privada, por eso se crea el método publico getX(), el cual tiene como función, retornar el valor de la variable x. Pero, falta apreciar como podemos ejecutar todo esto, es decir, nos falta una clase main para poder jugar con las clases que acabamos de crear.

40

Polimorfismo (Aplicado) Como expliqué anteriormente, polimorfismo es la capacidad de crear métodos que se aplican a distintos objetos con el mismo comportamiento, de hecho, ya hemos programado polimorfismo, solo que no han apreciado la manera básica como lo realizamos. Voy a presentar el método main en donde ejecutaremos. Archivo PruebaPuntos.java class PruebaPuntos{ static public void main(String [] args){ Punto2d punto= new Punto2d(3.4, 5);

System.out.println("La distancia del Pundo2d es: "+ punto.getDistancia());

Punto3d otropunto = new Punto3d(3,5,7); System.out.println();

System.out.println("La distancia del Pundo3d es: " + otropunto.getDistancia());

} } La idea es que los tres archivos los guardemos en el mismo directorio, para nuestro manual, estos tres archivos se encuentran en c:\manual\ Procederemos a compilarlos.

41

Ahora procedemos a ejecutar nuestro archivo main, es decir PruebaPuntos.java

Como podemos apreciar, la salida de nuestro archivo principal es súper simple, pero ¿se logra entender lo interesante de la codificación?, para aclarar un poco más todo lo que hemos realizado, lo voy a explicar paso a paso. En el archivo Punto2d.java tenemos:

• Declaramos una clase que contiene 2 atributos que fueron declarados como privados, por lo tanto no se pueden acceder desde otra clase.

• Declaramos el constructor, el cual entrega los valores iniciales de la clase, estos son entregados como parámetros directamente al constructor.

• Para obtener la distancia, declaramos el método getDistancia(), que nos retorna el valor de la distancia.

En el archivo Punto3d.java tenemos:

• Heredamos con (extends) la clase Punto2d, lo cual nos permite utilizar sus métodos y atributos.

• Declaramos sus atributos • Declaramos su constructor, el cual a su vez utiliza el constructor de la

superclase Punto2d con la sentencia super(x,y), en donde podemos imaginar que estamos utilizando el constructor de Punto2d para entregar los valores a las variables x e y de esa clase.

• Utilizamos la palabra clase this, la cual nos permite indicarle al compilador que el valor del parámetro x va a ser asignado a la variable de clase x (this.x), es decir nos ayuda a hacer una diferencia de las variables.

• Declaramos el método getDistancia(), pero con la salvedad de que la única manera que tenemos de obtener los atributos x e y, es llamando a los métodos getX() y getY() de la superclase, por eso se declaro una variable double en el método, la cual recibe el valor al cuadrado que nos devuelve la línea: Math.pow(super.getX(),2);

• Declaramos los métodos getX(), getY() y getZ().

42

En el archivo PruebaPunto.java tenemos: • Creamos una instancia de la clase Punto2d, que se llama punto.

o Éste objeto tiene dos atributos, un valor x y un valor y, además tiene tres métodos, el getDistancia y los getX() y getY().

• Presentamos en pantalla el resultado de la función getDistancia(), aplicado al objeto punto de la clase Punto2d.

• Creamos una instancia de la clase Punto3d, que se llamo otropunto. o Éste objeto tiene 2 atributos heredados y uno propio, además

sobrecargamos el método getDistancia(), getX() y getY(), además creamos un método propio denominado getZ().

• Presentamos en pantalla el resultado de la función getDistancia(), aplicado al objeto otropunto de la clase Punto3d, que es heredera de la clase Punto2d.

Como apreciamos anteriormente tenemos 2 objetos distintos con un mismo método getDistancia(), que se comporta de manera similar en ambos, a esto se le denomina básicamente polimorfismo.

43

MANUAL DE JAVA

CAPITULO 5: INTRODUCCIÓN A UML

44

MANUAL DE JAVA

CAPITULO 6: PAQUETES DE JAVA

45

Introducción En éste capítulo aprenderemos las capacidades de los paquetes estándar que trae Java, además aprenderemos a crear nuevos paquetes, a sacar partido a los paquetes definidos dentro del JDK, ya que ellos prestan a menudo una ayuda muy importante.

46

Paquetes y Directorios Todos los paquetes se han de convertir en un subdirectorio que tenga el mismo nombre que el sistema de archivos. Los paquetes anidados aparecerán como una jerarquía de directorios dentro de dicho sistema. Por ejemplo, los archivos class del paquete java.awt.image se tendrán que guardar entre el directorio java\awt\image. Declaración de Paquetes La forma general de la declaración package es la siguiente: package nombre; donde nombre puede ser el nombre de un paquete o una lista de paquetes separados por comas. Por ejemplo, las dos declaraciones siguientes son completamente legales. package miPaquete; package java.awt.*; En un archivo de programa solamente puede aparecer una declaración package y ésta deberá estar en la primera línea no comentada del archivo, si se omite, las clases se guardarán en un paquete determinado que no tendrá nombre. Importación de Paquetes La importación de paquetes se realiza mediante la palabra clave import, la cual nos permite hacer referencias a clases e interfaces definidas en otros paquetes. Estas declaraciones únicamente tendrán que utilizar el nombre de la clase en vez de todo el nombre completo. Pueden tener dos formas: import packageName.ClassName; import packageName.*; Y packageName puede ser un nombre de un paquete o de una lista de ellos, donde los distintos nombres aparecerán separados por puntos entre ellos. En la primera forma, sólo se especifica la clase del paquete que se ha importado. En la segunda, se utilizará el nombre simple para acceder a cualquiera de las clases e interfaces que se encuentren en dicho paquete. Las declaraciones import tienen que aparecer al principio del archivo del programa. La única que puede aparecer antes de ésta es package.

47

Paquetes Estándar de Java Los paquetes representan una forma de controlar la jerarquía de las clases, pero no nos ayudarán a exportarla. La versión 2 de Java tiene cerca de setenta paquetes java.*. Ahora comenzaremos a estudiar los más utilizados. Java.lang Contiene las clases con las que puede trabajar el lenguaje principal. Trabaja con envolturas de objetos, cadenas, multitarea y las correspondientes áreas relacionadas. java.util Contiene las clases que se pueden utilizar desde un punto de vista más natural. Entre estos nos encontramos con las clases especializadas en los calendarios y en las colecciones, así como también otros diseños abstractos que codifican las interfaces Comparator, Iterator y Observer. java.io Suministra un archivo independiente del dispositivo y servicios E/S. java.awt Contiene la mayoría de las clases dedicadas a los gráficos. com.sun.java.swing Ofrece un grupo de clases para componentes, controles de alto nivel y aquellas que mejoran el aspecto. java.net Combina las clases que pueden trabajar con los programas de bajo nivel de Internet, WWW y dispone de soporte HTML. java.applet Sólo contiene una clase que puede trabajar con el lenguaje HTML que se incluye en los applet.

48

java.lang La mayoría de las clases de java.lang son una aplicación de la clase Object, que es la raíz de toda la jerarquía de la clase de Java. La subjerarquía Number es un buen ejemplo de cómo funciona la herencia orientada a objeto y de cuándo se debe de aplicar. Las clases Byte, Short, Integer, Long, Float y Double tienen puntos en común, por eso se creó esta superclase. Number se declara como una clase abstracta (esto se suele hacer para concretar clases). Aunque disponer de una clase principal (superclase) es algo bastante normal, la verdad es que no es algo imprescindible, Clases concretas pueden ser raíces locales de todas las subjerarquías. De todos los paquetes, java.lang es el más excepcional porque es el único con el que nunca habrá que importar los programas de forma explícita. El compilador se encarga de agregar la siguiente línea al principio de los archivos fuentes. import java.lang.*; El asterisco indica que se importarán todas las clases del paquete. Sin embargo, no se importarán las clases de los subpaquetes. El paquete java.lang contiene los siguientes tipos de clases.

• Clases envolventes • Clases que admiten cadenas • Clases de bibliotecas matemáticas • Clases que pueden trabajar multitarea • Clases que permiten acceso de bajo nivel al sistema • Clases de excepciones y errores.

El paquete java.lang contiene las siguientes clases envolventes:

• Integer para el tipo primitivo int • Long para el tipo primitivo long • Byte para el tipo primitivo byte • Short para el tipo primitivo short • Float para el tipo primitivo float • Double para el tipo primitivo double • Carácter para el tipo primitivo char • Bolean para el tipo primitivo boolean • Void para el tipo primitivo void

Las clases envolventes son clases que permiten agregar metodos de trabajo a los tipos primitivos de datos en Java.

49

java.util Contiene más clases para datos abstractos (ADT) y trece interfaces. Aprovecha las herencias más que el paquete java.lang, por ejemplo, la clase Propierties es una extensión (subclase) de la clase Hashtable, que es (a su vez) una extensión de Dictionary. java.io El paquete java.io contiene un conjunto relacionada con las operaciones E/S. su clasificación principal podría ser ésta:

• Entrada y salida de Bytes. • Escritores y lectores de caracteres. • Filtros de corriente, lectura y escritura. • Conversión a objetos de corrientes. • Clase RandomAccessFile.

Una corrientes (stream) es un concepto abstracto que se suele utilizar dentro de la programación E/S. se representa como un flujo lineal y secuencial de bytes de entrada o de salida. Si se dirigen hacia nosotros, entonces diremos que se trata de un flujo de entrada, mientras que si sales de nuestro sistema, diremos que se trata de un flujo de salida. Los primeros los leemos y los segundos los escribimos. La principal ventaja de las corrientes es que no se apartan de los dispositivos de entrada y salida que hemos estado viendo, si es el código quien trabaja con estos objetos, podemos cambiar los dispositivos de entrada y salida sin modificar el código E/S de la aplicación. Los lectores y escritores se parecen a las corrientes de entrada y salida, con una excepción, su unidad es un dato unicote. Las clases de la corriente, del lector y del escritor que se encuentran dentro del java.io se pueden agrupar en dos:

• Clases que vinculan una corriente, el lector o escritor a una fuente o un origen de datos E/S.

• Clases que mejoran la funcionalidad de la corriente, lector o escritor.

50

java.awt El paquete java.awt se divide en una serie de grupos principales.

• Dos dedicados a los componentes GUI. o El subárbol Component que contiene a Container. o El subárbol MenuComponent.

• Clases especializadas en la gestión de capas. o FlowLayout o BorderLayout o CardLayout o GridLayout o GridBagLayout y GridBagContraints o Instes

• Clases Gráficas o Graphics, Graphics 2D y PrintGraphics. o Image o Color y SystemColor o Font o FontMetrics o AlphaComposite y Composite o BasicStroke y Stroke o GraphicsConfigTemplate, GraphicsConfiguration, GraphicsDevice y

GraphicsEnvironment. o GradientPaint y TexturePaint o RenderingHints

• Clases Geométricas o Point o Polygon o Dimension o Rectangle o Shape

• Clases para Eventos o Event o AWTEvent o AWTEventMulticaster o AWTQueue o ActiveEvent

• Clases Varias o MediaTraker o Toolkit o PrintJob o Cursor o ComponentOrientation

51

com.sun.java.swing Los paquetes com.sun.java.swing se introdujeron con la versión 1.2 de Java y suponen la segunda generación de los widget gráficos de Java. Sus clases se pueden agrupar en las siguientes áreas.

• Widget de Jcomponent • Clases para la gestión del diseño

o BoxLayout o OverlayLayout o ScrollPaneLayout o ViewportLayout o SizeRequirements

• Clases e interfaces de Model • Clases Manager

o DesktopManager y DefaultDesktopManager o FocusManager y DefaultFocusManager o MenuSelectionManager o RepaintManager o ToolTipManager o UIManager

• Clases de AbstractAction y KeyStroke y la interfaz Action • Otras clases

o BorderFactory o ImageIcon y la interfaz Icon o LookAndFeel o ProgressMonitor y ProgressMonitorInputStream o SwingUtilities o GrayFilter o Timer

Además del paquete que hemos visto anteriormente, se puede trabajar también con los siguientes: com.sun.java.swing.border Define varios estilos para dibujar bordes com.sun.java.swing.colorchooser Admite clases para los componentes del color com.sun.java.swing.event Clases para los eventos propios de swing com.sun.java.swing.filechooser Admite clases para seleccionar archivos com.sun.java.swing.plaf.* Clases para trabajar con módulos conectables com.sun.java.swing.table Clases que admiten el uso de las tablas com.sun.java.swing.text.* Clases que admiten componentes de texto,

incluyendo HTML y Rich Text Format(RTF) com.sun.java.swing.tree Clases que admiten componentes de árboles com.sun.java.swing.undo Clases que pueden trabajar con las

implementación deshacer/rehacer

52

java.net El paquete java.net es uno del más importante de Java. Proporciona una serie de interfaces de alto nivel y protocolo (menos sofisticados) especializados en la comunicación, llamados TCP/IP y UDP/IP. java.net ahorra al programador gran parte de las vicisitudes de la programación a nivel de Internet. Sus clases se pueden agrupar con los siguientes puntos:

• Dirección de Internet (clases InetAddress y URL). • Clases orientadas a la conexión TCP/IP (varias clases de Socket). • Clases sin un conexión UDP/IP (DatagramPacket, DatagramSocket y

MulticastSocket). • Diversas clases de autentificación URL (Authenticator,

PasswordAuthentication, URLDecoder y URLEncoder). • Controladores para los tipos MIME (ContentHandler y URLStreamHandler). • Clases relacionadas con la Web (varias clases URLConnection).

java.applet Una de las principales razones por las que es un lenguaje muy fácil de aprender y de una gran eficacia a la hora de distribuir componentes de software. Los applet en Java, más o menos, son componentes distribuidos de software. La clase estándar apenas contiene algo más que lo necesario para trabajar con estos applet. El paquete java.applet, cuando se compara con otros paquetes, parece bastante escaso. Solamente contiene una clase y tres interfaces. La clase java.applet.Applet representa el depósito principal don de se encuentran los métodos que se encargan de trabajar con los applet. Los métodos se pueden agrupar por categorías:

• Iniciación, pausa y reestablecimiento de la funcionalidad de los Applet. • Soporte de parámetros incluidos por los applet. • Carga de imágenes de alto nivel. • Carga de audio de alto nivel y reproducción para applet y reproducciones. • Consultas de orígenes (getDocumentBase() y getCodeBase()).

Muestra en pantalla el estado (showStatus(String)).

53

MANUAL DE JAVA

CAPITULO 7: MANEJO DE ARCHIVO EN JAVA

54

Introducción El manejo de archivos en Java se realiza mediante flujos (stream) o canal, o también denominado secuencia. Los flujos pueden estar abiertos o cerrados, conducen los datos entre el programa y los dispositivos externos. Con sus clases y métodos proporcionados por el paquete de clases de entrada y salida (java.io) se pueden tratar archivos secuénciales, de acceso directo, archivos indexados, etc. Los archivos tienen como finalidad guardar datos de forma permanente. Una vez que acaba la aplicación, los datos almacenados están disponibles para que otra aplicación los utilice. Los archivos son dispositivos externos, en contraposición de los datos que se guardan en arreglos (arrays), listas, árboles, etc. Que están en memoria interna y por lo tanto desaparecen al acabar la ejecución del programa.

55

Flujos Un flujo o Stream es una abstracción que se refiere a una corriente de datos que fluyen entre un origen o fuente (productor) y un destino (consumidor). Entre el origen y el destino debe existir una conexión o canal, también conocida como pipe por la que circulan los datos. La apertura del archivo supone establecer una conexión del programa y el dispositivo que contiene el archivo. Abrir un archivo supone crear un objeto y quedar asociado con un flujo. Al iniciar un programa en java, tenemos tres flujos que quedan abiertos de manera automática, estos son: System.in: Objeto entrada estándar; permite al programa la entrada de flujos de bytes desde el teclado. System.out: Objeto salida estándar; permite al programa la salida de datos por la pantalla. System.err: Objeto para salida estándar de errores; permite al sistema la salida de errores por pantalla. Estos tres objetos se crean al inicio del programa y sirven para admitir secuencias de caracteres en modo texto. Así cuando se ejecuta.

Se escribe la secuencia de caracteres en la pantalla. El paquete java.io agrupa el conjunto de clases para el manejo de entrada y salida; siempre que se vaya a procesar un archivo se tienen que utilizar clases de este paquete, por lo tanto se debe importar:

Para todas las clases.

56

Jerarquía de Clases En el paquete java.io se encuentran todas las clases Stream necesarias para dar entrada/salida a nuestros programas. Los flujos de datos, de caracteres, de bytes se pueden calificar en flujos de entrada (InputStream) y en flujos de salida (OutputStream). Por ello Java declara dos clases que derivan directamente de la clase Object: InputStream y OutputStream. Ambas son clases abstractas que declaran métodos que deben de redefinirse en sus clases derivadas. Además InputStream es la clase base de todas las clases definidas para Stream de entrada, y OutputStream es la clase base para todas las clases de Stream de salida.

InputStream OutputStream FileInputStream FileOutputStream ByteArrayInputStream ByteArrayOutputStream PipeInputStream PipeOutputStream SequenceInputStream StringBuffereInputStream FilterInputStream FilterOutputStream

57

FileInputStream y FileOutputStream La clase FileInputStream se utiliza para leer bytes desde un archivo. Los constructores de la clase permiten crear objetos asociados a un archivo. Algunos de los métodos más importantes de ésta clase, cabe destacar que todos son públicos y que es importante tener en cuenta el tipo de excepción que pueden lanzar. FileInputStream (String nombre) throws FileNotFoundException Crea un objeto inicializado con el nombre de archivo que pasa como argumento FileInputStream (File nombre) throws FileNotFoundException Crea un objeto inicializado con el objeto File pasado como parámetro int read() throws IOException Lee un byte del flujo asociado. Devuelve -1 si alcanza el fin de archivo int read(byte [] s) throws IOException Lee una secuencia de bytes del flujo y se almacena en el array s, devuelve -1 si alcanza el fin de archive, o bien el número de bytes leídos int read(byte [] s, int org, int largo) throws IOException Lee una secuencia de bytes del flujo y se almacena en el array s desde la posición org y un máximo de largo bytes. Devuelve -1 si alcanza el fin de archivo o bien el número de bytes leídos Con la clase FileOutputStream, se pueden escribir bytes en un flujo de salida asociado a un archivo. Los constructores inicializan objetos con el con el nombre del archivo, o bien con el archivo como un objeto File. A continuación presento algunos de los métodos más utilizados en esta clase. FileOutputStream(String nombre) throws IOException Crea un objeto inicializado con el nombre de archivo que se pasa como parámetro FileOutputStream(String nombre, bolean sw) throws IOException Crea un objeto inicializado con el nombre de archivo que se pasa como argumento. En el caso de qye sw = trae los bytes escritos se añaden al final FileOutputStream(File nombre) throws IOException Crea un objeto inicializado con el objeto File pasado como argumento void write(byte a) throws IOException Escribe el byte a en el flujo asociado void write(byte [] a) throws IOException Escribe el array de bytes a en el flujo asociado void write(byte [] a, int org, int largo) throws IOException Escribe el array s desde la posición org y un máximo de largo bytes en el flujo

58

Ejemplo Introductorio FileInputStream Vamos a leer un archivo con la clase derivada de InputStream y luego utilizaremos una clase derivada de Read y Writer, con la cual se facilita de manera considerada el manejo de archivos. Leer un archivo: Inicialmente vamos a crear un archivo de texto, de nombre datos.txt, con el siguiente contenido.

Ahora procederemos a leerlo con la case derivada de InputStream FileInputStream.

Se crea un objeto FileInputStream, con el nombre del archivo, posteriormente, se van evaluando los caracteres que se van sacando desde el archivo hasta que el numero del caracter sea distinto de -1. La salida de este programa sería la siguiente.

60

Ejemplo Introductorio FileOutputStream A continuación, utilizaremos la clase derivada de OutputStream FileOutputStream.

Se crea un objeto de la clase FileOutputStream, al cual se le entrega como parámetro de constructor el nombre del archivo en donde se va a escribir, posteriormente, se van agregando al archivo los datos ingresados por el usuario hasta que este presione F6, tecla que posee como número el -1. El ingreso de información es el siguiente.

Al revisar el archivo, la información ingresada esta almacenada en el archivo Temporal.txt.

61

Ejemplo Introductorio FileReader Utilizando el siguiente archivo de texto para leer la información que contiene.

El código fuente es el siguiente.

Se crea inicialmente un objeto de la clase FileReader, el cual se utiliza para entregarlo como argumento al BufferedReader, que es el lector de Buffer, seguido, se leen las líneas del archivo entregado y las presenta en la pantalla concatenadas con el caracter de fin de línea “\n”. La salida, liego de leer el archivo es la siguiente.

62

Ejemplo Introductorio FileWriter Vamos escribir información en un archivo de texto denominado Temporal.txt con el objeto FileWriter que deriva de la clase Writer.

Se crea un objeto de BufferedReader para que el usuario pueda ingresar la información que desea enviar al archivo, posteriormente, se crea un objeto de la clase FileWriter, con parámetro de constructor “Temporal.txt”, que es el nombre del archivo al cual le vamos a enviar lo que el usuario ingrese, después, se crea un objeto BufferedWriter, que hace referencia al flujo de salida y que utiliza a FileWriter como parámetro de constructor, este flujo de salida, lo utiliza PrintWriter, que es el objeto que nos permite enviar los caracteres al archivo. El ingreso de información es el siguiente.

El archivo Temporal.txt queda de la siguiente manera.

64

MANUAL DE JAVA

CAPITULO 8: APPLETS

65

Introducción a los Applets de Java

Para decir que es un applet en realidad, utilizaré la definición de Patrick Naughton, quien indica que… “un Applet es una pequeña aplicación accesible en un servidor Internet, que se trasporta por al red, se instala automáticamente y se ejecuta in situ como parte de un documento Web”.

Un applet, se carga y se ejecuta dentro de un navegador Web, más adelante veremos como se debe escribir este tag.

66

Applets Arquitectura de lo Applets Los applets tienen una arquitectura bien definida, la cual permite reconocer los pasos de su inicialización de una manera simple: Cuando un applet se carga, comienza su ciclo de vida, que pasaría por las siguientes fases:

• Se crea una instancia de la clase que controla el Applet. • El Applet se inicializa. • El Applet comienza a ejecutarse. • El Applet comienza a recibir llamadas de los métodos primarios de un Applet.

o init() (inicializar) o star() (empezar) o paint() (pintar)

Jerarquía de un applet

Las características de las applets se pueden considerar desde el punto de vista del programador y desde el del usuario. En este manual lo más importante es el punto de vista del programador: Las applets no tienen un método main() con el que comience la ejecución. El papel central de su ejecución lo asumen otros métodos que se verán posteriormente. Todas las applets derivan de la clase java.applet.Applet. La Figura anterior muestra la jerarquía de clases de la que deriva la clase Applet. Las applets deben

67

redefinir ciertos métodos heredados de Applet que controlan su ejecución: init(), start(), stop(), destroy(). Se heredan otros muchos métodos de las super-clases de Applet que tienen que ver con la generación de interfaces gráficas de usuario (AWT). Así, los métodos gráficos se heredan de Component, mientras que la capacidad de añadir componentes de interfase de usuario se hereda de Container y de Panel. Las applets también suelen redefinir ciertos métodos gráficos: los más importantes son paint() y update(), heredados de Component y de Container; y repaint() Heredado de Component. Las applets disponen de métodos relacionados con la obtención de información, como por ejemplo: getAppletInfo(), getAppletContext(), getParameterInfo(), getParameter(), getCodeBase(), getDocumentBase(), e isActive(). El método showStatus() se utiliza para mostrar información en la barra de estado del browser. Existen otros métodos relacionados con imágenes y sonido: getImage(), getAudioClip(), play(), etc. Métodos de un Applet

Los métodos propios de la clase Applet.

init()

El método init() se llama cada vez que el applet carga por primera vez. Si el applet llamado no lo sobrecarga, init() no hace nada. Fundamentalmente en este método se debe fijar el tamaño del applet, aunque en el caso de Netscape el tamaño que vale es el que se indique en la línea del fichero HTML que cargue el applet. También se deben realizar en este método las cargas de imágenes y sonidos necesarios para la ejecución del applet. Y, por supuesto, la asignación de valores a las variables globales a la clase que se utilicen. En el caso de los applet, este método únicamente es llamado por el sistema al cargar el applet.

start()

start() es la llamada para arrancar el applet cada vez que es visitado. La clase Applet no hace nada en este método. Las clases derivadas deben sobrecargarlo para comenzar la animación, el sonido, etc. Esta función es llamada automáticamente cada vez que la zona de visualización en que está ubicado el applet se expone a la visión, a fin de optimizar en uso de los recursos del sistema y no ejecutar algo que no puede ser apreciado (aunque el programador puede variar este comportamiento y hacer que un applet siga activo aun cuando esté fuera del

68

área de visión). Esto es, imaginemos que cargamos un applet en un navegador minimizado; el sistema llamará al método init(), pero no a start(), que sí será llamado cuando restauremos el navegador a un tamaño que permita ver el applet. Naturalmente, start() se puede ejecutar varias veces: la primera tras init() y las siguientes (porque init() se ejecuta solamente una vez) tras haber aplicado el método stop().

stop()

stop() es la llamada para detener la ejecución del applet. Se llama cuando el applet desaparece de la pantalla. La clase Applet tampoco hace nada en este método, que debería ser sobrecargado por las clases derivadas para detener la animación, el sonido, etc. Esta función es llamada cuando el navegador no incluye en su campo de visión al applet; por ejemplo, cuando abandona la página en que está insertado, de forma que el programador puede paralizar los threads que no resulten necesarios respecto de un applet no visible, y luego recuperar su actividad mediante el método start().

destroy()

El método destroy() se llama cuando ya no se va a utilizar más el applet, cuando se necesita que sean liberados todos los recursos dispuestos por el applet, por ejemplo, cuando se cierra el navegador. La clase Applet no hace nada en este método. Las clases derivadas deberían sobrecargarlo para hacer una limpieza final. Los applet multithread deberían utilizar destroy() para detener los threads que quedasen activos.

paint( Graphics g )

Es la función llamada cada vez que el área de dibujo del applet necesita ser refrescada. La clase Applet simplemente dibuja un rectángulo gris en el área, es la clase derivada, obviamente, la que debería sobrecargar este método para representar algo inteligente en la pantalla. Cada vez que la zona del applet es cubierta por otra ventana, se desplaza el applet fuera de la visión o el applet cambia de posición debido a un redimensionamiento del navegador, el sistema llama automáticamente a este método, pasando como argumento un objeto de tipo Graphics que delimita la zona a ser pintada; en realidad se pasa una referencia al contexto gráfico en uso, y que representa la ventana del applet en la página Web.

update( Graphics g )

Esta es la función que realmente se llama cuando se necesita una actualización de la pantalla. La clase Applet simplemente limpia el área y llama al método paint(). Esta funcionalidad es suficiente para la mayoría de los casos; aunque, de cualquier forma, las clases derivadas pueden sustituir esta funcionalidad para sus propósitos especiales. Es decir, en las situaciones detalladas anteriormente que dañan la zona de exposición del applet, el sistema llama al método paint(), pero en realidad la llamada se realiza al método update(), cuyo comportamiento establecido en la clase

69

Component es llamar al método paint(), tras haber rellenado la zona del applet con su color de fondo por defecto. Pudiera parecer así que se trata de un método de efecto neutro, pero si la función paint() cambiara el color del fondo, podríamos percibir un flick de cambio de colores nada agradable. Por tanto, habrá que cuidarse por lo común, de eliminar este efecto de limpia primero, sobrecargando el método update(), para que llame únicamente a paint(). Otra solución sería insertar el código de pintado en una sobrecarga del método update() y escribir un método paint() que sólo llame a update(). La última solución pasaría por usar el mismo método setBackground( Color ), en el método init() para así evitar el efecto visual sin tener que sobrecargar el método update(). Estas son las mismas razones que aconsejan usar el método resize() inserto en init(), para evitar el mismo desagradable efecto.

repaint

Llamando a este método se podrá forzar la actualización de un applet, la llamada a update(). Pero hay que tener cierto cuidado, porque AWT posee cierta inteligencia (combinación casi siempre nefasta), de forma que si se llama a update() mediante repaint() con una frecuencia muy corta, AWT ignorará las llamadas a update() que estime oportuno, pues considera a esta función como un bien escaso. A continuación ejecutaremos nuestro primer Applet: Archivo: Appletuno.java import java.applet.Applet; import java.awt.*; public class Appletuno extends Applet{ String texto; public void init(){ texto= “Primera Frase en un Applet!!!”; setBackground(Color.cyan); } public void start(){ System.out.println("Comenzando"); } public void stop(){ System.out.println("Parando"); } public void destroy(){ System.out.println("Preparando la destrucción"); } public void paint(Graphics g){ System.out.println("Pintando"); g.setColor(Color.blue); g.drawString(texto,15,25); } }

70

Como podemos apreciar, no es necesario escribir todos los métodos de un applet, basta con escribir los que necesitamos para ejecutar nuestro applet. Luego que escribimos nuestro código, pasaré a explicar como se realiza el proceso de carga del applet. Como sabemos, los applet son pequeñas aplicaciones que se ejecutan dentro de un navegador Web, el tag que acompaña al applet es <APPLET> y se debe especificar un applet de la siguiente manera: <APPLET CODE="miApplet.class" [CODEBASE="unURL"] [NAME="unName"] WIDTH="wpixels" HEIGHT="hpixels" [ALT="TextoAlternativo"]> [texto alternativo para browsers que reconocen el tag <applet> pero no pueden ejecutar el applet] [<PARAM NAME="MyName1" VALUE="valueOfMyName1">] [<PARAM NAME="MyName2" VALUE="valueOfMyName2">] </APPLET> Para nuestro archivo Appletuno.java, realizamos los siguientes pasos para ejecutarlo

1. Escribimos el código del applet (ya realizado) 2. Escribimos el Tag <APPLET> dentro de una página HTML

Esto lo realizamos de la siguiente manera, en un notepad, escribimos una página HTML simple y lo guardamos en el mismo directorio donde guardamos el Appletuno.java. <html> <body> <applet code="Appletuno.class" width=300 height=100> </applet> </body> </HTML>

71

3. A continuación compilaremos el applet. a. Procedemos a abrir un entorno de comando y nos dirigimos al

directorio donde esta el applet y procedemos a compilarlo con “javac”.

b. Para poder ver un Applet, podemos hacerlo de 2 manera, uno es ejecutándolo con el visor de applet de la JVM, el appletviewer. Esto se hace de la siguiente manera.

Si se dan cuenta, el appletviewer carga el archivo HTML que contiene el applet. Los mensajes que aparecen abajo, son los de los métodos, demostrando al momento que se ejecutan. Bueno, lo más importante de todo, nuestro applet aparecerá de la siguiente manera:

72

Al cerrar nuestro Applet, veremos que se escriben los mensajes de los métodos stop() y destroy().

A continuación, utilizaremos un ejemplo de traspaso de parámetros de una página HTML a nuestro applet. Como vimos anteriormente, nuestro applet presenta una frase, ahora esa frase va a estar como parámetro en una página HTML dentro del tag <applet> </applet>. Primero hacemos la modificación de prueba.html Archivo prueba.html <html> <body> <applet code="Appletuno.class" width=300 height=100> <param name=variable value="Parametro traspasado desde mi HTML"> </applet> </body> </HTML> a continuación hacemos la modificación del applet Appletuno.java Archivo Appletuno.java import java.applet.Applet; import java.awt.*; public class Appletuno extends Applet{ String texto; public void init(){ texto= getParameter("variable"); setBackground(Color.cyan); } public void start(){ System.out.println("Comenzando"); } public void stop(){

73

System.out.println("Parando"); } public void destroy(){ System.out.println("Preparando la destrucción"); } public void paint(Graphics g){ System.out.println("Pintando"); g.setColor(Color.blue); g.drawString(texto,15,25); } } Procedemos a compilar nuestro Appletuno.java y a ejecutarlo con appletvewer (visor de Applet)

El resultado sería el siguiente

Ya que aprendimos a realizar traspasos de parámetros, podemos comenzar a echar a volar la imaginación de las cosas que podríamos hacer con esta capacidad.

74

MANUAL DE JAVA

CAPITULO 9: INTERFASES GRÁFICAS DE USUARIO EN JAVA

76

Introducción La interfase de usuario es la parte del programa que permite a éste interactuar con el usuario. Las interfaces de usuario pueden adoptar muchas formas, que van desde la simple línea de comandos hasta las interfaces gráficas que proporcionan las aplicaciones más modernas. La interfase de usuario es el aspecto más importante de cualquier aplicación. Una aplicación sin un interfaz fácil, impide que los usuarios saquen el máximo rendimiento del programa. Java proporciona los elementos básicos para construir decentes interfaces de usuario a través del AWT. Al nivel más bajo, el sistema operativo transmite información desde el ratón y el teclado como dispositivos de entrada al programa. El AWT fue diseñado pensando en que el programador no tuviese que preocuparse de detalles como controlar el movimiento del ratón o leer el teclado, ni tampoco atender a detalles como la escritura en pantalla. El AWT constituye una librería de clases orientada a objeto para cubrir estos recursos y servicios de bajo nivel. Debido a que el lenguaje de programación Java es independiente de la plataforma en que se ejecuten sus aplicaciones, el AWT también es independiente de la plataforma en que se ejecute. El AWT proporciona un conjunto de herramientas para la construcción de interfaces gráficas que tienen una apariencia y se comportan de forma semejante en todas las plataformas en que se ejecute. Los elementos de interfase proporcionados por el AWT están implementados utilizando toolkits nativos de las plataformas, preservando una apariencia semejante a todas las aplicaciones que se creen para esa plataforma. Este es un punto fuerte del AWT, pero también tiene la desventaja de que una interfase gráfica diseñada para una plataforma, puede no visualizarse correctamente en otra diferente.

77

Estructura del AWT La estructura de la versión actual del AWT podemos resumirla en los puntos que exponemos a continuación:

• Los Contenedores contienen Componentes, que son los controles básicos • No se usan posiciones fijas de los Componentes, sino que están situados a

través de una disposición controlada (Layouts) • El común denominador de más bajo nivel se acerca al teclado, ratón y

manejo de eventos • Alto nivel de abstracción respecto al entorno de ventanas en que se ejecute

la aplicación (no hay áreas cliente, ni llamadas a X, ni hWnds, etc.) • La arquitectura de la aplicación es dependiente del entorno de ventanas, en

vez de tener un tamaño fijo • Es bastante dependiente de la máquina en que se ejecuta la aplicación (no

puede asumir que un diálogo tendrá el mismo tamaño en cada máquina) • Carece de un formato de recursos. No se puede separar el código de lo que

es propiamente interfase

78

Conenedores

Una interfase gráfica está construida en base a elementos gráficos básicos, los Componentes. Típicos ejemplos de estos Componentes son los botones, barras de desplazamiento, etiquetas, listas, cajas de selección o campos de texto. Los Componentes permiten al usuario interactuar con la aplicación y proporcionar información desde el programa al usuario sobre el estado del programa. En el AWT, todos los Componentes de la interfase de usuario son instancias de la clase Component o uno de sus subtipos.

Los Componentes no se encuentran aislados, sino agrupados dentro de Contenedores. Los Contenedores contienen y organizan la situación de los Componentes; además, los Contenedores son en sí mismos Componentes y como tales pueden ser situados dentro de otros Contenedores. También contienen el código necesario para el control de eventos, cambiar la forma del cursor o modificar el icono de la aplicación. En el AWT, todos los Contenedores son instancias de la clase Container o uno de sus subtipos.

Los Componentes deben circunscribirse dentro del Contenedor que los contiene. Esto hace que el anidamiento de Componentes (incluyendo Contenedores) en Contenedores crean árboles de elementos, comenzando con un Contenedor en la raíz del árbol y expandiéndolo en sus ramas.

Container es una clase abstracta derivada de Component, que representa a cualquier componente que pueda contener otros componentes. Se trata, en esencia, de añadir a la clase Component la funcionalidad de adición, sustracción, recuperación, control y organización de otros componentes.

El AWT proporciona cuatro clases de Contenedores:

• Window • Frame • Dialog • Panel

Además de estos Contenedores, la clase Applet también es un Contenedor, es un subtipo de la clase Panel y puede tener Componentes.

79

Window

Es una superficie de pantalla de alto nivel (una ventana). Una instancia de la clase Window no puede estar enlazada o embebida en otro Contenedor. Una instancia de esta clase no tiene ni título ni borde.

Frame

Es una superficie de pantalla de alto nivel (una ventana) con borde y título. Una instancia de la clase Frame puede tener una barra de menú. Una instancia de esta clase es mucho más aparente y más semejante a lo que nosotros entendemos por ventana.

Dialog

Es una superficie de pantalla de alto nivel (una ventana) con borde y título. Una instancia de la clase Dialog no puede existir sin una instancia asociada de la clase Frame.

Panel

Es un Contenedor genérico de Componentes. Una instancia de la clase Panel, simplemente proporciona un Contenedor al que ir añadiendo Componentes.

80

Crear un Contenedor

Antes de poder incorporar Componentes a la interfase de usuario que se desea implementar, el programador debe crear un Contenedor. Cuando se construye una aplicación, el programador debe crear en primer lugar una instancia de la clase Window o de la clase Frame. Cuando lo que se construye es un applet, ya existe un Frame (la ventana del navegador). Debido a que la clase Applet está derivada de la clase Panel, el programador puede ir añadiendo Componentes directamente a la instancia que se crea de la clase Applet.

En el siguiente ejemplo se crea un Frame vacío. El título del Frame, que corresponderá al título de la ventana, se fija en la llamada al constructor. Un Frame inicialmente está invisible, para poder verlo es necesario invocar al método show():

Nótese que se crea un nuevo objeto de la clase Frame, se redimensiona y posteriormente se muestra. El la ventana resultante del Frame ejecutado en el código anterior es la siguiente.

81

En el código de ejemplo que sigue, extendiendo el código anterior para que la nueva clase sea una subclase de la clase Panel. En el método main() de esta nueva clase se crea una instancia de ella y se le incorpora un objeto Frame llamando al método add(). El resultado de ambos ejemplos es idéntico a efectos de apariencia en pantalla:

Se crea un objeto de la clase Frame, con nombre Ejemplo 2, luego, utilizando la herencia de la clase, se procede a crear un objeto Ejemplo2, que en el fondo es un Panel, este se agrega al Frame y el Frame se procede a mostrar.

Derivando la nueva clase directamente de la clase Applet en vez de Panel, nuestro ejemplo puede ahora ejecutarse tanto como una aplicación solitaria como dentro de una página HTML en un navegador. El código siguiente muestra esta circunstancia:

El applet cargado es el siguiente.

82

Un objeto Window, y en algunos casos incluso un objeto Dialog, pueden reemplazar al objeto Frame. Son Contenedores válidos y los Componentes se añaden en ellos del mismo modo que se haría sobre un Frame.

83

Añadir Componentes a un Contenedor Para que la interfase sea útil, no debe estar compuesta solamente por Contenedores, éstos deben tener Componentes en su interior. Los Componentes se añaden al Contenedor invocando al método add() del Contenedor. Este método tiene tres formas de llamada que dependen del manejador de composición o layout manager que se vaya a utilizar sobre el Contenedor. En el código siguiente, incorporamos dos botones al código del último ejemplo. La creación se realiza en el método init() porque éste siempre es llamado automáticamente al inicializarse el applet. De todos modos, al iniciarse la ejecución se crean los botones, ya que el método init() es llamado tanto por el navegador como por el método main():

La ventana siguiente es la resultante de la ejecución del Applet Ejemplo4.

84

Layouts Los Layout Managers o manejadores de composición, en traducción literal, ayudan a adaptar los diversos Componentes que se desean incorporar a un Panel, es decir, especifican la apariencia que tendrán los Componentes a la hora de colocarlos sobre un Contenedor. Java dispone de varios, en la actual versión, tal como se muestra en la imagen:

¿Por qué Java proporciona estos esquemas predefinidos de disposición de componentes? La razón es simple: imaginemos que deseamos agrupar objetos de distinto tamaño en celdas de una rejilla virtual: si confiados en nuestro conocimiento de un sistema gráfico determinado, codificamos a mano tal disposición, deberemos prever el redimensionamiento del applet, su repintado cuando sea cubierto por otra ventana, etc., además de todas las cuestiones relacionadas con un posible cambio de plataforma (uno nunca sabe a donde van a ir a parar los propios hijos, o los Applets). Sigamos imaginando, ahora, que un hábil equipo de desarrollo ha previsto las disposiciones gráficas más usadas y ha creado un gestor para cada una de tales configuraciones, que se ocupará, de forma transparente para nosotros, de todas esas cuitas de formatos. Bien, pues estos gestores son instancias de las distintas clases derivadas de Layout Manager y que se utilizan en el applet que genera la figura siguiente, donde se muestran los diferentes tipos de Layouts que proporciona el AWT.

85

En el applet que genera la figura siguiente, se utilizan los diferentes tipos de Layouts que proporciona el AWT y Swing.

NOTA: Los Applets que se utilicen en los ejemplos, serán cargados con la página HTML ejemplo.html, en donde el único cambio que se le ha hecho para cada uno de los ejemplos, es cambiar el nombre del archivo class en el parámetro code. Código de página ejemplo.html

A continuación, explicaré el uso de cada uno de los Layout del Layout Manager.

86

FlotLayout Es el más simple y el que se utiliza por defecto en todos los Paneles si no se fuerza el uso de alguno de los otros. Los Componentes añadidos a un Panel con FlowLayout se encadenan en forma de lista. La cadena es horizontal, de izquierda a derecha, y se puede seleccionar el espaciado entre cada Componente

La ventana del Applet del código anterior es la siguiente.

87

BorderLayout La composición BorderLayout (de borde) proporciona un esquema más complejo de colocación de los Componentes en un panel. La composición utiliza cinco zonas para colocar los Componentes sobre ellas: Norte, Sur, Este, Oeste y Centro. Es el layout o composición que se utilizan por defecto Frame y Dialog. El Norte ocupa la parte superior del panel, el Este ocupa el lado derecho, Sur la zona inferior y Oeste el lado izquierdo. Centro representa el resto que queda, una vez que se hayan rellenado las otras cuatro partes.

Vista del Applet.

GridLayout

88

La composición GridLayout proporciona gran flexibilidad para situar Componentes. El layout se crea con un número de filas y columnas y los Componentes van dentro de las celdas de la tabla así definida.

Vista del Applet.

89

GridBagLayout Es igual que la composición de GridLayout, con la diferencia que los Componentes no necesitan tener el mismo tamaño. Es quizá el layout más sofisticado y versátil de los que actualmente soporta AWT.

90

Vista del Applet.

Como se pudo apreciar, es un poco complicada la utilización del GridBagLayout, pero nosotros podemos realizar algunos cambios y creando unos métodos, podemos hacer que construir un marco con GridBagLayout se vuelva un poco más fácil. A continuación, se utiliza una modificación del Layout GridBagLayout en donde podemos ubicar objeto a nuestra manera en un Frame.

91

Nótese la inclusión del método addComponent, éste método nos permite modificar el Layout que se utilizará en el Applet, dentro del cual se crea un gridBagConstraint para ubicar los componentes ingresados, las posiciones de estos componentes, quedan como parámetros del método addComponent. Vista del Applet.

92

CardLayout Este es el tipo de composición que se utiliza cuando se necesita una zona de la ventana que permita colocar distintos Componentes en esa misma zona. Este layout suele ir asociado con botones de lista (Choice), de tal modo que cada selección determina el panel (grupo de componentes) que se presentarán.

93

Vista del Applet con la primera selección del Cuadro de Selección utilizando el primer card.

Vista del Applet con la segunda selección del Cuadro de Selección utilizando el segundo card.

94

Crear un Layout Propio Se puede crear un Layout personalizado en base a la interfase LayoutManager. Hay que redefinir los cinco métodos que utiliza este interfase, lo cual puede no resultar sencillo, así que en lo posible se deben utilizar los métodos de colocación de componentes que proporciona AWT, fundamentalmente en el momento en que parezca que ninguno de los Layouts que hemos visto satisface nuestras exigencias, deberíamos volver a comprobar que el GridBagLayout, que es el más flexible, de verdad no cumple nuestros requerimientos. Creación de clase MiLayout que implementa la interfaz LayoutManager.

95

Continuación.

96

Código del Applet que utiliza el Layout creado anteriormente.

Vista del Applet

97

Controles y Componentes La finalidad de añadir controles como botones, cajas de texto, etiquetas, listas, etc. es que el usuario interactué con el entorno y pueda realizar las operaciones que desee. Nosotros seremos los encargados de añadir esos controles y asignarles las acciones que van a realizar. Muchos de estos controles comparten métodos y eventos.

Etiqueta (Label)

Se utilizan para dibujar una cadena de texto en una posición y con una alineación (dentro del componente). Lo primero que hacemos es crearla y luego la posicionamos dentro de la applet. Creación:

ALINEACIÓN DESCRIPCIÓN

Label.LEFT Izquierda.

Label.RIGHT Derecha.

Label.CENTER Centrado.

98

Campos de Texto (TextField)

TextField implementa un área de entrada de texto de una sola línea. Todo aquello que escribimos en una caja de texto es de tipo String por tanto si queremos realizar operaciones matemáticas deberemos transformarlo a un valor numérico. Creación:

Guardar Texto: (valido para etiquetas)

Mostrar Texto: (valido para etiquetas)

99

Cuadros de Chequeo (Checkbox)

Las casillas de verificación son botones de opciones, los cuales pueden estar varios seleccionados a la vez. El texto esta situado a la derecha. La clase Checkbox se utiliza para crear el control, y los métodos getState y setState para obtener y mostrar el estado, que admite dos valores True si esta seleccionado y False si no esta seleccionado.

Creación: Tenemos 2 maneras para crearlos. El primero si se quiere establecer un valor inicial, con el segundo se crea sin indicar el estado, (por defecto están sin seleccionar);

Estados:

Necesitamos ahora cambiar los Checkbox a botones de opción, para ello, debemos únicamente crear un CheckboxGroup y entregárselos como parámetro a cada uno de los Checkbox que deseamos estén como botones de opción.

Creación de Grupo:

Creación de Elementos:

100

Lista (List)

Mediante la clase List crearemos el objeto. Este tipo de lista puede admite más de una selección, el orden de sus elementos es según han sido añadidos. Los miembros son los mismos que en el control anterior solo cambia el modo de construirlos. En este control aparecen unas barras de desplazamiento verticales automáticamente.

Creación:

Agregar Ítem:

Seleccionar Ítem:

Obtener el índice seleccionado:

Obtener el valor seleccionado:

101

Botón (Button)

Son utilizados para ejecutar las acciones. La clase que se utiliza es Button. Una vez creado hay que asociarlo al método action para realizar la operación. El texto que aparece en los botones siempre va en el centro. Creación:

Áreas de Texto (TextArea)

A veces no es suficiente una entrada de texto de una única línea. TextArea es una caja de texto multilínea, es decir, admite varias líneas. Como valores en la construcción toma un String inicial, seguido del número de columnas y filas que se desean visualizar. Además del método constructor existen otros de gran importancia.

Creación:

Insertar Texto:

Al Final:

Posición Aleatorio:

Reemplazar:

102

Lista Desplegable de Selección (Choice)

Las Listas de Selección (Choice), funcionan de la misma manera que una List, salvo que en su gráfica, aparece el valor seleccionado en una casilla, y si el usuario desea seleccionar otro valor, deberá desplegar la lista para seleccionarlo.

Creación:

Agregar Ítem:

Seleccionar Ítem:

Obtener el índice seleccionado:

Obtener el valor seleccionado:

103

Barra de Desplazamiento (Scrollbar)

Se utiliza para seleccionar valores continuos entre un mínimo y un máximo especificado. Las barras pueden tener una orientación vertical u horizontal. Los métodos asociados sirven para obtener y establecer la posición de la barra y su valor mínimo y máximo. Para trabajar con las barras se utilizan los eventos que van asociadas a ellas junto con el método handleEvent.

Creación:

CONSTANTE DESCRIPCIÓN

Scrollbar.VERTICAL Orientación vertical

Scrollbar.HORIZONTAL Orientación horizontal

Valores Mínimos y Máximos:

Establecer Valor:

Obtener Valor:

104

Panel (Panel)

Panel es una clase derivada de Container la cual nos va a servir para introducir controles en su interior, de la misma forma que una canva. La principal utilidad que se le puede dar es para colocar controles a una ventana en un punto que a nosotros nos interese a través de un objeto Panel.

Creación:

Tamaño y Posición:

Movimiento:

Añadir Elemento:

105

Barra de Menú (MenuBar)

Cada ventana de nivel superior puede tener una barra de menús. Esta barra esta compuesta por menús Popup, los cuales están compuestos de menús ítem. Los menús de tipo ítem también pueden comportarse como Popup con lo que podremos anidar submenús creando una jerarquía. Lo primero es crear la barra de menús mediante la clase MenuBar. Una vez creada, iremos creando los menús popup y cada uno de los ítems que contengan los popup. Y por último tendremos que ir añadiendo los ítem a los popup y los popup a la barra. También debemos añadir la barra de menú a la ventana.

Crear Barra de Menú:

Crear Menú Popup:

Crear Menú Ítem:

Añadir Menú Ítem a Menú Popup:

Añadir Menú Popup a la Barra de Menú:

Añadir la Barra de Menú a la Ventana:

106

Cuadro de Dibujos (Canvas)

Además de los componentes estándar, hay un componente (Canvas), que nos permite implementar cualquier otro tipo de control en su interior y capturar sus eventos a través de la canva. Es muy útil cuando el control que implementamos no responde a eventos. La clase Canvas no responde a los eventos directamente si no que es el programador quien debe definir una subclase de Canvas a la que se envían todos los eventos y, otra clase donde crearemos el objeto de la subclase e implementaremos todo el código del programa.

Creación de la Subclase:

Creación del Objeto Canvas: Debe ser una clase distinta a la anterior.

Tamaño:

Los métodos relacionados con el diseño de los controles que hemos ido viendo anteriormente también se pueden aplicar al objeto canvas. Como por ejemplo los métodos para establecer color, tipo de letra, etc...

107

Opciones Gráficas de Dibujo A continuación se presentan los diferentes métodos para construir figuras en contenedores o componentes trabajen con la clase Graphics g. En capítulos anteriores ya se ha mostrado cómo escribir Applets, cómo lanzarlos y los fundamentos básicos de la presentación de información sobre ellos. Ahora, pues, haremos cosas más interesantes que mostrar texto; ya que cualquier página HTML puede mostrar texto. Para ello, Java proporciona la clase Graphics, que permite mostrar texto a través del método drawString(), pero también tiene muchos otros métodos de dibujo. Para cualquier programador, es esencial el entendimiento de la clase Graphics, antes de adentrarse en el dibujo de cualquier cosa en Java. Esta clase proporciona el entorno de trabajo para cualquier operación gráfica que se realice dentro del AWT. Juega dos importantes papeles: por un lado, es el contexto gráfico, es decir, contiene la información que va a afectar a todas las operaciones gráficas, incluyendo los colores de fondo y texto, la fuente de caracteres, la localización y dimensiones del rectángulo en que se va a pintar, e incluso dispone de información sobre el eventual destino de las operaciones gráficas (pantalla o imagen). Por otro lado, la clase Graphics proporciona métodos que permiten el dibujo de primitivas, figuras y la manipulación de fonts de caracteres y colores. También hay clases para la manipulación de imágenes, doble-buffering, etc. Para poder pintar, un programa necesita un contexto gráfico válido, representado por una instancia de la clase Graphics. Pero, como esta clase es abstracta, no se puede instanciar directamente; así que debemos crear un componente y pasarlo al programa como un argumento a los métodos paint() o update(). Los dos métodos anteriores, paint() y update(), junto con el método repaint() son los que están involucrados en la presentación de gráficos en pantalla. El AWT, para reducir el tiempo que necesitan estos métodos para realizar el repintado en pantalla de gráficos, tiene dos axiomas:

• Primero, el AWT repinta solamente aquellos Componentes que necesitan ser repintados, bien porque estuviesen cubiertos por otra ventana o porque se pida su repintado directamente

• Segundo, si un Componente estaba tapado y se destapa, el AWT repinta solamente la porción del Componente que estaba oculta

108

La pantalla en Java se incrementa de izquierda a derecha y de arriba hacia abajo, tal como muestra la figura:

Los pixels de la pantalla son pues: posición 0 + ancho de la pantalla - 1. En los textos, el punto de inserción se encuentra en la línea base de la primera letra. Vamos a presentar métodos para dibujar varias figuras geométricas. Como estos métodos funcionan solamente cuando son invocados por una instancia válida de la clase Graphics, su ámbito de aplicación se restringe a los componentes que se utilicen en los métodos paint() y update(). Normalmente los métodos de dibujo de primitivas gráficas funcionan por pares: un método pinta la figura normal y el otro pinta la figura rellena. drawLine( x1,y1,x2,y2 ) drawRect( x,y,ancho,alto ) fillRect( x,y,ancho,alto ) clearRect( x,y,ancho.alto ) drawRoundRect( x,y,ancho,alto,anchoArco,altoArco ) fillRoundRect( x,y,ancho,alto,anchoArco,altoArco ) draw3DRect( x,y,ancho,alto,boolean elevado ) fill3DRect( x,y,ancho,alto,boolean elevado ) drawOval( x,y,ancho,alto ) fillOval( x,y,ancho,alto ) drawArc( x,y,ancho,alto,anguloInicio,anguloArco ) fillArc( x,y,ancho,alto,anguloInicio,anguloArco ) drawPolygon( int[] puntosX,int[] puntosY[],numPuntos ) fillPolygon( int[] puntosX,int[] puntosY[],numPuntos )

109

drawString( string s,x,y ) drawChars( char data[],offset,longitud,x,y ) drawBytes( byte data[],offset,longitud,x,y ) copyArea( xSrc,ySrc,ancho,alto,xDest,yDest )

110

Eventos Java presenta una arquitectura para los eventos que funciona orientada al evento, es decir define clases que se encargan de manejar la interactividad de las aplicaciones con el usuario. El paquete que contiene las clases para manipular los eventos están contenida en la AWT, dentro de java.awt.event. Dentro del AWT, todas las acciones que pueda realizar el usuario caen dentro de un gran saco que son los eventos. Un evento describe, con suficiente detalle, una acción particular del usuario. En lugar de que el programa activamente recoja todos los eventos generados por el usuario, el sistema Java avisa al programa cuando se produce un evento interesante.

111

La Clase Event

Un contenedor soltado en un entorno gráfico se convierte en rápido receptor de eventos de todo tipo, singularmente de los relacionados con el movimiento del ratón, pulsaciones de teclas, creación/movimiento/destrucción de partes gráficas y, por último, los referidos a acciones del usuario respecto de componentes (elección de un menú, pulsación de un botón, etc.).

La clase Event es el jugador principal en el juego de los eventos. Intenta capturar las características fundamentales de todos los eventos que genera el usuario. Los datos miembro de la clase Event son los que se indican a continuación:

id - El tipo de evento que se ha producido

target - Componente sobre el que se ha producido el evento

x, y - Las coordenadas en donde se ha producido el evento relativas al Componente que actualmente está procesando ese evento. El origen se toma en la esquina superior izquierda del Componente

key - Para eventos de teclado, es la tecla que se ha pulsado. Su valor será el valor Unicode del carácter que representa la tecla. Otros valores que puede tomas son los de las teclas especiales como INICIO, FIN, F1, F2, etc.

when - Instante en que se ha producido el evento

modifiers - La combinación aritmética del estado en que se encuentran las teclas modificadoras Mays, Alt, Ctrl.

clickCount - El número de clicks de ratón consecutivos. Sólo tiene importancia en los eventos MOUSE_DOWN

arg - Es un argumento dependiente del evento. Para objetos Button, este objeto arg es un objeto String que contiene la etiqueta de texto del botón

evt - El siguiente evento en una lista encadenada de eventos

Una instancia de la clase Event será creada por el sistema Java cada vez que se genere un evento. Es posible, sin embargo, que un programa cree y envíe eventos a los Componentes a través de su método postEvent().

112

Los eventos se catalogan por su naturaleza, que se indicará en el miembro id de su estructura. Los grandes grupos de eventos son:

Eventos de Ventana

Son los que se generan en respuesta a los cambios de una ventana un frame o un dialogo.

• WINDOW_DESTROY • WINDOW_EXPOSE • WINDOW_ICONIFY • WINDOW_DEICONIFY • WINDOW_MOVED

Eventos de Teclado

Son generados en respuesta a cuando el usuario pulsa y suelta una tecla mientras un Componente tiene el foco de entrada.

• KEY_PRESS • KEY_RELEASE • KEY_ACTION • KEY_ACTION_RELEASE

Eventos de Ratón

Son los eventos generados por acciones sobre el ratón dentro de los límites de un Componente.

• MOUSE_DOWN • MOUSE_UP • MOUSE_MOVE • MOUSE_ENTER • MOUSE_EXIT • MOUSE_DRAG

Eventos de Barras

Son los eventos generados como respuesta a la manipulación de barras de desplazamiento (scrollbars).

• SCROLL_LINE_UP • SCROLL_LINE_DOWN • SCROLL_PAGE_UP • SCROLL_PAGE_DOWN • SCROLL_ABSOLUTE

113

Eventos de Lista

Son los eventos generados al seleccionar elementos de una lista.

• LIST_SELECT • LIST_DESELECT

Eventos Varios

Son los eventos generados en función de diversas acciones.

• ACTION_EVENT • LOAD_FILE • SAVE_FILE • GOT_FOCUS • LOST_FOCUS

Ahora para comprender un poco más lo anteriormente nombrado vamos a graficar lo siguiente: Lo que represento acá en este gráfico, es que al producirse un evento, podemos hacer que todos se vayan al mismo método, denominado handleEvent, y que recibe como parámetro el objeto evt de la clase Event. Posteriormente, podemos obtener el miembro de la clase del objeto evt, como por ejemplo la posición x e y del evento, con evt.x evt.y y si deseamos comparar el id del evento con los presentados anteriormente, por ejemplo si una tecla fue presionada, nos vamos consultar si evt.id == evt.KEY_PRESS, y si esto coincide, podemos tomar acciones para responderle al usuario o manipular nuestro sistema. Vamos a desarrollar una aplicación simple para entender esta forma de generar eventos.

Evento

public bolean handleEvent( Event evt)

evt.<miembros de la clase> ó

evt.<miembros de la clase> == evt.id

114

Necesitaremos JCreator para generar la codificación respectiva. Vamos a generar un frame que va a tener TextFields que van a representar los miembros de la clase Event. Y objetos que van a provocar la interactividad. Inicialmente crearemos un nuevo archivo en JCreator.

El archivo se denominará VisorEventos

Damos “Finish” y comenzamos.

115

Vamos inicialmente a importar el paquete java.awt con todas sus clases. Luego generamos la estructura que tendrá nuestro archivo.

1. Clase VisorEventos que se extiende de Frame 2. Método main 3. Constructor de VisorEventos 4. Método handleEvent(Event evt)

Nuestro archivo debería lucir más o menos así:

Ahora vamos a comenzar a generar la estructura externa que va a presentar nuestro Frame. Comenzamos por inicializar los objetos que van a estar en la pantalla. Deberá lucir más o menos así:

116

Entonces comenzamos a declarar los objetos que irán en nuestra pantalla.

1. Label que se encargará de ir colocando los nombres a la izquierda 2. Los TextFields que irán a la derecha presentando la información 3. Un botón al final junto con Combo con tres números.

Lo anterior debe lucir de la siguiente manera entre el inicio de la clase y el método main (solo por orden se ubica en este sector).

Ahora que tenemos inicializado lo principal, vamos adentrarnos en el constructor VisorEventos. En el visor de eventos vamos a:

1. Entregar el nombre de la ventana y el tamaño al constructor de la superclase. 2. Vamos a crear un Panel 3. Vamos a crear un Layout, que se lo vamos a pasar al panel. (GridLayout) 4. Agregaremos los componentes inicializados anteriormente al Panel 5. Dejaremos sin editar a los TextFields. 6. Vamos a crear un Layout para el Frame (BorderLayout) y se lo entregamos al

Frame. 7. Agregaremos el Panel al centro del Frame (Center). 8. Crearemos un nuevo Panel 9. Agregaremos el botón y el combo al Panel, previamente configurados para lo

que los necesitamos. 10. Agregaremos el Panel al Sur del Frame (South).

Como lucirá todo esto:

118

Configurar los TextFields sin edición.

119

Y así hemos armado nuestra pantalla, pero falta llamarla para poder mostrarla. Vamos al método main, en este método vamos:

1. A agregar una nueva instancia de la clase VisorEventos. 2. vamos a presentar la instancia creada.

Ahora, para poder ver como esta quedando nuestra ventana, vamos a poner una leve edición en el método handleEvent. Vamos a hacer que retorne algo, es decir, como se declara el retorno como bolean, vamos a retornar true, solo para que compile y presente la ventana.

Ahora podemos ejecutar compilar nuestra aplicación y ejecutarla.

120

Vemos que ya va tomando forma:

Ahora solo nos falta ingresar el código en el método que manipula los eventos, el handleEvent. En este método vamos a:

1. Configurar los textos de los TextFields, obteniendo los miembros de la clase Event del objeto evt. Los vamos a convertir a String a través de los métodos de la clase String, valueOf.

2. Veremos si el argumento viene como null o si trae un valor con if corto. 3. Veremos el uso del id, al preguntar por WINDOW_DESTROY, para terminar la

aplicación con System.exit (0); 4. Retornaremos el valor que nos arroje la superclase.

Lo anterior lucirá más menos así:

121

Ahora si compilamos y ejecutamos nuestro trabajo, se vería de la siguiente manera:

Como podemos observar y jugar con nuestra pequeña aplicación, hemos conseguido una herramienta para entender el comportamiento de los miembros de la clase Event. Si movemos el Mouse por el applet, notaremos que las coordenadas van a cambiar, si presionamos el botón, aparecerá el texto del mismo como argumento; a cada evento se va modificando el tiempo en que ha ocurrido, etc. Podemos ir aprendiendo mucho de esta aplicación.

122

Cuando un usuario interactúa con el applet, el sistema Java crea una instancia de la clase Event y rellena sus datos miembros con la información necesaria para describir la acción. Es en ese momento cuando el sistema Java permite al applet controlar el evento. Este control comienza por el Componente que recibe inicialmente el evento (por ejemplo, el botón que ha sido pulsado) y se desplaza hacia arriba en el árbol de Componentes, componente a componente, hasta que alcanza al Contenedor de la raíz del árbol. Durante este camino, cada Componente tiene oportunidad de ignorar el evento o reaccionar ante él en una (o más) de las formas siguientes:

• Modificar los datos miembros de la instancia de Event • Entrar en acción y realizar cálculos basados en la información contenida en el

evento • Indicar al sistema Java que el evento no debería propagarse más arriba en el

árbol

El sistema Java pasa información del evento a un Componente a través del método handleEvent() del Componente. Todos los métodos handleEvent() deben ser de la forma: public boolean handleEvent( Event evt ) Un controlador de eventos solamente necesita una información: una referencia a la instancia de la clase Event que contiene la información del evento que se ha producido. El valor devuelto por el método handleEvent() es importante. Indica al sistema Java si el evento ha sido o no completamente controlado por el controlador. Un valor true indica que el evento ha sido controlado y que su propagación debe detenerse. Un valor false indica que el evento ha sido ignorado, o que no ha sido controlado en su totalidad y debe continuar su propagación hacia arriba en el árbol de Componentes. El método handleEvent() es un lugar para que el programador pueda insertar código para controlar los eventos. A veces, sin embargo, un Componente solamente estará interesado en eventos de un cierto tipo (por ejemplo, eventos del ratón). En estos casos, el programador puede colocar el código en un método de ayuda, en lugar de colocarlo en el método handleEvent().

123

No hay métodos de ayuda para ciertos tipos de eventos, aquí está la lista de los que están disponibles para los programadores: action( Event evt,Object obj ) gotFocus( Event evt,Object obj ) lostFocus( Event evt,Object obj ) mouseEnter( Event evt,int x,int y ) mouseExit( Event evt,int x,int y ) mouseMove( Event evt,int x,int y ) mouseUp( Event evt,int x,int y ) mouseDown( Event evt,int x,int y ) mouseDrag( Event evt,int x,int y ) keyDown( Event evt,int key ) keyUp( Event evt,int key ) false indicará que el método de ayuda no maneja el evento. La implementación del método handleEvent() proporcionada por la clase Component invoca a cada método de ayuda. Por esta razón, es importante que las implementaciones redefinidas del método handleEvent() en clases derivadas, siempre finalicen con la sentencia: return( super.handleEvent( evt ) ); El siguiente trozo de código ilustra esta regla. public boolean handleEvent( Event evt ) { if( evt.target instanceof MiBoton ) { // Hace algo... return true; } return( super.handleEvent( evt ) ); } No seguir esta regla tan simple hará que no se invoquen adecuadamente los métodos de ayuda.

124

ACTION_EVENT Algunos de los eventos que más frecuentemente tendremos que controlar son los siguientes: ACTION_EVENT MOUSE_DOWN KEY_PRESS WINDOW_DESTROY En la documentación de la clase Event se encuentra toda la lista de eventos que cualquier aplicación puede necesitar manejar y su documentación; como ejemplo de uso vamos a detenernos en el primero de ellos, ACTION_EVENT. Como ejemplo del manejo de eventos vamos a ver este evento que se provoca al pulsar un botón, seleccionar un menú, etc. Para su control podemos manejarlo en el método handleEvent() o en el método action(). Los dos métodos anteriores pertenecen a la clase Component por lo que todas las clases derivadas de ésta contendrán estos dos métodos y se pueden sobrecargar para que se ajuste su funcionamiento a lo que requiere nuestra aplicación. Veamos el siguiente ejemplo, en que se controla este evento a través del método handleEvent(), que es el método general de manejo de eventos: public boolean handleEvent( Event evt ) { switch( evt.id ) { case Event.ACTION_EVENT: // evt.arg contiene la etiqueta del botón pulsado // o el item del menú que se ha seleccionado if( ( "Pulsado "+n+" veces" ).equals( evt.arg ) ) return( true ); default: return( false ); } } Pero en este caso, cuando se produce este evento se llama al método action(), que sería: public boolean action( Event evt,Object arg ) { if( ( "Pulsado "+n+" veces" ).equals( arg ) ) return( true ); return( false ); } Como se puede comprobar, incluso si las etiquetas cambian se puede recibir el evento. Los ejemplos anteriores corresponden al control de un evento producido por

125

un botón que cambia su etiqueta cada vez que se pulsa. Aunque esta no es la única forma de manejar eventos; de hecho se puede hacer: if( evt.target == miBoton ) En donde se comparan objetos en lugar de etiquetas. Es así como se presenta una forma de manipular los eventos en Java.

Manual+Java+UML+Básico

Documents

Transcript of Manual+Java+UML+Básico