INSTITUTO DE TECNOLOGÍA Y COMPUTACIÓN

MANUAL de JAVA y UML Básico

2006

CESAR ROJAS MORAGA

RELATOR
Í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

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

3
 MANUAL DE JAVA

CAPITULO 1: INTRODUCCION

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

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

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

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

Computador Local Computador Servidor (Host)

Sistema Operativo

Navegador Java
Código
Fuente
Máquina Virtual Java Código Nativo Java

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

8
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 1998, versión ampliada significativamente, incluye una nueva
1.2 interfaz gráfica de usuario, conectividad a bases de datos y
muchas otras mejoras.
Java 2 con SDK 2000, añade características notables como multimedia
1.3 mejorada, más accesibilidad y compilación más rápida.
Java 2 con SDK 2001, introduce la posibilidad de trabajar con XML
1.4
Java 2 con SDK
1.5

9
 MANUAL DE JAVA

CAPITULO 2: PROGRAMACION ORIENTADA

A OBJETOS

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

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

Animal

Mamífero

Perro

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

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

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

Editar y crear un
nuevo archivo .java

Compilar Editar y corregir

Errores errores de compilación

No existen errores

Ejecutar Programa Editar para corregir o

ampliar

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

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

15
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

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

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

18
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”.

19
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:

Holamundo.java

Javac Holamundo.java

Holamundo.class (en Bytecode)

Java Holamundo Java Holamundo Java Holamundo

(Solaris) (Windows) (Otra Maquina y S.O.)
Esto nos demuestra que Java es multiplataforma, ya que su JVM ejecuta su
Bytecode en cualquier máquina en la cual este instalada.

20
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

21
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”);
}

22
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

23
 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:

24
 • 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…
}

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

Este ejemplo nos entrega la siguiente salida.

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

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

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

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

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

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

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

33
 MANUAL DE JAVA

CAPITULO 4: PROGRAMACION ORIENTADA

A OBJETOS CON JAVA

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

(x,y)

v (x2+y2)

(0,0) X

Vamos a programar lo siguiente, en un diagrama de clases de UML se vería así:

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

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

37
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;
}

38
É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.

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

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

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

42
 MANUAL DE JAVA

CAPITULO 5: INTRODUCCIÓN A UML

43
 MANUAL DE JAVA

CAPITULO 6: PAQUETES DE JAVA

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

45
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 ejem plo, 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.

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

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

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

49
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

50
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
com.sun.java.swing.event
com.sun.java.swing.filechooser
com.sun.java.swing.plaf.*
com.sun.java.swing.table
com.sun.java.swing.text.*
com.sun.java.swing.tree
com.sun.java.swing.undo
Admite clases para los componentes del color
Clases para los eventos propios de swing
Admite clases para seleccionar archivos
Clases para trabajar con módulos conectables
Clases que admiten el uso de las tablas
Clases que admiten componentes de texto,
incluyendo HTML y Rich Text Format(RTF)
Clases que admiten componentes de árboles
Clases que pueden trabajar con las
implementación deshacer/rehacer

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

52
 MANUAL DE JAVA

CAPITULO 7: MANEJO DE ARCHIVO EN JAVA

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

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

55
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
FileInputStream
ByteArrayInputStream
PipeInputStream
SequenceInputStream
StringBuffereInputStream
FilterInputStream
OutputStream
FileOutputStream
ByteArrayOutputStream
PipeOutputStream
FilterOutputStream

56
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

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

58
59
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.

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

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

62
63
MANUAL DE JAVA

CAPITULO 8: APPLETS

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

65
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

66
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

67
á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

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

69
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>

70
 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:

71
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(){

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

73
 MANUAL DE JAVA

CAPITULO 9: INTERFASES GRÁFICAS DE

USUARIO EN JAVA

74
75
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.

76
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 Compone ntes, 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

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

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

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

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

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

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

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

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

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

86
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

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

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

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

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

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

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

93
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 i nterfaz LayoutManager.

94
Continuación.

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

Vista del Applet

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

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

98
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:

99
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:

100
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:

101
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:

102
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:

103
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:

104
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:

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

106
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

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

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

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

110
La Clase E vent

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

111
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

112
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:

Evento

public bolean handleEvent( Event evt)

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

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.

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

114
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í:

115
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:

116
117
Configurar los TextFields sin edición.

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

119
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í:

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

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

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

123
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

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

125