Libro Java

Escuela de Ingeniera en Computacin
Universidad de La Serena.
LECTURAS PARA PROGRAMACIN ORIENTADA A

OBJETOS UTILIZANDO
Dr. Eric Jeltsch F.

Agosto 2007.
INDICE
I N D I C E ............................................................................................................................................................... 2
C A P I T U L O I .................................................................................................................................................... 4
Caractersticas de la Poo ................................................................................................................................... 10
C A P I T U L O II................................................................................................................................................. 25
Elementos Bsicos en todo programa Java: Objetos y Mtodos. ....................................................................... 28
Como construyo programas? ............................................................................................................................. 29
Primer encuentro con POO, el mtodo System.out.println ............................................................................... 30
Cmo edito un programa?.................................................................................................................................. 30
Cmo ejecuto un programa Java ........................................................................................................................ 31
Java, una Plataforma Independiente .................................................................................................................. 33
Una visin de la plataforma JDK ....................................................................................................................... 35
Instalacin de Java ............................................................................................................................................. 36
C A P I T U L O III ............................................................................................................................................... 42
Elementos del Lenguaje...................................................................................................................................... 42
Tipos de Datos y Strings ..................................................................................................................................... 42
Algunos Operadores ........................................................................................................................................... 43
Variables ............................................................................................................................................................ 43
Asignaciones....................................................................................................................................................... 45
Punto Flotante. ................................................................................................................................................... 46
Funciones Estndares ........................................................................................................................................ 47
Clases de I/O ...................................................................................................................................................... 49
ConsoleReader ................................................................................................................................................... 52
hsa.* ................................................................................................................................................................... 53
Swing .................................................................................................................................................................. 54
Strings................................................................................................................................................................. 57
C A P T U L O IV ................................................................................................................................................ 63
Decisiones (if)..................................................................................................................................................... 63
Ciclos .................................................................................................................................................................. 76
C A P I T U L O V ................................................................................................................................................. 86
Excepciones y Flujo de Datos (Exceptions y Streams) ...................................................................................... 86
Como leer archivos de texto ............................................................................................................................... 95
Leer de un Archivo de Texto ............................................................................................................................. 104
Escribiendo un Archivo de Texto ...................................................................................................................... 106
Archivos y Filtros. ............................................................................................................................................ 107
Excepciones y Flujo de Datos (Exceptions y Streams) .................................................................................... 110
Diagnostico de los errores en Expresiones y Variables ................................................................................... 111
Excepciones ...................................................................................................................................................... 114
Leer desde el teclado ........................................................................................................................................ 117
Como leer archivos de texto ............................................................................................................................. 120
Leer de un Archivo de Texto ............................................................................................................................. 128
Escribiendo un Archivo de Texto ...................................................................................................................... 131
Archivos y Filtros. ............................................................................................................................................ 132
Dr. Eric Jeltsch F.
Captulo I: Programacin Orientada a Objetos
C A P T U L O VI ............................................................................................................................................. 135
Programacin Orientada a Objetos en Java .................................................................................................... 135
Clases y Objetos ............................................................................................................................................... 136
Instancias de una Clase .................................................................................................................................... 137
Constructores ................................................................................................................................................... 138
Variables en la clase ........................................................................................................................................ 139
Clase como Tipo ............................................................................................................................................... 139
Expresiones para instanciar ............................................................................................................................. 140
Mtodos Instanciados ....................................................................................................................................... 140
La palabra clave this ........................................................................................................................................ 141
Mtodos en las Clases ...................................................................................................................................... 142
Implementando Estructuras de Datos .............................................................................................................. 142
Listas ................................................................................................................................................................ 142
Arboles AVL ..................................................................................................................................................... 144
Jerarquia de Clases .......................................................................................................................................... 157
Herencia ........................................................................................................................................................... 158
Jerarquia de clases en Java.............................................................................................................................. 160
Herencia y Constructores ................................................................................................................................. 161
Dynamic Binding .............................................................................................................................................. 162
Polimorfismo .................................................................................................................................................... 162
Sobreescritura de mtodos ............................................................................................................................... 163
Clases Abstractas y Mtodos Abstractos .......................................................................................................... 163
Interfaces .......................................................................................................................................................... 165
Paquetes ........................................................................................................................................................... 168
Declaracin import ......................................................................................................................................... 168
Java-Paquetes Estandar ................................................................................................................................... 169
Programacin Orientada a Objetos comparada con la Programacin de Procesos y programacin orientada a
eventos. ............................................................................................................................................................. 169
C A P I T U L O VII ............................................................................................................................................ 181
Eventos (Events) ............................................................................................................................................... 181
Eventos ............................................................................................................................................................. 182
GUI Minimo-Minimorum: ............................................................................................................................... 186
Estuctura de una Aplicacin Swing. ................................................................................................................. 189
C A P T U L O VIII. .......................................................................................................................................... 203
Swing ................................................................................................................................................................ 203
C A P T U L O IX ............................................................................................................................................. 221
Swing: Eventos de Ratn y Movimientos del Ratn ......................................................................................... 221
C A P I T U L O X .............................................................................................................................................. 232
GUI Avanzado (con Swing) .............................................................................................................................. 232
C A P T U L O XI .............................................................................................................................................. 245
GUI Avanzado (con Swing) .............................................................................................................................. 245
Ingeniera en Computacin, Universidad de La Serena
CAPITULO I
PROGRAMACIN ORIENTADA A OBJETOS
La programacin orientada a objetos proporciona una forma de ver los programas en funcin de
los datos y los mtodos que operan sobre ellos. En la programacin orientada a objetos, la
atencin se aleja de las funciones y se acerca a las cosas (objetos) que componen el programa.
Las diferencias bsicas entre la programacin orientada a objetos y el enfoque de procesos,
eventos u aspectos, pueden agruparse en cuatro principios bsicos: abstraccin, encapsular,
herencia y polimorfismo.
Abstraccin es el proceso de ignorar temporalmente los detalles subyacentes al objeto, para
centrar la atencin en el problema u objeto y as extraer sus caractersticas esenciales. Por
ejemplo, si se consideran los neumticos de un auto, el neumtico abstracto puede tener una
marca, tamao precio y una cantidad ideal de aire. Estas caractersticas se aplican a todos los
neumticos. Al utilizar la abstraccin es posible centrar la atencin sobre estas caractersticas
(comunes), en lugar de hacerlo sobre los detalles de un tipo especfico de neumtico.
Encapsular es el proceso de agrupar la informacin abstrada del objeto con las operaciones
(mtodos) que un programa puede realizar sobre los datos. Por ejemplo, una clase es el
encapsulado de los datos y mtodos de un objeto.
Herencia es un marco en el cual se pueden crear nuevas clases al introducir nuevas
caractersticas o cambios a clases ya existentes. La herencia libera al programador de la tarea de
reescribir funciones cuando se deben hacer pequeos cambios.
Finalmente, el Polimorfismo es la habilidad que tiene un objeto de tomar diferentes formas. El
prefijo poli significa muchas; morfismo formas. Por ejemplo, en un programa, un objeto
polimorfo que represente un telfono puede cambiar de forma para representar un telfono de
tonos, un telfono de pulsos o incluso un telfono celular.
Como puede notar algunos conceptos de la POO son anlogos a los mtodos de programacin
convencional, por ejemplo. Un mtodo es como un procedimiento porque ambos contienen
instrucciones de procesamiento. Las variables de clase y modelo se correlacionan a los datos de
la programacin tradicional. Los mtodos y datos son diferentes porque los procedimientos no
estn encapsulados normalmente con los datos que manipulan. Una clase es como un tipo
abstracto de datos, aunque para la POO, el proceso de escribir no se revela fuera de la clase. La
herencia no tiene analoga inmediata en la programacin convencional. El paso de mensajes
reemplaza a las llamadas de funcin como mtodo principal de control en los sistemas orientados
a objeto. Con las llamadas de funciones, los valores se presentan y el control regresa a la funcin
que efecta la llamada. Por el contrario, los objetos entran en accin gracias a los mensajes, y el
control est distribuido.
Considere como ejemplo, una entidad bancaria. En ella identificamos entidades que son cuentas:
cuenta_del_cliente1, cuenta_del_cliente2, etc. Al mismo tiempo, una cuenta puede
verse como un objeto que tiene atributos. Por ejemplo, nombre, nmero_de_cuenta y saldo, y
Dr. Eric Jeltsch F.
un conjunto de mtodos como IngresarDinero, RetirarDinero, AbonarIntereses, SaldoActual,

Transferencia etc. En el caso de una transferencia, se podra escribir por ejemplo,
cuenta_del_clientel.Transferencia(cuenta_del_cliente2);
cuyo significado sera que, Transferencia es el mensaje que el objeto cuenta_del_cliente2

enva al objeto cuenta_del_cliente1, solicitando le sea hecha una transferencia, siendo la
respuesta a tal mensaje la ejecucin del mtodo Transferencia. Trabajando a este nivel de
abstraccin, manipular una entidad bancaria resultar algo muy sencillo.
Mecanismos Bsicos de la Poo

Objetos
Un programa OO se compone solamente de objetos, entendiendo por objeto una encapsulacin
genrica de propiedades o datos y de los mtodos para manipularlos. Por ejemplo una ventana de
Windows es un objeto, en donde, el color de fondo, la altura, la anchura son propiedades,
mientras que las rutinas (transparentes al usuario), que permiten maximizar o minimizar la
ventana son mtodos.
Mensajes
Cuando se ejecuta un programa OO los objetos estn recibiendo, interpretando y respondiendo a
mensajes de otros objetos. De manera que en la POO un mensaje est asociado con un mtodo. Si
continuamos con el ejemplo de la ventana de Windows, digamos que cuando un usuario desea
maximizar una ventana, lo que hace es pulsar el botn de la misma que realiza esa accin, esto es
que Windows enve un mensaje a la ventana para indicarle que tiene que maximizarse, y como
respuesta a este mensaje se ejecutar el mtodo programado para ese fin.
Mtodos
Un mtodo se implementa en una clase de objetos y determina cmo tiene que actuar el objeto
para cuando recibe el mensaje vinculado con ese mtodo. De la misma manera un mtodo puede
tambin enviar mensajes a otros objetos solicitando una accin o informacin.
Cuando se disea una clase de objetos, la estructura ms interna del objeto se oculta a los
usuarios que lo vayan a utilizar, manteniendo como nica conexin con el exterior, los mensajes.
Esto es, los datos que estn dentro de un objeto solamente podrn ser manipulados por los
mtodos asociados al propio objeto. Segn lo expuesto, podemos decir que la ejecucin de un
programa orientado a objetos realiza fundamentalmente tres cosas:
1. Crea los objetos necesarios.
2. Los mensajes enviados a unos y a otros objetos dan lugar a que se procese internamente la
informacin.
3. Finalmente, cuando los objetos no son necesarios, son borrados, liberndose la memoria
ocupada por los mismos.
Dr. Eric Jeltsch F.
Clases
Una clase es un tipo de objetos definido por el usuario. Una clase equivale a la generalizacin de
un tipo especfico de objetos. Por ejemplo, Empleado.
Empleado
No obstante esta clase puede expandirse para incluir atributos, en este caso apellido, nombre, rut
y sexo. Para tal efecto, todos los atributos son definidos en la clase a travs de variables, es as
como la clase adquiere la siguiente forma:
Cdigo Java
class Empleado {
String apellido;
String nombre;
int rut;
boolean esFemenino;
}
UML
Empleado
apellido: String
nombre: String
rut:
int
esFemenino: boolean
Adems, si Ud. desea puede definir que los atributos tengan algunas propiedades, tales como
privado (-), pblico(+) o protegido(#). En tal caso queda,
Cdigo Java
public class Empleado {
private
String apellido;
private
String nombre;
private
int rut;
private
boolean esFemenino;
}
UML
Empleado
-
apellido: String
nombre: String
rut:
int
esFemenino: boolean
Por otro lado cabe preguntarse que deseo hacer con la clase Empleado?. Por ejemplo se desea
registrar horas de trabajo, horas extraordinarias, sueldo, viticos, u otros. En tal caso, se deben
implementar ciertos mtodos que realicen sta tarea.
Segn lo expuesto hasta ahora, un objeto contiene, por una parte, atributos que definen su estado,
y por otra, operaciones que definen su comportamiento. Tambin sabemos que un objeto es la
representacin concreta y especfica de una clase. Cmo se escribe una clase de objetos? Como
ejemplo, podemos crear una clase PC1.
Ejemplo 1.
public class PC1 {
String marca;
String procesador;
String pantalla;
boolean PC1_Encendido;
boolean presentacion;
}
Dr. Eric Jeltsch F.
en esta oportunidad se han definido 5 atributos. Veamos ahora, desde un punto de vista prctico,
que acciones seran convenientes considerar, por ejemplo, ponerse en marcha, apagarse, cargar
una aplicacin, desactivar algn proceso o activar otro, etc. Ahora para implementar este
comportamiento hay que crear mtodos. Los mtodos son rutinas de cdigo definidas dentro de la
clase, que se ejecutan en respuesta a alguna accin tomada desde dentro de un objeto de esa clase
o desde otro objeto de la misma o de otra clase, recuerde que los objetos se comunican mediante
mensajes.
Ejemplo 2.
public class PC1
{
String marca;
String procesador;
String pantalla;
boolean presentacin;
//mtodo de la clase
void EncenderPC1()
{
if (PC1_Encendido == true) // si est encendido...
System.out.println("El PC ya est encendido.");
else // si no est encendido, encenderlo.
{
PC1_Encendido = true;
System.out.println("El PC se ha encendido.");
}
}
//mtodo de la clase
void Estado() {
System.out.println("\nEstado del PC:" +
"\nMarca " + marca +
"\nProcesador " + procesador +
"\nPantalla " + pantalla + "\n");
if (PC1_Encendido == true) // si el ordenador est encendido...
System.out.println("El PC est encendido.");
else // si no est encendido...
System.out.println("El PC est apagado.");
}
//mtodo de la clase, llamada clase principal
public static void main (String[] args)
{
PC1 miPC1 = new PC1();
miPC1.marca = "Dell";
miPC1.procesador = "Intel Pentium";
miPC1.pantalla = "AOC";
miPC1.EncenderPC1();
miPC1.Estado();
}
}
Dr. Eric Jeltsch F.
Como se puede observar un mtodo consta de su nombre precedido por el tipo del valor que
devuelve cuando finalice su ejecucin (la palabra reservada void indica que el mtodo no
devuelve ningn valor y seguido por una lista de parmetros separados por comas y encerrados
entre parntesis (en el ejemplo, no hay parmetros). Los parntesis indican a Java que el
identificador EncenderPC1() se refiere a un mtodo y no a un atributo. A continuacin se
escribe el cuerpo del mtodo encerrado entre {y}. Usted ya conoce algunos mtodos, llamados
en otros contextos funciones; seguro que conoce la funcin logaritmo que devuelve un valor real
correspondiente al logaritmo del valor pasado como argumento. Otro mtodo es Estado()que
visualiza los atributos especficos de un objeto. Finalmente para poder crear objetos de esta clase
y trabajar con ellos, tendr que aadir a esta clase el mtodo main(), tal como se hizo aqu, o
bien escribir un programa principal, tal como se muestra a continuacin, en donde MiPC.java
esta en un directorio y el archivo PC2.class en el mismo, de otra manera no se entendera el
llamado que se hace. A continuacin se visualiza un tpico mensaje de error de esta naturaleza.
C:\Documents and
Settings\usuario\Escritorio\POO\curso_poo_2006\MiPC.java:5:
cannot resolve symbol
symbol : class PC2
location: class MiPC
^
C:\Documents and
Settings\usuario\Escritorio\POO\curso_poo_2006\MiPC.java:5:
symbol : class PC2
location: class MiPC
^
2 errors
En resumen, Herramienta
las bibliotecas
de clases
y los marcos
proporcionan una excelente
completada
con cdigo
de salidaestructurales
1
plataforma para el desarrollo de las aplicaciones orientadas a objetos y la reutilizacin del cdigo.
Dr. Eric Jeltsch F.
Ejemplo 3.
public class MiPC {
public static void main (String[] args)
miPC2.marca = "Dell";
miPC2.procesador = "Intel Pentium";
miPC2.pantalla = "AOC";
miPC2.EncenderPC2();
miPC2.Estado();
}
}
//mtodo de la clase
class PC2{
String marca;
String procesador;
String pantalla;
boolean presentacin;
//mtodo de la clase
void EncenderPC2() {
if (PC2_Encendido == true) // si est encendido...
System.out.println("El ordenador ya est encendido.");
else // si no est encendido, encenderlo.
{
PC2_Encendido = true;
System.out.println("El ordenador se ha encendido.");
}
}
//mtodo de la clase
void Estado()
{
System.out.println("\nEstado del ordenador:" +
"\nMarca " + marca +
"\nProcesador " + procesador +
"\nPantalla " + pantalla + "\n");
if (PC2_Encendido == true) // si el ordenador est encendido...
System.out.println("El ordenador est encendido.");
else // si no est encendido...
System.out.println("El ordenador est apagado.");
}
}
Dr. Eric Jeltsch F.
Caractersticas de la Poo
Las caractersticas fundamentales de la POO son: encapsulacin, herencia, abstraccin, y
polimorfismo.
Encapsulamiento
La encapsulacin es el trmino formal que describe el conjunto de mtodos y datos dentro de un
objeto de forma que el acceso a los datos se permite solamente a travs de los mtodos del objeto.
Esta caracterstica permite entonces ver un objeto como una caja negra en la que se ha
introducido de alguna manera toda la informacin relacionada con dicho objeto, permitiendo
manipular los objetos como unidades bsicas, permaneciendo oculta su estructura interna.
Generalmente los atributos de una clase de objetos se declaran privados, estando as oculto para
otras clases, siendo posible el acceso a los mismos nicamente a travs de los mtodos pblicos
de dicha clase. El mecanismo de ocultacin de miembros se conoce en la POO como
encapsulacin. El nivel de proteccin predeterminado para un miembro de una clase es el de
package (paquete), habiendo otros tales como, public, private y protected.
Ejemplo 4.
/**
* Conversin de grados centgrados a fahrenheit:
* F = 9/5 * C + 32
*/
import java.lang.System;
// importar la clase System
public class CApGrados {

// Definicin de constantes
final static int limInferior = -30;
final static int limSuperior = 100;
final static int incremento = 6;
public static void main(String[] args)
// Declaracin de variables
CGrados grados = new CGrados();
int gradosCent = limInferior;
float gradosFahr = 0;
while (gradosCent <= limSuperior) // while ... hacer:

{
// Asignar al objeto grados el valor en grados centgrados
grados.CentgradosAsignar(gradosCent);
// Obtener del objeto grados los grados fahrenheit
gradosFahr = grados.FahrenheitObtener();
// Escribir la siguiente lnea de la tabla
System.out.println(gradosCent + " C" + "\t" + gradosFahr + " F");
// Siguiente valor
gradosCent += incremento;
}
}
}
/**
* Clase CGrados. Un objeto de esta clase almacena un valor
* en grados centgrados.
* Atributos:
*
gradosC
10
Dr. Eric Jeltsch F.
* Mtodos:
*
CentgradosAsignar, FahrenheitObtener y CentgradosObtener
*/
class CGrados
{
private float gradosC; // grados centgrados
public void CentgradosAsignar(float gC)
{
// Establecer el atributo grados centgrados
gradosC = gC;
}
public float FahrenheitObtener()
{
// Retornar los grados fahrenheit equivalentes a gradosC
return 9F/5F * gradosC + 32;
}
public float CentgradosObtener()
{
return gradosC; // retornar los grados centgrados
}
}
Tomando la clase CGrados, podemos advertir que contiene atributos private como gradosC, lo
que significa que un miembro de una clase declarado private puede ser accedido nicamente
por los mtodos de su clase, es decir, el atributo gradosC es accedido por el mtodo
CentgradosAsignar(). En la eventualidad que un mtodo de otra clase, por ejemplo el
mtodo main de la clase class CApGrados, incluyera una declaracin, tal como
grados.gradosC = 30; el compilador debera mostrar un error, indicando que el miembro
gradosC no es accesible desde esta clase, por tratarse de un miembro privado de Cgrados. Si
por otra parte, un miembro de una clase declarado public es accesible desde cualquier mtodo
definido dentro o fuera de la clase o paquete actual. Por ejemplo, en la clase CApGrados, se puede
observar cmo el ojeto grados de la clase CGrados creado en el mtodo main accede a su
mtodo CentgradosAsignar(), con el fin de modificar el valor de su miembro privado
gradosC.
En este sentido se dice que la clase CGrados encapsula una estructura de datos formada por un
float llamado gradosC, y que para acceder a esta estructura proporciona la interfaz pblica
formada
por
los
mtodos
CentgradosAsignar,
FahrenheitObtener
y
CentgradosObtener.
Herencia Simple en Java

La herencia permite el acceso automtico a la informacin contenida en otras clases. De esta
forma se garantiza la reutilizacin de cdigo. A travs de la herencia existe una estricta
jerarquerizacin, es decir cada clase tiene su superclase que es la clase superior en la jerarqua y
por otra parte ella podr tener subclases, que son las clases inferiores a ella. Las clases inferiores
se suponen que heredan de las clases que estn en la parte superior, esto significa tambin que las
subclases disponen de todos los mtodos y propiedades de su superclase, proporcionando con ello
un mecanismo rpido y cmodo de extender la funcionalidad de una clase. En Java cada clase
11
Dr. Eric Jeltsch F.
slo puede tener una superclase, llamada herencia simple, mientras que C++ y otros lenguajes
orientados a objeto las clases pueden tener ms de una superclase, conocida como herencia
mltiple. En esta ltima situacin una clase comparte los mtodos y propiedades de varias clases.
La forma de cmo Java supera esta situacin es a travs de la implementacin de interfaces. Una
interface es una coleccin de nombres de mtodos, sin incluir su implementacin y que pueden
ser aadidas a cualquier clase para proporcionarle comportamientos adicionales no incluidos en
los mtodos propios o heredados.
Por ejemplo pensemos en la clase Empleado definida como:
Ejemplo 5.
class Empleado {
String nombre;
int numEmpleado, sueldo;
static private int contador = 0;
//definir un constructor
Empleado(String nombre, int sueldo) {
/*Algunas veces un mtodo necesita hacer referencia al objeto que lo invoc, para
permitir esto Java define la palabra clave this, que puede ser usado dentro de
cualquier mtodo para referirse al objeto actual. Por ejemplo, */
this.nombre = nombre;
this.sueldo = sueldo;
numEmpleado = ++contador;
}
public void aumentarSueldo(int porcentaje) {
sueldo += (int)(sueldo * aumento / 100);
}
public String toString() {
return "Num. empleado " + numEmpleado + " Nombre: " + nombre +
" Sueldo: " + sueldo;
}
}
En el ejemplo, Empleado se caracteriza por un nombre (String) y por un nmero de empleado y

sueldo (enteros). La clase define un constructor que asigna los valores de nombre y sueldo y
calcula el nmero de empleado a partir de un contador (variable esttica que siempre ir
aumentando), y dos mtodos, uno para calcular el nuevo sueldo cuando se produce un aumento
de sueldo (mtodo aumentarSueldo) y un segundo que devuelve una representacin de los datos
del empleado en un String.(mtodo toString).
Con esta representacin podemos pensar en otra clase que reuna todas las caractersticas de
Empleado y aada alguna propia. Por ejemplo, la clase Ejecutivo. A los objetos de esta clase se
les podra aplicar todos los datos y mtodos de la clase Empleado y aadir algunos, como por
ejemplo el hecho de que un Ejecutivo tiene un presupuesto. As diriamos que la clase
Ejecutivo extiende o hereda la clase Empleado. Esto en Java se hace con la clausula extends
que se incorpora en la definicin de la clase, de la siguiente forma:
12
Dr. Eric Jeltsch F.
Ejemplo 6.
class Ejecutivo extends Empleado {
int presupuesto;
void asignarPresupuesto(int p) {
presupuesto = p;
}
}
Con esta definicin un Ejecutivo es un Empleado que adems tiene algn rasgo distintivo
propio. El cuerpo de la clase Ejecutivo incorpora slo los miembros que son especficos de esta
clase, pero implcitamente tiene todo lo que tiene la clase Empleado. A Empleado se le llama
clase base o superclase y a Ejecutivo clase derivada o subclase.
Los objetos de las clases derivadas se crean igual que los de la clase base y pueden acceder tanto
sus datos y mtodos como a los de la clase base. Por ejemplo:
Ejecutivo jefe = new Ejecutivo( "Armando Mucho", 1000);
jefe.asignarPresupuesto(1500);
jefe.aumentarSueldo(5);
Nota: La discusin acerca de los constructores la veremos un poco ms adelante.

Observar que un Ejecutivo ES un Empleado, pero lo contrario no es cierto. Si escribimos:
Empleado curri = new Empleado ("Esteban", 100);
curri.asignarPresupuesto(5000); // error
se producir un error de compilacin pues en la clase Empleado no existe ningn mtodo llamado
asignarPresupuesto.
En la prctica, se muestra otro ejemplo de herencia simple.

Ejemplo 7.
// Crea una superclass.
class A {
int i, j;
void showij() {
System.out.println("i y j: " + i + " " + j);
}
}
// Crea una subclass .
class B extends A {
int k;
void showk() {
System.out.println("k: " + k);
}
void sum() {
System.out.println("i+j+k: " + (i+j+k));
13
Dr. Eric Jeltsch F.
}
}
class SimpleHerencia {
public static void main(String args[]) {
A superOb = new A();
B subOb = new B();
// la superclass puede ser usada por ella misma.
superOb.i = 10;
superOb.j = 20;
System.out.println("Contenido de superOb: ");
superOb.showij();
System.out.println();
/* La subclass tiene acceso a todos los miembros public
de su superclass. */
subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
System.out.println("Contenido de subOb: ");
subOb.showij();
subOb.showk();
System.out.println("Sum de i, j y k en subOb:");
subOb.sum();
}
}
Como se puede ver, la subclase B incluye todos los miembros de su superclase A, por lo que
subOb puede acceder a las variables i y j, y llamar al mtodo showij(). Dentro se sum(),
tambin se pueden referenciar directamente las variables i y j, como si fuesen parte de B.
Abstraccin
Por medio de la abstraccin conseguimos no detenernos en los detalles, sino generalizar y

centrarse en los aspectos que permitan tener una visin global del problema. Por ejemplo el
estudio de un PC podra realizarlo a nivel de circuitos electrnicos, o a travs de transferencias
entre registros, en tal caso el estudio debera centrarse en el flujo de la informacin entre las
unidades (memoria, unidad aritmtica, unidad de control, etc.), sin importar el comportamiento
de los circuitos electrnicos que componen estas unidades. Es decir, cuando se desarrolla una
jerarqua de clases en que algn comportamiento est presente en todas ellas pero se materializa
de forma distinta para cada una. Por ejemplo, pensemos en una estructura de clases para
manipular figuras geomtricas.
clase Abstracta
Circulo
Fig_Geo
Triangulo
Poligono
14
Dr. Eric Jeltsch F.
Podramos pensar en tener una clase genrica, que podra llamarse Fig_Geo y una serie de clases
que extienden a la anterior que podran ser Circulo, Poligono, etc.
Podra haber un mtodo dibujar dado que sobre todas las figuras puede llevarse a cabo esta
accin, pero las operaciones concretas para llevarla a cabo dependen del tipo de figura en
concreto (de su clase). Por otra parte la accin dibujar no tiene sentido para la clase genrica
Fig_Geo, porque esta clase representa una abstraccin del conjunto de figuras posibles.
Para resolver esta problemtica Java proporciona las clases y mtodos abstractos. Un mtodo
abstracto es un mtodo declarado en una clase para el cual esa clase no proporciona la
implementacin (el cdigo). Una clase abstracta es una clase que tiene al menos un mtodo
abstracto. Una clase que extiende a una clase abstracta debe implementar los mtodos abstractos
(escribir el cdigo) o bien volverlos a declarar como abstractos, con lo que ella misma se
convierte tambin en clase abstracta.
Siguiendo con el ejemplo del apartado anterior, se puede escribir:
Ejemplo 8.
abstract class Fig_Geo {
. . .
abstract void dibujar();
. . .
}
class Circulo extends Fig_Geo {
. . .
void dibujar() {
// codigo para dibujar Circulo
. . .
}
}
La clase abstracta se declara simplemente con el modificador abstract en su declaracin. Los

mtodos abstractos se declaran tambin con el mismo modificador, declarando el mtodo pero sin
implementarlo (sin el bloque de cdigo encerrado entre {}). La clase derivada se declara e
implementa de forma normal, como cualquier otra. Sin embargo si no declara e implementa los
mtodos abstractos de la clase base (en el ejemplo el mtodo dibujar) el compilador genera un
error indicando que no se han implementado todos los mtodos abstractos y que, o bien, se
implementan, o bien se declara la clase abstracta.
En la prctica, se muestra otro ejemplo de Abstraccin.
Ejemplo 9.
abstract class A {
abstract void callme();
// mtodo en la abstract classes
void callmetoo() {
System.out.println("Este es un mtodo concreto.");
15
Dr. Eric Jeltsch F.
}
}
class B extends A {
void callme() {
System.out.println("B's es una implementacion de callme.");
}
}
class AbstractDemo {
B b = new B();
b.callme();
b.callmetoo();
}
}
En resumen, las clases abstractas dividen los problemas complejos en mdulos sencillos y
ocultan los detalles de la realizacin. La claridad conceptual est presente en el diseo, en el
programa y en la aplicacin final.
Polimorfismo
Esta caracterstica permite implementar mltiples formas de un mismo mtodo, dependiendo

cada una de ellas de la clase sobre la que se realice la implementacin. Esto hace que se pueda
acceder a una variedad de mtodos distintos (todos con el mismo nombre) utilizando el mismo
medio de acceso. La sobreescritura de mtodos constituye la base de uno de los conceptos ms
poderosos de Java llamada la seleccin de mtodo dinmica o dynamic binding, que es el
mecanismo mediante el cual una llamada a una funcin sobrescrita se resuelve en tiempo de
ejecucin, en lugar de compilacin. Esta es una forma muy usual de implementar el
polimorfismo. Por ejemplo
Ejemplo 10.
class A {
void callme() {
System.out.println("Dentro de A llamando a callme()");
}
}
class B extends A {
// sobre escritura callme()
void callme() {
16
Dr. Eric Jeltsch F.
System.out.println("Dentro de B llamando a callme()");

}
}
class C extends A {
// sobreescritura callme()
void callme() {
System.out.println("Dentro de C llamando a callme()");
}
}
class Despacho {
A a = new A(); // objeto de tipo A
B b = new B(); // objeto de tipo B
C c = new C(); // objeto de tipo C
A r; // obteniendo una referencia de tipo A
r = a; // r referencia a un objeto A
r.callme(); // llamando a la version A de callme()
r = b; // r referencia a un objeto B
r.callme(); // llamando a la version B de callme()
r = c; // r referencia a un objeto C
r.callme(); // llamando a la version C de callme()
}
}
Veamos ahora en general, a travs de un ejemplo una visin de lo tratado y lo que se aproxima a
travs del curso.
Ejemplo 11.
/************************************************************************
* Una clase para representar un empleado. Un ejemplo.
*
***********************************************************************/
public class Empleado {
protected String nombre; // nombre del empleado
protected String jobT; // trabajo del empleado, el ttulo
protected double jornal; // horas asociadas al jornal del empleado
// el monto de dinero que la compaia cancela al empleado
protected double pagoO;
/**********************************************************************
* Constructor: Crea un empleado standar dando nombre, titulo del job,
jornal.
*
* Parametros:
*
nombre: el nombre del empleado
17
Dr. Eric Jeltsch F.
*
titulo: trabajo del empleado, el ttulo
*
jornal: jornal del empleado
**********************************************************************/
public Empleado(String nombre, String titulo, double jornal) {
this.jobT = titulo;
if (jornal < 0) {
System.out.println("Error: jornal negativo!");
jornal = 0;
} // end if
this.jornal = jornal;
// parte sin pago acumulado
this.pagoO = 0;
} // end constructor
/**********************************************************************
* Returns el nombre del empleado.
*********************************************************************/
public String getNombre() {
return nombre;
} // end getNombre
/**********************************************************************
* Returns el trabajo del empleado.
*********************************************************************/
public String getTitulo() {
return jobT;
} // end getTitulo
/**********************************************************************
* Pago al empleado por n de horas trabajadas. Incrementando
* el monto del pago.
*
* Parameter: n de horas trabajadas
*********************************************************************/
public void pago(double horas) {
pagoO += horas * jornal;
} // end pago
/**********************************************************************
* Returns el monto del pago para el empleado.
*********************************************************************/
public double monto_a_Pagar() {
return pagoO;
} // end monto_a_Pagar
/**********************************************************************
* Cero el monto adeudado. Llamada para establecer que se ha cancelado
* a empleado de alguna manera.
*********************************************************************/
public void cero() {
pagoO = 0;
} // end cero
/**********************************************************************
* Compara este empleado con otro.
* Se define para cuando ellos tienen el mismo nombre, jobTitulo y jornal.
* Parametros: otro objeto para comparar con este
* Return valor: true si este objeto es considerado igual al
*
otro objeto.
*********************************************************************/
public boolean igual(Object otro) {
if (otro instanceof Empleado) {
18
Dr. Eric Jeltsch F.
Empleado otroEmp = (Empleado) otro;

return (nombre.equals(otroEmp.nombre))
&& (jobT.equals(otroEmp.jobT))
&& (jornal == otroEmp.jornal);
}
else {
// un objeto no- Empleado
return false;
} // end if
} // end igual
/**********************************************************************
* Crea un String para la representacion de empleado, incluyendo,
* nombre,job titulo, jornal y pago.
*
* Return valor: el string
*********************************************************************/
public String aString() {
return nombre + ": " + jobT + ", jornal=" + jornal
+ ", pago = " + pagoO;
} // end aString
} // end class Empleado
Empleado
-
nombre: String
jobT: String
jornal : double
pagoO: double
+
+
+
+
+
+
+
getNombre():String
getTitulo():String
pago(horas: double)
monto_a_Pagar(): double
cero(): void
igual(): boolean
aString(): String
Como Ud. puede notar en el cdigo de la clase Empleado existe un mecanismo que le llamamos
Constructor. A saber, un constructor es un procedimiento especial de una clase que es llamado
automticamente siempre que se desee crear un objeto de esa clase, siendo su funcin iniciar el
objeto. Por otra parte un destructor es un procedimiento especial de una clase que es llamado
automticamente siempre que se desee destruir un objeto de esa clase, siendo su funcin acabar
cualquier proceso en el que este objeto haya estado involucrado. Observar que cada objeto
mantiene su propia copia de los atributos, pero no de los mtodos de su clase, esto es cada objeto
almacena sus propios datos, pero para acceder y operar con ellos, todos comparten los mismos
mtodos definidos en su clase. Por lo tanto, para que un mtodo conozca la identidad del objeto
particular para el que ha sido invocado, Java proporciona una referencia al objeto denominada
this, tal como ud. lo aprecia en el constructor anterior. Como Uds. pueden notar existen otro tipo
de Empleados, por ejemplo un Vendedor Viajero (Salesperson) a quien se le paga por horas pero
adems obtiene una comisin, es decir un porcentaje de las ventas realizadas. A continuacin
veamos como tratar esta propuesta o cambio en la organizacin, y desde luego cambios en los
sistemas de administracin de la misma.
19
Dr. Eric Jeltsch F.
Propuesta 1: cambiar la clase Empleado por otra en que a todos los Empleados se les incluya el
concepto de Comisin, en donde la Comisin tal vez para muchos es 0. Ante lo cual deriva en
una excesiva computacin y capacidad de almacenamiento para todos los Empleados, pues no
todos estarn en esta situacin.
Propuesta 2: Crear una nueva clase, llamemosla Salesperson, la cual copia todas las variables
y mtodos desde la clase Empleado, pero agregando la comisin, o datos faltantes. Los problemas
que trae esta propuesta es la duplicidad de cdigo, es decir ms tipeo, lo que trae como
consecuencia una alta probabilidad de errores, y 2 clases a mantener. Ante las propuestas
anteriores surge una mucho ms plausible, y se refiere a extender la clase Empleado, y esto se
visualiza de la siguiente manera:
public class Salesperson extends Empleado{
//extra variables
//extra mtodos
}//end class Salesperson
en donde se dice que la clase Salesperson hereda todos los mtodos y variables desde la clase
Empleado, adems de otros extras que pueda incluir. La vista de heredar en UML es como sigue,
Empleado
-
nombre: String
jobTitulo: String
peso : double
pagoDeuda: double
+ getNombre():String
+ getTitulo():String
+ pago(horas: double)
+ montoPago(): double
+Ok()
Salesperson
- tasa: double
+ pagoSale(montoSale : double)
Veamos la implementacin de la clase Salesperson

Ejemplo 12.
/************************************************************************
* Una clase para representar un salesperson. Pago de jornal mas comisiones.
*
***********************************************************************/
public class Salesperson extends Empleado {
// la comision de salesperson esta representado como una fraccion, no
// un porcentaje, esta debera estar entre 0 y 1.
protected double razon;
/**********************************************************************
* Constructor: Crea un salesperson dando nombre, job titulo, jornal,
20
Dr. Eric Jeltsch F.
* y una razon de comision.

*
* Parametros:
*
nombre: nombre del empleado
*
titulo: el job titulo para el empleado
*
*
razon: razon de la comision entre 0 y 1.
*********************************************************************/
public Salesperson(String nombre, String titulo, double jornal, double razon) {
super(nombre, titulo, jornal);
if (razon < 0 || razon > 1) {
System.out.println("error: comision debe estar entre 0 y 1");
this.razon = 0;
}
else {
this.razon = razon;
} // end if
/**********************************************************************
* Constructor: Crea un salesperson quien recibe comision solamente
* (no pago por horas), dar el nombre, job titulo y razon de la comision.
*
* Parametros:
*
*
titulo: el job titulo para el empleado
*
razon: razon de comision del empleado, entre 0 y 1.
*********************************************************************/
public Salesperson(String nombre, String titulo, double razon) {
this(nombre, titulo, 0, razon);
/**********************************************************************
* Pago al salesperson por viaje, de acuerdo a la razon de comision.
*
* Parametro: monto para el viaje.
*********************************************************************/
public void pagoViaje(double montoViaje) {
pagoO += razon * montoViaje;
} // end pagoViaje
/**********************************************************************
* Crea una representacion String para Salesperson, incluyendo nombre,
* job titulo, jornal, pagoO, y razon de comision.
*
* Return valor: representacion string
*********************************************************************/
return "(Salesperson) " + super.aString()
+ ", razon de comision: " + razon;
} // end aString
} // end class Salesperson
Algo que se debe tener cuenta respecto al vocabulario es que la clase Empleado es la superclase(o
clase padre), Salesperson es una subclase (o clase derivada). Se dice tambin que la clase
Salesperson extiende a la clase Empleado. Salesperson hereda variables y mtodos de la clase
Empleado. Salesperson es una clase derivada, que deriva de la clase Empleado.
21
Dr. Eric Jeltsch F.
Una clase hija o derivada hereda todas las variables y mtodos del padre, pero NO constructores,
esto significa que cada clase necesita de un constructor o constructores propios. Por otra parte, un
mejor camino para evitar duplicidad en la codificacin de la inicializacin es considerar el
mtodo super(), considerada como superclase. La declaracin
dice que llama al constructor de la superclase, es decir Empleado. Invocar a super(), se debe
hacerse en el constructor en la primera llamada, para que pueda asumirlo.
Otra clase derivada podra ser, si es que sigue el juego de la organizacin, los empleados
ejecutivos, los que pueden recibir bonos de productividad, los que no estn basados en horas
necesariamente. Por ejemplo
Ejemplo 13.
/************************************************************************
* clase para empleado ejecutivo. Obtiene jornal plus bonos.
***********************************************************************/
public class Ejecutivo extends Empleado {
/**********************************************************************
* Constructor: Crea un ejecutivo dando nombre, job titulo, y jornal.
* Parametros:
*
*
titulo: el job titulo del empleado
*
*********************************************************************/
public Ejecutivo(String nombre, String titulo, double jornal) {
/* Note que TODOS estos constructores hacen esto para llamar a la clase
padreconstructor con los mismos parametros. Este constructor es necesario ,pues
clases hijas no heredan constructores, por eso la declaracion.*/
/**********************************************************************
* Pago de bonos al ejecutivo.
*
* Parametro: monto del bono
*********************************************************************/
public void pagoBono(double bono) {
pagoO += bono;
} // end pagoBono
/**********************************************************************
* Crea una representacin String de Ejecutivo, incluyendo nombre,
* job titulo, jornal y pago.
*
* Return valor: representacion string
*********************************************************************/
return "(Ejecutivo) " + super.aString();
} // end aString
} // end class Ejecutivo
22
Dr. Eric Jeltsch F.
Veamos a continuacin una clase principal que servir para testear la clase Empleado sus
mtodos y las subclases.
Ejemplo 14.
/************************************************************************
* Un programa para testear la clase Empleado y sus subclases.
*
***********************************************************************/
public class EmpleadoTest {
// Metodo principal main: Crea varios empleados de diferentes tipos y testeamos
// los diferentes mtodos.
public static void main(String noUsado[]) {
// un empleado "normal" , pago $2. 250/hora, sin sobretiempo
Empleado ambler = new Empleado("Ambler", "agente", 2.250);
ambler.pago(8);
ambler.pago(10);
// total horas son 18, pago es de 2.250 * 18 = $40.500.
System.out.println("monto a pagar a ambler: $" + ambler.monto_a_Pagar());
// chequear el metodo cero
ambler.cero();
ambler.pago(8);
// pago es de 8 * 2.250 = 18.000.
System.out.println("monto a pagar a ambler: $" + ambler.monto_a_Pagar());
// un ejecutivo recibe $3.000/hora, sin sobretiempo pero puede recibir bonos
Ejecutivo perez = new Ejecutivo("perez", "director", 3.000);
perez.pago(10);
perez.pago(10);
perez.pagoBono(10);
// pago debera ser 2.000 * 3.000 + 10.000 = $70.000
System.out.println("montoa a pagar a perez: $" + perez.monto_a_Pagar());
// un vendedor viajero, recibe $1.000/hora plus 20% comision. Sin bonos o
sobretiempo
Salesperson castillo = new Salesperson("castillo", "salesperson", 1.000, .2);
castillo.pago(10);
castillo.pagoViaje(40);
// pago debera ser 1.000 * 1.000 + .2 * 40.000 = $18.000.
System.out.println("montoa pagar a castillo: $" + castillo.monto_a_Pagar());
// Demo para el metodo igual
Empleado emp1 = new Empleado("Mario", "ingeniero", 3.000);
Empleado emp2 = new Empleado("Maria", "programador", 3.000);
System.out.println(emp1.igual(emp2)); // false
Salesperson emp3 = new Salesperson("Mario", "ingeniero", 3.000, .1);
System.out.println(emp1.igual(emp3)); // true
} // end main
} // end class EmpleadoTest
23
Dr. Eric Jeltsch F.
De la misma forma como se ha realizado aqu podra construirse una nueva clase que resulte ser
una extensin de Empleado. Por ejemplo, considerar la situacin de que algunos Empleados
reciben pago extra por sobretiempo, en tal caso considere el clculo del sueldo con sobretiempo.
Por ejemplo incremento de horas > 8 se paga 50% sino se paga como antes, etc.
24
Dr. Eric Jeltsch F.
Captulo 2: Fundamentos
C A P I T U L O II
FUNDAMENTOS
El libro Java How To Program (Deitel & Deitel 3Ed.) comienza con un captulo que describe
las ideas bsicas de computacin, programas, y lenguajes de programacin, este es un buen
libro gua. Por otra parte, el libro de Cay S. Horstmann, Core Java 2, Volumen I, es un libro
para personas que ya se manejan en Java. En la prctica siempre nos encontraremos con libros
que de una u otra manera tienen enfoques distintos. Este material tampoco es la excepcin y
en nuestro caso est orientado a los alumnos que en cierto modo han programado en algn
lenguaje de programacin y poseen un conocimiento de las herramientas bsicas de la
programacin, no obstante lo anterior, me he esmerado en mostrar en cada captulo las
herramientas que deberan conocer. No pretendo ser exhaustivo en el tema, sino tan slo fijar
ciertos estndares de conocimientos no importando el orden usual, es decir en este sentido no
comienzo definiendo los tipos de datos, luego operadores, como usualmente se hace, sino que
con el tipo de datos enteros voy utilizando las asignaciones, operadores, definicin de
funciones en diversas aplicaciones, ya que Ud. se supone que aprendi C, y adems curso
Estructuras de Datos.
El lenguaje Java que estaremos usando es uno de los ms recientes lenguajes de programacin
de alto nivel, la primera versin apareci en 1995, y Java2 versin 1.4 que estaremos usando
slo se libero el ao 2001. Java naci bajo el alero de una gran empresa de hardware y de
desarrollo de tecnologas, como es la empresa SUN Microsystems, siendo uno de los
referentes ms importantes en el tema. Hoy en da ya se cuenta con la versin 1.5, apropiada
para la programacin genrica. El programa en Java es traducido por el compilador que es un
programa en un lenguaje llamado bytecode que es similar al cdigo de mquina pero es
independiente de cualquier sistema en particular. El bytecode producido por compilador e
interpretado por la mquina virtual de Java (JVM) se llama cdigo del objeto. Fig. 1 muestra
la forma en que se realizan los procesos.
Figura 1.
Los 3 procesos: escribir un programa, compilarlo, y ejecutarlo.
Ingeniera en Computacin, Universidad de La Seren
25
Dr. Eric Jeltsch F.
Existe un nmero de herramientas disponibles para compilar y ejecutar programas Java. Para
este curso utilizaremos la versin liberada y disponible en el sitio Web, llamada Software
Development Kit (SDK), que puede ser bajada en forma gratuita de la direccin,
http://java.sun.com/j2se/
Un primer programa en Java

Aqu mostramos algunos programas, su compilacin y ejecucin.
public class Hola
{
/* Escribe un mensaje sobre la pantalla. */
{ System.out.println(Hola La Serena!);
}
declaraciones.
Todo programa en Java contiene declaraciones. Cada declaracin describe algunas

operaciones que el computador lleva a cabo. Por ejemplo, con la lnea
System.out.println(Hola La Serena!);
se pretende desplegar el mensaje: Hola La Serena! en la pantalla de la consola. Java tiene

varios caminos para escribir mensajes en la pantalla o desplegarlos en pginas Web. En este
caso, usamos una parte de un programa(o mtodo) llamado System.out.println. El
resultado ser que el mensaje sea desplegado en la pantalla DOS Window. Aqu se muestra el
programa con dos declaraciones. Las dos declaraciones son escritas en bold face. (Es solo
para resaltar, no use bold face en el programa actual, Java no acepta formatos ni fuentes
extraas.)
public class Hola1
{ /* Escribe un mensaje sobre la pantalla. */
{ System.out.println(Hola La Serena!);
System.out.println(Nos vemos.);
}
}
La salida ser: Hola La Serena! en una lnea, y en la prxima se ver Nos vemos.
Notar la forma clsica del programa modelo, en donde las declaraciones estn entre{ }.
26
Dr. Eric Jeltsch F.
public class Hola

{ /* Escribir un mensaje simple. */
{
Declaraciones
}
}
La Fig. 2, muestra el efecto que se genera sobre el archivo fuente Hola_Alumnos tras de
realizar la compilacin (con el comando javac). Ud. podr notar la generacin de dos nuevos
archivos con extensin .class (conteniendo bytecode).
Fig. 2: Generacin de archivos .class en bytecode
27
Dr. Eric Jeltsch F.
Elementos Bsicos en todo programa Java: Objetos y Mtodos.

Por ejemplo, si escribe un programa para alguna organizacin que posee un gran registro de
personal deber considerar un registro de personas y categoras, siendo probable entonces que
defina Empleados, Secretarias u otros, estos elementos en la Programacin Orientada a
Objetos se llaman objetos. Al mismo tiempo se necesitan, para que el programa pueda decidir,
que operaciones se pueden llevar a cabo sobre los objetos antes definidos. Por ejemplo,
actualizar la lista de Empleados, o desplegar algn reporter de alguna informacin registrada
sobre el Personal. Las operaciones que Ud. puede ejecutar sobre los objetos se llaman
mtodos. Cuando Ud. defina un nuevo tipo de objetos deber definir tambin sus mtodos.
Incluso en las declaraciones de Java ya est implcito este concepto. Por ejemplo, la
declaracin System.out.println denota el mtodo llamado println que pertenece al
objeto llamado System.out. System.out es un objeto cuya labor es recibir la informacin
para luego desplegarla sobre la pantalla. El mtodo println es la operacin usada para
emisin de mensajes. As la declaracin
System.out.println(Hola amigos!);
usa el mtodo println para enviar el mensaje Hola amigos! al objeto System.out (el que
lo despliega en pantalla). Todo objeto pertenece a una clase la cual especifica los mtodos y
objetos que all habitan. La potencialidad, en la prctica del lenguaje Java viene dada por su
biblioteca de clases. Entre las cuales destacan 2 paquetes (packages) de propsito general
como son java.io y java.lang.
Por ejemplo, la biblioteca de Java proporciona 3 flujos estndar, manejados por la clase
System del paquete java.lang, que son automticamente abiertos cuando se inicia un
programa y cerrado para cuando finaliza.
System.in, referencia a la entrada estndar del sistema que normalmente coincide con el
teclado. Se utiliza para leer datos introducidos por el usuario.
System.out, referencia a la salida estndar del sistema que normalmente es el monitor. Se
utiliza para mostrar datos al usuario.
System.err, referencia a la salida estndar de error del sistema, que normalmente es el
monitor. Se utiliza para mostrar mensajes de error al usuario.
Java en general nos ofrece la libertad de crear nuestras propias clases, mtodos, objetos y
paquetes, pero por lo mismo debemos conocer al menos la biblioteca de clases de Java, pues
no en vano la librera de Java esta compuesta enteramente de clases.
Existen algunas clases que consisten de un nmero de mtodos stand-alone, es decir que no
pertenecen a algn objeto en particular, a estos le llamaremos mtodos static. No todos los
datos utilizados en los programas Java son objetos, es as por ejemplo los tipos de datos
simples, tales como integers y nmeros floating-point son considerados en forma diferente.
Ellos son llamados tipos datos primitivos, porque estn integrados en el sistema. Sin
embargo, no confundirse porque la biblioteca de Java proporciona las clases: Byte,
28
Dr. Eric Jeltsch F.
Character, Short, Integer, Long, Float, Double y Boolean, para encapsular cada uno de los
tipos expuestos.
Vea http://java.sun.com/docs/books/tutorial/java/data/numbers.html
Como construyo programas?
En la ltima seccin explicamos que un programa Java consiste de un nmero de clases. El
ejemplo anterior es una muestra de ello pero muy simple. En todo caso, todo programa
consiste de una clase que contiene justamente un mtodo esttico. Todo lenguaje de
programacin hace uso de mtodos pero usualmente bajo nombres diferentes, por ejemplo,
procedure o function son frecuentes en Pascal o C. En Java se conocen como mtodos.
Aqu est el programa anterior usando mtodos con una indentacin apropiada para entender
cuando y donde termina una declaracin
1. /* Escribir un mensaje en pantalla. */
2.
3. { System.out.println(Hola, amigo! );
4. System.out.println(Luego nos vemos. );
5. }
Comentarios:
1.
/* Escribir un mensaje en pantalla. */
Esto es un comentario que describe lo que el programa hace. Puede usar tambin //, en el
caso que sea solamente una lnea.
2.
Este es el encabezado del mtodo principal. Todo mtodo tiene un nombre, en este caso es
la palabra main (principal) que viene justamente antes del parntesis. Las palabras public,
static y void son llamadas por el compilador Java para cuando el mtodo deba ser usado.
Esto lo explicaremos despus. La parte String[] args, describe la informacin que esta
puesta a disposicin, llamada a los parmetros.
3-5. {
System.out.println(Hola, amigos! );
System.out.println(Luego nos vemos. );
es el cuerpo del mtodo.

Todo programa consiste de un nmero de clases. En los ejemplos anteriores, los programas
tienen solamente una clase llamada Hola. Posible de darse cuenta de esto por el encabezado
public class Hola
29
Dr. Eric Jeltsch F.
Primer encuentro con POO, el mtodo System.out.println

System.out.println
es nuestro primer ejemplo de un mtodo que pertenece a la librera de

Java, la que contiene mtodos que controlan ms aspectos, tales como desplegar un string de
caracteres en DOS window. Este es un tipo muy simple de tratamiento de ventanas. El
nombre println es la abreviacin de print line, imprime lnea.. Para ver otra sutil
diferencia reemplace println por print. As una declaracin del tipo
System.out.print(Hola, amigo!\nLuego nos vemos.\n)
imprime Hola, amigo!, moviendo el cursor al comienzo de la siguiente lnea, en donde

imprimir Luego nos vemos., y mueve el cursor a la partida de la siguiente lnea. La
declaracin anterior tiene el mismo efecto que las dos declaraciones siguientes.
System.out.println(Hola, amigo! );
System.out.println(Luego nos vemos. )
Cmo edito un programa?

Cuando escriba un programa, tenga especial cuidado al usar System.out.println. Para
escribir un mensaje sobre la pantalla termine con un semicolon, si lo olvida el compilador
detectara un error y abortara la compilacin de su programa, enviando un mensaje de error
compiler error (o syntax error, o parse error). Java es un lenguaje sensitivo, es decir
distingue entre maysculas y minsculas, por ejemplo CLASS o Class al comienzo del
programa. Ud. debe siempre tipear class, que es la palabra reservada.
30
Dr. Eric Jeltsch F.
Cuntos errores de sintaxis visualiza en este programa?

public Clase Holas
{ /* Escribir un mensaje en la pantalla.
public static viod Main(string[] args)
{ System.out,println('Hola, amigo!);
System.out.printline(Luego nos vemos.);
)
}
Otro problema comn son los espacios en blanco, por ejemplo,

public c lass H ola{public static void main(String[]
args){System.out.println(Hola, amigo!);System.
out.println(Luego nos vemos.);}}
}
Cmo ejecuto un programa Java

Supongamos que ejecutamos el ejemplo.
public class Hola
{ /* Escribir un mensaje en pantalla. */
{ System.out.println(Hola, amigo!);
}
}
Se supone que Ud. cuenta con un editor de texto como NotePad, TextPad o JPadPro
1.
2.
3.
4.
5.
6.
Editar el programa y guardarlo en un archivo llamado Hola.java.

Si su programa consta de una sola clase gurdelo con el mismo nombre de la clase
seguido de la extensin .java. En nuestro caso gurdelo en Hola.java
Para compilar escriba el comando en la consola DOS > javac Hola.java
Si no tiene problemas de compilacin u errores sintcticos el compilador genera una
versin en bytecode en el archivo con el nombre Hola.class.
Obtenga ahora una Java Virtual Machine (JVM) que viene incorporada con la
distribucin para ejecutar el bytecode compilado del programa que esta en
Hola.class , esto lo logra escribiendo >java Hola
31
Dr. Eric Jeltsch F.
Fig. 3. Los tres procesos: escribir el archivo del programa, compilar para producir el archivo .class, y ejecutar el archivo
class.
Existen dos formas de correr un archivo ejecutable, ellas son llamadas Aplicaciones Java y
Applet Java.
Una Aplicacin Java, son programas que pueden ser ejecutados invocando al interprete
Java, desde la lnea de comando.
Un Applet es un programa Java que es incrustado en pginas Web y ejecutados por un
browser que soporta a Java. Hoy en da los Browser, tales como Explorer, Netscape,
lo poseen. As se visualizan ambos, note la diferencia.
public class TrivialAplicacion {
public static void main(String[] args) {
System.out.println("Hola,amigos.!");
}
}
import java.awt.*;
import java.applet.Applet;
public class TrivialApplet extends Applet {
public void paint(Graphics g) {
g.drawString("Hola,amigos.!", 20, 20);
}
}
cdigo HTML
<applet code="TrivialApplet.class" width=90 height=90>
</applet>
32
Dr. Eric Jeltsch F.
Java, una Plataforma Independiente

Compilar
Fig 4. La mquina virtual JVM, en accin
Para traducir un programa escrito en un lenguaje de alto nivel (programa fuente) a lenguaje
mquina se utiliza un programa llamado compilador. Este programa tomar como datos
nuestro programa escrito en lenguaje de alto nivel y dar como resultado el mismo programa
pero escrito en lenguaje mquina (en java bytecode), programa que ya puede ejecutar directa o
indirectamente el computador. Por ejemplo, un programa escrito en el lenguaje C necesita del
compilador C para poder ser traducido. Posteriormente el programa traducido podr ser
ejecutado directamente por el computador. En cambio, para traducir un programa escrito en el
lenguaje Java necesita del compilador Java; en este caso, el lenguaje mquina no corresponde
al del computador sino al de una mquina ficticia, denominada mquina virtual Java(JVM,
Java Virtual Machine), que ser puesta en marcha por el computador para ejecutar el
programa.
JVM (Mquina Virtual)
Qu es una mquina virtual?. Una mquina que no existe fsicamente sino que es simulada en
un computador por un programa. Por qu utilizar una mquina virtual? Porque, por tratarse
de un programa, es muy fcil instalarla en cualquier computador, basta con copiar ese
programa en su disco duro, por ejemplo. Y, qu ventajas reporta? Pues, en el caso de Java,
que un programa escrito en este lenguaje y compilado, puede ser ejecutado en cualquier
computador que tenga instalada esa mquina virtual, de hecho ya todos los sistemas operativos
cuentan con este soporte, vea Fig. 4. Esta solucin hace posible que cualquier computador
pueda ejecutar un programa escrito en Java independiente de la plataforma que utilice.
33
Dr. Eric Jeltsch F.
Por otra parte, a diferencia de un compilador, un intrprete no genera un programa escrito en

lenguaje mquina a partir del programa fuente, sino que efecta la traduccin y ejecucin
simultneamente para cada una de las sentencias del programa. Por ejemplo, un programa
escrito en el lenguaje javaScript necesita el intrprete que por lo general est en los browser
(Netscape, Explorer, etc.) para ser ejecutado. Durante la ejecucin de cada una de las
sentencias del programa, ocurre simultneamente la traduccin. Notar que, a diferencia de un
compilador, un intrprete verifica cada lnea del programa cuando se escribe, lo que facilita la
puesta a punto del programa. En cambio la ejecucin resulta ms lenta ya que acarrea una
traduccin simultnea.
Observacin importante:
Un programa en Java puede ser una aplicacin o un applet. En este curso aprender principalmente a escribir aplicaciones Java. Despus aplicar lo aprendido para escribir algunos
applets. Dentro de las aplicaciones estn las aplicaciones con y sin Swing, en este curso
principalmente aprender aplicaciones mixtas, es decir con y sin Swing. La librera Swing es
una librera con interfaces grficas muy novedosas. Convengamos sin embargo que una
aplicacin puede tener una forma ms sofisticada (al menos sintcticamente), tal como se
muestra a continuacin, pudiendo tener otros componentes, tales como extend, implement,
abstract y otras que luego veremos
package package_nombre;
import class_nombre;
import package_nombre.*;
. . .
public class ClassNombre
{
campo-declaracion 1;
campo-declaracion 2;
. . .
metodos-definicion 1;
metodos-definicion 2;
. . .
public static void main(String [] args)
{
declaracion 1;
declaracion 2;
. . .
ejecucion-declaracion 1;
ejecucion-declaracion 2;
. . .
}
}
En general, si quisiramos ya incorporar elementos de la Programacin Orientada a Objetos

podramos haber escrito en forma ms general,
import java.lang.*;
/* Primer programa como una aplicacin en POO*/
public class PrimerProgramm extends Object
{
// Comienzo clsico de los Programas en Java
public static void main(String args[])
{
// salida estandar
34
Dr. Eric Jeltsch F.
System.out.println(
"Nuestro primer programa Java, pero sofisticado.");
}
}
Notar que la expresin import java.lang.*; siempre existe por defecto, de manera que se
puede omitir, adems de extends Object dado que toda clase no se crea por si solo, sino que
proviene de una clase madre o padre (super clase) en este caso es Object.
Una visin de la plataforma JDK
La plataforma JDK pone a disposicin una serie de comandos y herramientas de utilidad entre
las cuales se encuentra:
Java-Compilador: javac, generando Byte-Code
Comando: javac ejemplo.java
Ejemplo: javac Hola_Alumno.java genera el archivo Hola_Alumno.class y digaHola.class.
Java-Interprete: java, llamando los Bytecode
Comando: java ejemplo
Importante: La extensin .class no debe incorporarse!
Ejemplo: java Hola_Alumno lleva a cabo la aplicacin.
Applet-Viewer: appletviewer, sirve para testear los Java-Applets sin Web-Browser
Comando: appletviewer ejemplo.html
Nota: El Applet debe ser referenciado en una pgina-HTML.
Ejemplo (absolutamente AppletMinimal (Hola_AlumnoApplet.java):
appletviewer Hola_AlumnoApplet.html.
Generador de Documentos estndar: javadoc, genera documentacin en la forma de
HTML-Documentos del cdigo fuente Java y contiene comentarios formales.
Comando: javadoc ejemplo.java
Ejemplo: javadoc -private -version -author -windowtitle "Ejemplo de un JavaDoc"
Hola_Alumno.java
Textmode-Debugger: jdb, Debugger orientado al texto.
Comando: jdb ejemplo
Desamblador: javap, recuperar cdigos fuentes Java desde Bytecode
Comando: javap ejemplo.
La devolucin del compilado Hola_Alumno.class con javap -c Hola_Alumno se v, as:
Compiled from Hola_Alumnos.java
public class Hola_Alumnos extends java.lang.Object {
public Hola_Alumnos();
public static void main(java.lang.String[]);
}
35
Dr. Eric Jeltsch F.
Method Hola_Alumnos()
0 aload_0
1 invokespecial #1 <Method java.lang.Object()>
4 return
Method void main(java.lang.String[])
0 getstatic #2 <Field java.io.PrintStream out>
3 ldc #3 <String "Hola alumnos">
5 invokevirtual #4 <Method void println(java.lang.String)>
8 return
Nota:
Si Ud. observa NO se recupera el cdigo fuente original, esto es por razones de proteccin
comercial. Sin embargo, existe un Java-Interpete disponible, llamado JavaRuntime
Environment (abrev. JRE).
Instalacin de Java
Como Ud. podr haber notado, para escribir programas se necesita un entorno de desarrollo
Java. Sun MicroSystems, propietario de Java, proporciona una forma gratuita, llamada Java
Development Kit(JDK) que se puede obtener en la direccin Web, http://www.sun.com
36
Dr. Eric Jeltsch F.
Para instalar la versin del CD Rom en una plataforma Windows, hay que ejecutar el archivo
j2sdk1_4_0-win.exe. De manera predeterminada el paquete ser instalado en jdk1.4,
pudindose instalar en cualquier otra carpeta. A continuacin podr instalar la documentacin
en jdk1.4\docs que se proporciona en el archivo j2sdk1_3_0-doc.zip.
La carpeta jre es el entorno de ejecucin de Java utilizado por el SDK. Es similar al intrprete
de Java (java), pero destinado a usuarios finales que no requieran todas las opciones de
desarrollo proporcionadas con la utilidad java. Incluye la mquina virtual, la biblioteca de
clases, y otros archivos que soportan la ejecucin de programas escritos en Java.
La carpeta lib contiene bibliotecas de clases adicionales y archivos de soporte requeridos por
las herramientas de desarrollo.
La carpeta demo contiene ejemplos. Por ejemplo Java2Demo a travs de un browser, en este
caso a travs de Netscape.
La carpeta include contiene los archivos de cabecera que dan soporte para aadir a un
programa Java cdigo nativo (cdigo escrito en un lenguaje distinto de Java, por ejemplo Ada
o C++).
La carpeta include-old contiene los archivos de cabecera que dan soporte para aadir a un
programa Java cdigo nativo utilizando interfaces antiguas.
37
Dr. Eric Jeltsch F.
Ahora, que ya tiene todos los archivos y carpetas de la distribucin instalados, slo le falta un
editor de cdigo fuente Java. Es suficiente con un editor de texto sin formato; por ejemplo el
bloc de notas de Windows. No obstante, todo el trabajo de edicin, compilacin, ejecucin y
depuracin, se har mucho ms fcil si se utiliza un entorno de desarrollo con interfaz grfica
de usuario que integre las herramientas mencionadas, en lugar de tener que utilizar las interfaz
de lnea de rdenes del JDK, como veremos a continuacin. Algunos entornos de desarrollo
integrados para Java son: Forte de Sun, Visual Caf de Symantec, JBuilder de Borland, Kawa
de Tek- Tools, Visual Age Windows de IBM, pcGRASP de Auburm University, Visual J++ de
Microsoft, JPadPro, BlueJ, Eclipse, y otros. La mayora de ellos se ajustan a las necesidades
del curso. Tomar la precaucin de que algunos IDEs para que funcionen requieren ciertas
versiones de Java, infrmese.
JDK 5.0 ( java.sun.com/j2se/1.5.0/download.jsp).
JBuilder 2005 Foundation (www.borland.com/products/downloads/download_jbuilder.html).
NetBeans 5.5 ( www.netbeans.org).
Eclipse 3.1 ( www.eclipse.org).
TextPad ( www.textpad.com).
JCreator LE ( www.jcreator.com).
JEdit ( www.jedit.org).
JGrasp ( www.bluej.org).
DrJava ( drjava.sourceforge.net).
WinZip ( www.winzip.com).
MySQL ( www.mysql.com).
MySQL JDBC Driver ( www.cs.armstrong.edu/liang/intro6e/book/mysqljdbc.jar).
Tomcat ( www.apache.org).
Verificar que el sistema operativo haya asumido los cambios, producto de la instalacin de
jdk1.4. Para tal efecto, utilizando lneas de comando MSDOS habr que aadir a la variable de
entorno path la ruta de la carpeta donde se encuentra esta utilidad, como por ejemplo:
38
Dr. Eric Jeltsch F.
A continuacin se muestran algunas demos que trae la distribucin, las que Ud. puede ejecutar
sin dificultad. Por ejemplo,
C:\jdk1.3.1\demo\sound\JavaSound.jar
C:\jdk1.3.1\demo\jfc\Java2D\Java2Demo.jar
39
Dr. Eric Jeltsch F.
40
Dr. Eric Jeltsch F.
41
Dr. Eric Jeltsch F.
Captulo 3: Elementos del Lenguaje
C A P I T U L O III
Elementos del Lenguaje
En esta leccin veremos los elementos que aporta Java (caracteres, tipos de datos, operadores,
y otros) para escribir un programa. Considere esta leccin como soporte para el resto de las
lecciones.
Tipos de Datos y Strings
Integers
Hemos visto que no todos los valores tratados por programas Java son objetos. Los tipos de
valores simples, tales como integers y floating-point son tratados en forma diferente y son
llamados tipos de datos primitivos. Empezaremos con el uso de los enteros (integers.)
Suponga que Ud. visit Miami, y al regresar le quedan 8 pennies, ningn nickels, 5 dimes y 6
quarters. Cuanto tiene en total?
Para trabajar la respuesta sepa que un penny es una moneda de 1 cent., un nickel son 5 cents,
un dime son 10 cents, y un quarter es un cuarto de dlar o 25 cents. A travs del siguiente
programa no le ser difcil saber que Ud. tiene 208 cents. El siguiente programa ilustra varios
puntos de inters respecto al trabajo con enteros.
Ejemplo 1
public class Cambio1
{ /* Calcular cuantas monedas Ud. tiene (en cents)
Sabiendo que tiene 6 quarters, 5 dimes, ningn nickels,
y 8 pennies(o centavos en USA). */
{ System.out.print("Ud. tiene ");
System.out.print(6*25 + 5*10 + 0*5 + 8);
System.out.println(" cents.");
}
//declaracin1
//declaracin2
//declaracin3
En ejemplo1, el mtodo main contiene tres declaraciones. Cuando lo ejecuta, las tres
declaraciones generan tres partes de lnea simple sobre la pantalla. Note que las primeras 2
usan print en vez de println. Permitiendo que el valor 208 aparezca inmediatamente
despus de la palabra Ud. tiene, sobre la misma lnea, y cents aparece despus.
Ud.tiene
208
cents
Generado por
declaracin1
declaracin2
declaracin3
42
Dr. Eric Jeltsch F.
Cuando Java obedece la declaracin2, calculara el valor de la expresin aritmtica (El

smbolo denota multiplicacin.) 6*25 + 5*10 + 0*5 + 8 desplegando el resultado, 208.
Algunos Operadores
En Java los siguientes operadores pueden ser usados con expresiones aritmticas.
+
/
%
adicin
substraccin
multiplicacin
divisin
mdulo
En Java (y muchos otros lenguajes de programacin) nmeros son ya sea integers o floatingpoint. Estos 2 tipos son almacenados en memoria en diferentes sentidos. Si el valor es, por
ejemplo 4, se trata de un integer. Por otro lado si es 4.0, ser tratado como floating-point.
Todos los valores del Ejemplo1 son integers. En la medida que pueda siempre use integers,
pues sern tratados ms rpido al requerir menos memoria, y no existe peligro de redondeo.
El operador, /, tiene 2 formas. Si es usado con 2 integers entonces es integer division
(divisin entera). Por ejemplo, 11 / 4 = 2, (11) / 4 = 2. Si es usado con dos valores
floating-point , o un integer y un valor floating-point, denota divisin normal. Por ejemplo,
10.5 / 2 = 5.25. El mdulo o resto es solamente usado con dos integers. Por ejemplo, 11%4 =
3 y (11)%4 = 3. Si evala m/n o m%n donde n es cero, le enva un error.
En los procesos de evaluacin, Java asume que los operadores , / y % tienen ms alta
prioridad que la + y la . Por ejemplo, 3+45 es lo mismo que 3+(45), pero no (3+4)5.
Cuando evala expresiones con varios operadores + y en una fila, o varios operadores , / y
% en una fila, el criterio es de izq. a der. Por ejemplo, 345 es lo mismo que (34)5, no
3(45). Similarmente 3/4/5 es lo mismo que (3/4)/5, no 3/(4/5) (el que produce un error).
Variables
Ejemplo2
{ /* Idem Ejemplo1. */
{ int total = 6*25 + 5*10 + 0*5 + 8;
System.out.print("Ud. tiene ");
System.out.print(total/100);
System.out.print(" dlares con ");
System.out.print(total%100);
}
}
43
Dr. Eric Jeltsch F.
El Ejemplo2 es otra versin del programa Ejemplo1, esta vez haciendo uso de variables.
La declaracin
int total = 6*25 + 5*10 + 0*5 + 8;
nos dice: crea una variable total que denota la expresin 625 + 510 + 05 + 8 ( = 208).
La palabra int muestra que el valor de total es un valor integers. Llamado declaracin de
variable. La declaracin
dice: la salida es el cuociente entre total que es dividido por 100 (divisin entera). Es decir
208/100 (= 2) es la salida. La declaracin
dice: la salida es el resto de la divisin de total dividido por 100. Es decir 208%100 (= 8).
Esto es lo que se despliega en pantalla.
Ud. tiene
dlares con 8
cents
Ejemplo 3
{
public
{ int
int
int
int
static void main(String[] args)

quarters = 6;
dimes = 5;
nickels = 0;
cents = 8;
int total =
quarters*25 + dimes*10 + nickels*5 + cents;
}
}
Si al ejemplo 2 se le incorpora la declaracin de variables, se genera el Ejemplo 3. Es

importante mencionar que en Java, cuando una variable es creada tiene un rea de memoria
para almacenar sus valores. La memoria depende del tipo de dato que se le asigno a la
variable en la declaracin. Por ejemplo, si la declaracin dice que es de tipo int, como es el
caso de la variable total, dejara 32 bits de memoria. El valor de una variable int esta en el
rango 2147483648 a 2147483647. Si maneja enteros ms grande reemplace int por long, a
lo que la variable le dejar 64 bits de memoria.
44
Dr. Eric Jeltsch F.
Asignaciones
Toda variable tiene un nombre y una porcin de memoria, segn el tipo de dato declarado.
Decimos que el valor en la porcin de memoria es el valor asignado a la variable. En el
siguiente ejemplo el valor de la variable peso es cambiada una vez.
Ejemplo 4
public class Peso1
{
/* Calcula las libras a kilos

dado el peso almacenado en libras. */
{
int stones = 10;

int libras = 8;
libras = 14*stones + libras;
double kilos = libras * 0.4536;
System.out.print("Ud. pesa ");
System.out.print(kilos);
System.out.println(" kilos.");
}
}
Este programa parte creando 2 variables llamadas stones y libras . (1 stone = 14 libras.)
y declara
esto dice: calcula el valor de la expresin 14*stones + libras, y almacena el resultado en

la variable libras. En otras palabras, reemplaza el valor original almacenado en libras (= 8)
por la persona con peso total en libras (= 148).
La declaracin
es nuestro primer ejemplo de cmo usar el valor floating-point. Y dice: crea una variable
llamada kilos de tipo double, y le asigna el valor libras * 0.4536 . Una variable de tipo
double posee 64 bits de memoria. El producto de un entero y un floating-point es calculado
en floating-point. En este caso la respuesta ser 67.1328. Una vez que el peso de la persona
ha sido calculado, las ltimas tres declaraciones entregan la respuesta.
Ud. pesa 67.1328 kilos.
La declaracin
es una declaracin de variable de tipo int. Esto significa que cuando Java obedece la
declaracin de asignacin la realiza en 2 etapas: primero evala la expresin a la derecha de
=, y almacena el resultado en la variable a la izquierda de =. De esta manera cuando
agregamos 15stones y el valor original en libras, obtendremos la respuesta en la variable
45
Dr. Eric Jeltsch F.
libras,
libras.
sobreescribiendo en el antiguo valor. En efecto, agregamos 14stones al valor de

Si a menudo necesita hacer este tipo de declaraciones, hgalo como en C. En tal caso
podr escribir.
libras += 14stones;
que dice: adicione 14stones a libras. Similarmente puede usar = para cuando quiera
restar o substraer un valor desde una variable, y podemos usar = cuando queramos
multiplicar una variable por el valor, y as sucesivamente. Uno de los ejemplos ms comnes
en este tipo de declaraciones es para cuando queremos adicionar 1 al valor de la variable. En
tal caso podemos escribir, por ejemplo,
x += 1;
para sumar 1 al valor de x. Sin embargo, es ms comn una declaracin del tipo
x++;
Similarmente para restar 1 desde x, podemos escribir x--.

Ud. podr cambiar el valor almacenado en la variable, pero nunca podr cambiar el tipo de
valor. Por ejemplo, dada la declaracin de la variable int libras en el ltimo ejemplo,
cualquier nuevo valor asignado a l deber ser un entero, y siempre ser almacenado en 32 bits
de memoria. El siguiente diagrama describe las diferentes formas de declaracin.
declaracin (con un valor inicial)

Tipo Nombre = Expresion ;
Por ejemplo, Tipo puede ser int, Nombre puede ser quarters, y Expresion ser 6. Esta sera
la declaracin
int quarters = 6;
Punto Flotante.
El nombre punto flotante floating-point proviene en el sentido que estos nmeros son
representados en la memoria del computador. La notacin es similar a la notacin cientfica
(es decir, 1.0751024), pero usando base 2 en vez de base 10.
En Java, el tipo de dato double es el usado ms comnmente para valores punto flotante.
64 bits son usados para valores double. Siendo el rango de los valores: aproximadamente
1.810308, equivalente a 15 dgitos significativos. El nombre double es para double
precision floating-point. Java tiene un segundo tipo de dato para tratar nmeros floatingpoint, llamados float. Este tipo de dato usa solamente 32 bits para los valores, siendo ms
econmico en el uso de memoria, pero tiene la mitad de la precisin de double.
46
Dr. Eric Jeltsch F.
Los nmeros floating-point pueden ser escrito con punto decimal, es decir, 14.56 o 14.0.
Puede tambin ser escrito con exponente, es decir, 14.56E-12, que es equivalente a
14.561012.
Como cualquier tipo de dato, podemos declarar variables de tipo double. Por ejemplo,
double radio = 1.67;
que crear una variable llamada radio, considerando 64-bit en memoria que contiene el valor
inicial 1.67.
Funciones Estndares
Java proporciona mtodos que calculan el rango de las funciones matemticas usando valores
double. Aqu hay algunos ejemplos, ellos son mtodos static (es decir, mtodos que NO
pertenecen a un objeto) en la librera Math de Java.
Math.sin(x)
Math.cos(x)
Math.tan(x)
Math.exp(x)
Math.log(x)
Math.abs(x)
Math.floor(x)
Math.ceil(x)
seno de x
coseno de x
tangente de x
ex
log natural de x
valor absoluto de x
entero ms grande que sea x
entero ms pequeo que sea x
En cada caso el parmetro x es de tipo double y el resultado es de tipo double. Notar la

perdida de precisin que se obtiene con
float r;
r= (float)Math.sqrt(10);
pues el resultado se redondea perdiendo precisin ya que sqrt() devuelve un valor de tipo
doble. Algunas otras observaciones, son las siguientes,
int m = 3;
int n = 4;
double x = mn;
cuando Java ejecuta la tercera declaracin evalua mn usando aritmtica entera para dar 32-bit
al valor entero 12. Entonces convertir el valor 12 a 64-bit floating-point, que ser
almacenado en x. Si reemplazamos, la tercera declaracin por,
double x = m/n;
la respuesta es que x ser seteado a 0. La razn es que en aritmtica entera usar la expresin
m/n, y el operador ser divisin entera. As el valor es cero.
47
Dr. Eric Jeltsch F.
Suponga que queremos usar una divisin normal en floating-point para trabajar sobre x
Debemos entonces tratar el valor de m y n como valor floating-point. Pudiendo escribir,
double x = ((double) m) / n;
El trmino (double) es llamado cast. Podemos usar casts para transformar un valor de un tipo
cualquiera que sea en un valor equivalente de otro tipo.
La parte entera de un nmero floating-point. Por ejemplo, el nmero floating-point 4.7 se
convierte en el entero 4. El camino para hacer esto en Java es usar el cast int. Supongamos
lo siguiente,
double x = 4.7;
int i = (int) x;
la segunda declaracin convertir el valor de x al entero 4, y lo almacenar en i. Si x ha sido

seteado a 4.7, i tomar el valor 4.
Redondear el nmero. Por ejemplo, el techo de 4.7 es 5. Supongamos lo siguiente,
procurando que el valor no sea negativo.
int i = (int) (x + 0.5);
Por ejemplo, si x es igual a 4.7, el valor de x + 0.5 ser 5.2, y el valor de(int)(x + 0.5)
ser 5, el cual es el techo de 4.7. Sin embargo, si x es 4.7, se obtiene que el valor de x + 0.5
ser 4.2, y el valor de (int)(x + 0.5) ser 4, el que no es el techo de 4.7.
Ejemplo 5.
// Demo para practicar con los tipos de datos y operadores
class BasicaMate {
// aritmetica usando integers
System.out.println("Aritmtica");
/*
double x =4.7;
int i = (int) (x + 0.5);
System.out.println("x es " + x);
System.out.println("i es " + i);
*/
/*
double r;
r= Math.sqrt(10);
*/
float r;
r=(float)Math.sqrt(10);
int m = 3;
int n = 4;
double x = m/n;
double z = ((double) m) / n;
System.out.println("r es " + r);
System.out.println("m es " + m);
System.out.println("n es " + n);
System.out.println("x es " + x);
48
Dr. Eric Jeltsch F.
System.out.println("z es " + z);

}
}
Clases de I/O
Por lo general, cada texto introductorio en el lenguaje Java trae hoy en da sus propias clases,
generando que inevitablemente debamos conocer como trabajan las clases, los mtodos y la
forma de ingresar y retornar datos. Tal como se mencionaba, en la Leccin1 Fundamentos),el
libro Java How To Program (Deitel & Deitel 3Ed.) posee el paquete com.deitel.jhtp3.*,
de la misma manera el libro de Cay S. Horstmann, Core Java 2, Volumen I, (Fundamentals)
trae el paquete corejava, y David Flanagan trae el paquete com.davidflanagan.*. Con esto
quiero decir que en la prctica siempre nos encontraremos con libros que de una u otra manera
tienen enfoques distintos y distintas clases para tratar el ingreso y retorno de datos.
Frecuentemente un programa necesita obtener informacin desde un origen o enviar
informacin a un destino, hasta el momento los datos son estticos, es decir han sido
incorporados al programa a travs de asignaciones simples con expresiones aritmticas. Sin
embargo en general la comunicacin entre el origen de cierta informacin y el destino, se
realiza mediante un flujo de informacin (llamado, stream en ingls), que es un objeto que
hace de intermediario entre el programa, y el origen o el destino de la informacin. Luego,
para que un programa pueda obtener informacin desde un origen tiene que abrir un flujo y
leer la informacin, anlogamente para escribir la informacin. De all que necesitemos
incorporar datos en forma dinmica a travs del teclado. Todas las clases relacionadas con
flujos en la distribucin estndar de Java estn en el paquete java.io, de manera que en rigor
debera importar este paquete en el encabezado mediante la declaracin import java.io.*;
en el encabezado del programa. Sin embargo, Java lo importa por defecto, de manera que no
se preocupe de hacerlo. Como ya habamos mencionado, existen normalmente tres flujos de
datos de I/O conectados a su programa:
System.in--- el flujo de entrada.
System.out--- el flujo para los resultados normales.
System.err--- el flujo para los mensajes de error.
Normalmente System.in se conecta al teclado y los datos son carcteres. System.out y

System.err se conectan ambos al monitor, y los datos son carcter. Los datos que un teclado
enva a un programa son datos character, incluso cuando los carcteres incluyen los
digitos ' 0 ' a ' 9 '.
Si su programa hace aritmtica, los caracteres de la entrada se convertirn en uno de los tipos
numricos primitivos. Se calcula (usando aritmtica), y luego el resultado se convierte a dato
character. La informacin que un programa enva al monitor son datos character:
49
Dr. Eric Jeltsch F.
(Realmente, los caracteres no se envan directamente al monitor, sino que ellos se convierten
primero en una seal de video por la tarjeta grfica. Esta forma de convertir datos de una
forma a otra es muy comn). El siguiente programa lee characters desde el teclado en el
String llamado enDato. Luego los caracteres almacenados en String son enviados al
monitor.
Ejemplo 6.
import java.io.*;
class Eco{
public static void main (String[] args) throws IOException
{
InputStreamReader inStream = new InputStreamReader( System.in ) ;
BufferedReader stdin = new BufferedReader( inStream );
String enDato;
System.out.println("Ingrese el dato:");
enDato = stdin.readLine();
System.out.println("Ud. ingreso:" + enDato );
}
}
La lnea import java.io.*; dice que el paquete java.io ser usado y * significa que
cualquier clase al interior del paquete sera usada.
IOException
es necesario para programas que tienen entrada por teclado (por lo menos por
ahora.) para informarle al compilador que main() tiene un funcionamiento de entrada que
eventualmente podra fallar. A lo que si el programa que se est ejecutando y un
funcionamiento de la entrada falla, el sistema le informar del fracaso y el programa se
detendr. En otras lecciones donde tratemos (Exceptions) veremos con ms detalle esta y otras
situaciones. Examinemos las siguientes declaraciones, que son bsicas para el I/O de datos en
Java.
(1) InputStreamReader inStream = new InputStreamReader (System.in);
(2) BufferedReader stdin= new BufferedReader (inStream);
La (1) construye un objeto de InputStreamReader y le da el nombre inStream. La (2)

construye un objeto de BufferedReader llamado stdin que lo conecta al inStream.
Pudiendo escribirse en forma resumida como
50
Dr. Eric Jeltsch F.
BufferedReader stdin = new BufferedReader( new InputStreamReader( System.in

) );
La variable inStream. es usada para conectar el InputStreamReader a la BufferedReader.
Observar que si Ud. quisiera que el usuario ingresara datos numericos, su programa debera
convertir los caracteres a tipo de dato numrico. Para ello no olvidar que los caracteres son
primero ledos en un objeto String para luego convertirlo a dato numrico. Para tal efecto se
usa la declaracin
enDato = stdin.readLine();
num = Integer.parseInt( enDato );// convertir a int
Aqu se muestra una nueva versin del programa Peso1.java , usando BufferReader.
Ejemplo 7.
import java.io.*;
public class PesoBuffer
{
public static void main(String[] args) throws IOException
{
BufferedReader stdin = new BufferedReader ( new InputStreamReader( System.in )
);
String stones, libras;
int num, num1;
double kilos;
System.out.println("Digame su peso.");
System.out.print("Cuantos stones: ");
stones = stdin.readLine();
num
= Integer.parseInt( stones );
System.out.print("Cuantas libras: ");
libras = stdin.readLine();
num1 = Integer.parseInt(libras);
num1 = 14*num + num1;
kilos = num1 * 0.4536;
}//end main
}//end PesoBuffer
51
Dr. Eric Jeltsch F.
Aqu se muestra un ejemplo de lo que aparece en pantalla. (Usando input en boldface.)

Digame su peso.
Cuantos stones: 8
Cuantas libras: 5
ConsoleReader
ConsoleReader es otra clase usada para leer datos de entrada. Horstmann en su libro Core
Java, proporciona un paquete corejava para, entre otras cosas, leer la entrada de datos por
teclado. La clase es llamada ConsoleReader, que est habilitada en un archivo de nombre
ConsoleReader.java. Para usarla basta insertar la siguiente declaracin
ConsoleReader in = new ConsoleReader(System.in);
en su programa, y no olvidar de guardar su programa junto con ConsoleReader en el mismo

directorio, o bien guardar la extensin ConsoleReader.class en la misma carpeta de trabajo,
as podr acceder el objeto System.in, el que est conectado al teclado.
in.readInt()
in.readDouble()
in.readLine()
// devuelve un valor int.

// devuelve un valor double.
// devuelve un string, que consiste de todos los caracteres
ingresados por consola por el usuario hasta el fin de lnea.
Aqu se muestra una nueva versin del programa Peso1.java , usando ConsoleReader.
Ejemplo 8
public class PesoConsole
{

{
int stones = in.readInt();
int libras = in.readInt();
}//end main
} //end PesoConsole
52
Dr. Eric Jeltsch F.
Aqu se muestra un ejemplo de lo que aparece en pantalla. (Usando input en boldface.)

Digame su peso.
Cuantos stones: 8
Cuantas libras: 5
Obs: Ud. ver el siguiente mensaje si no tiene la librera o archivo ConsoleReader

C:\Documents and
Settings\usuario\Escritorio\POO\lect_Jpoo_06\source2\PesoConsole.java:8: cannot
resolve symbol
symbol : class ConsoleReader
location: class PesoConsole
{ ConsoleReader in = new ConsoleReader(System.in);
^
C:\Documents and
Settings\usuario\Escritorio\POO\lect_Jpoo_06\source2\PesoConsole.java:8: cannot
resolve symbol
symbol : class ConsoleReader
location: class PesoConsole
^
2 errors
Herramienta completada con cdigo de salida 1.
Para evitar esto, deber incluir el archivo ConsoleReader.class en el directorio en donde

Ud. est trabajando.
hsa.*
A continuacin, se muestra otro ejemplo de Peso1.java, usando el paquete hsa que lo puede
obtener de la direccin Web: http://www.holtsoft.com/java/hsa_pkg_overview.html
Ejemplo 9.
import hsa.*;
public class PesoHsa {
public static void main (String [] args) {
int libras, stones;
stones = Stdin.readInt();
libras = Stdin.readInt();
//System.out.println("The number: " + aNum);
} //end main
} //end PesoHsa
53
Dr. Eric Jeltsch F.
Swing
Y finalmente mediante el uso de la librera Swing. Observar que el encabezado invoca a la
direccin javax.swing.JOptionPane;
Ejemplo 10.
import javax.swing.JOptionPane;
public class PesoSwing {
public static void main( String args[] )
{
int stones, libras;
String entrada;
// prompt para input y leer la entrada
entrada = JOptionPane.showInputDialog("Digame su peso. Cuantos stones: " );
// convertir la entrada de String a integer

stones = Integer.parseInt( entrada );
entrada = JOptionPane.showInputDialog("Cuantas libras: " );
// convertir la entrada de String a integer

libras = Integer.parseInt( entrada );
// display el promedio de los datos
JOptionPane.showMessageDialog(
null, "Ud. pesa " + kilos + " kilos ", "Resultado",
JOptionPane.INFORMATION_MESSAGE );
54
Dr. Eric Jeltsch F.
System.exit( 0 );
// termina el programa
}
}
Es as como podramos continuar haciendo funcionar nuestros programas soportados por

diversas libreras de clases. Sin embargo, lo que deseo transmitir es que aprenda a tener la
capacidad de incursionar en otros tipos de paquetes y clases para ver el que le convenga o sino
buscar nuevas alternativas o bien generar sus propias clases.
Modelemos desde un punto de vista ms abstracto una arquitectura para la aplicacin que
transforma grados Celsius a Fahrenheit. Por ejemplo,
Ejemplo 11.
CelsiusToFarehheit2
main
JOptionPane
showInputDialog
Integer
intValue
System.out
main
DecimalFormat
format
import java.text.*;
import javax.swing.*;
/** CelsiusToFahrenheit2 convierte Celsius a Fahrenheit.
*
input: los grados Celsius, se lee un integer de dialog
*
output: los grados Fahrenheit, un double */
public class CelsiusToFahrenheit2{
String input = JOptionPane.showInputDialog("Ingresar entero, C T.:");
int c = new Integer(input).intValue(); // convierte input en un int
double f = ((9.0 / 5.0) * c) + 32;
DecimalFormat formato = new DecimalFormat("0.0");
System.out.println("para C Celsius " + c + ",");
System.out.println("grados F Fahrenheit = " + formato.format(f));
}
}
55
Dr. Eric Jeltsch F.
cuyo resultado es 73.4 F, pero en MS-DOS. Sin embargo a veces es necesario ingresar los
datos por teclado y con varios parmetros a la vez. Esto ltimo lo veremos en el prximo
captulo.
Ahora, nos falta aprender el ingreso de datos a travs de archivos, que sean ledos por el
programa, tratados o manipulados por l, para luego ir a depositarlos en otro archivo de salida,
por ejemplo. Esto lo veremos ms adelante, en las siguientes secciones. El propsito del
siguiente ejemplo es mostrar entrada y salida de datos usando la consola y los archivos de la
clase hsa. El paquete hsa posee muchas otras clases que le pueden ser de utilidad. Ud. podr
comprobar tras la ejecucin del programa ArchivoHsaDemo.java que en el archivo
salida.txt en su carpeta de trabajo estn los datos 34, 56, 78, 90, 12. Adems intente
ingresar un nmero NO entero y ver otra de las gracias del paquete hsa, y digo gracia
porque el cdigo no posee declaraciones try-catch (atrapa excepciones).
Ejemplo 12.
import hsa.*;
public class ArchivoHsaDemo {
public static void main (String [] args) {
int [] numsArray = {34, 56, 78, 90, 12};
int i, aNum;
String entraString, saleString;
//Screen Input en la Consola
System.out.print("Ingrese un nmero entero: ");
aNum = Stdin.readInt();
// Screen Output para un nmero
System.out.println("El nmero es: " + aNum);
//Archivo Texto de Output
TextOutputFile saleFile = new TextOutputFile ("salida.txt");
for (i = 0 ; i < numsArray.length ; i++)
saleFile.println (numsArray [i]);
saleFile.close ();
//Archivo Texto de Entrada
int numNums = 0;
int[] leerNums;
TextInputFile enFile = new TextInputFile ("salida.txt");
56
Dr. Eric Jeltsch F.
while (!enFile.eof()) {
aNum = enFile.readInt();
numNums++;
} // end while
enFile.close();
leerNums = new int [numNums];
enFile = new TextInputFile ("salida.txt");
for (i = 0; i < numNums; i++)
leerNums[i] = enFile.readInt();
enFile.close();
// Chequear los nmeros que han sido ledos.
saleString = "Los nmeros son: ";
for (i = 0 ; i < numNums ; i++)
saleString = saleString + leerNums [i] + ", ";
System.out.println(saleString);
} //end main method
} //end ArchivoHsaDemo
Strings.
Esta seccin contiene informacin sobre uno de los tipos de datos ms comunes, strings. Un
literal string es escrito entre comillas. Por ejemplo, el perro. Si el literal es vaco se
escribe . Un string puede contener control de caracteres, esta es una lista de
combinaciones que se pueden hacer.
\n
\t
\b
\r
\f
\\
\
\
Por ejemplo,
newline
tab
backspace
return
line feed
\ character
caracter
caracter
System.out.print(El\nfin);
Escribir El en una lnea y en la otra lnea ver fin.

Si desea almacenar un string basta usar una variable de tipo String. Por ejemplo,
String animal = perro;
La concatenacin es denotada por +. Por ejemplo, si la variable animal ha sido asignada a

perro, entonces la expresin
El + animal + corre. denota el string
El perro corre. Expresiones usuales en programas son por ejemplo, la declaracin
System.out.println(El + animal + corre.);
57
Dr. Eric Jeltsch F.
que desplegara el mensaje El perro corre. sobre la pantalla. Por otra parte El +
animal + corre + cuanTas + veces, denota el string El perro corre 10
veces.
Si recuerda estas declaraciones

Las cinco declaraciones han sido combinadas en una sola,

System.out.println
( Ud. tiene + (total/100) + dolares con +
(total%100) + cents. );
El siguiente programa usa los mtodos usuario.readLine() para leer el nombre del
usuario y usuario.readInt() para leer la edad.
Ejemplo 13
public class Chatear
{
{
/* Chateando. */
ConsoleReader usuario =new ConsoleReader(System.in);

System.out.println
("Hola. Cmo te llamas?");
String nombre = usuario.readLine();
System.out.println
("Que edad tienes " + nombre + "?");
int edad = usuario.readInt();
System.out.print(edad + "no esta mal la edad, ");
System.out.println
("pues yo tengo " + (edad+1) + " que es mejor.");
System.out.println
("Hasta la vista " + nombre + ".");
}
}
En pantalla podr ver,

Hola. Como te llamas?
Alicia Lobos
Que edad tienes Alicia Lobos?
20
20 no esta mal, pues yo tengo 71 que es mejor.
Hasta la vista Alicia Lobos.
58
Dr. Eric Jeltsch F.
Algunas expresiones tiles st.substring(m,n), tal como animal.substring(5,8)

genera el string nte, tal como se describe.
e
e
2
f
3
a
4
Java tiene un tipo de dato llamado String que difiere de los 8 tipos primitivos, en lo
fundamental porque un valor del tipo string es un objeto. Un string no es justamente un valor
de dato, tambin tiene "mtodos". (Un mtodo es un subprograma que es parte de un objeto.)
por ejemplo, si str es una variable de tipo String, Ud. puede llamar al mtodo str.length(), que
es una funcin que devuelve el nmero de carcteres en el string. Hay mucho ms que usted
puede hacer con string. Una cosa que usted no puede hacer con string es usar los operadores
<,>, <=, y <= para compararlos. Usted puede usar legalmente = = y != para comparar String,
pero debido a las peculiaridades en los objetos de la manera de comportarse, ellos no darn
los resultados que usted quiere. (El operador = = verifica si se guardan dos objetos en la
misma direccin de memoria, en lugar de si ellos contienen el mismo valor. Si Ud. examina la
distribucin de Java2 ver que en java.lang.String se encuentran estos y otros mtodos que le
pueden
servir
de
ayuda.
No
obstante,
la
versin
1.4
trae
en
C:\j2sdk1.4.2_05\src\java\util el directorio regex, que es de mucha utilidad.
La clase String define una serie de mtodos, al cual le dedicaremos algunos ejemplos. Se
supone que s1 y s2 son de tipo Strings:
s1.equals(s2)
es una funcin valor que retorna true si s1 consiste de exactamente los

mismos caracteres que s2.
s1.equalsIgnoreCase(s2)chequea
si s1 es el mismo string que s2, sin distinguir

maysculas de minsculas. Entonces, si s1 es "cat", s1.equals("Cat") es false, mientras
que s1.equalsIgnoreCase("Cat") es true.
s1.length(),
entrega el nmero de caracteres en s1.
s1.charAt(N), N integer, es un valor char que retorna el N-simo caracter en el string.

Posicin son numeradas partiendo de 0, asi s1.charAt(0) es actualmente el primer caracter,
s1.charAt(1) el segundo y asi sucesivamente. La posicin final es s1.length() - 1.
s1.substring(N,M), N y M integers, retorna un String que contiene un substring de los
caracteres en s1. El substring consiste de los caracteres en s1 en posicin N, N+1,..., M-1.
Note que el caracter en posicin M no est includo. Vea y analice la salida de Ejemplo7.
Ejemplo 14
public class Test {
public static void main (String argv [] ) {
String s = "123456";
String t = "012345";
String u = s;
59
Dr. Eric Jeltsch F.

System.out.println
System.out.println
System.out.println
System.out.println
System.out.println
System.out.println
System.out.println
System.out.println
(s.length( ) );
(s.indexOf('3') );
(t.indexOf('6') );
("char:" + s.charAt(3) );
("sub:" + s.substring (2) );
( (s == t)? "Y" : "N" );
( (s.equals (t) ? "Y" : "N" ));
("compare:" + s.compareTo(u) );
}
}
La respuesta es 6, 2, -1, char:4, sub:3456, N, N, compare:0

Notar que equals verifica los contenidos de 2 objetos String. Mientras que a diferencia del
mtodo equals, el operador = = NO compara los contenidos de los objetos referenciados sino
las referencias, es decir, si tenemos
String str1=abc;
String str2=abc;
if (str1.equals(str2)){}
//el resultado es siempre true!!, pues independiente de que se traten o no de objetos

diferentes, los contenidos son los mismos.
if (str1==str2){}
//el resultado es siempre true!!, porque ambos identificadores se refieren al mismo objeto. str1
y str2 ocupan la misma rea de memoria para objetos String.
str1
abc
str2
rea de memoria
Sin embargo, la utilizacin del operador new hace que se reserve o asigne memoria para un
nuevo objeto. Por ejemplo,
String str1= new String(abc);
String str2=abc;
if (str1.equals(str2)){}
//el resultado es siempre true!!, pues Java aade el objeto String abc al rea de memoria
destinada a tales objetos, de manera que cuando se compila, la segunda lnea no aade un
nuevo objeto porque ya existe uno con el mismo literal.
if (str1==str2){}
//el resultado es siempre false!!.
60
Dr. Eric Jeltsch F.
equals()
es un mtodo de la clase java.lang.Object, de manera que Object es la clase
madre.
Ejemplo 15
class StringTest {
public static void main ( String[] args )
String str;
str
= new String("Hola alumnos");
System.out.println(str);
str
= new String("Chao alumnos");
}
}
El programa hace exactamente lo esperado, es decir escribe en la salida:

Hola alumnos
Chao alumnos
Veamos algunos detalles del programa.

str
= new String("Hola alumnos");
crea un primer Objeto, e inserta una referencia a este objeto en str, y lo imprime
Crea un segundo Objeto, e inserta una referencia al segundo objeto en str

str
= new String("Chao alumnos");
En este momento no existe referencia al primer objeto, el cual es ahora "garbage."(basura)

obtiene el dato y lo imprime. Notar que:

1. Cada vez que el operador new es usado, un nuevo objeto es creado.
2. Cada vez que un objeto es creado, existe una referencia a l..
3. Esta referencia es almacenada en una variable.
4. ms tarde, la referencia en la variable es usada para encontrar el objeto.
5. Si otra referencia es almacenada en la variable, ella reemplazar la referencia previa.
6. Si ninguna variable referencia a un objeto, no existe forma de encontrarlas.
La forma (6) recibe el nombre de "garbage." La palabra "garbage" es el trmino correcto para
expresar en ciencias de la computacin el uso de objetos que no tienen referencias. Esta es una
situacin comn, la que no usualmente representa un mistake(equivocacin-error). En Java
61
Dr. Eric Jeltsch F.
un programa ejecutable con este tipo de situacin invoca a su recolector de basura, a lo que el
object (el "garbage") puede volver a usar su memoria.
Ejemplo 16
Este ejemplo muestra varios objetos de la misma clase
class StringTest1
{
{
String strA; // referencia al primer objeto
String strB; // referencia al segundo objeto
// crea primer objeto y almacena su referencia
strA
= new String( "Hola alumnos" );
//sigue referenciando al objeto e imprime los datos
System.out.println( strA );
// crea un segundo objeto y almacena su referencia.
StrB
= new String( "Chao alumnos" );
System.out.println(
strB
);

System.out.println(
}
strA
);
El programa imprime:
Hola alumnos
Chao alumnos
Hola alumnos
62
Dr. Eric Jeltsch F.
Captulo 4: Estructuras de Control
CAPTULO4
Llegado a esta leccin el alumno ya podr escribir programas simples pero completos. En esta
seccin se estudiarn las estructuras de control de un programa Java, entre las cuales estn las
repeticiones o ciclos y otras.
Decisiones (if)
Ahora nos dedicaremos al uso de la declaracin if. Existe una gran cantidad de alternativas
en la programacin en donde se debe ya sea decidir o seleccionar desde algunas alternativas.
En la mayora de los programas que hemos visto hasta ahora, las declaraciones no tienen
alternativas de hacer otras cosas, es un tanto lineal de cmo el compilador se comporta, dada
las instrucciones que hemos utilizado. No obstante existen posibilidades de usar alternativas o
decisiones. Este tipo de decisiones se llama en Java declaracin o estructura if. Un ejemplo
de este tipo es,
if (resp == 6048)
System.out.println("Bien!");
else
System.out.println("Error.");
que nos dice, que si el valor de resp es igual a 6048, despliega el mensajeBien!, De otra
manera dir Error. Notar que la expresin,
resp == 6048
se refiere a la condicin resp es igual a 6048, usando el smbolo = = para la relacin de

igualdad, en vez de = para evitar confusin con la asignacin. Aqu tenemos un ejemplo que
usa la estructura if.
Ejemplo 1
/** ConvertHora traslada tiempo en hrs. en su equivalente en seg.
* Input: un entero no-negativo
* Output: convierte las horas en seg. */
public class ConvertHora{
int hora = new Integer(
JOptionPane.showInputDialog("Ingrese Hora, un entero:")).intValue();
if ( hora >= 0 )
{ // si la entrada de datos es correcta:
int segundo = hora * 60 * 60;
JOptionPane.showMessageDialog(null,
hora + " hora es " + segundo + " segundos");
}
else { // si la entrada no corresponde, error:
"ConvertHora error: entrada negativa " + hora);
}
}
}
63
Dr. Eric Jeltsch F.
De manera similar, podemos hacer uso de la lgica, en particular del conectivo `ànd''
(conjuncin) para escribir una expresin que busca una variable entero minuto que se
encuentra en un rango de 0..59:
(minuto >= 0) && (minuto <= 59)
El simbolo, &&, denota `ànd.'' Una pequea ejecucin de la traza de esta expresin para
cuando minuto es 64, y donde el resultado es false, como se aprecia.
(minuto >= 0) && (minuto <= 59)
=> (64 >= 0) && (minuto <= 59)
=> true && (minuto <= 59)
=> true && (64 <= 59)
=> true && false => false
TABLA 1: Operadores Lgico

Operador
Semantica
E1 && E2
conjuncin (`ànd''):
true && true => true
true && false => false
false && E2 => false
E1 || E2
disjuncin (`òr''):
false || false => false
false || true => true
true || E2 => true
!E
negacin(``not''):
!true => false
!false => true
La semntica debe respetarse, por ejemplo:

(2 != 1) || (x == 3.14)
=> true || (x == 3.14)
=> true
esta disjuncin, ||, resulta ser true, por lo tanto no existe necesidad de calcular el 2
argumento, resultando la expresin, true.
64
Dr. Eric Jeltsch F.
Ejemplo 2
Otro ejemplo interesante es considerar el mtodo: deposit(int monto): boolean, que
trata de especificar lo siguiente..
1. Si monto es no-negativo, entonces adiciona monto a la cuenta balance.
2. de otra manera, use un error de mensaje e ignore el depsito.
3. return el resultado.
Vea la salida y siga practicando, dndose otras situaciones.
/** BankCuenta administra una cuenta simple */
public class BankCuenta{
private int balance;
// balance >= 0
siempre!
/** Constructor BankCuenta inicializa la cuenta

* @param inicial_m cuenta balance,nonegativo. */
public BankCuenta(int inicial_m) {
if ( inicial_m >= 0 )
{
balance = inicial_m; }
else { balance = 0; }
}
/** deposita adiciona dinero a la cuenta.
* @param monto el monto a ser agregado, un int nonegativo
* @return true, si el deposito sucedio; false, en otro caso */
public boolean deposit(int monto)
{ boolean result = false;
if ( monto >= 0 )
{ balance = balance + monto;
result = true;
}
else { JOptionPane.showMessageDialog(null,
"BankCuenta error: mal el monto del deposito---ignorado");
}
return result;
}
/* sacarMonto, elimina dinero desde la cuenta, si es posible.
* @param monto el monto de dinero a ser eliminado, un int nonegativo
* @return true, si la eliminacin ocurri; false, en otro caso */
public boolean sacarMonto(int monto)
{ boolean result = false;
if ( monto < 0 )
{ JOptionPane.showMessageDialog(null,
"BankCuenta error: monto malo---ignorado"); }
else if ( monto > balance )
{ JOptionPane.showMessageDialog(null,
"BankCuenta error: monto a sacar excede balance");
}
else { balance = balance - monto;
result = true;
}
return result;
}
65
Dr. Eric Jeltsch F.
/* getBalance reporta lo ocurrido en balance

* @return balance */
public int getBalance()
{ return balance; }
// Un test de la propuesta:
public static void main(String[] args){
BankCuenta tester = new BankCuenta(0); // test objeto
// tratar con el mtodo getBalance:
System.out.println("Inicial balance = " + tester.getBalance());
// tratar con deposito:
boolean test1 = tester.deposit(5050); // depositamos 5050 pesos
System.out.println("Deposito es " + test1 + ": " + tester.getBalance());
// tratar con sacarMonto:
boolean test2 = tester.sacarMonto(3033);
System.out.println("el monto a sacar es " + test2 + ": " +
tester.getBalance());
// tratar una mistake:
boolean test3 = tester.sacarMonto(6000);
System.out.println("el monto a sacar es" + test3 + ": " +
tester.getBalance());
}
}
Ejemplo 3
public class Multiplica1
{
/* Un usuario busca saber cuanto es

72 veces 84, y chequear su respuesta. */
{
ConsoleReader usuario =new ConsoleReader(System.in);
System.out.println("Cuanto es 72 veces 84?");
int resp = usuario.readInt();
if (resp == 6048)
System.out.println("Exito!");
else
System.out.println("Error!");
}
}
Aqu se muestra la salida.

Cuanto es 72 veces 84?
6048
Exito!
Y aqu un ejemplo para el caso de no estar en lo correcto.

Cuanto es 72 veces 84?
5704
Error!
66
Dr. Eric Jeltsch F.
La forma general de la estructura if es,
El esquema siguiente corresponde al programa anterior usando diagramas de flujo
67
Dr. Eric Jeltsch F.
En el siguiente ejemplo, se muestra otra alternativa de uso de la estructura if,

Ejemplo 4
public class Multiplica2 {
/* Un usuario busca saber cuanto es 72 veces 84, y chequear que la respuesta
es 6048. */
{ ConsoleReader usuario =new ConsoleReader(System.in);
System.out.println("Cuanto es 72 veces 84?");
int resp = usuario.readInt();
if (resp == 6048)
System.out.println("Exito!");
else
{ System.out.println
("Error. Trate otra vez.");
resp = usuario.readInt();
if (resp == 6048)
System.out.println
("Exito.");
else
System.out.println
("No. La respuesta es 6048");
}
}
}
68
Dr. Eric Jeltsch F.
Existe una forma corta de usar if. Por ejemplo,

if (a < b) then
System.out.println(El nmero ms pequeo es + a);
Que dice: Si a es menor que b despliega un mensaje, de otra manera NO hace nada.
Esta
if (a < b) then
System.out.println(El nmero ms pequeo es + a);
else
{}
es una forma ms general de una rama en if,
if (con una rama)

if (EXPRESION-Booleana)
Declaracin
Otra forma un tanto ms general,

s = a;
if (b < s) s = b;
if (c < s) s = c;
if (d < s) s = d;
Por ejemplo, si a, b, c y d tienen los valores:

a = 5,
b = 10,
c = 3,
d = 8.
Las respuestas sern:.

1.
2.
3.
4.
La primera declaracin almacena un 5 en s. (Ahora s contiene el 5.)

La segunda, no hace nada pues 10 < 5 es false. (Sigue s con 5)
La tercera almacena 3 en s, pues 3 < 5 es true. (Ahora s contiene 3.)
La cuarta, no hace nada pues 8 < 3 es false. (Sigue s con 3.)
Note que la declaracin if siempre contiene el valor ms pequeo de los valores testeados, de
manera que al final, s contiene el ms pequeo de todos los valores. Una forma simple de if
con una rama es usar la declaracin return. Aqu les muestro un programa que usa el mtodo
Math.sqrt para calcular la raz cuadrada para el usuario.
69
Dr. Eric Jeltsch F.
Ejemplo 5
public class RaizCua
{ /* Busca el usuario calcular la raz cuadrada de un nmero, para ello
ingresa un valor y la salida es lo que espera. */
System.out.print("Ingrese un nmero: ");
double x = in.readDouble();
if (x < 0)
("Nmero debe ser >= 0.");
return;
}
System.out.println
("La raz cuadrada es " + Math.sqrt(x));
}
}
Aqu se muestra un ejemplo de la salida.

Ingrese un nmero: 9.2
La raz cuadrada es 3.03315017762062
Ingrese un nmero: -3
Nmero debe ser >=0.
Esta es la forma comn de este tipo de estructura,

return
(con valor de return)
return statement
(sin valor de return)
return EXPRESION;
return;
La primera forma es usada al interior de un mtodo que retorna un valor. Que dice: termina
obedeciendo este mtodo y retorna el valor dado por la EXPRESION. El segundo es usado al
interior de un mtodo que no retorna valor.
Escogiendo entre alternativas
A menudo es necesario escoger entre 3 o ms alternativas. Esto puede hacerse combinando
varios if. Por ejemplo,
Si el rango de consumo de agua est entre 70 100 costo = A
Si el rango de consumo de agua est entre 60 69 costo = B
Si el rango de consumo de agua est entre 50 59 costo = C
Si el rango de consumo de agua est entre 40 49 costo = D
Si el rango de consumo de agua est entre 30 39 costo = E
Si el rango de consumo de agua est entre 20 29 costo = F
Si el rango de consumo de agua est entre 10 19 costo = G
Si el rango de consumo de agua est entre 0 9 costo = H.
70
Dr. Eric Jeltsch F.
En tal caso, basta considerar las declaraciones

if (rango >= 70) costo = A;
else rango estar entre 0 a 69.
if (rango >= 70) costo = A;
else if (rango >= 60) costo = B;
else rango estar entre 0 a 59.
Eventualmente puede tener

if (rango >= 70) costo = "A";
else if (rango >= 60) costo = "B";
else if (rango >= 50) costo = "C";
else if (rango >= 40) costo = "D";
else rango = "F";
Aqu mostramos un programa completo que convierte un rango ingresado por usuario en
costos.
Ejemplo 6
public class Costos
{ /* Lee un valor en el rango 0 a 100,
y como salida le entrega el costo.
*/
System.out.print("Ingrese el rango [0-100]: ");
int rango = in.readInt();
String costo;
if (rango >= 70) costo = "A";
else if (rango >= 60) costo = "B";
else if (rango >= 50) costo = "C";
else if (rango >= 40) costo = "D";
else costo = "F";
System.out.println("Costo = " + costo);
}
}
La misma tcnica puede ser usada para situaciones en las que se quiera testear una serie de
situaciones una despus de otra
if (B1)
else if
else if
else if
else T
S1
(B2) S2
(B3) S3
(Bn) Sn
71
Dr. Eric Jeltsch F.
Podramos tener un diagrama de flujo que lo representa,
Un tipo de dato bastante frecuente de usar en los cdigos donde intervienen las decisiones son
los tipos de datos booleanos, llamados boolean. La expresin booleana resp == 6048
puede ser evaluada para obtener uno de los valores de verdad true o false. Estos valores
son llamados valores booleanos. Determinando un tipo de dato llamado boolean. Ud. puede
crear variables de tipo boolean y asignarlo a una expresin Booleana, por ejemplo,
boolean ok = (x > 0);
El operador == normalmente nunca es usado para testear si 2 string son los mismos, una
alternativa es utilizar el mtodo equalsIgnoreCase()
st1.equalsIgnoreCase(st2)
que retorna true si st1 y st2 son dos string que consisten de los mismos caracteres, ya sea
mayscula o minsculas, de otra manera ser false. Como ejemplo mostramos un pequeo
sistema de registro para alumnos. En este ejemplo se ha construido una clase llamada Alumno
y un archivo para testear si la clase esta correcta para los datos que se le ingresan, al cabo del
cual entrega una edicin de los datos que Ud. ingreso pudiendo en on-line cambiar los datos
que acabo de ingresar.
72
Dr. Eric Jeltsch F.
Ejemplo 7
public class Alumno {
private String idNumero;
private String nombre;
private String preGrado;
private int anhos;
private boolean estaRegistrado;
/* alumno se ha registrado.
*/
public void registro()
{ estaRegistrado = true;
}
/* alumno NO se ha registrado.
*/
public void desregistro()
{ estaRegistrado = false;
}
/* Return true si el alumno se ha registrado, sino
return false.
*/
public boolean tieneRegistro()
{ return estaRegistrado;
}
/* Editar los detalles del alumno.
*/
public void edit(ConsoleReader input)
{
System.out.print("ID numero (" + idNumero +") " );
String replica = input.readLine();
if (! replica.equals(""))
idNumero = replica;
System.out.print("Nombre (" + nombre + ") ");
replica = input.readLine();
nombre = replica;
System.out.print("Programa de pregrado (" + preGrado + ") ");
if (replica.equals("Ing. Civil") ||
replica.equals("Ing. Alimentos") ||
replica.equals("Ing. Computacion") ||
replica.equals("Ped. Matematicas"))
preGrado = replica;
else
System.out.println("programa de pregrado desconocido.");
System.out.print("Aos (" + anhos + ") ");
anhos = Integer.parseInt(replica);
if (estaRegistrado)
System.out.print("Esta registrado (si) ");
else
System.out.print("Esta registrado (no) ");
if (replica.equals("si"))
estaRegistrado = true;
73
Dr. Eric Jeltsch F.

else if (replica.equals("no"))
estaRegistrado = false;
else
System.out.println("Replica no entendida.");
}
//los datos de pregrado, aos y nombre no son cambiados.

/* Crea un nuevo alumno con el ID numero dado, nombre y pregrado. Los
aos son seteados a 1. Sern registrado como no registrados.
*/
public Alumno(String id, String nm, String preG)
{ idNumero = id;
nombre = nm;
preGrado = preG;
anhos = 1;
estaRegistrado = false;
}
}//end class Alumno
Observar que Test Alumno es una nueva clase pblica la cual invoca a Alumno y
ConsoleReader. TestAlumno esta guardado en archivo con nombre TestAlumno.java,
independiente de la clase Alumno. Pero si en el mismo directorio donde se reconocen.
public class TestAlumno
{
/* Lee detalles de los alumnos. Crea el correspondiente objeto Alumno, y edita
los detalles del objeto.
*/
{
/* Crea ConsoleReader para leer el tipo de usuario. */
/* Crea el Alumno. */
System.out.println
("Cul es el nmero ID del alumno(a)?");
String i = in.readLine();
System.out.println
("Cul es el nombre del alumno(a)?");
String n = in.readLine();
System.out.println
("Pregrado al que pertenece el alumno(a)?");
String d = in.readLine();
Alumno st = new Alumno(i,n,d);
System.out.println("Editar los detalles del alumno.");
st.edit(in);
}
}
Aqu se ve la salida posible al programa anterior, llamado Test Alumno.java con la clase
Alumno en el archivo Alumno.java, adems de la clase ConsoleReader.java
74
Dr. Eric Jeltsch F.
Cul es el nmero ID del alumno(a)?

9912345
Cul es el nombre del alumno(a)?
Alicia Lobos
Pregrado al que pertenece el alumno(a)?
Ing. Computacion
Editar los detalle del alumno.
ID numero (9912345) 9912346
Nombre (Alicia Lobos)
Programa de pregrado(Ing. Computacion)
Aos (1) 2
Esta registrado(no) Si
Algunas expresiones booleanas son:

= =
!=
<
<=
>
>=
igual
no igual
menor que
menor o igual a
mayor que
mayor o igual a
Justamente algunas expresiones aritmticas pueden ser construdas de una forma muy simple
usando operadores aritmticos, tales como, +, , , etc. Si B1 y B2 son expresiones Booleanas.
operador
B1 && B2
B1 || B2
! B1
hace
B1 and B2
B1 or B2
not B1
Expresiones cuyo resultado estn basado en la lgica Boolena, por ejemplo, B1 && B2 es
true si B1 y B2 son ambos true, de otra manera es false. Cuando Java evala B1 && B2,
evaluara primero B1. Si B1 es false no evaluara B2, pues esta condenado a ser false. Un
anlisis similar se hace con los otros conectivos. La expresin ! B1 ser true si B1 es false,
y ser false si B1 es true.
Una expresin de este tipo,
n >= 0 && n< 10 || n >= 20 && n < 30
Java lo interpreta as,

((n>=0) && (n<20)) || ((n>=20) && (n<30))
Una de las tareas ms comunes para cuando compara string, es salir en forma elegante de un
men, por ejemplo tipeando quit, para tal efecto se usa que un valor boolean es o no
equals.
75
Dr. Eric Jeltsch F.
Ejemplo 8
public class ComoEstas
{
/* Busca el usuario hacer un comentario.

*/
System.out.println
(Hola usuario. Como estas?");
String replica = in.readLine();
if (replica.equals("A la Pinta"))
System.out.println
("Yo tambin.");
else if (replica.equals("Para bajo"))
System.out.println("Cuanto lo lamento.");
}
Ciclos
Esta seccin trata de un problema comn en programacin y se refiere a la construccin de
loops o ciclos. Ud. conoce que declaracin usar para la accin de repetir cada vez, lo mismo
de la expresin booleana a usar para testear si el loop a finalizado su tarea. Pero
desafortunadamente para llevar a cabo este tipo de test, es ya sea al comienzo de la accin, de
donde Ud. usa la declaracin while, si ocurre al final usa la declaracin do-while. Pero
que usar cuando desea testear lo que esta ocurriendo a mitad de camino?
Existen varias formas de solucionar esto, un ejemplo tpico es que el usuario ingrese un
nmero x, si x 0, despliegue la raz cuadrada de x. Si el usuario ingresa un nmero negativo
obtendr una seal de trmino del programa,
Repeat
{ Lea el siguiente valor de la entrada
y almacenelo en x;
Si x es negativo termina;
Salida, la raz cuadrada de x;
}
Aqu les muestro 3-versiones

Versin 1
Lea x la primera vez antes de partir el loop. Entonces la declaracin while testea, si x0, y
si es as, la salida ser la raz cuadrada de x, y entonces leera el siguiente valor de x. Es decir,
Lea el siguiente valor de entrada
Y almacenelo en x;
while (x>=0)
{ Salida, la raz cuadrada de x;
lea el siguiente valor de la entrada
y almacenelo en x;
}
76
Dr. Eric Jeltsch F.
Versin 2
Esta versin usa break. Un break dice a Java: termine el loop que Ud. esta realizando en el
acto. En esta version, es un break que causa el termino del loop, y no la expresin Booleana
al comienzo del while. La expresin Boolean al comienzo del while es la constante true. De
seguro que cuando Java evala esto, siempre obtendr el resultado true. As este ciclo nunca
concluye, pero junto con un break podemos generar cdigos que terminen la ejecucin del
programa.
while (true)
{ Lea el siguiente valor de entrada
y almacenelo en x.
if (x<0) break.
Salida, la raz cuadrada de x.
}
break puede ser usado para terminar cualquier tipo de
un break esta en el interior de un ciclo que es a su vez
ciclo incluyendo do-while y for. Si

parte de un ciclo entonces el interprete
terminara la declaracin ms interna.

Versin 3
La tercera versin es usar while junto con una declaracin Booleana. La variable esta seteada
a false al comienzo, y cuando llega el momento de salir del loop switched a true. Al testear
el comienzo del while detecta que la variable es ahora true, causando el trmino del loop.
boolean done = false;
while (! done)
{ lea el siguiente valor de entrada
y almacenelo en x.
if (x>=0)
Salida, la raz cuadrada de x;
else
done = true;
}
Personalmente prefiero versin 2, otras personas consideran

break ser peligroso,
aparentemente porque confunde su aplicacin. En todo caso, Ud. decide cual utilizar para
trabajar con ciclos. Aqu esta el programa completo de la raz cuadrada usando break.
Ejemplo 9
public class RaizCuaLoop
{ /* Lee nmero punto flotante ingresado por el usuario y entrega la
raz cuadrada. Terminando si el usuario ingresa un valor <0. */
{ ConsoleReader in =
new ConsoleReader(System.in);
System.out.println("Programa de Calculo de la Raiz Cuadrada.\n" +
"(Ingrese valor<0 para terminar.)");
while (true)
{ System.out.print("Ingrese el nmero: ");
77
Dr. Eric Jeltsch F.

double x = in.readDouble();
if (x<0) break;
System.out.println
("Raiz Cuadrada = " + Math.sqrt(x));
}
System.out.println("Chao");
}
}
Note que usamos un valor negativo para controlar el programa, valores de este tipo se llaman
sentinelas. Otra forma es usar un mensaje de quit. En tal caso Ud. ingresa esta palabra para
terminar el programa, sino convertir el valor ingresado a double y continua procesando los
datos.
while (true)
{ System.out.print("Ingrese el nmero: ");
String replica = in.readLine();
if (replica.equalsIgnoreCase(quit)) break;
double x = Double.parseDouble(replica);
System.out.println
("Raiz Cuadrada = " + Math.sqrt(x));
}
for
A menudo los loop son usados para generar una serie de valores, cada uno de los cuales esta
almacenado en una variable. Por ejemplo, supongamos que queremos desplegar una tabla de
valores de cos(x) para los valores x: 0, 5, 10, 15, 85, 90. Tal cdigo sera,
double x = 0;
while (x <= 90)
{ Display el valor de x y cos(x).
x = x+5;
}
Un loop de esta forma puede expresarse como for , que tiene la forma,
for (Primero; Continua; Siguiente)
Declaracion
Por ejemplo,
for (double x = 0; x <= 90; x = x + 5)
System.out.println(\t + x + \t + Math.cos(x));
(El valor de cos(x) esta desplegado con 16 decimales). Cuando tengamos un loop del tipo
while, tal como,
int i = 0;
while (i < n)
{ Declaracin
i++;
}
78
Dr. Eric Jeltsch F.
Alternativamente podremos convertirlo en for como sigue.

for (int i = 0; i < n; i = i+1)
Declaracin
Para dejar el termino como una constante, podemos usar una constante llamada cuanTos
for (int i = 0; i < cuanTos; i++)
Escoger un circulo y un color al azar
Y pinte el circulo con el color.
APLICACIONES
En este segmento he escogido estas tres aplicaciones con la intencin de usar de mejor manera
las estructuras de control en beneficio de obtener un programa amigable.
a) Argumentos en la lnea de comando.
Muchas veces, cuando invocamos a un programa desde el sistema operativo, necesitamos
escribir uno o ms argumentos a continuacin del nombre del programa, separados por un
espacio en blanco. Por ejemplo, ls -l del sistema operativo UNIX o en dir /p del sistema
operativo MS-DOS. Tanto ls como dir son programas; -l y /p son opciones o argumentos en la
lnea de rdenes que pasamos al programa para que tenga un comportamiento diferente al que
tiene de forma predeterminada; es decir, para cuando no se pasan argumentos. De la misma
forma, podemos construir aplicaciones Java que admitan argumentos a travs de la lnea de
comando. Qu mtodo recibir esos argumentos? El mtodo main, ya que este mtodo es el
punto de entrada a la aplicacin y tambin el punto de salida.
// Cuerpo del mtodo
Como se puede observar, el mtodo main tiene un argumento args que en lo formal es una
matriz unidimensional de tipo String. Para ejecutarlo con parmetros deber ir a INICIOprogramas-accesorios-simbolo del sistema, aunque algunos IDEs traen incorporado esta
alternativa. Si Ud. lo hubiese ejecutado de la misma forma que antes, le debera salir un
mensaje, como el siguiente.
Ejemplo 10
import java.text.*;
/** CelsiusAFahrenheit convierte input Celsius a Fahrenheit.
*
input: C Celsius, un integer
*
output: F Fahrenheit, un double */
public class CelsiusAFahrenheit
{ public static void main(String[] args) {
int c = new Integer(args[0]).intValue();//args[0] argumento del programa
79
Dr. Eric Jeltsch F.
double f = ((9.0/5.0) * c) + 32;

System.out.println("para C Celsius " + c + ",");
DecimalFormat format = new DecimalFormat("0.0");
System.out.println("F Fahrenheit = " + format.format(f));
}
}
En general, el nombre args puede ser cualquier otro. Esta matriz almacenar los argumentos
pasados en la lnea de comando cuando se invoque a la aplicacin para su ejecucin de la
forma que se observa a continuacin. Observe que cada argumento est separado por un
espacio.
>java MiAplicacion argumento1 argumento2 ...
Cada elemento de la matriz args referencia a un argumento, de manera que args[0] contiene el
primer argumento de la lnea de comando, args[1] es el segundo, y as sucesivamente. Por
ejemplo, supongamos que tenemos una aplicacin Java denominada Test.java que acepta los
argumentos -n y -l. Entonces, podramos invocar a esta aplicacin escribiendo en la lnea de
comando del sistema operativo el siguiente comando:
>java Test -n -l
Esto hace que automticamente la matriz args de objetos String se cree para contener dos
objetos String: uno con el primer argumento y otro con el segundo. Para clarificar lo expuesto
vamos a mostrar una aplicacin a travs de un ejemplo que simplemente visualiza los valores
de los argumentos que se la han pasado en la lnea de comando. Esto nos dar una idea de
cmo acceder desde un programa a esos argumentos. Supongamos que la aplicacin se
denomina Test y que slo admite argumentos -n, -k y -l. Esto quiere decir que podremos
especificar de cero a tres argumentos. Los argumentos repetidos y no vlidos se desecharn.
Por ejemplo, la siguiente lnea invoca a la aplicacin Test pasndole los argumentos n y -l:
>java Test -n -l
80
Dr. Eric Jeltsch F.
El cdigo completo de la aplicacin propuesta, se muestra a continuacin.

Ejemplo 11
public class Test
{
{
// Cdigo comn a todos los casos
System.out.println("Argumentos: ");
if (args.length == 0)
{ // Escriba aqu el cdigo que slo se debe ejecutar cuando
// no se pasan argumentos
System.out.println(" ninguno");
}
else
{
boolean argumento_k = false, argumento_l = false,
argumento_n = false;
// Qu argumentos se han pasado?
for (int i = 0; i < args.length; i++)
{
if (args[i].compareTo("-k") == 0) argumento_k = true;
if (args[i].compareTo("-l") == 0) argumento_l = true;
if (args[i].compareTo("-n") == 0) argumento_n = true;
}
if (argumento_k) // si se pas el argumento -k:
// se pasa el argumento -k
System.out.println("
-k");
}
if (argumento_l) // si se pas el argumento -l:
// se pasa el argumento -l
-l");
}
if (argumento_n) // si se pas el argumento -n:
// se pasa el argumento -n
-n");
}
}
// Cdigo comn a todos los casos
}
}
Al ejecutar el comando >java Test -n -l , se obtendr el siguiente resultado. Notar el orden de salida de los
datos
Argumentos:
-l
-n
b) Relacin con el usuario.

En lo fundamental se refiere a los ciclos anidados. Este es un programa que pregunta por las
tablas de multiplicar, me da una ayuda y acertando (o errando) me pregunta, si me quiero ir o
no, con un mensaje de consola. La idea ahora es usar ciclos anidados para evitar de enviarme
afuera hasta mientras no d con el resultado correcto!!, de ser as me pregunta si quiero seguir
practicando las tablas de multiplicar, ahora si ingreso me rindo me entregara el resultado
81
Dr. Eric Jeltsch F.
correcto, y me volver a preguntar si deseo seguir practicando. Generando con ello un

programa amigable para un usuario eventualmente inexperto.
Ejemplo 12
import java.util.*;
public class Multiplicar
{
/* Test para las tablas de multiplicar.*/

Random rand = new Random();
System.out.println("Practicando las Tablas.");
String replica;
do
{ /* Escoger 2 numeros entre 1 y 12. */
int a = rand.nextInt(12) + 1;
int b = rand.nextInt(12) + 1;
/* Test para el usuario si sabe las tablas. */
System.out.println
("Cuanto es " + a + " multiplicado por " + b + "?");
int respuesta = in.readInt();
if (respuesta == a*b)
System.out.println("Bien!");
else
System.out.println
("No. La respuesta es a*b");
/* Chequea si el usuario quiere seguir. */
System.out.println
("Quiere seguir practicando (si/no)?");
replica = in.readLine();
}
while (replica.equals("si"));
System.out.println("Chao");
}
Lo siguiente es lo que aparece cuando el programa esta corriendo.

Practicando las Tablas.
Cuanto es 11 multiplicado por 8?
9
No. La respuesta es a*b
Quiere seguir practicando (si/no)?
si
Cuanto es 5 multiplicado por 4?
20
Bien!
Quiere seguir practicando (si/no)?
no
Chao
82
Dr. Eric Jeltsch F.
c) Recursividad
Existen procesos que se llaman a s mismo, tales procesos o mtodos son llamados mtodos
recursivos, muy tiles y fcil de programar en contraste con los mtodos iterativos. Por eso
que los mtodos recursivos son muy aplicados en la programacin y Ud. podra seguirse
familiarizandose con esto. Consideremos el siguiente programa. Lea dos enteros de la
entrada de usuario y luego despliege el valor del primero elevado al segundo. El valor es
power(n,p). Note que power es un mtodo recursivo.
Ejemplo 13
public class PotenProg
{ /* Lee 2 integers, x e y, donde y>=0. Output es el valor de x elevado
a y. */
System.out.print
("Ingrese el primer entero: ");
int i1 = in.readInt();
System.out.print
("Ingrese el segundo entero(>0): ");
int i2 = in.readInt();
System.out.println
(i1 + " elevado a " + i2 +
" = " + power(i1,i2));
}
/* Si p>=0, return n elevado a p. */
private static int power(int n, int p)
{ if (p == 0)
return 1;
else
return power(n,p-1)*n;
}
}
Lo que realiza este programa es lo siguiente, as se visualiza su interaccin con el usuario.

Ingrese el primer entero: 3
Ingrese el segundo entero(>0): 5
3 elevado a 5
= 243
Suponga ahora que el programa est siendo ejecutado y la entrada por usuario es 2 y 4. Luego
el mtodo main es llamado, el usuario ingresa los dos valores, luego Java llamar a
power(2,4) para encontrar la solucin y respuesta, notar que la funcin est definida como
mtodo. En la primera llamada al mtodo power el parmetro valor es n = 2 y p = 4. En este
caso la segunda declaracin return en el cuerpo del mtodo ser realizada, esto significa que
Java evaluar la expresin power(n,p-1)*n, y entonces power(2,3) ser evaluado. Se tiene,
power(2,4) power(2,3). La siguiente vez que power es llamado pasa lo mismo, esta vez
power(2,2) ser llamada y el diagrama queda, power(2,4) power(2,3) power(2,2).
83
Dr. Eric Jeltsch F.
Similarmente cuando power(2,2) es realizada llamar a power(2,1). Y cuando

power(2,1) se realice, llamara a power(2,0).
power(2,4) power(2,3)
power(2,2) power(2,1) power(2,0). Aqu la cadena se detiene pues power(2,0) es

realizado y va al primer return y se ejecuta. As, power(2,0) retorna el valor 1, el que ser
usado en la ejecucin de power(2,1), entregando el valor 12, que es 2, el que ser usado en la
ejecucin de power(2,2), entregando el valor 4, y as sucesivamente. En general, podemos ver
que si power(n,p) es realizada, con p0, la cadena completa contendr p+1 llamadas a
power, siendo la ltima llamada la que entrega 1. Todos los otros entregan n veces el valor
retornado por el siguiente. Las llamadas a power(n,p) entregan np. Vea el diagrama
No digo que este proceso sea rpido, pero si es sencilla su implementacin para calcular np.
Si p < 0 la cadena seguir por siempre. Luego un cdigo para calcular np, donde p 0, deber
tener probablemente algo parecido a esto.
int resp = 1;
for (int i = 0; i < p; i++)
resp = resp * n;
En general, cualquier mtodo recursivo puede ser escrito usando cdigo no-recursivo. Otro
ejemplo tpico es el factorial de un nmero entero.
Ejemplo 14
public class FactorialTest
{ // Clculo del factorial de un nmero
public static long factorial(int n)
{
if (n == 0)
return 1;
else
return n * factorial(n-1);
}
{
int numero;
long fac;
84
Dr. Eric Jeltsch F.
do
{
System.out.print("Ingrese el Nmero:");
numero = in.readInt();
}
while (numero < 0 || numero > 25);
fac = factorial(numero);
System.out.println("\nEl factorial de " + numero + " es: " + fac);
}
}
85
CAPITULO5
Excepciones y Flujo de Datos (Exceptions y Streams)
Mensajes de error enviados por el compilador.
Los humanos podemos tolerar errores ortogrficos y gramaticales, pero los computadores no,
y por esta razn el compilador Java cumple con su labor de denunciar este tipo de errores,
identificando la lnea y dando una corta explicacin. Por ejemplo, aqu tenemos un programa
que tiene varios errores.
public class test
{ public static main(String[] args)
{ System.out.println(Hello!)
}
Almacenemos el programa en Test.java y compilemoslo. El compilador replica, con varios

errores de mensaje, el primero de ellos es
C:\Documents and
Settings\usuario\Escritorio\POO\POO_web_CD\Java_poo\Libro_Base_java\test.jav
a:2: invalid method declaration; return type required
^
a) Estableciendo que existe un error en la lnea 2 del programa y que se ubica

aproximadamente en la posicin marcada con ^. No nos dice exactamente cual es el
problema, pero si nos invita a reflexionar respecto de la sintaxis de un programa. En
este caso particular hemos olvidado la palabra clave void.
C:\Documents and
a:3: ')' expected
{ System.out.println(Hola!)
^
b) Luego el compilador reporta otro error en la lnea 3 del programa y que se ubica
aproximadamente en la posicin marcada con ^. Lo que nos ayuda a ver con mayor
preocupacin que pasa en ese segmento de programa, y notamos que al escribir la
palabra. Hola!, hemos olvidado escribirlo entre comillas.
C:\Documents and
a:4: ';' expected
}
^
c) El compilador reporta otro error en la lnea 4 del programa y que se ubica

aproximadamente en la posicin marcada con ^. Y notamos que nos falto cerrar una
declaracin con ;
Dr. Eric Jeltsch F.
Captulo 5: Excepciones y Flujo de Datos
C:\Documents and
a:5: '}' expected
^
4 errors
Herramienta completada con cdigo de salida 1
d) El compilador reporta otro error en la lnea 5 del programa y que se ubica

aproximadamente en la posicin marcada con ^. Y notamos que nos falto cerrar un
parntesis, con un semicolon }
Desafortunadamente, el compilador no es perfecto en detectar todos los errors gramaticales en
una primera leda, es as como se require compilarlos e ir modificando el cdigo del programa,
hasta que quede libre de errores, no obstante el compilador no podr hacer nada frente a un
error semntico. Para completar este segmento digamos que este es un tpico error para cuando
una clase est carente de una clase principal para ser testeada.
Para mayor consulta dirigirse a The Java Language Specification, de J. Gosling, B. Joy, y G.
Steele, Addison Wesley Publishing, 1996, para la definicin del lenguaje Java.
Diagnostico de los errores en Expresiones y Variables
Expresiones y variables le dan a un programa ms potencia, pero al mismo tiempo ofrecen la
oportunidad de generar ms errores. Los errores en este sentido pueden ser de dos formas:
Errores relacionados con la gramtica, contexto (tipo de datos), que el compilador Java
puede detectar, son llamados: errores en tiempo de compilacin.
Errores que ocurren para cuando el programa es ejecutado, deteniendose su ejecucin

en forma temprana, son llamados errores en tiempo de ejecucin o excepciones.
Si consideramos el programa
public class Test1{
System.out.println( (1+2(*3 );//que desea?
System.out.println(Hola!);
}
}
a) vemos que el compilador notifica y anuncia:

C:\Documents and
Settings\usuario\Escritorio\POO\POO_web_CD\Java_poo\Libro_Base_java\Test1.java:
3: ')' expected
System.out.println( (1+2(*3 );
^
87
Dr. Eric Jeltsch F.
b) Si consideramos ahora el programa, detecta un problema en la definicin del tipo de dato.

public class Test1{
string s;//basta con saber que el tipo de dato es String
}
}
C:\Documents and
4: cannot resolve symbol
symbol : class string
location: class Test1
string s;
^
C:\Documents and
3: operator + cannot be applied to int,boolean
System.out.println(3 + true);
^
la explicacin del compilador es elocuente, es decir enteros con boolenos no se entienden.

public class test {
int i=0;
System.out.println(1/i);
System.out.println("Hola!");
}
}
tras el proceso natural de compilacin podr ver que el compilador no anuncia ningn tipo de
problemas. Sin embargo, en la ejecucin dice lo que se muestra.
este es un tpico error en tiempo de ejecucin, o tambin llamado una exception. Esto surgi
cuando un programa usa tipos de datos incorrectos como argumentos del programa. No
obstante si declara double i=0; en la ejecucin saldr
c) Otro ejemplo, surge para cuando se desea ejecutar un programa Java pero con varios
parmetros desde la consola.
88
Dr. Eric Jeltsch F.
public class test {

int i = new Integer(args[0]).intValue();
System.out.println(1 / i);
}
}
El mensaje de error fue gatillado por la lnea 3, y fue generado por la creacin de un objeto
Integer en la lnea, siendo que la entrada de datos es un carcter, en este caso a.
Finalmente, mostremos algunos errores que no son detectados ni por el compilador de Java, ni
por su intrprete. Por ejemplo, se imprimen las variables x e y que son la misma. La
declaracin pasa la inspeccin del compilador Java, ahora realiza su ejecucin y si Ud. espera
ver ya sea un true o un false ver que surge un resultado, 7.
public class test {
int x = 3;
int y = 7;
System.out.println(x = y);
}
}
89
Dr. Eric Jeltsch F.
La razn es que x = y es una asignacin y no un test para igualdad, como (x = = y). La

declaracin, System.out.println(x = y), asigna y's valor a x's y lo imprime.
Luego de haber visto esta serie de errores podr formarse una idea, de lo que se trata este
captulo y que se refiere a complementar y reforzar el uso de excepciones, en donde Java
posee una forma de tratar los errores en tiempo de ejecucin. Adems veremos como leer
desde el teclado sin usar la clase que se le ha pedido prestada a Horstmanns llamada
ConsoleReader, y como leer y escribir archivos de texto, adems de como hacer uso de los
parmetros que todo mtodo main posee.
Excepciones
Java tiene un especial mecanismo para tratar errores en tiempo de ejecucin. Suponga que
escribe algn cdigo que puede tener errores cuando lo ejecuta. Por ejemplo, si una cierta
variable se refiriese a un objeto, y un error ocurre si la variable contiene null. Entonces puede
Ud. insertar una declaracin que arroja una excepcin (throws and exception) si la condicin
de error ocurre. Veamos 2 situaciones.
1. Crear un objeto que describe la condicin de error, usualmente llamada un objeto
exception. (Ella pertenece a la clase Throwable, y estar ya sea en la subclase Error, si es
un serio error del sistema, o en la subclase Exception, si ocurri el error en el tiempo de
ejecucin normal.)
2. Esto causa que el interprete se detenga en la secuencia de declaraciones en donde ocurri el
error y comience a buscar una clausuala catch que ha sido escrita para responder al error
apropiadamente, es decir, desplegando un window que le informa al usuario que hacer en lo
sucesivo. (Como buscar la clausula catch se describir posteriormente.) Si el interprete no
puede encontrar una clausula disponible catch, el programa se detiene y Java desplegara
un mensaje de error por defecto en la ventana DOS. Esto origina el nombre de excepciones
y una lista de todos los mtodos que estn siendo ejecutados actualmente.
Las excepciones son a menudo atrapadas o arrojadas por el mismo Java, ya sea por uno de los
mtodos de librera, o por un interprete, es decir, cuando encuentra algo el mismo trata de
accesar a un array de elementos con un valor del indice fuera del rango correcto de valores. En
este caso, la excepcion ser una IndexOutOfBoundsException.
Una clusula catch es parte de una declaracin try-catch y tiene la forma siguiente.
try
{ Declaraciones
catch (EXCEPCION1 e1)
{ Declaraciones
}
{ Declaraciones
finally
{ Declaraciones
}
90
Dr. Eric Jeltsch F.
La ltima parte finally clausula es por lo general omitida. Cuando el interprete obedece la
declaracin try-catch, ella ejecuta la DECLARACION try normalmente. Si ninguna
excepcion es arrojada, eso es todo cuanto la declaracin try-catch hace. Si una excepcion es
arrojada, el interprete partira buscando para una try-clausula que sea obedecida para cuando
la excepcion fue arrojada.
Por supuesto la declaracin try en la declaracin try-catch fue obedecida, pero puede
haber otra declaracin try-catch ms cerca de donde ocurri el error. El intrprete entonces
buscar el ms interno, llamaremos a la declaracin que produjo el error S0. Primero el
intrprete mira dentro del cuerpo del mtodo que contiene S0. Si encuentra que S0 est dentro
de una try, toma una. Si hay dos o ms declaraciones try anidadas que contienen a S0,
toma la ms interna. Si S0 no est al interior de una try, el intrprete va a la declaracin S1
que llam el mtodo que contiene S0. Entonces empieza buscando la catch ms interna que
contiene S1. Si no puede encontrar uno en ese cuerpo del mtodo, va a la declaracin S2
llamando el mtodo que contiene S1. Y as sucesivamente. Aqu se muestra un programa que
contiene una declaracin try-catch. El programa lee una serie de valores de punto flotante
ingresados por el usuario, y se detiene cuando lee la palabra fin. Suma los nmeros y al
mismo tiempo cuenta cuantos nmeros son, finalmente, divide la suma de los nmero por el
contador generando as el promedio de los nmeros ingresados, el cual es desplegado en
pantalla.
El programa chequea si ve en la lnea la palabra fin. La lnea es leda usando readLine. Si
ella no tiene fin, el programa procura convertirla en nmero usando el metodo
Double.parseDouble. Si por error de tipeado, el usuario tipea algo que no es un nmero o la
palabra fin, entonces una NumberFormatException ser lanzada. Si no es capturado el
programa despliega un mensaje de error por defecto y para.
Una declaracin try-catch ha sido insertada en esta versin del programa para capturar las
excepciones, y as evitar el mensaje de error. La clausula try incluye la llamada a
Double.parseDouble, y la accin que continua para cuando el nmero esta correcto. La
clausula catch justamente despliega un simple error de mensaje, y entonces el programa esta
habilitado para realizar su tarea.
Ejemplo 1
public class Promedio1
{
/* Lee nmeros flotante ingresados por el
usuario y entrega el promedio.
(Version que usa ConsoleReader.)
*/
ConsoleReader usuario = new ConsoleReader(System.in);
/* Lee y agrega los valores, y cuenta cuantos son. */
double sum = 0;
int cuanTos = 0;
System.out.println("Ingrese los datos.");
while (true)
{ String linea = usuario.readLine();
91
Dr. Eric Jeltsch F.
if (linea.equals("fin")) break;
try
/* proteccin de cdigo, que podra lanzar una excepcin dentro de try, pues
este segmento de cdigo podra causar una excepcin, si no existen problemas
continue, sino*/
{
double siguiente = Double.parseDouble(linea);

sum = sum + siguiente;
cuanTos++;
}
catch (NumberFormatException e)
/* Atrape la excepcin, haciendo una prueba para manejar una excepcin dentro
de catch*/
("Ingreso NO reconocido, intentelo de nuevo!.");
}
}
/* el promedio. */
if (cuanTos > 0)
System.out.println
("El valor promedio es = " + sum/cuanTos);
else
System.out.println("Sin resultado.");
}
}
Tambin como excepciones producidas por Java, puede forzar una excepcion para ser arrojada
mediante la declaracin throw . Esta clausula indica que algn cdigo en el cuerpo de su
mtodo podra lanzar una excepcin, para tal efecto simplemente agregar la palabra throw
despus del nombre del mtodo pero antes de abrir el bloque. Por ejemplo,
public boolean miMetodo(int x, int y) trows AnException {
o ms simple seguida por la referencia a un objeto excepcion. Por ejemplo,

throw new NumberFormatException();
Note que un constructor es usado para crear el objeto exception aqu. Existen muchos tipos de
excepciones definidas en la librera. Para encontrarlas todas vea la clase Exception y sus
subclases. Tambin, puede Ud. definir sus propias clases exccepcion extendiendo la clase
Exception.
Leer desde el teclado
Cuando un programa Java lee la entrada, usa un objeto de algn tipo para manejar la entrada.
El objeto ser conectado a la fuente de la entrada, es decir la entrada fuente, me refiero a el
teclado o archivo de texto. En trminos de leer valores de entrada desde la fuente usamos
mtodos pertenecientes a ese objeto. El objeto ConsoleReader el cual hemos usado durante el
curso para leer desde el teclado es un tpico ejemplo de un objeto que maneja la entrada.
92
Dr. Eric Jeltsch F.
El objeto que maneja la entrada ser llamada InputStream o un Reader. La diferencia depende
sobre que valores produce para cuando lea los caracteres. Un InputStream returns un 8-bit
byte cada vez que lea un carcter, que es como el sistema lo representa. Un Reader returns 16bit caracteres. Esta es la forma estandar que Java representa caracteres, usando caracteres de
cdigo llamados unicode.
Cada vez que se crea un objeto ConsoleReader, hacemos uso de otro objeto llamado
System.in. Esto es un InputStream conectado directamente al teclado. InputStreams tiene
varios mtodos asociados con ellos, pero solamente uno puede ser usado para leer la entrada
que es read que lee 8-bit byte. El siguiente diagrama representa el objeto System.in
conectado al teclado, con la informacin que fluye del teclado,
keyboard
System.in
Java posee clases llamadas InputStreamReader que consiste de objetos que producen los
caracteres 16-bit unicode usados por Java. Existe un constructor que puede convertir un
InputStream en un InputStreamReader. Ud. deber darle InputStream como parametro, y el
creara el InputStreamReader.
Por ejemplo, la declaracin siguiente construira una
InputStreamReader conectado a System.in.
InputStreamReader lector = new InputStreamReader(System.in);
Ud. puede incluir un segundo parmetro para especificar un decodificador noestandar para
devolver bytes en caracteres unicode. Sin el segundo parametro, el InputStreamReader usar
un decodificador estandar, el cual es satisfactorio para usos o propsitos normales. Lo mismo
es posible para la salida. Aqu esta el diagrama de InputStreamReader definido anteriormente.
Se obtiene 8-bit bytes desde el teclado, usando System.in, convirtindolos en caracteres de
16-bit.
teclado
System.in
InputStreamReader
Un InputStreamReader tiene un mtodo read que entrega un carcter simple. Esto sera
posible de usarse para cuando escriba mtodos que usan nmeros reales, lneas de texto, etc.
Sin embargo, un conveniente punto de partida es un objeto, el cual puede leer una linea de
caracteres ala vez. Existen 2 tipos de objetos que pueden hacer uso de ellos. Uno es llamado
BufferedReader y el otro es LineNumberReader. Ambos tienen un mtodo readLine que
retorna la siguiente lnea de entrada. Ud, puede convertir un InputStreamReader en
BufferedReader. Usualmente se hace mediante constructores. Por ejemplo,
BufferedReader usuario =
new BufferedReader
(new InputStreamReader(System.in));
93
Dr. Eric Jeltsch F.
La declaracin se v como sigue,

teclado
System.in
InputStreamReader
BufferedReader
Ejemplo 2
Un programa que pregunta por la dimensin del cuadrado y entrega lo solicitado. Si le ingresa
el valor 5, vera la figura:
*****
*
*
*
*
*
*
*****
import java.io.*;
public class Ejerc5{
public static void main(String args[]) throws IOException {
int tam;
BufferedReader din;
din = new BufferedReader( new InputStreamReader(System.in));
System.out.println("Cuadrado");
System.out.println("========");
while (true) {
System.out.print("Largo del lado [1-20,0=Fin]: ");
tam = Integer.parseInt(din.readLine());
if (tam < 1) {
break;
}
else if (tam <= 20) {
for (int i = 1; i <= tam; ++i) {
for (int j = 1; j <= tam; ++j) {
if (j == 1 || j == tam || i == 1 || i == tam){
System.out.print("*"); }
else {
System.out.print(" ");
}
}
}
}
}
}
}
94
Dr. Eric Jeltsch F.
Ejemplo 3
El programa CambioMoneda, calcula el cambio para un monto de dolares-y cents, todo ello
ingresado por teclado.
import java.io.*;
/** CambioMoneda calcula el cambio para un monto de dolares-y -cents.
* input: un monto en dolares y un monto en cents. Ambos enteros.
* output: el listado de las monedas necesarias. */
public class CambioMoneda
{ public static void main(String[] args) throws IOException
{ BufferedReader teclado = new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Tabla de Montos");
System.out.println("===============");
System.out.print("Ingrese monto de dolares: ");
String dolares = teclado.readLine();
System.out.print("Ingrese monto de cets: ");
String cents = teclado.readLine();
int monedas = (100 * new Integer(dolares).intValue())
+ new Integer(cents).intValue();
System.out.println( "quarters = " + (monedas/25) );
monedas = monedas % 25;
System.out.println( "dimes = " + (monedas/10) );
System.out.println( "nickels = " + (monedas/5) );
System.out.println( "pennies = " + monedas );
}
Como leer archivos de texto

Existen 2 formatos de archivo:
character file, que es una secuencia de simbolos del teclado, almacenados en un

archivo como una secuencia de bytes;
binary file, que es una secuencia de unos y ceros.
Un texto depositado en un archivo podr tener diferentes formatos, por ejemplo.

Hola!
Cmo estas t?
49
como una secuencia Hola!\nCmo estas t?\n

49\n
95
Dr. Eric Jeltsch F.
Por otra parte un archive binario es una secuencia de unos y ceros, de manera que 49 es
expresado como, 11001, y no como la representacin '4' y '9').
Cuando obtenemos informacin de entrada desde un archivo, se dice que read desde el
archivo; para cuando depositamos una informacin de salida en un archivo, decimos write en
l. Cuando comenzamos a usar un archivo, decimos que se open , y cuando terminamos de
usarlo, lo close. Los archivos pueden ser read/written en dos sentidos:
sequential file pueden ser read (o written) desde front to back; es decir es un libro que
tiene una sola direccin de lectura, pudiendo regresar en una sola direccin,
(forwards).
random access file pueden ser reads (o writes) sobre cualquier lugar, es como si en un
libro pudiese abrirlo en cualquier pgina.
Sequential files son simples para manejar y trabajar aplicaciones estandares, mientras que los
Random access files son usados principalmente para aplicaciones de database donde se
especifican bits de informacin. En este segmento se vern solamente sequential files. Para
programas Java que usan sequential file, se debe establecer si el archio usado es usado para
input: el file es read sequentially y no puede ser written.
output: el file esta written sequentially y no puede ser read.
La clase BufferedReader lee un flujo de entrada de caracteres y los guarda en un array llamado
buffer. Para crear una versin en buffer se debe tener un objeto Reader existente de algn
tipo. Para crear un BufferedReader se puede utilizar el siguiente constructor.
BufferedReader(Reader).
Que crea un flujo de caracteres almacenado en bufer,

asociado con el objeto especificado Reader, como FileReader.
BufferedReader(Reader, int). Que crea un flujo de caracteres almacenado en
buferasociado con el objeto especificado Reader y con un buffer de tamao int.
Un flujo de caracteres almacenado en bufer se puede leer utilizando los mtodos read() y
read(char[], int , int) descritos en FileReader. Puede leer una lnea de texto usando el mtodo
readLine(). El mtodo readLine() devuelve un objeto String que contiene la prxima lnea de
texto en el flujo, sin incluir el carcter o caracteres que representan el final de una lnea, que
puede ser(\n, lnea nueva), (\r, retorno de carro) o una combinacin de esta ltima con la
primera. Si se llega al final del flujo, el valor devuelto de la cadena es igual a null.
Ejemplo 4:
Escribimos una aplicacin que lee el contenido de un archivo secuencial cuyo nombre es dado
por el usuario desde el teclado y copia el archivo, f, line by line, en otro file, f.out.
import java.io.*;
/** CopiarFile copia el contenido de un file, f,
* cuyo nombre es sustituido por un file, f.out
*/
96
Dr. Eric Jeltsch F.
public class CopiarFile

{ String f = JOptionPane.showInputDialog("Input nombrefile: ");
// se construye el objeto view que reads desde el input file:
BufferedReader infile = new BufferedReader(new FileReader(f));
// se construye el objeto view que writes al output file:
PrintWriter outfile = new PrintWriter(new FileWriter(f + ".out"));
while ( infile.ready() ) // existen ms lineas que leer en infile?
{ String s = infile.readLine();
outfile.println(s);
}
infile.close();
outfile.close();
}
}
al ingresar su nombre, asumir que ese archivo existe y copiara su contenido en un archivo de
salida similar. Todo esto lo comprobar si se remite a ver el directorio en donde esta
trabajando. A continuacin se ve un mensaje clsico para cuando no existe el archivo en
cuestin.
El error, java.io.FileNotFoundException, es un ejemplo de una IOException---el

programa thrown (lanza) una exception. En todo caso tales exceptions pueden ser
manejadas. En este sentido, manejaremos esta excepcin para el caso que se ingrese un 0. Y
Ud. vera la diferencia, en donde el programa me invita a ejecutarlo nuevamente.
Ejemplo 5:
/** Dividir lee un int y lo divide en 12 */
public class DividirTC {
int i = readAnInt();
try {
JOptionPane.showMessageDialog(null, "La respuesta es" + (12 / i));
97
Dr. Eric Jeltsch F.
}
catch(RuntimeException e)
{
"Error en input: " + i + ". Ejecutelo nuevamente.");
}
System.out.println("Terminado.");
}
/** readAnInt lee un int y lo retorna */
private static int readAnInt() {
String s = JOptionPane.showInputDialog("Ingrese un entero:");
int num = new Integer(s).intValue();
return num;
}
}
String tokenizers y los file objects pueden ayudar a crear una aplicacin cuya entrada se basa
en un cierto formato, as como su salida. Un ejemplo estndar es el proceso de enlistar alguna
informacin, en donde en este ejemplo se trata de un archivo secuencial, donde cada lnea
contiene el nombre de un empleado, las horas trabajadas y el pago por ellas, ya sea en un
contexto de sobretiempo o alguna otra que no interesa. La informacin se ve as.
Fred Mercader|31|20.25
Lucy Riggs|42|24.50
Ethel Meza|18|18.00
Notar que la secuencia de lneas es terminada por un simbolo especial, !. Una aplicacin de
este tipo lee las lneas una por una, extrae el tokens de cada lnea, convirtiendo a nombre y
nmero y calculando el sueldo.
98
Dr. Eric Jeltsch F.
class LeerInfo
Metodos
getNextRecord():
boolean
Lee el siguiente registro desde el archivo de entrada. Returns V o F, si esta o

no el archivo segn el formato deseado.
nombreE(): String
Return el nombre del empleado.
horasE(): int
Return las horas trabajadas por el empleado.
sueldoE(): double
Return el pago para el empleado.
close()
Close el archivo base.
/** LeerInfo lee los records desde un sequential file. El records tiene el
formato, NOMBRE|HORA|PAGO. El file termina con un ! */
import java.io.*;
import java.util.*;
public class LeerInfo{
private BufferedReader infile; // la direccin del input file
private String END_OF_FILE = "!";
// nombre, hora y pago del record ledo:
private int hora;
private double pago;
/**constructor de LeerInfo para leer desde un file el file_nombre*/
public LeerInfo(String file_nombre) {
try { infile = new BufferedReader(new FileReader(file_nombre)); }
catch (Exception e){
System.out.println("LeerInfo error: nombre file malo: "
+ file_nombre + "
Abortando!");
throw new RuntimeException(e.toString());
}
}
public String nombreE() { return nombre; }
public int horasE() { return hora; }
public double sueldoE() { return pago; }
public void close() {
try { infile.close();
}
catch (IOException e){
System.out.println("LeerInfo Atencin: falla"); }
}
/** getNextRecord pretende leer un nuevo registro.
* @return si otro record record fue read y esta ready para procesar*/
public boolean getNextRecord()
boolean result = false;
nombre = null;
hora = -1;
pago = -0.1;
try {
99
Dr. Eric Jeltsch F.
if ( infile.ready() ) {
String linea = infile.readLine();
StringTokenizer t = new StringTokenizer(linea, "|");
String s = t.nextToken().trim();
if ( ! s.equals(END_OF_FILE) ) {
// termina?
if ( t.countTokens() == 2 ) { // hora y pago?
nombre = s;
hora = new Integer( t.nextToken().trim()).intValue();
pago = new Double(t.nextToken().trim()).doubleValue();
result = true;
}
else { throw new RuntimeException(linea);
}
}
}
}
System.out.println("LeerInfo error: " + e.getMessage());
}
catch (RuntimeException e){
System.out.println("LeerInfo error: mal formato record: "
+ e.getMessage() + " se salta este record y trata otra vez");
result = getNextRecord(); // try again
}
return result;
}
}
Para testear la clase LeerInfo, implementemos una clase principal llamada Pagos.java para
testearla.
/** Pagos lee un archivo bajo un cierto formato. */
public class Pagos{
String in_nombre = JOptionPane.showInputDialog("Nombre archivo
entrada:");
String out_nombre = JOptionPane.showInputDialog("Nombre archivo
salida:");
if ( in_nombre != null && out_nombre != null ) {
procesandoArchivo(in_nombre, out_nombre);
}
System.out.println("Terminado");
}
private static void procesandoArchivo(String in, String out) {
LeerInfo leer = new LeerInfo(in);
while ( leer.getNextRecord() ) {//algo se hace con ellos?
double pago = leer.horasE() * leer.sueldoE();
}
leer.close();
}
}
100
Dr. Eric Jeltsch F.
El trabajo duro es realizado al interior de getNextRecord, el que verifica el input file si es no

vaco antes de leer el siguiente record. El mtodo tambin se asegura que el record no este con
la bandera, !, y que el record posee un string al nombre, un integer como horas trabajadas y un
double para el pago. Si todo esto ocurre, entonces la informacin desde el record es
almacenada y devuelve true. El mtodo no acepta malos formatos de los records y returns false
cuando alcanza el fin de la entrada. Algunas de las exception son tratadas, tal como las que
surgen cunado intValue y doubleValue fallanl. En tal caso estamos forzados a usar un throw
new RuntimeException(linea), lo que nos informar la cantidad incorrecta de datos sobre la
lnea de entrada. Como un buen ejercicio complementario, sera interesante que se construyera
una clase EscribirInfo para el ejemplo recin dado, en donde los clculos de los sueldos vayan
a dar a otro archivo.
En este otro ejemplo se muestra una aplicacin de Java que lee su propio archivo fuente
atravs de un flujo de caracteres almacenado en buffer.
Ejemplo 4
import java.io.*;
public class leeFuente {
public static void main(String[] arguments) {
try {
//se crea una fuente de entrada, en este caso el archivo //leeFuente.java
FileReader archivo = new
FileReader("leeFuente.java");
//un filtro de bufer se asocia al archivo, llamado buff,
//que es un objeto .
BufferedReader buff = new
BufferedReader(archivo);
boolean eof = false;
while (!eof) {
//mtodo readLine()dentro de un loop para leer el archivo
//de texto lnea por lnea. El loop termina para cuando
//el mtodo devuelve el valor null.
String linea = buff.readLine();
if (linea == null)
eof = true;
else
System.out.println(linea);
}
buff.close();
} catch (IOException e) {
System.out.println("Error -- " + e.toString());
}
}
}
Aqu tenemos otra versin de Promedio1, la diferencia radica en que el programa no usa la
clase ConsoleReader. El programa parte creando un BufferedReader para leer la entrada del
usuario. Las diferencias son mostrada en bold. Como Ud. ver la primera lnea ser
afectada
101
Dr. Eric Jeltsch F.
Ejemplo 5
import java.io.*;
{
/* Lee punto flotante ingresado por

el usuario y entrega el promedio.
(Version que usa BufferedReader.)
*/
throws IOException
{ BufferedReader usuario = new BufferedReader
/* Lee y suma los valores, y cuenta cuantos son. */
double sum = 0;
int cuanTos = 0;
System.out.println("Ingrese los valores.");
while (true)
try
{
cuanTos++;
}
("Entrada No reconocida, intente nuevamente!.");
}
}
/* promedio. */
if (cuanTos > 0)
System.out.println
("El promedio es = " + sum/cuanTos);
else
System.out.println("Sin valor.");
}
}
Note que en el encabezado del programa as como en ejemplo que haca referencia a la
formacin de cuadrados se tiene,
Este llama al compilador que el mtodo main contiene, llamado readLine, que puede arrojar
la IOException, la cual no ser atrapada pues main no tiene la declaracin try-catch para
atraparla. En IOException se cubre un rango de diferentes errores o condiciones que pueden
ocurrir en la entrada. Un excepcin de chequeo( checked exception) . Esto significa que
debemos ya sea escribir una declaracin que la atrape, o debemos agregar una clausula
throws
102
Dr. Eric Jeltsch F.

throws IOException
al encabezado del mtodo. Una clausula throws lista una o ms exepciones, separadas por
comas.
CAY HORSTMANNS ConsoleReader CLASS
import
import
import
import
java.io.BufferedReader;
java.io.InputStream;
java.io.InputStreamReader;
java.io.IOException;
/**
A class to read strings and numbers
from an input stream.
This class is suitable for
beginning Java programmers.
It constructs the necessary buffered
reader, handles I/O exceptions, and
converts strings to numbers.
*/
public class ConsoleReader
{
private BufferedReader reader;

/** Constructs a console reader from
an input stream such as System.in.
*/
public ConsoleReader(InputStream inStream)
{ reader =
new BufferedReader
(new InputStreamReader(inStream));
}
/** Read a line of input and
convert it into an integer.
*/
public int readInt()
{ String inputString = readLine();
int n = Integer.parseInt(inputString);
return n;
}
/** Reads a line of input and convert it
into a floating-point number.
*/
public double readDouble()
double x =
Double.parseDouble(inputString);
return x;
}
/** Read a line of input.
In the (unlikely) event of
an IOException, the program halts.
*/
public String readLine()
103
Dr. Eric Jeltsch F.

{
String inputLine = "";

try
{ inputLine = reader.readLine();
}
catch(IOException e)
{ System.out.println(e);
System.exit(1);
}
return inputLine;
}
}
Ud. podr utilizar esta clase en el futuro o tal vez adaptarla para sus propsitos. Recuerde que
esta versin como un ejemplo del tema que se esta tratando captura cualquier IOExceptions
que ocurra, y detiene el programa. Si Ud. no quiere esto tendr que eliminar la declaracin
try-catch.
Leer de un Archivo de Texto

Para leer de un archivo de texto podemos crear un tipo especial de Reader llamados
FileReader que estn conectados al archivo. Para construir la conexin, usamos el
constructor FileReader que tiene el nombre de un archivo como parmetro. Por ejemplo,
supongamos que queremos leer de un archivo llamado data.txt. Entonces FileReader puede
ser construdo como sigue.
FileReader input = new FileReader(data.txt);
Si el archivo no es encontrado, Java lanza una excepcin del tipo FileNotFoundException.

Esto es una excepcin de chequeo, de manera que deber incluir una clausula throws para que
ella en cualquier mtodo no pueda atrapar o capturar.
Un FileReader, tiene un mtodo read que retorna el siguiente carcter unicode en la forma
de un valor int, pero carece de un mtodo readLine. Para obtenerlo debemos convertir el
FileReader en BufferedReader usando el mismo constructor de la ltima seccin. Este
constructor puede ser aplicado a cualquier objeto Reader incluyendo FileReader. La
siguiente declaracin construye un BufferedReader conectado al archivo data.txt.
BufferedReader data =
new BufferedReader
(new FileReader(data.txt));
Aqu est el diagrama que muestra la conexin generada.

Archivo
FileReader
BufferedReader
104
Dr. Eric Jeltsch F.
Una vez que BufferedReader ha sido construdo, podemos coleccionar las lineas de entrada
desde el archivo usando el mtodo readLine justamente como cuando los datos vinieran del
teclado. Una diferencia es que se necesita chequear cuando todas las lneas del archivo han
sido ledas. El mtodo readLine returns null cuando el fin de archivo ha sido alcanzado.
Tambin, cuando se lee desde un archivo, se le recomienda que siempre cierre la conexin al
archivo como si Ud. hubiese terminado con l. FileReaders y BufferedReaders tienen
ambos un mtodo llamado close para hacerlo lanzando un IOException.
Tenemos una versin final del programa promedio, el cual lee datos desde un archivo llamado
hola.dat. Justamente un BufferedReader es construdo, conectando al archivo. No existe
ningn Reader conectado al teclado.
Ejemplo 6
import java.io.*;
{ /* Lee nmeros punto flotante desde un archivo
hola.dat, y entrega su promedio.
*/
{ BufferedReader datos;
try
{ datos = new BufferedReader
(new FileReader("hola.dat"));
}
catch (FileNotFoundException e)
("Archivo hola.dat no fue encontrado.");
return;
}
/* Lee y suma los valores, contando cuantos son. */
double sum = 0;
int cuanTos = 0;
try
{ while (true)
{ String linea = datos.readLine();
if (linea == null) break;
try
{ double siguiente =
Double.parseDouble(linea);
cuanTos++;
}
("Datos malos: " + linea);
}
}
datos.close();
}
catch (IOException e)
return;
}
105
Dr. Eric Jeltsch F.
/* promedio. */
if (cuanTos > 0)
System.out.println
else
System.out.println("Ningn resultado.");
}
}
Notas
Si el archivo no existe el resultado atrapa inmediatamente una excepcin del tipo
FileNotFoundException a raz de la primera declaracin try-catch y el programa detiene su
ejecucin.
La declaracin fuera de try-catch , la cual contiene el loop while, atrapa la excepcin
IOExceptions arrojado o lanzado por readLine y close.
La declaracin interna de try-catch , interna al loop, atrapa cualquier exepcin
NumberFormatExceptions arrojada por Double.parseDouble.
La secuencia de datos continua hasta fin de archivo. Si no existe la palabra fin al final, el
programa detiene su ejecucin leyendo cuando linea este seteado a null.
Si cualquier lnea de datos contiene algn error, el programa imprimir la lnea para ayudar al
usuario a entender que es lo malo en el archivo.
Escribiendo un Archivo de Texto
Si desea escribir a un archivo de texto en lnea basta con usar FileWriter, tal como se
muestra en el siguiente ejemplo.
import java.io.*;
public class FileWriterDemo{
public static void main( String args[] ) {
FileWriter fw = null;
try
{
fw = new FileWriter( "fileWriter.txt" );
fw.write( "Hola erico, aqui va el archivo" );
}
catch ( IOException e ) {
System.out.println( "No se pudo generar el archivo" );
}
finally {
try {
if ( fw != null ) fw.close();
} catch ( IOException e ) {}
}
}
}
106
Dr. Eric Jeltsch F.
Si desea escribir a un archivo de texto, es mejor usar un objeto PrintWriter. Este objeto tiene
mtodos convenientes, tales como println y print, justamenta para System.out. Un
PrintWriter no puede ser conectado directamente al archivo, pero puede ser conectado al
objeto FileWriter, el cual acepta caracteres unicode y los escribe al archivo de texto. Aqu
se da una declaracin que crea un PrintWriter para escribir un archivo de texto hola.txt.
PrintWriter salir =
new PrintWriter
(new FileWriter(hola.txt))
As es la relacin entre ellos,

Archivo
FileWriter
PrintWriter
Una vez realizado esto podemos usar los mtodos out.print y out.println para enviar los
datos al archivo hola.txt. Despus que toda la salida ha sido escrita al archivo llame a
out.flush(), para asegurarse que ningn carcter este perdido en la cola para cuando la
coneccin se cierre. Finalmente, llamar a out.close() para cerrar la conexin.
Archivos y Filtros.
En varios de los ejemplos que se han visto se ha utilizado una cadena para referirse al archivo
incluido en la operacin de un flujo. Esto es suficiente si queremos trabajar con archivos y
flujos pero el problema surge para cuando queramos trabajar con copiar archivos, cambiar
nombre u otras tareas. Para solucionar este problema se debe trabajar con un objeto File.
File es tambin parte del paquete java.io, y representa una referencia de archivos o carpeta.
Los constructores que puede utilizar son:
File(String), File(String, String), File(File, String). Junto con ellos existe una
cantidad de mtodos tales como exists(), length(), renameTo(File), delete() o
deleteOnExit(), mkdir(), etc..
Hemos visto que al realizar el comando

>java miProg
el Java interprete obtendr la clase compilada miProg.class y se dirige a unos de los

mtodos main , el cual obedecera. En vez de este simple comando podemos tipear el comando
107
Dr. Eric Jeltsch F.
java
seguido con algunos argumentos de caracteres llamados command line arguments. Por
ejemplo,
java miProg data.txt hola.dat
command line arguments

Un command line argument puede ser cualquier string de caracteres.
Una lista de command line arguments se pasarn del mtodo main en la forma de un array de
strings. Si son dos argumentos como en el ejemplo anterior entonces el arreglo es de 2
elementos los que hacen referencia a 2 strings. Este array es parmetro de tipo String[] ,
que todo mtodo main posee. Si suponemos que, en el encabezado del mtodo main es,
y suponemos que el interprete Java es dado la lnea de comando con 2 argumentos , como
antes se mencionaba, entonces un parametro variable llamado args sera creado que contenga
una referencia a los 2 elementos del array que anteriormente hacan referencia al strings
data.txt y hola.dat.
data.txt
args
hola.dat
Con los argumentos strings presentados en esta forma, el mtodo main puede procesarlo en el
sentido que el programador decida. Por ejemplo, puede usar la expresin
args.length
para denotar el nmero de argumentos. Y los argummentos individuales pueden ser referidos
como args[0], args[1], etc.
Un ejemplo de esta idea esta dado por la siguiente aplicacin que convierte en mayscula todo
el texto de un archivo. El archivo es ledo mediante un flujo de entrada almacenado en buffer,
y se lee un carcter a la vez. Una vez convertido en mayscula, el carcter se enva a un
archivo temporal por medio de un flujo de entrada almacenado en buffer. Los objetos File se
usan en vez de las cadenas para indicar los archivos involucrados, lo cual hace posible
cambiarles el nombre y borrarlos segn se necesite.
108
Dr. Eric Jeltsch F.
Ejemplo 7
import java.io.*;
public class todoMayusDemo {
todoMayus may = new todoMayus(arguments[0]);
may.convert();
}
}
class todoMayus {
String nombreFuente;
todoMayus(String nombreArg) {
nombreFuente = nombreArg;
}
void convert() {
try {
// Crea los objetos archivos(File)
File nombre = new File(nombreFuente);
File temp = new File( nombreFuente + ".tmp");
// Crea una entrada stream
FileReader fr = new
FileReader(nombre);
BufferedReader in = new
BufferedReader(fr);
// Crea la salida stream
FileWriter fw = new
FileWriter(temp);
BufferedWriter out = new
BufferedWriter(fw);
int inChar = 0;
do {
inChar = in.read();
if (inChar != -1) {
char outChar = Character.toUpperCase( (char)inChar );
out.write(outChar);
} else
eof = true;
} while (!eof);
in.close();
out.close();
boolean borrar = nombre.delete();
if (borrar)
temp.renameTo(nombre);
} catch (SecurityException se) {
System.out.println("Error -- " + se.toString());
}
}
}
109
Dr. Eric Jeltsch F.
Excepciones y Flujo de Datos (Exceptions y Streams)

Mensajes de error enviados por el compilador.
Los humanos podemos tolerar errores ortogrficos y gramaticales, pero los computadores no,
y por esta razn el compilador Java cumple con su labor de denunciar este tipo de errores,
identificando la lnea y dando una corta explicacin. Por ejemplo, aqu tenemos un programa
que tiene varios errores.
public class test
{ System.out.println(Hello!)
}
Almacenemos el programa en Test.java y compilemoslo. El compilador replica, con varios

errores de mensaje, el primero de ellos es
C:\Documents and
Settings\usuario\Escritorio\POO\POO_web_CD\Java_poo\Libro_Base_java\test.java:2
: invalid method declaration; return type required
^
a)
Estableciendo que existe un error en la lnea 2 del programa y que se ubica

aproximadamente en la posicin marcada con ^. No nos dice exactamente cual es el
problema, pero si nos invita a reflexionar respecto de la sintaxis de un programa. En
este caso particular hemos olvidado la palabra clave void.
C:\Documents and
Settings\usuario\Escritorio\POO\POO_web_CD\Java_poo\Libro_Base_java\test.java:3
: ')' expected
{ System.out.println(Hola!)
^
b)
Luego el compilador reporta otro error en la lnea 3 del programa y que se ubica
aproximadamente en la posicin marcada con ^. Lo que nos ayuda a ver con mayor
preocupacin que pasa en ese segmento de programa, y notamos que al escribir la
palabra
Hola!, hemos olvidado escribirlo entre comillas.
C:\Documents and
a:4: ';' expected
}
^
c)
El compilador reporta otro error en la lnea 4 del programa y que se ubica

aproximadamente en la posicin marcada con ^. Y notamos que nos falto cerrar una
declaracin con ;
110
Dr. Eric Jeltsch F.
C:\Documents and
a:5: '}' expected
^
4 errors
Herramienta completada con cdigo de salida 1
d)
El compilador reporta otro error en la lnea 5 del programa y que se ubica

aproximadamente en la posicin marcada con ^. Y notamos que nos falto cerrar un
parntesis, con un semicolon }.
Desafortunadamente, el compilador no es perfecto en detectar todos los errors gramaticales en

una primera leda, es as como se require compilarlos e ir modificando el cdigo del programa,
hasta que quede libre de errores, no obstante el compilador no podr hacer nada frente a un
error semntico. Para completar este segmento digamos que este es un tpico error para cuando
una clase est carente de una clase principal para ser testeada.
Para mayor consulta dirigirse a The Java Language Specification, de J. Gosling, B. Joy, y G.
Steele, Addison Wesley Publishing, 1996, para la definicin del lenguaje Java.
Diagnstico de los errores en Expresiones y Variables

Expresiones y variables le dan a un programa ms potencia, pero al mismo tiempo ofrecen la
oportunidad de generar ms errores. Los errores en este sentido pueden ser de dos formas:
Errores relacionados con la gramtica, contexto (tipo de datos), que el compilador Java
puede detectar, son llamados: errores en tiempo de compilacin.
Errores que ocurren para cuando el programa es ejecutado, deteniendose su ejecucin

en forma temprana, son llamados errores en tiempo de ejecucin o excepciones.
Si consideramos el programa
public class Test1{
System.out.println( (1+2(*3 );//que desea?
System.out.println(Hola!);
}
}
111
Dr. Eric Jeltsch F.
a) vemos que el compilador notifica y anuncia:

C:\Documents and
Settings\usuario\Escritorio\POO\POO_web_CD\Java_poo\Libro_Base_java\Test1.java:3:
')' expected
System.out.println( (1+2(*3 );
^
b) Si consideramos ahora el programa, detecta un problema en la definicin del tipo de dato.

public class Test1{
string s;//basta con saber que el tipo de dato es String
}
}
C:\Documents and
symbol : class string
location: class Test1
string s;
^
C:\Documents and
operator + cannot be applied to int,boolean
System.out.println(3 + true);
^
la explicacin del compilador es elocuente, es decir enteros con boolenos no se entienden.

public class test {
int i=0;
System.out.println(1/i);
}
}
tras el proceso natural de compilacin podr ver que el compilador no anuncia ningn tipo de
problemas. Sin embargo, en la ejecucin dice lo que se muestra.
este es un tpico error en tiempo de ejecucin, o tambin llamado una exception. Esto surgi
cuando un programa usa tipos de datos incorrectos como argumentos del programa. No
obstante si declara double i=0; en la ejecucin saldr
112
Dr. Eric Jeltsch F.
c) Otro ejemplo, surge para cuando se desea ejecutar un programa Java pero con varios
parmetros desde la consola.
public class test {
int i = new Integer(args[0]).intValue();
System.out.println(1 / i);
}
}
El mensaje de error fue gatillado por la lnea 3, y fue generado por la creacin de un objeto
Integer en la lnea, siendo que la entrada de datos es un carcter, en este caso a.
113
Dr. Eric Jeltsch F.
Finalmente, mostremos algunos errores que no son detectados ni por el compilador de Java, ni
por su intrprete. Por ejemplo, se imprimen las variables x e y que son la misma. La
declaracin pasa la inspeccin del compilador Java, ahora realiza su ejecucin y si Ud. espera
ver ya sea un true o un false ver que surge un resultado, 7.
public class test {
int x = 3;
int y = 7;
System.out.println(x = y);
}
}
La razn es que x = y es una asignacin y no un test para igualdad, como (x = = y). La

declaracin, System.out.println(x = y), asigna y's valor a x's y lo imprime.
Luego de haber visto esta serie de errores podr formarse una idea, de lo que se trata este
captulo y que se refiere a complementar y reforzar el uso de excepciones, en donde Java
posee una forma de tratar los errores en tiempo de ejecucin. Adems veremos como leer
desde el teclado sin usar la clase que se le ha pedido prestada a Horstmanns llamada
ConsoleReader, y como leer y escribir archivos de texto, adems de como hacer uso de los
parmetros que todo mtodo main posee.
Excepciones
Java tiene un especial mecanismo para tratar errores en tiempo de ejecucin. Suponga que
escribe algn cdigo que puede tener errores cuando lo ejecuta. Por ejemplo, si una cierta
variable se refiriese a un objeto, y un error ocurre si la variable contiene null. Entonces puede
Ud. insertar una declaracin que arroja una excepcin (throws and exception) si la condicin
de error ocurre. Veamos 2 situaciones.
1.
Crear un objeto que describe la condicin de error, usualmente llamada un objeto

exception. (Ella pertenece a la clase Throwable, y estar ya sea en la subclase Error, si
es un serio error del sistema, o en la subclase Exception, si ocurri el error en el tiempo
de ejecucin normal.)
2.
Esto causa que el interprete se detenga en la secuencia de declaraciones en donde ocurri

el error y comience a buscar una clausuala catch que ha sido escrita para responder al
error apropiadamente, es decir, desplegando un window que le informa al usuario que
hacer en lo sucesivo. (Como buscar la clausula catch se describir posteriormente.) Si
el interprete no puede encontrar una clausula disponible catch, el programa se detiene y
Java desplegara un mensaje de error por defecto en la ventana DOS. Esto origina el
nombre de excepciones y una lista de todos los mtodos que estn siendo ejecutados
actualmente.
114
Dr. Eric Jeltsch F.
Las excepciones son a menudo atrapadas o arrojadas por el mismo Java, ya sea por uno de los
mtodos de librera, o por un interprete, es decir, cuando encuentra algo el mismo trata de
accesar a un array de elementos con un valor del indice fuera del rango correcto de valores. En
este caso, la excepcion ser una IndexOutOfBoundsException.
Una clusula catch es parte de una declaracin try-catch y tiene la forma siguiente.
try
{ Declaraciones
{ Declaraciones
}
{ Declaraciones
finally
{ Declaraciones
}
La ltima parte finally clausula es por lo general omitida. Cuando el interprete obedece la
declaracin try-catch, ella ejecuta la declaracin try normalmente. Si ninguna excepcin es
arrojada, eso es todo cuanto la declaracin try-catch hace. Si una excepcin es arrojada, el
intrprete partira buscando para una try-clausula que sea obedecida para cuando la excepcin
fue arrojada.
Por supuesto la declaracin try en la declaracin try-catch fue obedecida, pero puede
haber otra declaracin try-catch ms cerca de donde ocurri el error. El intrprete entonces
buscar el ms interno, llamaremos a la declaracin que produjo el error S0. Primero el
intrprete mira dentro del cuerpo del mtodo que contiene S0. Si encuentra que S0 est dentro
de una try, toma una. Si hay dos o ms declaraciones try anidadas que contienen a S0,
toma la ms interna. Si S0 no est al interior de una try, el intrprete va a la declaracin S1
que llam el mtodo que contiene S0. Entonces empieza buscando la catch ms interna que
contiene S1. Si no puede encontrar uno en ese cuerpo del mtodo, va a la declaracin S2
llamando el mtodo que contiene S1. Y as sucesivamente. Aqu se muestra un programa que
contiene una declaracin try-catch. El programa lee una serie de valores de punto flotante
ingresados por el usuario, y se detiene cuando lee la palabra fin. Suma los nmeros y al
mismo tiempo cuenta cuantos nmeros son, finalmente, divide la suma de los nmeros por el
contador generando as el promedio de los nmeros ingresados, el cual es desplegado en
pantalla.
El programa chequea si ve en la lnea la palabra fin. La lnea es leda usando readLine. Si
ella no tiene fin, el programa procura convertirla en nmero usando el metodo
Double.parseDouble. Si por error de tipeado, el usuario tipea algo que no es un nmero o la
palabra fin, entonces una NumberFormatException ser lanzada. Si no es capturado el
programa despliega un mensaje de error por defecto y para.
Una declaracin try-catch ha sido insertada en esta versin del programa para capturar las
excepciones, y as evitar el mensaje de error. La clausula try incluye la llamada a
115
Dr. Eric Jeltsch F.
Double.parseDouble, y la accin que continua para

clausula catch justamente despliega un simple error de
cuando el nmero esta correcto. La

mensaje, y entonces el programa esta
habilitado para realizar su tarea.

Ejemplo 1
{
/* Lee nmeros flotante ingresados por el
usuario y entrega el promedio.
(Version que usa ConsoleReader.)
*/
ConsoleReader usuario = new ConsoleReader(System.in);
/* Lee y agrega los valores, y cuenta cuantos son. */
double sum = 0;
int cuanTos = 0;
System.out.println("Ingrese los datos.");
while (true)
try
/* proteccin de cdigo, que podra lanzar una excepcin dentro de try, pues este
segmento de cdigo podra causar una excepcin, si no existen problemas continue,
sino*/
{

cuanTos++;
}
/* Atrape la excepcin, haciendo una prueba para manejar una excepcin dentro de
catch*/
("Ingreso NO reconocido, intentelo de nuevo!.");
}
}
/* el promedio. */
if (cuanTos > 0)
System.out.println
("El valor promedio es = " + sum/cuanTos);
else
System.out.println("Sin resultado.");
}
}
Tambin como excepciones producidas por Java, puede forzar una excepcion para ser arrojada
mediante la declaracin throw . Esta clausula indica que algn cdigo en el cuerpo de su
mtodo podra lanzar una excepcin, para tal efecto simplemente agregar la palabra throw
despus del nombre del mtodo pero antes de abrir el bloque. Por ejemplo,
public boolean miMetodo(int x, int y) trows AnException {
o ms simple seguida por la referencia a un objeto excepcion. Por ejemplo,

throw new NumberFormatException();
116
Dr. Eric Jeltsch F.
Note que un constructor es usado para crear el objeto exception aqu. Existen muchos tipos de
excepciones definidas en la librera. Para encontrarlas todas vea la clase Exception y sus
subclases. Tambin, puede Ud. definir sus propias clases exccepcion extendiendo la clase
Exception.
Leer desde el teclado
Cuando un programa Java lee la entrada, usa un objeto de algn tipo para manejar la entrada.
El objeto ser conectado a la fuente de la entrada, es decir la entrada fuente, me refiero a el
teclado o archivo de texto. En trminos de leer valores de entrada desde la fuente usamos
mtodos pertenecientes a ese objeto. El objeto ConsoleReader el cual hemos usado durante el
curso para leer desde el teclado es un tpico ejemplo de un objeto que maneja la entrada.
El objeto que maneja la entrada ser llamada InputStream o un Reader. La diferencia depende
sobre que valores produce para cuando lea los caracteres. Un InputStream returns un 8-bit
byte cada vez que lea un carcter, que es como el sistema lo representa. Un Reader returns 16bit caracteres. Esta es la forma estandar que Java representa caracteres, usando caracteres de
cdigo llamados unicode.
Cada vez que se crea un objeto ConsoleReader, hacemos uso de otro objeto llamado
System.in. Esto es un InputStream conectado directamente al teclado. InputStreams tiene
varios mtodos asociados con ellos, pero solamente uno puede ser usado para leer la entrada
que es read que lee 8-bit byte. El siguiente diagrama representa el objeto System.in
conectado al teclado, con la informacin que fluye del teclado,
keyboard
System.in
Java posee clases llamadas InputStreamReader que consiste de objetos que producen los
caracteres 16-bit unicode usados por Java. Existe un constructor que puede convertir un
InputStream en un InputStreamReader. Ud. deber darle InputStream como parametro, y el
creara el InputStreamReader.
Por ejemplo, la declaracin siguiente construira una
InputStreamReader conectado a System.in.
InputStreamReader lector = new InputStreamReader(System.in);
Ud. puede incluir un segundo parmetro para especificar un decodificador noestandar para
devolver bytes en caracteres unicode. Sin el segundo parametro, el InputStreamReader usar
un decodificador estandar, el cual es satisfactorio para usos o propsitos normales. Lo mismo
es posible para la salida. Aqu esta el diagrama de InputStreamReader definido anteriormente.
117
Dr. Eric Jeltsch F.
Se obtiene 8-bit bytes desde el teclado, usando System.in, convirtindolos en caracteres de

16-bit.
teclado
System.in
InputStreamReader
Un InputStreamReader tiene un mtodo read que entrega un carcter simple. Esto sera
posible de usarse para cuando escriba mtodos que usan nmeros reales, lneas de texto, etc.
Sin embargo, un conveniente punto de partida es un objeto, el cual puede leer una linea de
caracteres ala vez. Existen 2 tipos de objetos que pueden hacer uso de ellos. Uno es llamado
BufferedReader y el otro es LineNumberReader. Ambos tienen un mtodo readLine que
retorna la siguiente lnea de entrada. Ud, puede convertir un InputStreamReader en
BufferedReader. Usualmente se hace mediante constructores. Por ejemplo,
BufferedReader usuario =
new BufferedReader
La declaracin se v como sigue,

teclado
System.in
InputStreamReader
BufferedReader
Ejemplo 2
Un programa que pregunta por la dimensin del cuadrado y entrega lo solicitado. Si le ingresa
el valor 5, vera la figura:
*****
*
*
*
*
*
*
*****
import java.io.*;
public class Ejerc5{
public static void main(String args[]) throws IOException {
int tam;
BufferedReader din;
din = new BufferedReader( new InputStreamReader(System.in));
System.out.println("Cuadrado");
System.out.println("========");
while (true) {
118
Dr. Eric Jeltsch F.
System.out.print("Largo del lado [1-20,0=Fin]: ");

tam = Integer.parseInt(din.readLine());
if (tam < 1) {
break;
}
else if (tam <= 20) {
for (int i = 1; i <= tam; ++i) {
for (int j = 1; j <= tam; ++j) {
if (j == 1 || j == tam || i == 1 || i == tam){
System.out.print("*"); }
else {
System.out.print(" ");
}
}
}
}
}
}
}
Ejemplo 3
El programa CambioMoneda, calcula el cambio para un monto de dolares-y cents, todo ello
ingresado por teclado.
import java.io.*;
/** CambioMoneda calcula el cambio para un monto de dolares-y -cents.
* input: un monto en dolares y un monto en cents. Ambos enteros.
* output: el listado de las monedas necesarias. */
public class CambioMoneda
{ BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Tabla de Montos");
System.out.println("===============");
System.out.print("Ingrese monto de dolares: ");
String dolares = teclado.readLine();
System.out.print("Ingrese monto de cets: ");
String cents = teclado.readLine();
int monedas = (100 * new Integer(dolares).intValue())
+ new Integer(cents).intValue();
System.out.println( "quarters = " + (monedas/25) );
System.out.println( "dimes = " + (monedas/10) );
System.out.println( "nickels = " + (monedas/5) );
System.out.println( "pennies = " + monedas );
}
}
119
Dr. Eric Jeltsch F.
Como leer archivos de texto

Existen 2 formatos de archivo:
character file, que es una secuencia de simbolos del teclado, almacenados en un

archivo como una secuencia de bytes;
binary file, que es una secuencia de unos y ceros.
Un texto depositado en un archivo podr tener diferentes formatos, por ejemplo.

Hola!
Cmo estas t?
49
como una secuencia Hola!\nCmo estas t?\n
49\n
Por otra parte un archive binario es una secuencia de unos y ceros, de manera que 49 es
expresado como, 11001, y no como la representacin '4' y '9').
Cuando obtenemos informacin de entrada desde un archivo, se dice que read desde el archivo;
para cuando depositamos una informacin de salida en un archivo, decimos write en l. Cuando
comenzamos a usar un archivo, decimos que se open , y cuando terminamos de usarlo, lo close.
Los archivos pueden ser read/written en dos sentidos:
sequential file pueden ser read (o written) desde front to back; es decir es un libro que
tiene una sola direccin de lectura, pudiendo regresar en una sola direccin,
(forwards).
random access file pueden ser reads (o writes) sobre cualquier lugar, es como si en un
libro pudiese abrirlo en cualquier pgina.
Sequential files son simples para manejar y trabajar aplicaciones estandares, mientras que los
Random access files son usados principalmente para aplicaciones de database donde se
especifican bits de informacin. En este segmento se vern solamente sequential files. Para
programas Java que usan sequential file, se debe establecer si el archio usado es usado para
input: el file es read sequentially y no puede ser written.
output: el file esta written sequentially y no puede ser read.
120
Dr. Eric Jeltsch F.
La clase BufferedReader lee un flujo de entrada de caracteres y los guarda en un array llamado
buffer. Para crear una versin en buffer se debe tener un objeto Reader existente de algn
tipo. Para crear un BufferedReader se puede utilizar el siguiente constructor.
BufferedReader(Reader).
Que crea un flujo de caracteres almacenado en bufer,

asociado con el objeto especificado Reader, como FileReader.
BufferedReader(Reader, int). Que crea un flujo de caracteres almacenado en
buferasociado con el objeto especificado Reader y con un buffer de tamao int.
Un flujo de caracteres almacenado en bufer se puede leer utilizando los mtodos read() y
read(char[], int , int) descritos en FileReader. Puede leer una lnea de texto usando el mtodo
readLine(). El mtodo readLine() devuelve un objeto String que contiene la prxima lnea de
texto en el flujo, sin incluir el carcter o caracteres que representan el final de una lnea, que
puede ser(\n, lnea nueva), (\r, retorno de carro) o una combinacin de esta ltima con la
primera. Si se llega al final del flujo, el valor devuelto de la cadena es igual a null.
Ejemplo 4:
Escribimos una aplicacin que lee el contenido de un archivo secuencial cuyo nombre es dado
por el usuario desde el teclado y copia el archivo, f, line by line, en otro file, f.out.
import java.io.*;
/** CopiarFile copia el contenido de un file, f,
* cuyo nombre es sustituido por un file, f.out */
public class CopiarFile
{ String f = JOptionPane.showInputDialog("Input nombrefile: ");
// se construye el objeto view que reads desde el input file:
BufferedReader infile = new BufferedReader(new FileReader(f));
// se construye el objeto view que writes al output file:
PrintWriter outfile = new PrintWriter(new FileWriter(f + ".out"));
while ( infile.ready() ) // existen ms lineas que leer en infile?
{ String s = infile.readLine();
outfile.println(s);
}
infile.close();
outfile.close();
}
}
121
Dr. Eric Jeltsch F.
al ingresar su nombre, asumir que ese archivo existe y copiara su contenido en un archivo de
salida similar. Todo esto lo comprobar si se remite a ver el directorio en donde esta
trabajando. A continuacin se ve un mensaje clsico para cuando no existe el archivo en
cuestin.
El error, java.io.FileNotFoundException, es un ejemplo de una IOException---el

programa thrown (lanza) una exception. En todo caso tales exceptions pueden ser
manejadas. En este sentido, manejaremos esta excepcin para el caso que se ingrese un 0. Y
Ud. vera la diferencia, en donde el programa me invita a ejecutarlo nuevamente.
Ejemplo 5:
/** Dividir lee un int y lo divide en 12 */
public class DividirTC {
int i = readAnInt();
try {
JOptionPane.showMessageDialog(null, "La respuesta es" + (12 / i));
}
catch(RuntimeException e)
{
"Error en input: " + i + ". Ejecutelo nuevamente.");
}
System.out.println("Terminado.");
}
/** readAnInt lee un int y lo retorna */
private static int readAnInt() {
String s = JOptionPane.showInputDialog("Ingrese un entero:");
int num = new Integer(s).intValue();
return num;
}
}
122
Dr. Eric Jeltsch F.
String tokenizers y los file objects pueden ayudar a crear una aplicacin cuya entrada se basa
en un cierto formato, as como su salida. Un ejemplo estndar es el proceso de enlistar alguna
informacin, en donde en este ejemplo se trata de un archivo secuencial, donde cada lnea
contiene el nombre de un empleado, las horas trabajadas y el pago por ellas, ya sea en un
contexto de sobretiempo o alguna otra que no interesa. La informacin se ve as.
Fred Mercader|31|20.25
Lucy Riggs|42|24.50
Ethel Meza|18|18.00
!
Notar que la secuencia de lneas es terminada por un simbolo especial, !. Una aplicacin de
este tipo lee las lneas una por una, extrae el tokens de cada lnea, convirtiendo a nombre y
nmero y calculando el sueldo.
class LeerInfo
Metodos
getNextRecord():
boolean
Lee el siguiente registro desde el archivo de entrada. Returns V o

F, si esta o no el archivo segn el formato deseado.
nombreE(): String
Return el nombre del empleado.
horasE(): int
Return las horas trabajadas por el empleado.
sueldoE(): double
Return el pago para el empleado.
close()
Close el archivo base.
/** LeerInfo lee los records desde un sequential file. El records tiene el
formato, NOMBRE|HORA|PAGO. El file termina con un ! */
import java.io.*;
import java.util.*;
public class LeerInfo{
private BufferedReader infile; // la direccin del input file
private String END_OF_FILE = "!";
123
Dr. Eric Jeltsch F.
// nombre, hora y pago del record ledo:

private int hora;
private double pago;
/**constructor de LeerInfo para leer desde un file el file_nombre*/
public LeerInfo(String file_nombre) {
try { infile = new BufferedReader(new FileReader(file_nombre)); }
catch (Exception e){
System.out.println("LeerInfo error: nombre file malo: "
+ file_nombre + "
Abortando!");
throw new RuntimeException(e.toString());
}
}
public String nombreE() { return nombre; }
public int horasE() { return hora; }
public double sueldoE() { return pago; }
public void close() {
try { infile.close();
}
System.out.println("LeerInfo Atencin: falla"); }
}
/** getNextRecord pretende leer un nuevo registro.
* @return si otro record record fue read y esta ready para procesar*/
public boolean getNextRecord() {
boolean result = false;
nombre = null;
hora = -1;
pago = -0.1;
try {
if ( infile.ready() ) {
String linea = infile.readLine();
StringTokenizer t = new StringTokenizer(linea, "|");
String s = t.nextToken().trim();
if ( ! s.equals(END_OF_FILE) ) {
// termina?
if ( t.countTokens() == 2 ) { // hora y pago?
nombre = s;
hora = new Integer( t.nextToken().trim()).intValue();
pago = new Double(t.nextToken().trim()).doubleValue();
result = true;
}
else { throw new RuntimeException(linea);
}
}
}
}
System.out.println("LeerInfo error: " + e.getMessage());
}
catch (RuntimeException e){
System.out.println("LeerInfo error: mal formato record: "
+ e.getMessage() + " se salta este record y trata otra vez");
result = getNextRecord(); // try again
}
return result;
}
}
124
Dr. Eric Jeltsch F.
Para testear la clase LeerInfo, implementemos una clase principal llamada Pagos.java para
testearla.
/** Pagos lee un archivo bajo un cierto formato. */
public class Pagos{
String in_nombre = JOptionPane.showInputDialog("Nombre archivo
entrada:");
String out_nombre = JOptionPane.showInputDialog("Nombre archivo salida:");
if ( in_nombre != null && out_nombre != null ) {
procesandoArchivo(in_nombre, out_nombre);
}
System.out.println("Terminado");
}
private static void procesandoArchivo(String in, String out) {
LeerInfo leer = new LeerInfo(in);
while ( leer.getNextRecord() ) {//algo se hace con ellos?
double pago = leer.horasE() * leer.sueldoE();
}
leer.close();
}
}
El trabajo duro es realizado al interior de getNextRecord, el que verifica el input file si es no

vaco antes de leer el siguiente record. El mtodo tambin se asegura que el record no este con
la bandera, !, y que el record posee un string al nombre, un integer como horas trabajadas y un
double para el pago. Si todo esto ocurre, entonces la informacin desde el record es
almacenada y devuelve true. El mtodo no acepta malos formatos de los records y returns
false cuando alcanza el fin de la entrada. Algunas de las exception son tratadas, tal como las
que surgen cunado intValue y doubleValue fallanl. En tal caso estamos forzados a usar un
throw new RuntimeException(linea), lo que nos informar la cantidad incorrecta de
datos sobre la lnea de entrada. Como un buen ejercicio complementario, sera interesante que
se construyera una clase EscribirInfo para el ejemplo recin dado, en donde los clculos de
los sueldos vayan a dar a otro archivo.
En este otro ejemplo se muestra una aplicacin de Java que lee su propio archivo fuente
atravs de un flujo de caracteres almacenado en buffer.
Ejemplo 4
import java.io.*;
public class leeFuente {
try {
//se crea una fuente de entrada, en este caso el archivo //leeFuente.java
FileReader archivo = new
FileReader("leeFuente.java");
//un filtro de bufer se asocia al archivo, llamado buff,
//que es un objeto .
BufferedReader buff = new
125
Dr. Eric Jeltsch F.
BufferedReader(archivo);
while (!eof) {
//mtodo readLine()dentro de un loop para leer el archivo
//de texto lnea por lnea. El loop termina para cuando
//el mtodo devuelve el valor null.
String linea = buff.readLine();
if (linea == null)
eof = true;
else
System.out.println(linea);
}
buff.close();
}
}
}
Aqu tenemos otra versin de Promedio1, la diferencia radica en que el programa no usa la
clase ConsoleReader. El programa parte creando un BufferedReader para leer la entrada del
usuario. Las diferencias son mostrada en bold. Como Ud. ver la primera lnea ser
afectada
Ejemplo 5
import java.io.*;
{
/* Lee punto flotante ingresado por

el usuario y entrega el promedio.
(Version que usa BufferedReader.)
*/
throws IOException
{ BufferedReader usuario = new BufferedReader
/* Lee y suma los valores, y cuenta cuantos son. */

double sum = 0;
int cuanTos = 0;
System.out.println("Ingrese los valores.");
while (true)
try
{
cuanTos++;
}
("Entrada No reconocida, intente nuevamente!.");
}
}
126
Dr. Eric Jeltsch F.
/* promedio. */
if (cuanTos > 0)
System.out.println
else
System.out.println("Sin valor.");
}
}
Note que en el encabezado del programa as como en ejemplo que haca referencia a la
formacin de cuadrados se tiene,
Este llama al compilador que el mtodo main contiene, llamado readLine, que puede arrojar
la IOException, la cual no ser atrapada pues main no tiene la declaracin try-catch para
atraparla. En IOException se cubre un rango de diferentes errores o condiciones que pueden
ocurrir en la entrada. Un excepcin de chequeo( checked exception) . Esto significa que
debemos ya sea escribir una declaracin que la atrape, o debemos agregar una clausula
throws
throws IOException
al encabezado del mtodo. Una clausula throws lista una o ms exepciones, separadas por
comas.
CAY HORSTMANNS ConsoleReader CLASS
import
import
import
import
java.io.BufferedReader;
java.io.InputStream;
java.io.InputStreamReader;
java.io.IOException;
/**
A class to read strings and numbers
from an input stream.
This class is suitable for
beginning Java programmers.
It constructs the necessary buffered
reader, handles I/O exceptions, and
converts strings to numbers.
*/
public class ConsoleReader
{
private BufferedReader reader;

/** Constructs a console reader from
an input stream such as System.in.
127
Dr. Eric Jeltsch F.
*/
public ConsoleReader(InputStream inStream)
{ reader =
new BufferedReader
(new InputStreamReader(inStream));
}
/** Read a line of input and
convert it into an integer.
*/
public int readInt()
int n = Integer.parseInt(inputString);
return n;
}
/** Reads a line of input and convert it
into a floating-point number.
*/
public double readDouble()
double x =
Double.parseDouble(inputString);
return x;
}
/** Read a line of input.
In the (unlikely) event of
an IOException, the program halts.
*/
public String readLine()
{ String inputLine = "";
try
{ inputLine = reader.readLine();
}
catch(IOException e)
System.exit(1);
}
return inputLine;
}
}
Ud. podr utilizar esta clase en el futuro o tal vez adaptarla para sus propsitos. Recuerde que
esta versin como un ejemplo del tema que se esta tratando captura cualquier IOExceptions
que ocurra, y detiene el programa. Si Ud. no quiere esto tendr que eliminar la declaracin
try-catch.
Leer de un Archivo de Texto

Para leer de un archivo de texto podemos crear un tipo especial de Reader llamados
FileReader que estn conectados al archivo. Para construir la conexin, usamos el
constructor FileReader que tiene el nombre de un archivo como parmetro. Por ejemplo,
supongamos que queremos leer de un archivo llamado data.txt. Entonces FileReader puede
ser construdo como sigue.
128
Dr. Eric Jeltsch F.
FileReader input = new FileReader(data.txt);
Si el archivo no es encontrado, Java lanza una excepcin del tipo FileNotFoundException.

Esto es una excepcin de chequeo, de manera que deber incluir una clausula throws para que
ella en cualquier mtodo no pueda atrapar o capturar.
Un FileReader, tiene un mtodo read que retorna el siguiente carcter unicode en la forma
de un valor int, pero carece de un mtodo readLine. Para obtenerlo debemos convertir el
FileReader en BufferedReader usando el mismo constructor de la ltima seccin. Este
constructor puede ser aplicado a cualquier objeto Reader incluyendo FileReader. La
siguiente declaracin construye un BufferedReader conectado al archivo data.txt.
BufferedReader data =
new BufferedReader
(new FileReader(data.txt));
Aqu est el diagrama que muestra la conexin generada.

Archivo
FileReader
BufferedReader
Una vez que BufferedReader ha sido construdo, podemos coleccionar las lineas de entrada
desde el archivo usando el mtodo readLine justamente como cuando los datos vinieran del
teclado. Una diferencia es que se necesita chequear cuando todas las lneas del archivo han
sido ledas. El mtodo readLine returns null cuando el fin de archivo ha sido alcanzado.
Tambin, cuando se lee desde un archivo, se le recomienda que siempre cierre la conexin al
archivo como si Ud. hubiese terminado con l. FileReaders y BufferedReaders tienen
ambos un mtodo llamado close para hacerlo lanzando un IOException.
Tenemos una versin final del programa promedio, el cual lee datos desde un archivo llamado
hola.dat. Justamente un BufferedReader es construdo, conectando al archivo. No existe
ningn Reader conectado al teclado.
Ejemplo 6
import java.io.*;
{ /* Lee nmeros punto flotante desde un archivo
hola.dat, y entrega su promedio.
*/
{ BufferedReader datos;
129
Dr. Eric Jeltsch F.
try
{ datos = new BufferedReader
(new FileReader("hola.dat"));
}
catch (FileNotFoundException e)
("Archivo hola.dat no fue encontrado.");
return;
}
/* Lee y suma los valores, contando cuantos son. */
double sum = 0;
int cuanTos = 0;
try
{ while (true)
{ String linea = datos.readLine();
if (linea == null) break;
try
{ double siguiente =
Double.parseDouble(linea);
cuanTos++;
}
("Datos malos: " + linea);
}
}
datos.close();
}
catch (IOException e)
return;
}
/* promedio. */
if (cuanTos > 0)
System.out.println
else
System.out.println("Ningn resultado.");
}
}
Notas
Si el archivo no existe el resultado atrapa inmediatamente una excepcin del tipo

FileNotFoundException a raz de la primera declaracin try-catch y el programa detiene
su ejecucin.
La declaracin fuera de try-catch , la cual contiene el loop while, atrapa la excepcin
IOExceptions arrojado o lanzado por readLine y close.
La declaracin interna de try-catch , interna al loop, atrapa cualquier exepcin
NumberFormatExceptions arrojada por Double.parseDouble.
La secuencia de datos continua hasta fin de archivo. Si no existe la palabra fin al final, el
programa detiene su ejecucin leyendo cuando linea este seteado a null.
130
Dr. Eric Jeltsch F.
Si cualquier lnea de datos contiene algn error, el programa imprimir la lnea para
ayudar al usuario a entender que es lo malo en el archivo.
Escribiendo un Archivo de Texto

Si desea escribir a un archivo de texto en lnea basta con usar FileWriter, tal como se
muestra en el siguiente ejemplo.
import java.io.*;
public class FileWriterDemo{
FileWriter fw = null;
try
{
fw = new FileWriter( "fileWriter.txt" );
fw.write( "Hola erico, aqui va el archivo" );
}
catch ( IOException e ) {
System.out.println( "No se pudo generar el archivo" );
}
finally {
try {
if ( fw != null ) fw.close();
} catch ( IOException e ) {}
}
}
}
Si desea escribir a un archivo de texto, es mejor usar un objeto PrintWriter. Este objeto tiene
mtodos convenientes, tales como println y print, justamenta para System.out. Un
PrintWriter no puede ser conectado directamente al archivo, pero puede ser conectado al
objeto FileWriter, el cual acepta caracteres unicode y los escribe al archivo de texto. Aqu
se da una declaracin que crea un PrintWriter para escribir un archivo de texto hola.txt.
PrintWriter salir =
new PrintWriter
(new FileWriter(hola.txt))
As es la relacin entre ellos,

Archivo
FileWriter
PrintWriter
131
Dr. Eric Jeltsch F.
Una vez realizado esto podemos usar los mtodos out.print y out.println para enviar los
datos al archivo hola.txt. Despus que toda la salida ha sido escrita al archivo llame a
out.flush(), para asegurarse que ningn carcter este perdido en la cola para cuando la
coneccin se cierre. Finalmente, llamar a out.close() para cerrar la conexin.
Archivos y Filtros.
En varios de los ejemplos que se han visto se ha utilizado una cadena para referirse al archivo
incluido en la operacin de un flujo. Esto es suficiente si queremos trabajar con archivos y
flujos pero el problema surge para cuando queramos trabajar con copiar archivos, cambiar
nombre u otras tareas. Para solucionar este problema se debe trabajar con un objeto File.
File es tambin parte del paquete java.io, y representa una referencia de archivos o carpeta.
Los constructores que puede utilizar son:
File(String), File(String, String), File(File, String). Junto con ellos existe una
cantidad de mtodos tales como exists(), length(), renameTo(File), delete() o
deleteOnExit(), mkdir(), etc..
Hemos visto que al realizar el comando
>java miProg
el Java interprete obtendr la clase compilada miProg.class y se dirige a unos de los mtodos
main , el cual obedecera. En vez de este simple comando podemos tipear el comando java
seguido con algunos argumentos de caracteres llamados command line arguments. Por
ejemplo,
java miProg data.txt hola.dat
command line arguments

Un command line argument puede ser cualquier string de caracteres.
Una lista de command line arguments se pasarn del mtodo main en la forma de un array de
strings. Si son dos argumentos como en el ejemplo anterior entonces el arreglo es de 2
elementos los que hacen referencia a 2 strings. Este array es parmetro de tipo String[] ,
que todo mtodo main posee. Si suponemos que, en el encabezado del mtodo main es,
y suponemos que el interprete Java es dado la lnea de comando con 2 argumentos , como
antes se mencionaba, entonces un parametro variable llamado args sera creado que contenga
132
Dr. Eric Jeltsch F.
una referencia a los 2 elementos del array que anteriormente hacan referencia al strings
data.txt y hola.dat.
data.txt
args
hola.dat
Con los argumentos strings presentados en esta forma, el mtodo main puede procesarlo en el
sentido que el programador decida. Por ejemplo, puede usar la expresin
args.length
para denotar el nmero de argumentos. Y los argummentos individuales pueden ser referidos
como args[0], args[1], etc.
Un ejemplo de esta idea esta dado por la siguiente aplicacin que convierte en mayscula todo
el texto de un archivo. El archivo es ledo mediante un flujo de entradab almacenado en
buffer, y se lee un carcter a la vez. Una vez convertido en mayscula, el carcter se enva a
un archivo temporal por medio de un flujo de entrada almacenado en buffer. Los objetos File
se usan en vez de las cadenas para indicar los archivos involucrados, lo cual hace posible
cambiarles el nombre y borrarlos segn se necesite.
Ejemplo 7
import java.io.*;
public class todoMayusDemo {
todoMayus may = new todoMayus(arguments[0]);
may.convert();
}
}
class todoMayus {
String nombreFuente;
todoMayus(String nombreArg) {
nombreFuente = nombreArg;
}
void convert() {
try {
// Crea los objetos archivos(File)
File nombre = new File(nombreFuente);
File temp = new File( nombreFuente + ".tmp");
// Crea una entrada stream
FileReader fr = new
FileReader(nombre);
BufferedReader in = new
BufferedReader(fr);
133
Dr. Eric Jeltsch F.

// Crea la salida stream
FileWriter fw = new
FileWriter(temp);
BufferedWriter out = new
BufferedWriter(fw);

int inChar = 0;
do {
inChar = in.read();
if (inChar != -1) {
char outChar = Character.toUpperCase( (char)inChar );
out.write(outChar);
} else
eof = true;
} while (!eof);
in.close();
out.close();
boolean borrar = nombre.delete();
if (borrar)
temp.renameTo(nombre);
} catch (SecurityException se) {
System.out.println("Error -- " + se.toString());
}
}
}
134
Dr. Eric Jeltsch F.
Captulo 6: Programacin Orientada a Objetos
CAPTULO 6
Programacin Orientada a Objetos en Java
Hasta el momento hemos discutido una serie de conceptos de la programacin orientada a
objetos en Java, sin preocuparnos mayormente sobre el detalle de ciertas declaraciones, como
por ejemplo, Porqu main() en los programas antes escrito deben ser public y static?. La
idea para entender la filosofa que est detrs de Java pasa por analizar y entender algunos
conceptos de la POO. Por otra parte, en esta oportunidad pretendo que aprendan aplicar en
java la POO, as como los fundamentos de la POO, y como ellos se visualizan en Java, como
por ejemplo los conceptos de: clase, objeto, mtodo, instancia, herencia, polimorfismo,
constructor, interface, sobrecarga, etc. En resumen este segmento trata de introducirlo en los
fundamentos que le harn tomar confianza con la POO.
Un pequeo adelanto respecto de los conceptos de la POO es que la POO encapsula datos
(atributos) y mtodos en un objeto. Los objetos tienen la propiedad de ocultar la informacin.
Ahora si Ud. ha programado en C, ver que es orientado a la accin, Java en cambio es
orientada a objetos, esto significa que en C la unidad de programacin son las funciones (en
Java este tipo de estructuras se llaman mtodos). No obstante, las funciones no desaparecen
en Java, sino que ellas son encapsuladas como mtodos con datos que se procesan al interior
de la clase. La Fig.1, nos muestra cmo se ve en general un segmento de programa en Java.
Declaracin de clase
public abstract final class Nombre_Clase
extends Nombre_Clase
implements lista_Interface {
Atributo
type Nombre Atributo;
Constructor
public Nombre_Clase ( )
{//...}
Mtodo
public hola (...)
{//...}
Fig. 1
135
Dr. Eric Jeltsch F.
Trminos tcnicos
en POO
-Agente
-Progr. Visual
-dynamic binding
Caractersticas
-Polimorfismo
-Abstraccin
-Encapsulacin
-Persistencia
Mecanismos Bsicos
-Objeto
-Mensaje y MtodosClase y ModeloHerencia
Fig. 2
La Fig. 2 muestra los pilares bsicos de la orientacin a objeto. Los programadores en Java se
concentran en crear sus propias Clases, que son tipos definidos de programas o bien utilizar
algunas para sus propios fines. As por ejemplo, ya hemos usado la clase ConsoleReader en
los ejemplos de las otras lecciones. Cada clase contiene datos, como tambin un conjunto de
mtodos que manipulan los datos.
Observacin: El modelamiento de grandes sistemas es exitoso en la medida que se haga
asesorar por una herramienta de modelamiento. UML (Unified Modeling Language) es un
lenguaje de programacin grfico til para la descripcin de diferentes aspectos en la
modelacin de un sistema orientado a objetos, en donde se pueden representar clases, objetos
y su relacin.
Clases y Objetos
Una class (clase) es una estructura de programacin en la que se pueden agrupar los datos de
un objeto junto con los mtodos que operan sobre ellos. En Ejemplo1, se declara una clase de
nombre Empleado como Tipo, la que no posee mtodos (por ahora). Formalmente una clase
puede considerarse como una especificacin 4-upla, por tener 4 componentes, en forma de
variables con tipo y nombre. El modelo UML asociado a la clase, se muestra a continuacin.
En donde se han definido 4 atributos, dos de ellos pueden contener una cadena de caracteres
(recordar que una cadena de caracteres es un objeto de la clase String), el otro es de tipo entero
y finalmente un atributo de tipo boolean , el que puede ser verdadero o falso.
Ejemplo 1
class Empleado {
String apellido;
String nombre;
int rut;
boolean esFemenino;
}
136
Dr. Eric Jeltsch F.
Empleado
Apellido: String
Nombre: String
Rut:
int
EsFemenino: boolean
objetoEmpleado: Empleado
Apellido: Rojas
Nombre: Lautaro
Rut:
73881706
EsFemenino: false
Cada componente de este tipo es una clase_instancia de la clase Empleado, usualmente

llamada instancia (instance en Ingls), las que usualmente se conocen como objetos. Un objeto
es una variable de la clase, intuitivamente un objeto es una entidad del mundo real, por otra
parte como ya lo mencionabamos un objeto es una variable (del tipo) de la clase, y los
programadores lo conocen como una instancia (es decir, una ejemplificacin concreta) de la
clase y por ende deber contener todas las componentes que tenga la clase. En este caso todo
objeto de la clase Empleado deber tener ejemplares de las 4-variables, como lo muestra la
figura anterior.
Para mayor informacin vea, http://java.sun.com/docs/books/tutorial/java/data/objects.html
Instancias de una Clase

Cmo entender el enunciado la clase ser instanciada?. La concepcin de nuevas instancias
en una clase se realizan sintcticamente a travs de la palabra new, y la forma de cmo llegar a
las variables que tiene la clase se logran a travs de la creacin de este nuevo objeto seguido
de un punto(.).
Ejemplo 2
/*Incorpore Empleado.class a su directorio, o sino compile con el contenido de
Empleado.java dentro de su archivo NuevaInstancia.java.
*/
class NuevaInstancia {
public static void main(String args[]){
Empleado m;
// Instancia: creacin de un nuevo Objeto
m = new Empleado();
// forma de escribir sobre las Instancia-variable:
m.apellido = "Montes";
m.nombre = "Hugo";
m.rut = 11073;
m.esFemenino = false;
// leer las Instancia-variable:
System.out.println("Apellido: " + m.apellido);
System.out.println("Nombre: " + m.nombre);
System.out.println("Numero Personal: " + m.rut);
System.out.println("Hablamos de: " + (m.esFemenino ? "Sra." :
"Sr."));
// le ponemos un segundo Objeto:
Empleado n = new Empleado();
n.apellido = "Rojo";
137
Dr. Eric Jeltsch F.

n.nombre = "Maria;
n.rut = 865;
n.esFemenino = true;
}
Constructores
Al crear la instancia de un objeto, el programa habitualmente asigna valores iniciales a sus
elementos de datos. Para simplificar la inicializacin de los elementos del objeto, Java soporta
una funcin o mtodo especial llamado constructor, que se ejecuta de forma automtica al
crear la instancia. La funcin contructora es un mtodo pblico que tiene el mismo nombre de
la clase.
Es necesario tener en cuenta que:
Un constructor tiene el mismo nombre que la clase,
Un constructor siempre se llama con la palabra clave new,
Los constructores pueden tener ceros o ms parmetros,
Los constructores no devuelven ningn tipo en forma explcita. Por eso que la llamada a
constructores, como tambin los mtodos con tipo de resultado void entregan el resultado
en la forma " return;.Veamos el siguiente ejemplo.
Ejemplo 3
class Empleado {
String apellido;
String nombre;
int rut;
boolean esFemenino;
// Declaracin de un Constructor:
Empleado(String nn, String vn, int pn, boolean w) {
apellido = nn;
nombre = vn;
rut = pn;
esFemenino = w;
}
}
class EjemploConstructor {
Empleado m,n;
// Llamada al Constructor:
m = new Empleado("Meyer", "Hans", 11073, false);
n = new Empleado("Rojo", "Maria", 865, true);
// leer las Instancia-variable:
System.out.println("Apellido: " + m.apellido);
System.out.println("Nombre: " + m.nombre);
System.out.println("Numero Personal: " + m.rut);
System.out.println("Hablamos de:" +(m.esFemenino ? "Sra.": "Sr."));
}
}
138
Dr. Eric Jeltsch F.
Variables en la clase
En contrario a la instancia-variable existe tambin para una clase y para todo objeto de una
clase un ejemplar, llamada variable de la clase, an cuando la clase no tenga ninguna
instancia. Esta variable es esttica, y un ejemplo tpico es un contador.
Ejemplo 4
class Empleado {
String apellido;
String nombre;
int rut;
boolean esFemenino;
// una variable de la clase,inicializada por 0.
static int contador = 0;
Empleado(String nn, String vn, int pn, boolean w) {
apellido = nn;nombre = vn;rut = pn;esFemenino = w;
contador++;
}
}
class EjemploContador {
System.out.println("Contador: " + Empleado.contador);
Empleado m1 = new Empleado("Montes","Hugo",11073,false);
Empleado m2 = new Empleado("Rojo", "Maria", 865, true);
}
}
Clase como Tipo

La clase Empleado puede variar, de manera que contenga una instancia-variable con nombre
ascenso, que puede ser de tipo Empleado.
Ejemplo 5
class Empleado {
String apellido;
String nombre;
int rut;
boolean esFemenino;
// una clase como tipo en una instancia-variable
Empleado ascenso;
// Constructor:
Empleado(String nn,String vn,int pn,boolean w,Empleado as) {
apellido = nn;
nombre = vn;
rut = pn;
esFemenino = w;
ascenso = as;
}
}
139
Dr. Eric Jeltsch F.
class EjemploClasecomoTipo {
Empleado m, jefe; // una clase como tipo variable local
jefe = new Empleado("Rojo", "Martin", 341, false, null);
m = new Empleado("Meyer", "Hans", 11073, false, jefe);
}
}
Expresiones para instanciar

Las variables como Uds. notaron fueron inicializadas por:
Empleado jefe = new Empleado("Soto","Martin",341,false,null);
Empleado m = new Empleado("Meyer","Juan",11073,false,jefe);
Otra expresin un tanto ms sofisticada pero igualmente vlida es:

Empleado m = new Empleado("Meyer", "Juan", 11073, false,
new Empleado("Soto", "Martin", 341, false, null));
Es as como a travs de los operadores = = y != pueden ser comparadas expresiones, tales

como.
Ejemplo 6
class CompararObjetos {
Empleado m1=new Empleado("Soto","Martin",341,false,null);
Empleado m2=new Empleado("Soto","Martin",341,false,null);
boolean b = (m1 == m2); // b tendra el valor "false".
System.out.println(b);
b = (null != null); // b tendr el valor "false".
}
}
Mtodos Instanciados
Al interior de una clase cada declaracin sin la palabra static describe un mtodo instanciado.
Ejemplo 7
class Empleado {
String apellido;
String nombre;
int rut;
boolean esFemenino;
// Constructor:
Empleado(String nn, String vn, int pn, boolean w){
apellido = nn;
nombre = vn;
rut = pn;
esFemenino = w;
}
// un mtodo Instanciado:
void salida(){
System.out.print(esFemenino ? "Sra. " : "Sr. ");
140
Dr. Eric Jeltsch F.
System.out.print(apellido + " ");

System.out.print(nombre);
System.out.println(" (Rut: " + rut + ")");
}
}
class EjemploMetodoInstanciado {
Empleado m1 = new Empleado("Soto", "Martin", 341, false);
Empleado m2 = new Empleado("Barrios", "Petra", 865, true);
// dos llamadas al mtodo instanciado:
m1.salida();
m2.salida();
}
}
La palabra clave this

Al trabajar con objetos, a veces es necesario hacer referencia al objeto de la clase en s. Por
ejemplo, un mtodo de clase puede requerir pasarse a s mismo otra funcin, de la misma
forma, un mtodo puede necesitar devolver el objeto en s a la funcin que lo llama, de manera
que el solicitante sepa que objeto est manipulando. En estos casos es posible utilizar la
palabra this para hacer referencia al objeto en s.
a)
class Miembro {
Miembro anterior;
Miembro posterior;
void ingreso(Miembro nuevo){
// pone "nuevo" detras de "this" en la cadena:
if(nuevo != null){
this.posterior = nuevo;
nuevo.anterior = this;
}
}
}
b)
class Empleado {
String apellido;
String nombre;
int rut;
boolean esFemenino;
//Constructor:
Empleado(String apellido, String nombre, int pn, boolean w){
this.apellido = apellido; // "this" es imprescindible
this.nombre = nombre; // "this" es imprescindible
int rut;
boolean esFemenino;
this.rut = pn; // "this" es imprescindible
this.esFemenino = w; // "this" es imprescindible
}
}
141
Dr. Eric Jeltsch F.
Mtodos en las Clases

Son como las variables en la clase, sin embargo es fcil darse cuenta de ella al reconocer la
palabra clave static, tambin conocidos como mtodos estticos. Este tipo de mtodo son
globales que funcionan para la clase en general, y no solamente para una determinada
instancia.
Ejemplo 8
class Empleado {
String apellido;
String nombre;
int rut;
boolean esFemenino;
static int contador = 0;
// Constructor:
apellido= nn;
nombre = vn;
rut = pn;
esFemenino = w;
contador++;
}
// 2 mtodos en la clase:
static int leerContador(){
return contador;
}
static void imprimirContador(){
System.out.print("Numero de Empleados: ");
// llamada al metodo:
System.out.println(leerContador());
}
}
class Ejemplometodo {
Empleado jefe = new Empleado("Soto", "Martin", 341, false);
// llamada al metodo (con nombre de la clase):
int a = Empleado.leerContador();
Empleado.imprimirContador();
}
}
Implementando Estructuras de Datos

Un importante campo de aplicacin de la programacin es la forma de estructurar los datos,
una de las estructuras ms conocidas sin duda son los arrays, colas, stack, listas etc. Sin
embargo existen otras ms complejas, como arboles y grafos. Con Java tambin es muy simple
de implementarlas.
Listas
En teora las listas pueden en contrario a los array aceptar muchos elementos y se pueden
realizar operaciones que son ms elegantes y eficientes que los arrays. Aqu se muestra un
ejemplo de lista enlazada.
142
Dr. Eric Jeltsch F.
Ejemplo 9
class Empleado {
String apellido;
String nombre;
int rut;
boolean esFemenino;
apellido= nn;
nombre = vn;
rut = pn;
esFemenino = w;
}
}
class ListaEmpleados {
Empleado elemento;
ListaEmpleado continua;
// Constructor para Listas con un elemento:
ListaEmpleado(Empleado m){
elemento = m;
continua = null;
}
// Constructor para Lista con ms de un elemento:
ListaElemento(Empleado m, ListaEmpleado l){
elemento = m;
continua = l;
}
}
class EjemploLista {
Empleado m1 = new Empleado("Soto", "Martin", 341, false);
Empleado m2 = new Empleado("Barrios", Petra", 865, true);
Empleado m3 = new Empleado("Meyer", "Hans", 11073, false);
// Construccin de una lista con estos 3 Empleados:
ListaEmpleado l = new ListaEmpleado(m1,
new ListaEmpleado(m2, new ListaEmpleado(m3)));
}
}
Arboles
En teora los rboles no son nada ms que grafos sin ciclos, cuyos elementos relevantes son
los vrtices(nodos) y los lados(edges). Aqu se muestra un ejemplo de rbol de
jerarquerizacin. Este es un caso particular para la implementacin de cualquier tipo de
rboles, en particular arboles binarios.
Ejemplo 10
class Persona {
String apellido, nombre;
Persona padre, madre;
Persona(String apellido, String nombre, Persona padre, Persona madre){
this.apellido = apellido;
this.padre = padre;
this.madre = madre;
143
Dr. Eric Jeltsch F.
}
void salida(int e){
for(int s = e ; s > 0 ; s--) System.out.print(' ');
System.out.println(vorname + " " + nachname);
if( padre != null) padre.salida(e+4);
if(madre != null) madre.salida(e+4);
}
}
class Arbolito {
Persona p =
new Persona("Martin", "Schmidt",
new Persona("Hans", "Schmidt", // padre
new Persona("Ulrich", "Schmidt", null, null), // padre del padre
new Person("Susanne","Schmidt", null, null)), // Madre del padre.
new Person("Petra","Schmidt", // Madre
new Person("Josef", "Mayer" , null, null ), // Padre de la madre.
new Person("Claudia","Mayer" , null, null))); // Madre de la madre.
p.salida(0);
}
}
Arboles AVL
Mtodos de Consulta
Al igual que como se hizo para los rboles de bsqueda binaria podemos realizar consultas en
un rbol AVL. A saber, Insertar y Eliminar, y otros mtodos que no resultan tan directos como
en los rboles de bsqueda binaria, por el problema de balanceo que se genera.
Ejemplos:
Dado el siguiente rbol T de bsqueda binaria
8
10
1) En este rbol, son insertados los nodos con claves 9 y 11. Generndose el rbol T1 :
8
10
11
144
Dr. Eric Jeltsch F.
2) Basado en T, son insertados los nodos con claves 1, 3, 5 y 7. Generndose el rbol T2:
8
-1
-2
10
Ya al insertar la clave 1 el rbol pierde la propiedad de AVL.. De aqu el aplicar una doble
rotacin.
4
10
Arbol obtenido luego de insertar las claves 3, 5 y 7.

4
10
La insercin de las claves 3, 5 y 7 no hacen perder la propiedad AVL.

La propiedad de AVL se pierde si H = +2 resp. -2. Esto se remedia mediante rotaciones.
Rotaciones
a) Los rboles siguientes contienen los mismos elementos y son ambos rboles de bsqueda
binaria. Primero, en ambos casos k1 < k2, segundo, todos los elementos en los subrboles X
son menores que k1 en ambos rboles, tercero, todos los elementos en el subrbol Z son
mayores que k2. Finalmente todos los elementos en el subrbol Y estn entre k1 y k2. La
145
Dr. Eric Jeltsch F.
conversin de uno de ellos al otro se conoce como Rotacin simple, que significa en lo
substancial cambiar la estructura del rbol. Las figuras muestran tambin las variantes
simetricas.
k2
k1
k1
k2
Z
k1
k2
k2
k1
Z
Rotaciones Simples
Representacin en Java
Un rbol AVL se representa de la misma manera que un rbol binario de bsqueda, esto es con
nodos que contienen punteros a su padre y a sus hijos izquierdo y derecho, sin embargo, un
nodo ahora debe almacenar un campo adicional que indica la altura o balance del nodo.
// Descripcin de un nodo para un rbol AVL
class Nodo_Avl
{ // Instancias
protected Nodo_Avl izq;
// hijo Izquierdo
protected Nodo_Avl der;
// hijo derecho
protected int altura;
// altura
public Comparable datos;
// elementos
// Constructores
public Nodo_Avl(Comparable datElem)
{
this(datElem, null, null );
}
public Nodo_Avl( Comparable datElem, Nodo_Avl ib, Nodo_Avl db )
146
Dr. Eric Jeltsch F.
{
datos = datElem;
izq = ib;
der = db;
balance = 0;
}
}
/*
Este mtodo puede ser llamado solamente si k2 tiene un hijo
izquierdo,
realizando una rotacin entre el nodo k2, tal como lo muestra la figura 7.
Adems, actualiza la altura, asignando la nueva raz a k2.
*/
private static Nodo_Avl RotacionSimpleIzq(Nodo_Avl k2)
{
Nodo_Avl k1 = k2.izq;
k2.izq = k1.der;
k1.der = k2;
k2.altura = max( altura( k2.izq ), altura( k2.der ) ) + 1;
k1.altura = max( altura( k1.izq ), k2.altura ) + 1;
return k1;
}
b) Existen situaciones en donde el desbalanceo es generado por un nodo que es insertado en el

rbol que est contenido en el subrbol de el medio( es decir Y) y que al mismo tiempo como
los otros arboles tienen idntica altura. El caso es fcil de chequear y la solucin es llamada
Rotacin Doble, la cual es muy similar a la rotacin simple salvo que ahora se ven
involucrados 4 subrboles en vez de 3.
k3
k2
k1
k1
k3
D
k2
B
A
A
B
C
D
C
Rotacin Izq-Der, Rotacin Doble.
147
Dr. Eric Jeltsch F.
K3
k2
K1
A
k3
k1
k2
D
B
A
C
D
Rotacin Der-Izq, Rotacin Doble.
/*
Rotacin Doble, basada en Fig. 8: Este mtodo solo puede ser usadosi k3 tiene
hijo izquierdo y los hijos de k3 tienen hijo derecho. Esta rotacin se conoce
como rotacin izq-der. Actualiza la altura, y su raz.
*/
private static Nodo_Avl DobleRotacionIzq_Der(Nodo_Avl k3) {
/* Rotacin entre k1 y k2*/
k3.izq = RotationSimpleIzq( k3.izq);
return RotationSimpleDer( k3 ); }
148
Dr. Eric Jeltsch F.
Ejemplo:
Ud. podr verificar que cualquier desbalanceo causado por una insercin en un rbol AVL
puede ser realizada por una Rotacin Doble o Simple, (Ver (1)). Ahora, respecto a la
eficiencia de esta TDA mencionemos que almacenar la informacin de la altura, que en este
caso son suficientes con +1, 0 y 1, es de gran utilidad
149
Dr. Eric Jeltsch F.
/* Mtodo para calcular la altura de un nodo en un rbol AVL.

*/
private static int altura( Nodo_Avl b)
{
return b == null ? -1 : b.altura;
}
Entonces recordemos que para Insertar un nodo con la clave x en un rbol AVL, el valor x
se inserta recursivamente en el subarbol correspondiente, tal como en los rboles de bsqueda
binario. En el caso que la altura del subrbol no cambie, la insercin concluye. En caso
contrario es necesario utilizar segn sea el caso, Rotacin Simple o Rotacin Doble.
Implementacin de la Insercin en los rboles AVL
Archivo Nodo_Avl.java
// Declaracion de la clase Nodos para los elementos en los arboles AVL.
class Nodo_Avl
{
// Instancias
protected Nodo_Avl izq;
protected Nodo_Avl der;
protected int altura;
public Comparable datos;
//
//
//
//
hijo izquierdo
hijo derecho
altura
los datos como elementos del arbol avl
// Constructores
public Nodo_Avl(Comparable datElem)
{
this(datElem, null, null );
}
public Nodo_Avl( Comparable datElem, Nodo_Avl ib, Nodo_Avl db )
{
datos = datElem;
izq = ib;
der = db;
altura = 0;
}
}
Archivo Arbol_Avl.java
//
//
//
//
//
//
//
//
//
//
//
//
//
Mtodos Tpicos para los Arboles de Busqueda Binaria

Constructor: Inicializar la raz con null
*** algunos mtodos usuales para los arboles***
void insertar( x )
--> inserta x
void eliminar( x )
--> elimina x
Comparable hallar( x )
--> hallar un Elemento que corresponde a x
Comparable hallarMin( ) --> Entrega el Elemento ms pequeo
Comparable hallarMax( ) --> Entrega el Elemento ms grande
boolean esVacio( )
--> Return true si es vacio; else false
void hacerVacio( )
--> Eliminar todos
void printArbol( )
--> Salida de los datos en una sucesin ordenada
void salidaArbolBinario() --> Salida de los datos girados en 90 grados.
/*
150
Dr. Eric Jeltsch F.
* Comparaciones se basan en el mtodo compareTo.(REPASAR)

*/
public class Arbol_Avl
{
/* Raiz del Arbol */
private Nodo_Avl raiz;
/*
* Constructor por defecto
*/
public Arbol_Avl( )
{
raiz = null;
}
/*
* Insertar: Duplicados son ignorados.
* x es el dato a ser insertado.
*/
public void insertar(Comparable x )
{
raiz = insertar( x, raiz );
}
/*
* Eliminar un nodo del Arbol. Caso que x no este,
* nada ocurre.
* Si x esta, es eliminado.
*/
//no esta la implementacin......
/*
* Determinar el elemento ms pequeo en el arbol..
* Devuelve: el dato ms pequeo o null,
* en el caso que el arbol este vacio.
* Analogamente se podra determinar el ms grande elemento en el
*/
//no esta implementado.....
arbol
/*
* Eliminar el arbol.
*/
//no esta implementado....
/*
* Test, si el arbol esta vacio o no.
* devuelve true, caso de vacio; sino false.
*/
public boolean esVacio( )
{
return raiz == null;
}
/*
* Entregar el contenido del rbol en una sucesion ordenada.
*/
public void printArbol( )
{
if( esVacio( ) )
System.out.println( "Arbol vacio" );
else
printArbol( raiz );
}
/*
* Salida de los elementos del arbol binario rotados en 90 grados
*/
151
Dr. Eric Jeltsch F.
public void salidaArbolBinario()

{
if( esVacio() )
System.out.println( "Arbol vacio" );
else
salidaArbolBinario(raiz,0);
}
/*
* Metodo interno para tomar un nodo del arbol.
* Parametro b referencia al nodo del arbol.
* Devuelve los elementos o null,
* caso de b sea null.
*/
private Comparable elementAt(Nodo_Avl b )
{
return b == null ? null : b.datos;
}
/*
* Metodo Interno para agregar o insertar un nodo en un subarbol.
* x es el elemento a agregar.
* b es el correspondiente nodo raiz.
* Devuelve la nueva raiz del respectivo subarbol.
*/
private Nodo_Avl insertar(Comparable x, Nodo_Avl b)
{
if( b == null )
b = new Nodo_Avl(x, null, null);
else if (x.compareTo( b.datos) < 0 )
{
b.izq = insertar(x, b.izq );
if (altura( b.izq ) - altura( b.der ) == 2 )
if (x.compareTo( b.izq.datos ) < 0 )
b = RotacionSimpleIzq(b);
else
b = RotacionDobleIzq_Der(b);
}
else if (x.compareTo( b.datos ) > 0 )
{
b.der = insertar(x, b.der);
if( altura(b.der) - altura(b.izq) == 2)
if( x.compareTo(b.der.datos) > 0 )
b = RotacionSimpleDer(b);
else
b = RotacionDobleDer_Izq(b);
}
else
; // Duplicados; no hace nada
b.altura = max( altura( b.izq ), altura( b.der ) ) + 1;
return b;
}
/*
* Metodo Interno para determinar el dato ms pequeo.
* b es la raiz.
* Devuelve: Nodo con el elemento mas pequeo.
*/
private Nodo_Avl hallarMin(Nodo_Avl b)
{
if (b == null)
return b;
while(b.izq != null )
b = b.izq;
152
Dr. Eric Jeltsch F.
return b;
}
/*
* Analogamente al anterior pero el ms grande.
*/
private Nodo_Avl hallarMax(Nodo_Avl b )
{
if (b == null)
return b;
while (b.der != null)
b = b.der;
return b;
}
/*
* Metodo interno para determinar un dato.
* x es el dato buscado
* b es la raiz
* Devuelve: Nodo con el correspondiente dato.
*/
private Nodo_Avl hallar(Comparable x, Nodo_Avl b)
{
while( b != null )
if (x.compareTo( b.datos) < 0 )
b = b.izq;
else if( x.compareTo( b.datos ) > 0 )
b = b.der;
else
return b;
// paso
return null;
// no paso nada
}
/*
* Metodo Interno para devolver los datos de un subarbol en una sucesion
ordenada.
* b es la raiz.
*/
private void printArbol(Nodo_Avl b)
{
if( b != null )
{
printArbol( b.izq );
System.out.println( b.datos );
printArbol( b.der );
}
}
/*
* salida del arbol binario rotado en 90 Grados
*/
private void salidaArbolBinario(Nodo_Avl b, int nivel)
{
if (b != null)
{
salidaArbolBinario(b.izq, nivel + 1);
for (int i = 0; i < nivel; i++)
{
System.out.print(' ');
}
System.out.println(b.datos);
salidaArbolBinario(b.der, nivel + 1);
153
Dr. Eric Jeltsch F.
}
}
/*
* Salida: altura de los nodos, o -1, en el caso null.
*/
private static int altura(Nodo_Avl b)
{
return b == null ? -1 : b.altura;
}
/*
* Salida: Maximum entre lhs y rhs.
*/
private static int max( int lhs, int rhs )
{
return lhs > rhs ? lhs : rhs;
}
/*
* Rotacion Simple Izquierda(simetrica a Rotacion Simple Derecha).
* Para los arboles AVL, esta es una de las simples rotaciones.
* Actualiza la altura, devuelve la nueva raiz.
*/
private static Nodo_Avl RotacionSimpleIzq(Nodo_Avl k2)
{
Nodo_Avl k1 = k2.izq;
k2.izq = k1.der;
k1.der = k2;
k1.altura = max( altura( k1.izq ), k2.altura ) + 1;
return k1;
}
/*
* Rotacin Simple Derecha.
*/
private static Nodo_Avl RotacionSimpleDer(Nodo_Avl k1)
{
Nodo_Avl k2 = k1.der;
k1.der = k2.izq;
k2.izq = k1;
k2.altura = max( altura( k2.der ), k1.altura ) + 1;
return k2;
}
/*
* Rotacion doble: primero hijo izquierdo con su hijo derecho
* entonces nodo k3 con el nuevo hijo izquierdo.
* para los arboles AVL, esta es una doble rotacin
* actualiza alturas, entrega nueva raiz.
*/
private static Nodo_Avl RotacionDobleIzq_Der(Nodo_Avl k3)
{
k3.izq = RotacionSimpleDer( k3.izq );
return RotacionSimpleIzq( k3 );
}
/*
* rotacion doble: primero hijo derecho
* con su hijo izquierdo; luego nodo k1 con nuevo hijo derecho.
* Para los AVL, esta es una doble rotacin.
* actualiza alturas, entrega nueva raiz.
*/
private static Nodo_Avl RotacionDobleDer_Izq(Nodo_Avl k1)
{
k1.der = RotacionSimpleIzq(k1.der);
154
Dr. Eric Jeltsch F.
return RotacionSimpleDer(k1);
}
}
archivo Arbol_AvlTest.java
public class Arbol_AvlTest
{
// Programa Test
public static void main(String [] args)
{
Arbol_Avl b1 = new Arbol_Avl();
Arbol_Avl b2 = new Arbol_Avl();
for (int i = 0; i < 7; i++) //
{
Integer r = new Integer(i);
b1.insertar(r);
}
System.out.println("Arbol girado en 90 grados");
b1.salidaArbolBinario();
for (int i = 0; i < 10; i++)
{
// Genera un nmero entre 0 y 100
Integer r = new Integer((int)(Math.random()*100));
b2.insertar(r);
}
System.out.println("Arbol girado en 90 grados");
b2.salidaArbolBinario();
System.out.println("Travesia en Inorden(Izq-Raiz-Der)");
b2.printArbol();
}
}
Salida que se genera:
Arbol girado en 90 grados
0
1
2
3
4
5
6
4
14
35
39
52
64
74
75
77
Travesia en Inorden(Izq-Raiz-Der)
4
14
35
39
155
Dr. Eric Jeltsch F.
52
64
74
75
77
Interpretacin de la salida
0
1
2
3
4
5
6
La implementacin de los rboles AVL, as como su salida estn basados en los ejemplos y
materiales entregados en (3).
3
Propuestas: Una mejora factible de considerar en la implementacin del mtodo insertar es

considerar que los elementos a ingresar son String o caracteres, adems de considerar el factor
de balance y la nueva raz que se obtiene. Como se muestra en el ejemplo siguiente.
caracter que desea insertar al arbol-AVL (Borrar: \n): a
a insertado
AVL con balanceo:
a(0)
Caracter que desea insertar al arbol-AVL (Borrar: \n): b

b insertado
AVL con balanceo:
b(0)
a(1)
c insertado
AVL con balanceo:
c(0)
b(0)
a(0)
156
Dr. Eric Jeltsch F.
Jerarquia de Clases
Las clases que poseen la (o las) propiedad de la clase superior son descritas como subclases de
la superclase.
Ejemplo 11
class Alumno {
String apellido;
String nombre;
boolean esFemenino;
String carrera;
byte semestre;
// Constructor
Alumno (String apellido, String nombre, boolean,esFemenino,
String carrera, byte semestre) {
this.esFemenino = esFemenino;
this.carrera = carrera;
this.semestre = semestre;
}
}
Una clase puede a menudo ser especializada, de la misma manera que una superclase puede
ser generalizada. Un ejemplo, para la especializacin sera una clase Colaborador, la que
asume una nueva propiedad traducida en una variable tarifa, incorporandosela a la clase
Empleado.
Ejemplo 12
class Colaborador {
String apellido; // copia de la clase Empleado
String nombre; // copia de la clase Empleado
int rut; // copia de la clase Empleado
boolean esFemenino; // copia de la clase Empleado
String tarifa;// trato preferencial??
// Constructor
Colaborador (String apellido, String nombre, int rut, boolean
esFemenino,String tarifa) {
this.rut = rut;
this.tarifa = tarifa;
}
Importante: La clase Persona es tambin una superclase de la clase Colaborador, pero ella
no es una superclase directa. En contrario, la clase Colaborador es una subclase ( o indirecta)
subclase de la clase Persona. En general, entre una super y una subclase pueden existir
muchas (sub- resp.super-)clases.
157
Dr. Eric Jeltsch F.
Herencia
En Java la herencia es descrita a travs de la palabra reservada extends, en general se tiene
class sub-clase extends super-clase{...}
La Herencia es una de las caractersticas ms importantes de la POO. En su forma ms

simple, es el proceso de construir sobre una clase que ya est definida, extendindola de
alguna forma. Cuando entiende cmo funciona la herencia, puede disear y derivar nuevas
clases diferentes en forma sustancial a las clases existentes. La herencia proporciona acceso a
la informacin contenida en cualquiera de las clases madre a lo largo de la cadena de herencia.
Todas las clases que se escriben, excepto el caso especial de las interfaces, son de forma
automtica subclases de la clase raz que incluye Java, llamada Object (objeto). Al crear una
clase ya est usando la herencia, es as como este concepto permite a las subclases aprovechar
las caractersticas de las clases que proporciona Java, las de otros programadores, proveedores
y las creadas por el programador.
La mejor forma de visualizar la herencia es pensar en un rbol jerrquico. La siguiente figura
muestra una jerarqua de clase bsica, donde las clases inferiores se derivan de las superiores.
Una subclase hereda todos los mtodos y variables de todas sus clases madre. Al escribir una
subclase derivada, es como si tecleara de nuevo todos los mtodos y variables pblicas
existentes en las superclases. Desde luego, Java hace esto de forma automtica, lo nico que
debe hacer es crear los mtodos y variables nuevos o diferentes que requiere la nueva subclase
y que sus clases madres no proporcionan.
A diferencia de otros lenguajes orientados a objetos, como C++, Java slo permite derivar a
partir de una clase madre. No se puede derivar una nueva subclase a partir de dos o ms clases
madre. La herencia mltiple es el proceso de derivar una clase a partir de dos o ms
superclases y es una de las caractersticas que los diseadores de Java dejaron fuera.
Afortunadamente, como veremos en el siguiente tip, Java proporciona una alternativa mucho
ms transparente que la herencia mltiple, utilizando lo que Java llama interface. En la figura
se muestra en flecha punteada el modelo de herencia mltiple, en el sentido que Juan no puede
heredar de Gerente e Ingeniero.
Empleado
Ingeniero
Gerente
Juan
Secretaria
Susana
158
Dr. Eric Jeltsch F.
Ejemplo 13
// Empleado como subclase de Persona
class Empleado extends Persona {
// componentes heredadas:directo de Persona:
apellido, nombre, esFemenino.
// nueva declaracin de componente objeto:
int rut;
// constructor
Empleado (String apellido, String nombre, int rut, boolean esFemenino) {
this.rut = rut;
}
void salida() {
System.out.print(esFemenino ? "Sra. " : "Sr. ");
System.out.print(nombre + " " + apellido);
}
}
// Alumno como subclase de Persona
class Alumno extends Persona {
// componente heredada:
// directamente de Persona: apellido, nombre, esFemenino
// nueva declaracin de componentes objeto:
String carrera;
byte semestre;
// Constructor
Alumno (String apellido, String nombre, boolean esFemenino, String carrera, byte
semestre) {
}
}
//Colaborador como subclase de Empleado
class Colaborador extends Empleado {
// componentes heredadas:
// indirectamente de Persona: apellido, nombre, esFemenino
// directamente de Empleado: rut, salida()
// nueva componente Objeto:
String tarifa;
// constructor
Colaborador (String apellido, String nombre,int rut, boolean esFemenino, String
tarifa) {
this.rut = rut;
this.tarifa = tarifa;
}
}
159
Dr. Eric Jeltsch F.
Estos segmentos de programa se pueden visualizar a travs de la siguiente figura dejando en

claro el concepto de herencia o jerarqua.
Persona
Apellido : String
Nombre: String
esFemen: boolean
Empleado
Rut : int
Salida ()
alumno
carrera: String
Semestre: byte
Colaborador
Tarifa: String
Las variables instanciadas apellido, nombre y esFemenino estn implcitamente declaradas

en la subclase a travs de la herencia. Ud. pueden notar que para colaboradores que realizan
labor de investigacin pueden de manera elegante a travs de 2 superclases ser modeladas,
a saber Colaborador y Academico.
De esta forma pueden varias clases tener sus propiedades en una o varias superclases, en tal
caso se habla de Herencia Multiple. Java no permite (en contrario a C++) la herencia
multiple, en la prctica significa que tras la llave extends puede ser incluida solamente una
superclase.
Jerarquia de clases en Java
La clase Object pertenece a una de las clases estandares de Java, se encuentra en
java.lang.Object, en trminos generales se dice que la clase Object se encuentra en la raiz de la
jerarqua de clases.
class Persona {
...
}
//posee el mismo significado que
class Persona extends Object {
...
}
160
Dr. Eric Jeltsch F.
Herencia y Constructores
String carrera;
byte semestre;
// constructor general:
Alumno(String apellido, String nombre, boolean esFemenino,String carrera, byte
semestre) {
// llamada a los constructores de "Persona" con "super":
super(apellido, nombre, esFemenino);
}
// Constructor para alumno de Computacin en I Sem:
Alumno (String apellido, String nombre, boolean esFemenino) {
// llamada del constructor de "Alumno" con "this":
this(apellido, nombre, esFemenino, "Computacion", 1);
}
}
Como ejemplo del uso de estas propiedades sera contar el nmero de todos los Empleados.
Para eso la clase Empleado debera verse as.
Ejemplo 14
class Empleado extends Persona{
static int numEmpleados = 0;
int rut;
// cambio del constructor
Empleado () {
numEmpleados++;
}
// constructor
numEmpleados++;
this.rut = rut;
}
void salida() {
System.out.print(esFemenino ? "Sra " : "Sr ");
}
}
Es generada una instancia de la subclase Empleado, la que es declarada en la clase Empleado,

de manera que el valor de numEmpleados entrega un objeto Empleado. La ausencia de
parametros en el constructor Empleado permite que el nmero de instancias de las subclases
sean llamadas.
161
Dr. Eric Jeltsch F.
Dynamic Binding
Dynamic Binding es una caracterstica comn de los lenguajes orientados a objeto y se refiere
al proceso de entrelazar un programa de forma que existan todas las conexiones apropiadas
entre sus componentes, en rigor es una consecuencia de la puesta en prctica o realizacin del
polimorfismo.
Polimorfismo
Polimorfismo es un trmino que se utiliza para describir una situacin en donde un nombre
puede referirse a diferentes mtodos. En Java existen dos tipos de polimorfismo: el que ocurre
en la sobrecarga y el que ocurre en el reemplazo.
El polimorfismo en la sobrecarga sucede cuando existen varios mtodos dentro de una clase,
todos ellos con el mismo nombre, lo cual est permitido siempre y cuando los mtodos tengan
diferente nmero o tipos de parmetros. Tener diferentes tipos de retorno no sirve al eliminar
la ambigedad de los mtodos y no ayuda si se necesitan dos mtodos con el mismo nombre y
los mismos parmetros pero diferentes tipos de retorno. Al crear mtodos de clase
polimrficos y escribir cdigo que acceda a ellos, Java determina cul de los mtodos debe
llamar durante la compilacin.
Por otra parte, al reemplazar mtodos, Java determina cul debe llamar al momento de ejecutar
el programa, no durante la compilacin. Para determinar qu mtodos debe llamar, Java debe
considerar no slo los que estn dentro de una clase, sino adems los que estn en las clases
madres. El reemplazo ocurre cuando un mtodo en una clase tiene el mismo nombre y firma
(nmero, tipo y orden de los parmetros) que un mtodo de una clase madre ( o superclase).
En caso de que los mtodos tengan el mismo nombre y firma, el mtodo de la clase derivada
siempre reemplaza al mtodo de la clase madre.
Ejemplo 15
class EjemploPoli {
public static void pago (Empleado empleado) {
System.out.println("Empleado" + empleado.apellido + " recibe Pago.");
}
public static void main (String[] args) {
Empleado empleado;
// Polimorfismo
empleado = new Colaborador("Meyer", "Hans", false, 1, "IIa");
// Polimorfismo en la entrega de parametros
pago(empleado);
}
}
162
Dr. Eric Jeltsch F.
Sobreescritura de mtodos
Ejemplo 16
class Colaborador extends Empleado {
String tarifa;
// sobreescritura de Metodo
void salida () {
System.out.print(esFemenino ? "Sra. " : "Sr ");
System.out.println(" Rut: " + rut);
System.out.println(" Tarifa: " + tarifa);
}
}
class EjemploSobreescritura {
public static void main (String[] args) {
Empleado m;
m = new Empleado("Meyer", "Hans", false, 1);
m.salida(); // llamada a salida() de la clase "Empleado"
m = new Colaborador("Soto", "Martin", false, 2, "IIa");
m.salida(); // llamada a salida() de la clase "Colaborador"
}
}
Clases Abstractas y Mtodos Abstractos

Al disear un programa en Java o cualquier otro lenguaje orientado a objetos, por lo general se
inicia con una descripcin de alto nivel de lo que se desea que haga el programa. Los
lenguajes orientados a objetos facilitan el modelaje (o la representacin) del problema que
tiene que resolver el programa, ya que se pueden utilizar clases para representar las cosas
que componen la solucin.
Digamos que quiere comenzar con el modelaje de un Alumno y un Empleado y que crea clases
para cada uno de estos modelos. Al desarrollarlas, quiz aparecern caractersticas que son
comunes a los Alumnos y a los Empleados. Por ejemplo, ambos hacen docencia en la Uni,
entonces ser necesario escribir un mtodo (tal vez llamado docente) para cada uno. Java
proporciona un tipo especial de clase, llamada clase abstracta, que puede ayudar a la
organizacin de las clases basadas en mtodos comunes. Una clase abstracta permite colocar
los nombres de los mtodos comunes en una sola clase (sin tener que escribir el cdigo que los
instrumente). Despus, al crear nuevas clases como Alumno y Empleado, stas pueden
derivar de una clase abstracta que contiene una serie de mtodos requeridos (docente, por decir
algo).
Los mtodos abstractos contienen slo el nombre del mtodo seguido de una lista de
parmetros (esto tambin se conoce como firma). No contienen el cdigo que instrumenta el
mtodo esto se deja para las clases derivadas-, despus. Otros puntos clave acerca de los
mtodos abstractos son:
Las clases que contienen mtodos abstractos se conocen como clases abstractas.
Un programa no puede crear instancias de una clase abstracta de forma directa, es
necesario crear instancias de sus subclases.
163
Dr. Eric Jeltsch F.
Las clases abstractas pueden contener una mezcla de mtodos abstractos y no abstractos
(concretos). Los mtodos concretos contienen la instrumentacin del mtodo.
Cualquier subclase que extienda a la clase abstracta debe proporcionar la instrumentacin
de todos los mtodos abstractos. En caso contrario, la subclase misma se convierte en una
clase abstracta.
Un ejemplo de mtodo abstracto puede ser integrado en la clase Persona, con el nombre de
mtodo Ocupacin(), la que para esta clase no es todava realizada y por tal motivo se deja
declarada como abstracta.
Ejemplo 17
abstract class Persona {
String apellido;
String nombre;
boolean esFemenino;
Persona () {
}
// constructor
Persona (String apellido, String nombre, boolean esFemenino) {
}
// mtodo Abstracto
abstract void Ocupacion();
}
Importante: Los mtodos abstractos al igual como otros mtodos son heredados.
class Empleado extends Persona {
int rut;
this.rut = rut;
}
void salida() {
System.out.print(esFemenino ? "Sra " : "Sr ");
}
// sobreeescritura del mtodo abstracto heredado
void Ocupacion() {
System.out.println("Trabajan");
}
}
String carrera;
byte semestre;
Student (String apellido, String nombre, boolean esFemenino, String carrera,
byte semestre) {
164
Dr. Eric Jeltsch F.
}
// sobreescritura del mtodo abstracto heredado
void Ocupacion() {
System.out.println("Aprender");
}
}
Interfaces
En Java, una clase puede tener slo una superclase (clase madre). Como ya vimos, puede
crear nuevas clases derivndolas de clases existentes, heredando as las variables y mtodos de
la clase madre. sta es una tcnica poderosa que permite agregar funcionalidad de forma
creciente y al mismo tiempo mantener las clases tan sencillas como sea posible. Adems,
obliga a pensar bien el diseo de los programas y organizar su flujo.
Sin embargo, tal vez quiera derivar caractersticas de ms de una clase madre, lo cual puede
venir a raz del problema que desea resolver, como representar la solucin en trminos de
clases. Java no permite la herencia mltiple, es decir, la capacidad de derivar una nueva clase
a partir de ms de una clase existente. De cualquier modo, Java tiene una forma para declarar
tipos especiales de clase que permite un nmero ilimitado de derivaciones. Las diferencias
principales entre una interface y una clase son las siguientes:
Una interface, al igual que una clase abstracta, proporciona los nombres de los mtodos
pero no sus instrumentaciones.
Una clase puede instrumentar varias interfaces, ordenando de esta forma la restriccin de
herencia mltiple de Java.
Un programa no puede crear una instancia u objeto de una interface.
Todos los mtodos de una interface son implcitamente pblicos y abstractos.
Todas las variables de una interface son implcitamente pblicas, estticas y finales. No se
permite ningn otro tipo.
La clase que instrumenta a la interface debe instrumentar todos los mtodos, a menos que
sea declarada como abstracta.
Una interface no tiene una clase padre antecesora (Object). En su lugar, las interface
tienen una jerarqua independiente que puede ser aplicada a cualquier parte del rbol de
clases.
Ejemplo 18
public class Alumno extends Persona implements nombreEntidad{
private String matriculaNo;
public Alumno(String matriculaNo)
{
this.matriculaNo = matriculaNo;
} //constructor
public String getMatriculaNo()
{
return matriculaNo;
} //getMatriculaNo;
public boolean setMatriculaNo(String matriculaNo)
if (matriculaNo.compareTo("")==0)
165
Dr. Eric Jeltsch F.
{
this.matriculaNo = matriculaNo;
return true;
}
else
return false;
} //setMatriculaNo()
public String getNombre()
return nombre;
} //getNombre()
public boolean setNombre(String newNombre)

{
if (newNombre.compareTo("")!=0)
{
nombre = newNombre;
return true;
}
else
return false;
} //setNombre()
public String toString()
{
return("Nombre:"+this.getNombre()+"\nMatricula
Numero:
"+this.getMatriculaNo()
);
} //toString()
Alumno mario = new Alumno("0793022");
System.out.println( mario.getMatriculaNo() );
System.out.println("mario.toString()returns:
\n"+mario.toString() );
mario.setNombre("Mario Jorquera");
System.out.println("mario.toString()returns:
\n"+mario.toString() );
} //main()
} //end class Alumno
class Persona
{
String
nombre;
} //class Persona
interface nombreEntidad
{
String getNombre();
boolean setNombre(String newNombre);
} //interface nombreEntidad
166
Dr. Eric Jeltsch F.
Modelamiento UML
Persona
nombre: String
nombreEntidad
<<interface>>
getNombre( ) : String
setNombre(String newNombre): boolean
Alumno
matricN: String
getNombre: String
setNombre(String newNombre): boolean
getMatricN( ) : String
setMatricN(String newMN): boolean
Una interface agrega la flexibilidad de declarar un conjunto de mtodos y variables que

pueden ser instrumentados por cualquier clase en el rbol de jerarqua de clases. Otro uso que
tienen las interfaces es proporcionar un conjunto de constantes a las que pueda accederse de
forma directa con cualquier otra clase. Por ejemplo, las siguientes instrucciones muestras
cmo definir una interfaz que defina un conjunto de constantes.
Importante: En contrario a la herencia normal puede una clase implementar varias Interfaces.
Las interfaces al igual que las clases pueden ser utilizadas como tipo de dato. Ejemplo, dado
una Interface Academico:
interface Academico {
byte SIN_TITULO = 0;
byte MAGISTER= 1;
byte DOCTOR = 2;
byte PROFESOR = 3;
void titulo();
}
Ahora si Ud. notan la clase Investigacion nos da una informacin extra sobre el curriculum
del Academico dentro de la organizacin o Colaboradores. Es as como es posible tener:
class Investigador extends Colaborador implements Academico {
byte titulo;
Investigador (String apellido, String nombre, int rut, boolean esFemenino,
int tarifa, byte titulo) {
super(apellido, nombre, rut, esFemenino, tarifa);
this.titulo = titulo;
}
void Ocupacion() {
System.out.println("Investigar");
}
// Implementar el mtodo abstracto
void titulo() {
switch(titulo) {
case MAGISTER:
167
Dr. Eric Jeltsch F.
case DOCTOR:
case PROFESOR:
System.out.println("Titulo o grado");
break;
case SIN_TITULO:
default:
System.out.println("Sin Titulo");
break;
}
}
}
Paquetes
Generalmente las clases e Interfaces en Java estn subordinadas a paquetes, de manera que
para utilizarlos significa darles en el encabezamiento del programa la ruta adecuada. Para
generar nuestros propios paquetes se deben declarar a travs de la declaracin
package NombrePaquete;
Con esto, se verifica que toda clase e interface contenida en el programa pertenece a
NombrePaquete.
// Declaracion de NombrePaquete
package AdministracindelPersonal
class Personal {
String apellido;
String nombre;
boolean esFemenino;
Personal () {
}
Personal (String apellido, String nombre, boolean esFemenino){
}
}
Declaracin import
import NombrePaquete.Tiponombre;
import NombrePaquete.*;
La primera declaracin declara el paquete completo con todas sus clases e interfaces, de
manera que durante la ejecucin del programa el compilador deber examinar la clase o
paquete correspondiente y no todo su contenido, como se realiza en la segunda declaracin
// Declaracion de NombrePaquetes
package AdministracindelPersonal;
// Importando la clase java.lang.Object
// (Sin ms ni ms, siempre esta este paquete presente)
import java.lang.Object;
class Persona extends Object {
168
Dr. Eric Jeltsch F.
String apellido;
String nombre;
boolean esFemenino;
Persona () {
}
Persona(String apellido, String nombre, boolean esFemenino) {
}
}
Java-Paquetes Estandar
Para Java existe un gran conjunto de paquetes estandares, en donde las clases e interfaces para
diferentes aplicaciones estn a disposicin.
java.lang: clases e interfaces fundamentales.

java.io: Entrada y Salida de datos y filtros.
java.net: soporte para redes (Sockets, URLs, ...)
java.util: clases para diversas estructuras de datos, entre ellas, Listas, Stacks, Hash, fecha y hora.
java.util.zip (desde Java 1.1): compresin de datos.
java.text (desde Java 1.1): soporte para programas, que consideran diversas lenguajes y pases (por
ejemplo: formato de salida para nmeros, fecha u hora local).
java.math: soporte para el manejo de nmeros, exactitud, etc.
java.beans (desde Java 1.1): soporta los llamados beans (en Java son componentes de software que
pueden ser reutilizados.)
java.applet: clase que ayuda en la generacin de Applets (programas Java, que se ejecutan bajo un
determinado Browser como parte de una pgina WWW).
java.awt: popularmente llamada Abstract Windowing Toolkit (abrev. AWT), una coleccin de
clases e interfaces para las interfaces grficas.
java.awt.event (desde Java 1.1): una extensin de AWT.
java.awt.image: Elaboracin de imgenes.
java.awt.peer: interfaces, que son significativas en la realizacin de AWT .
Programacin Orientada a Objetos comparada con la Programacin de Procesos y

programacin orientada a eventos.
Al comparar la programacin orientada a objetos (POO) con la metodologa tradicional de
programacin por proceso, puede ver que la primera proporciona un nuevo marco de
referencia a travs del cual se pueden estudiar los problemas de programacin. En una
metodologa por proceso, se escriben funciones para resolver piezas de un problema. Si otro
programador ha escrito funciones que resuelven problemas especficos, es posible, en un
nuevo programa, utilizar (llamar) estas funciones. En la programacin tradicional, el
programador comnmente ocupa ms tiempo en las funciones que en el problema que debe
resolver el programa.
Como ya hemos visto, la programacin orientada a objetos proporciona una forma de ver los
programas en funcin de los datos y los mtodos que operan sobre ellos.. En la programacin
169
Dr. Eric Jeltsch F.
orientada a objetos, la atencin se aleja de las funciones y se acerca a las cosas (objetos) que
componen el programa. Las diferencias bsicas entre la programacin orientada a objetos y el
enfoque de procesos pueden agruparse en cuatro principios bsicos: abstraccin, encapsulado,
herencia y polimorfismo.
La abstraccin es el proceso de ignorar temporalmente los detalles subyacentes al objeto, para
centrar la atencin en el problema u objeto y as extraer sus caractersticas esenciales. Por
ejemplo, si se consideran los neumticos de un auto, el neumtico abstracto puede tener una
marca, tamao precio y una cantidad ideal de aire. Estas caractersticas se aplican a todos los
neumticos. Al utilizar la abstraccin es posible centrar la atencin sobre estas caractersticas
cave (comunes), en lugar de hacerlo sobre los detalles de un tipo especfico de neumtico.
Encapsular es el proceso de agrupar la informacin abstrada del objeto con las operaciones
(mtodos) que un programa puede realizar sobre los datos. Por ejemplo, una clase es el
encapsulado de los datos y mtodos de un objeto.
La herencia es un marco en el cual se pueden crear clases nuevas al introducir nuevas
caractersticas o cambios a clases existentes. La herencia libera al programador de la tarea de
rescribir funciones cuando se deben hacer pequeos cambios.
Finalmente, el polimorfismo es la habilidad que tiene un objeto de tomar diferentes formas. El
prefijo poli significa muchas; morfismo formas. Por ejemplo, en un programa, un objeto
polimorfo que represente un telfono puede cambiar de forma para representar un telfono de
tonos, un telfono de pulsos o incluso un telfono celular.
Como puede notar algunos conceptos de la POO son anlogos a los mtodos de programacin
convencional, por ejemplo.
Un mtodo es como un procedimiento porque ambos contienen instrucciones
de
procesamiento. Las variables de clase y modelo se correlacionan a los datos de la
programacin tradicional. Los mtodos y datos son diferentes porque los procedimientos no
estn encapsulados normalmente con los datos que manipulan.
Una clase es como un tipo abstracto de datos, aunque para la POO, el proceso de escribir no se
revela fuera de la clase.
La herencia no tiene analoga inmediata en la programacin convencional.
El paso de mensajes reemplaza a las llamadas de funcin como mtodo principal de control
en los sistemas orientados a objeto. Con las llamadas de funciones, los valores se presentan y
el control regresa a la funcin que efecta la llamada. Por el contrario, los objetos entran en
accin gracias a los mensajes, y el control est distribuido.
En resumen, la orientacin a objetos se define por medio de un conjunto de mecanismos:
objetos, clases y modelos, mtodos y mensajes, y herencia. Estos mecanismos dan origen a
conceptos clave inherentes a los sistemas orientados a objetos: encapsulacin, abstraccin y
polimorfismo. Los mecanismos y conceptos de la orientacin a objetos llevan esencialmente a
170
Dr. Eric Jeltsch F.
los programadores a escribir cdigo en un nivel superior de abstraccin. Asimilar las ideas
orientadas a objetos significa aprender las diferencias as como las similitudes entre este
mtodo y la programacin convencional.
Un ejemplo practico.
Metas:
a) Recrear los conceptos de la POO, vistos hasta ahora.
b) Ganar habilidades en la creacin y uso de una jerarqua de clases.
Descripcin del Problema

Crear un sistema capaz de administrar un examen tipo cuestionario, basado en 3 tipos de
preguntas. Se fijan entre ellas, preguntas del tipo
a) Verdadero/falso,
b) Seleccin mltiple,
c) Respuesta cortas.
Cada pregunta debe tener un puntaje o peso, el que representar el resultado del examen. Su
propuesta deber ser capaz de crear un pequeo examen, con tal vez 10 preguntas, y administrarlo
en el sentido de dar respuestas a las distintas preguntas que se proponen pero en el contexto de la
pregunta, ya sea del tipo a) , b) o c). Para finalmente reportar los resultados en porcentaje.
Algunas consideraciones para la propuesta de solucin.

Pregunta.java: es una clase abstract que acoge los elementos comunes a todos los tipos de
preguntas. Debera contener:
una variable peso para el "peso" de la pregunta, adems de mtodos public getPeso() y
setPeso() para esta variable.
una variable text para el texto de la pregunta, adems de un mtodo public getText()
para esta variable. El texto de la pregunta deber ser "seteado" por constructores y
nunca cambiado, de manera que Ud. no necesita un mtodo set para ello.
un mtodo abstract buscar(), que pedir la pregunta, lee la respuesta del usuario y
return un resultado boolean indicando si el usuario la respondi correctamente.
Tambin deber imprimir un mensaje al usuario, llamando la atencin de que el
resultado a la pregunta fue correcto o no. Estudie la forma de definir las variables, es
decir protected, private, u otra.
171
Dr. Eric Jeltsch F.
/**
* Una clase que representa una pregunta de un examen.
*
*/
public abstract class Pregunta {
/**
* El n de puntos para las preguntas. Default es un punto.
* es private en vez de protected , as la subclase son forzadas a usar
* el metodo getPeso, y as prevenir pesos ilegales.
*/
private int peso = 1;
/**
* texto de la pregunta. Todas las preguntas tienen un texto; la diferencia
* esta en el tipo de respuesta y el mtodo de chequear la respuesta.
*/
protected String text;
/**
* Obtener el texto de esta pregunta.
*
* @return el texto de esta pregunta
*/
public String getText() {
return text;
} // end getText
/**
* obtener el peso de esta pregunta
*
* @return el peso
*/
public int getPeso() {
return peso;
} // end getPeso
/**
* setear el peso de esta pregunta
*
* @param wt el nuevo peso para esta pregunta. Debe ser mayor que cero, o el
metodo imprime un
* un mensaje de error y se sale el programa.
*/
public void setPeso(int wt) {
if (wt <= 0) {
System.out.println("Error: peso ilegal" + wt);
System.exit(1);
}
else {
peso = wt;
} // end if
} // end setPeso
/**
* Busca el usuario la pregunta y chequea para ver si la respuesta dada es
correcta
* El metodo depende del tipo de pregunta, por eso es un metodo abstract.
*
* @return true si el usuario responde correctamente
*/
public abstract boolean buscar();
172
Dr. Eric Jeltsch F.
} // end class Pregunta
TFpregunta.java: Una extensin de la clase Preguntas, para preguntas del tipo

true/false. Deber contener:
un mtodo concreto buscar(). La respuesta "legal" es "t" o "T" para true, y "f" o "F"
para false. Si el usuario responde cualquier otro string que no sea lo antes dicho,
deber intentarlo otra vez, hasta cuando Ud. le diga Stop, y lo mande a estudiar, o bien
comience con un nuevo Examen. Para tal efecto podr importar otras clases para la
lectura de los datos, como lo visto con Console, con hsa o con SavitchIn
una variable para registrar la respuesta correcta (true o false)
un constructor, que crea una pregunta true/false, dado el texto de la pregunta, la

respuesta correcta, y el peso "peso". Algo as
/**
* Preguntas v/f para un examen.
*
*/
public class TFpregunta extends Pregunta {
/**
* La respuesta correcta para esta pregunta.
* boolean -- ya sea true o false.
*/
private boolean correctResp;
En este caso la respuesta es
/**
* Constructor: crea una pregunta true/false dado un textopara la pregunta,
* la respuesta coorrecta, y el peso (n de puntos).
*
* @param pregunta el texto para la pregunta
* @param respuesta la respuesta correcta
* @param wt el peso
*/
public TFpregunta(String pregunta, boolean respuesta, int wt) {
text = pregunta;
correctResp = respuesta;
setPeso(wt);
/**
correcta
* el usuario puede ingresar "t" o "T" para true, y
* "f" o "F" para false. Si el usuario ingresa una respuesta
* que no es ninguna de ellas este mtodo se mantendr hasta que de con ella
* obteniendo un true para la resp. legal o false en otro caso. Cuando el
usuario ingresa
* una respuestavlida, prints un message estableciendo que la respuesta es
correcta.
*
*/
173
Dr. Eric Jeltsch F.
public boolean buscar() {

System.out.print(text + " (ingrese T o F): ");
// obtener respuesta del usuario y tralada a to lower case
String usuText = SavitchIn.readLine().toLowerCase();
if (usuText.equals("t")) {
if (correctResp) {
System.out.println("correcta!");
return true;
}
else {
System.out.println("no, la respuesta es falsa");
return false;
} // end if
}
else if (usuText.equals("f")) {
if (!correctResp) {
return true;
}
else {
System.out.println("no, la respuesta es verdadera");
return false;
} // end if
}
else { // respuesta no valida true/false
System.out.println("Error: Ud. debe responder 'T' o 'F'.
vez.");
return buscar(); // hacerlo otra vez
} // end if
} // end buscar
Trate otra
} // end class TFpregunta
Resp_Cortas_Pregunta.java: Una extensin de la clase Preguntas, para las respuestas

cortas. El propsito, es que las respuestas cortas tienen solo una posible respuesta. Deber
contener:
un mtodo concreto buscar() . Comparando la respuesta del usuario a la respuesta

correcta, use equalsIgnoreCase.
una variable para registrar la respuesta correcta (un String).
un constructor, que crea una respuesta corta a la pregunta, dado el texto de la pregunta,
la respuesta correcta y el peso "peso".
/**
* Para responder en forma muy escueta ante una pregunta, para un examen.
* Este tipo de preguntas toma una respuesta que puede ser ingresada sobre una
linea de entrada
*
*/
public class Resp_Cortas_Pregunta extends Pregunta {
/**
* La respuesta correcta para esta pregunta. En este caso, la respuesta es
* un string -- el string exacto debe ser ingresado por el usuario.
*/
174
Dr. Eric Jeltsch F.
private String correctResp;

/**
* Constructor: crea la pregunta y da un texto para la pregunta y la
respuesta
* correcta, ademas del peso (n de puntos.).
*
* @param pregunta el texto para la pregunta
* @param respuesta la respuesta correcta
* @param wt el peso
*/
public Resp_Cortas_Pregunta(String pregunta, String respuesta, int wt) {
// usa los dos parametros del contructor y setea el peso
text = pregunta;
setPeso(wt);
/**
* correcta. El usuario responde exactamente, excepto por mayusculas.
* Prints un message estableciendo si la respuesta fue correcta.
*
*/
System.out.print(text + ": ");
String usuText = SavitchIn.readLine();
if (usuText.equalsIgnoreCase(correctResp)) {
return true;
}
else {
System.out.println("no, la respuesta correcta es " + correctResp);
return false;
} // end if
} // end buscar
} // end class Resp_Cortas_Pregunta
Selec_Mul_Pregunta.java: Una extensin de la clase Preguntas, para las preguntas de

seleccin mltiple. Recordar que preguntas de seleccin mltiple deben tener al menos 2
elecciones. Esta clase deber contener:
un mtodo concreto buscar() . Imprimir la pregunta, seguida por las elecciones,

identificndolas por letras 'a', 'b', 'c', etc.
una variable para registrar la eleccin (un array de Strings) y la respuesta correcta (un
int -- es el index de la respuesta correcta en el array de elecciones).
un constructor que crea la pregunta de eleccin mltiple, dado el texto de la pregunta,

el arrray de elecciones, la respuesta correcta y el peso "peso".
175
Dr. Eric Jeltsch F.
/**
* preguntas de eleccin multiple para un examen. La respuesta puede
cualquier n de elecciones (al menos 2).
*
*/
public class Selec_Mul_Pregunta extends Pregunta {
/**
* La respuesta correcta para esta pregunta funciona como un
* index en el array de elecciones.
*/
private int correctResp;
tener
/**
* el array de elecciones.
*/
private String elec[];
/**
* Constructor: crea una pregunta de seleccin -multiple, con un peso dado.
*
*
* @param pregunta el texto de la pregunta
* @param eleArray un array de seleccion para la respuesta
* @param respuesta la respuesta correcta (debe ser un index en el array
anterior)
* @param wt el peso
*/
public Selec_Mul_Pregunta(String pregunta, String eleArray[], int respuesta,
int wt) {
// chequea parametros para validar
if (eleArray == null || eleArray.length < 2) {
System.out.println("Error: preguntas de seleccin multiple necesitan al
menos 2 elecciones");
System.exit(1);
}
else if (respuesta < 0 || respuesta >= eleArray.length) {
System.out.println("Error: respuesta para seleccin multiple deben ser un
index legal en el array de eleccin");
System.exit(1);
} // end if
text = pregunta;
elec = eleArray;
setPeso(wt);
/**
correcta.
* El usuario debe responder 'a', 'b', 'c', o 'd'. Si el usuario ingresa una
respuesta, que no esta
* este metodo le mandara un mensaje y lo intenta otra vez, hasta obtener la
respuesta legal.
* Cuando el usuario ingresa una respuesta valida prints un message
estableciendo que la respuesta es correcta.
*
*/
int numElec = elec.length; // n de elecciones para esta pregunta
176
Dr. Eric Jeltsch F.
System.out.println(text + "?");
for (int i = 0; i < numElec; i++) {
" + (char)('a' + i) + ". " + elec[i]);
} // end for
System.out.print("ingrese la letra de su eleccion: ");
// obtener la respuesta del usuario y la traslada a mayuscula
String usuText = SavitchIn.readLine().toLowerCase();
if (usuText.length() != 1) {
System.out.println("Error: por favor ingrese un caracter simple");
return buscar(); // repetir
} // end if
// el usuario responde como un numero, con 'a' = 0, 'b' = 1, etc.
int respIndex = usuText.charAt(0) - 'a';
if (respIndex < 0 || respIndex >= numElec) {
System.out.println("Error: caracter ilegal");
return buscar(); // repetir
} // end if
if (respIndex == correctResp) {
return true;
}
else {
System.out.println("no, la respuesta es " + elec[correctResp]);
return false;
} // end if
} // end buscar
} // end class Selec_Mul_Pregunta
Exam.java: Es una clase que entrega una coleccin de preguntas para un examen dado. El
examen parte vaco (no existen preguntas), y proporciona un mtodo para agregar preguntas a
un examen. Esta clase deber contener:
Un array de preguntas. Estudie la forma de limitar el n lmite de preguntas, por ahora

cree un array de tamao 10.
Un contador para el n de preguntas en el array.
Un mtodo agregaPregunta() , el que toma una pregunta (de cualquier tipo) como
argumento y la agrega al examen.
Un mtodo darExam() el cual administra el examen al usuario, con el fin de garantizar

el n de respuestas, con su porcentaje y el redondeo apropiado, como resultado.
/**
* Un examen es una coleccion de preguntas. En este caso, un examen esta
* implementado como un array de preguntas y tiene un tamao maximo.
*/
public class Exam {
/**
* El n maximo de preguntas admitidas en un examen.
*/
177
Dr. Eric Jeltsch F.
public static final int MAX_PREGUNTAS = 10;

/**
* El n actual de preguntas actualmente en el examen.
*/
private int numPreguntas = 0;
/**
* Las preguntas en el examen.
*/
private Pregunta lasPreguntas[] = new Pregunta[MAX_PREGUNTAS];
/**
* Agrega una pregunta al examen. Si el examen ya esta lleno,
* prints un mensaje de error y no hace nada.
*
* @param q la pregunta a agregar
*/
public void agregaPregunta(Pregunta q) {
if (numPreguntas == MAX_PREGUNTAS) {
System.out.println("Error: excede n maximum de preguntas para el
examen");
System.exit(1);
} // end if
lasPreguntas[numPreguntas] = q;
numPreguntas++;
} // end agrega Preguntas
/**
* Administra el examen: busca todas las preguntas y entrega un puntaje
*
* @return el puntaje (en porcentaje)
*/
public int darExam() {
int total = 0; // total de puntos en el examen
int puntaje = 0;
// buscar todas las preguntas
for (int i = 0; i < numPreguntas; i++) {
int peso = lasPreguntas[i].getPeso();
total += peso;
if (lasPreguntas[i].buscar())
puntaje += peso;
} // end for
// reporta el puntaje,
if (total == 0) {
return 0;
}
else {
double razon = (double)puntaje / total;
return (int)(razon * 100 + .5);
} // end if
} // end darExam
} // end class Exam
178
Dr. Eric Jeltsch F.
ExamDemo.java Es una clase testeadora capaz de ilustrar el trabajo de cada una de las clases
antes definidas, y al mismo tiempo administrar una propuesta de examen, con una solucin
final.
/**
* Un programa principal para testear.
*/
public class ExamDemo {
/**
* Este programa principal crea un pequeo examen y lo administra, tal como
se espera.
*/
// crea un examen con un total de 10 puntos: 8 preguntas de un punto y una
de dos puntos
Exam miExam = new Exam();
miExam.agregaPregunta(new TFpregunta("La capital de Chile es Santiago",
true, 1));
String santiagoElec[] = {"Santiago", "Valparaiso", "Concepcion",
"Magallanes", "Arica"};
miExam.agregaPregunta(new Selec_Mul_Pregunta("Cul es la capital de Region
Metropolitana", santiagoElec, 0, 1));
miExam.agregaPregunta(new Resp_Cortas_Pregunta("Cul es la capital de IV
Region", "Coquimbo", 1));
miExam.agregaPregunta(new TFpregunta("La capital de Alberta es Calgary",
false, 1));
String BCElec[] = {"Victoria", "Vancouver", "Nanaimo"};
miExam.agregaPregunta(new Selec_Mul_Pregunta("Cul es la capital de British
Columbia", BCElec, 0, 1));
miExam.agregaPregunta(new Resp_Cortas_Pregunta("Cul es la capital de
Argentina", "Buenos Aires", 1));
miExam.agregaPregunta(new Resp_Cortas_Pregunta("Cul es la capital de
Canada", "Ottawa", 2));
miExam.agregaPregunta(new TFpregunta("La capital de La Serena es Illapel",
false, 1));
String PElec[] = {"Brasilia", "Rio de Janeiro", "Sao Paulo", "Blumenau"};
miExam.agregaPregunta(new Selec_Mul_Pregunta("Cul es la capital de
Brasil?", PElec, 0, 1));
// give the exam and report the score
int puntaje = miExam.darExam();
System.out.println("su resultado es " + puntaje + "%");
} // end main
} // end class ExamDemo
179
Dr. Eric Jeltsch F.
Salida:
Condiciones de error: debern ser TODAS cauteladas, ya sea con excepciones o

asserciones.
El programa principal o testeador es para fijar un estndar, no obstante si Ud. estima
conveniente puede modificarlo.
Pauta de Correccin: (Total 70 ptos.)
correctness de las 4 clases:
testing (error de condiciones):
style y documentation:
propuesta.)
Mapa de clases con UML documentacin: 5 (Ir escogiendo alguna herramienta para el
modelamiento, por ejemplo, ArgoUML, Poseidon u otra.)
15 ptos por clase(60), funcionando por separado.

- 5 ptos al total. por cada ERROR.
5 (debern contener las pruebas y testing que se le realiz a su
180
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
CAPITULO 7
Eventos (Events)
La mayora de los programas o aplicaciones comerciales responden a una amplia gama de
acciones, tales como pulsar el mouse sobre un botn o pulsar una tecla de la consola. En todo
caso existen otras acciones ms sofisticadas, tales como cerrar windows, salvar un archivo etc.
a lo que el usuario las utiliza una despus de otra sin grandes dificultades. Ahora, el tipo de
programas que abordaremos esta relacionada con este tipo de aplicaciones, es decir aquellas
que son orientados al usuario. Java2 ofrece facilidades especiales para este propsito, en
particular veremos como escribir programas que sean capaces de realizar este tipo de eventos
o acciones, tales como presionar o pulsar el mouse sobre una porcin de la pantalla o sobre un
frame(marco), etc. Hoy en da existen herramientas que le facilitarn la vida, en trminos de
generar frames, textbox y otros, (por ejemplo, SUN One Studio, entre otros.), pero NO olvide
que jams podr sustituir lo que Ud. realmente desea de la aplicacin, a pesar de todo el
cdigo que pudo haber generado la herramienta. En resumen, siempre deber entrar a
manipular el cdigo generado por la herramienta CASE, esto le responde el porque hemos
empezado explicando y repasando los conceptos de POO, los que estn ntimamente
relacionados con los objetivos de manejar eventos.
Java proporciona una biblioteca de herramientas (o clases) denominada JFC (Java Foundation
Classes), con el fin de disear herramientas Graphic User Interface (GUI), interfaces grficas
(es decir, ventanas con componentes, tales como etiquetas, cajas de texto, botones, barras de
desplazamiento, etc.) Actualmente bajo esta denominacin se agrupan varias APIs:
Swing. Conjunto de componentes escritos en Java para disear interfaces grficas de usuario
que se ejecutan uniformemente en cualquier plataforma nativa que soporta la mquina virtual
de Java.
AWT (Abstract Window Toolkit - kit de herramientas de ventanas abstractas). Conjunto de
componentes para disear interfaces grficas de usuario comn a todas las plataformas
nativas. Este grupo ha sido sustituido en gran medida por el conjunto de componentes Swing;
muchos de stos heredan de sus correspondientes componentes AWT.
Java 2D. Permite incorporar en los programas, grficos 2D de alta calidad, texto e imgenes.
Drag and Drop. Soporte para arrastrar y colocar. Permite la transferencia de datos entre
aplicaciones mediante la simple operacin de arrastrarlos hasta el lugar de destino.
Swing o AWT?. La gran diferencia entre los componentes Swing y los componentes AWT es
que los primeros estn implementados absolutamente con cdigo no nativo lo que los hace
independientes de la plataforma, razn que justifica sobradamente su utilizacin. Adems
proporcionan ms capacidades que los componentes AWT. Los componentes Swing se pueden
identificar porque su nombre empieza por J; por ejemplo, el componente AWT Button tiene su
correspondiente componente Swing JButton. Los componentes AWT se localizan en el paquete
java.awt y los componentes Swing en el paquete javax.swing.
181
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
Las herramientas para construir GUIs en Java pueden realizarse con Applets o a travs de las
aplicaciones, sin embargo los applets tienen serias rectricciones respecto del acceso al disco
para nombrar o rescribir un archivo. Notar un dato importante, todos los componentes Swing
son subclases de la clase JComponent.
Eventos
Para disear interfaces grficas (llmese ventanas con componentes, cajas de texto, botones,
barras de desplazamiento) java proporciona una biblioteca de clases llamada JFC (Java
Foundation Classes), que cobija a Swing, AWT, Java 2D y otras APIs. Swing o AWT?. La
gran diferencia entre los componentes es que los primeros estn implementados absolutamente
con cdigo no nativo lo que los hace independiente de la plataforma, adems proporciona ms
capacidades que AWT. Los componentes de AWT se ubican en java.awt, mientras que los
componentes de Swing se ubican en javax.swing. En todo caso todos los componentes
Swing son subclases de la clase JComponent. Los programas en Java pueden reaccionar a un
amplio rango de acciones orientadas al usuario. Por ejemplo, pulsar el mouse sobre la pantalla,
ajustar los bordes del window, tipear un key sobre la consola y muchas otras. Cada una de
estas acciones son llamados eventos.
Ejemplo 1
import java.awt.*;
import java.awt.event.*;
public class AplicacionSwing extends JFrame{
// Referencias a los componentes
private JLabel etiqueta;
private JButton botn;
// Otras referencias
private static String mensaje = "Hola mundo!!!";
private AplicacionSwing(String ttulo) { // constructor
super(ttulo); // ttulo de la ventana principal
iniciarComponentes();
// Ajustar el tamao de la ventana al mnimo
pack();
}
private void iniciarComponentes() {
// Crear una etiqueta con el texto centrado
etiqueta = new JLabel();
etiqueta.setHorizontalAlignment(JLabel.CENTER);
// Crear un botn
botn = new JButton("Haga clic aqu");
// Establecer como tecla aceleradora la C. Entonces, pulsar Alt+C
// ser equivalente ha hacer clic, sobre el botn.
botn.setMnemonic(KeyEvent.VK_C);
// Asignar al botn una descripcin abreviada
botn.setToolTipText("botn de pulsacin");
// Permitir que el botn responda a los eventos de accin
ActionListener al = new ActionListener()
{
// Este mtodo se ejecutar cuando se haga clic en "botn"
182
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
public void actionPerformed(ActionEvent evento)

{
Object obj = evento.getSource();
if (obj == botn)
mostrarMensaje();
}
};
botn.addActionListener(al);
// Crear un panel para colocar los controles
JPanel panel = new JPanel();
// Introducimos un borde sin pintar alrededor de los controles:
// createEmptyBorder(top, left, bottom, right)
panel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
// Establecer un administrador de diseo de cuadrcula
panel.setLayout(new GridLayout(0, 1));
// Los controles se aaden en columna (filas = 0)
panel.add(etiqueta);
panel.add(botn);
// Aadir los componentes al contenedor de la aplicacin
getContentPane().add(panel, BorderLayout.CENTER);
// Permitir que la ventana de la aplicacin responda a los
// eventos de ventana (p.e. cerrar la ventana)
addWindowListener(
new WindowAdapter()
{
public void windowClosing(WindowEvent evento)
{
cerrarVentana();
}
} );
}
private void mostrarMensaje()
{
// Mostrar el "mensaje" en la "etiqueta"
etiqueta.setText(mensaje);
}
private void cerrarVentana()
{
// Salir de la aplicacin
System.exit(0);
}
{
try
{
// Aspecto y percepcin de la interfaz grfica, look and feel
UIManager.setLookAndFeel(
UIManager.getCrossPlatformLookAndFeelClassName());
}
catch (Exception e)
{
System.out.println("No se pudo establecer el aspecto deseado: " + e);
}
AplicacionSwing vPpal = new AplicacionSwing("Aplicacin Swing");
vPpal.show();
}
}
183
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
Marco
Panel
Etiqueta
Botn
Ud. puede observar que cuando pulsa el botn la etiqueta muestra el mensaje Hola
Mundo!!!, ms an, en ella se puede observar que el botn puede activarse, adems de un clic
sobre el mouse, puede utilizarse las teclas aceleradoras Alt+C, y que tiene asociada una breve
descripcin.
Ejemplo 2
import java.awt.*;
class ButtonPanel extends JPanel implements ActionListener {
public ButtonPanel() {
amaButton = new JButton("Amarillo");
azulButton = new JButton("Azul");
rojoButton = new JButton("Rojo");
add(amaButton);
add(azulButton);
add(rojoButton);
amaButton.addActionListener(this);
azulButton.addActionListener(this);
rojoButton.addActionListener(this);
}
public void actionPerformed(ActionEvent evt)
{ Object source = evt.getSource();
Color color = getBackground();
if (source == amaButton) color = Color.yellow;
else if (source == azulButton) color = Color.blue;
else if (source == rojoButton) color = Color.red;
184
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
setBackground(color);
repaint();
}
private JButton amaButton;
private JButton azulButton;
private JButton rojoButton;
}
class ButtonFrame extends JFrame
{ public ButtonFrame()
{ setTitle("Y mas Botones...");
setSize(300, 200);
addWindowListener(new WindowAdapter()
{ public void windowClosing(WindowEvent e)
{ System.exit(0);
}
} );
Container contentPane = getContentPane();
contentPane.add(new ButtonPanel());
}
}
public class ButtonDemo
{ public static void main(String[] args)
{ JFrame frame = new ButtonFrame();
frame.show();
}
}
Cuando se crean eventos, Java crea un objeto evento para representarlo. El tipo de objeto
que es producido depende del orden del evento. Por ejemplo, el objeto evento que se crea para
cuando pulsa el mouse pertenece a la clase MouseEvent. Existen varias otras acciones que
producen objetos MouseEvent: el botn izquierdo del mouse ha sido presionado etc, o sobre el
teclado con keyEvent.
Una vez que ha creado el objeto de evento, Java lo pasar a un mtodo que ha sido escogido
para tratarlo como un tipo particular de evento. El mtodo se llama event listener, (mtodo
que escucha), este mtodo debe ser capaz de contestar apropiadamente la accin que el usuario
demanda o requiere, pero para eso debi haber escogido el o los mtodos apropiados. Los
185
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
mtodos listener tienen nombres especiales que indican el tipo de evento a los que ellos
responden. Por ejemplo, un mtodo que escucha que se ha pulsado el mouse debe responder a
este evento llamado mouseClicked, si es una tecla el evento asociado es keyTyped, y as
sucesivamente. (Una lista completa de sus nombres aparece a la parte final de estas notas.)
Cada mtodo que escucha tiene un solo parmetro que es el objeto de evento que representa el
evento al que l est respondiendo. La vida de un programa interactivo simple, la dividiremos
en dos fases.
Fase de la estructuracin. Esto puede involucrar el crear una GUI para el programa, y
variables de inicializacin.
Fase interactiva. Durante esta fase, el programa est esperando por los eventos
comenzados por el usuario, de manera que en cuanto uno ocurra, el mtodo
correspondiente que escucha obedece. Si no hay ningn evento, el programa se sienta y
espera hasta que otro evento venga. En general esta fase se reconoce por estar
involucrados declaraciones del tipo
public class MiPanel extends JPanel implements ActionListener
Si un mtodo listener no completa su tarea lo bastante rpida, el prximo evento puede ocurrir
antes de que este ltimo haya terminado. Para manejar esta posibilidad, todos los objetos
eventos se agregan a una cola de prioridades, esto se llama cola de despacho de evento (event
dispatching queue). Apenas un mtodo listener ha terminado el proceso de un evento, el
prximo evento (si hay uno) en la cola se pasa al mtodo que escucha.
GUI Minimo-Minimorum:
Usualmente un programa GUI consiste de una Interface, event listener y cdigos de
aplicaciones. Nuestro primer programa GUI adolece de listener, pero esto no ser lo usual.
import java.awt.*; // import la clase AWT
public class ejGUI1 {
public static void main ( String[] args ) // usual start de una aplicacin y no de
un Applet!!
{
Frame frm = new Frame();//construye objeto Frame, no un Applet!
frm.setSize(
150, 100 );// setea a 150 pixeles ancho y 100 alto
frm.setVisible( true ); // lo hace visible, sino debe ser false.
}
}
Si Ud. lo ejecuto habr notado que no tiene un event listener, pues no responde por ejemplo
para cuando Ud. desea cerrar el frame, veremos como lograrlo a travs de una declaracin que
incluye una expresin del tipo frm.addWindowListener( wquit);. Ms simple an es el siguiente
programa, que en realidad no hace absolutamente nada, en realidad teoricamente crea un
window, pero nunca es posible de ver el screen.
import javax.swing.*; // import la clase swing
186
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
public class MiniSwing1 {

JFrame miFrame = new JFrame();
} // end main
} // end class MiniSwing1
Ms simple an a los programas anteriores es el siguiente, que en realidad muestra una barra
solamente, sin dimensin para el frame.
miFrame.setVisible(true);
} // end main
Como podr haber notado, hay que otorgarle un crdito al mtodo setSize, pues ayudo a
cambiar el tamao del frame sobre su pantalla, incluso durante su ejecucin, como lo muestra
el siguiente ejemplo, pero sigue siendo un problema que el frame aparezca en la esquina
superior-izquierda de su pantalla.
import java.awt.*;
public class ejGUI2
{
{
Frame frm = new Frame();
int ancho = 20;
int alto = 10;
frm.setVisible( true );
for ( int cont=1; cont<300; cont++ )
frm.setSize( ancho++, alto++ );
}
}
Otra gracia que presenta la POO como ya lo hemos adelantado es el de poder extender la clase
incorporandole nuevas propiedades, como por ejemplo, un mensaje. Notar que se incorpora el
mtodo paint(), la tarea de ste mtodo consiste en dar las medidas del rea de despliegue.
Ahora para lograrlo, hace uso de un objeto Graphics2D, que tiene su semejanza al System.out
para cuando se enviaban cadenas de caracteres a la pantalla de la consola. El objeto Graphics
tiene a su vez un mtodo llamado drawString(), que se usa para desplegar texto, como muestra
el siguiente ejemplo.
import java.awt.*;
class miFrame extends Frame {
public void paint ( Graphics g ) {
g.drawString("Un objeto MiFrame", 10, 50 );
//escribe un string en el Frame con x=10 y=50
}
}
public class ejGUI3 {
public static void main ( String[] args ) {
miFrame frm = new miFrame();
frm.setSize( 150, 100 );
187
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
}
}
Ud. habr notado que no le hemos puesto nombre al frame o a la barra del frame, ahora ver
una propuesta.
miFrame.setSize(200, 100);
miFrame.setTitle("Titulando los frames"); // lo nuevo.
} // end main
Vamos a lo prometido, me refiero a tratar de cerrar el frame para cuando pulsemos el cierre de
ventana del frame que se ha creado, siendo este otro ejemplo de cuando realizar o gatillar un
evento.
import java.awt.*;
class miFrame extends Frame {
public void paint ( Graphics g ) {
g.drawString("Click el boton de cierre", 10, 50 );
}
}
class WindowQuit extends WindowAdapter {
public void windowClosing( WindowEvent e )
{
System.exit( 0 ); // exit del programa
}
}
public class GUItester {
public static void main ( String[] args ) {
miFrame frm = new miFrame();
WindowQuit wquit = new WindowQuit();
// construye un listener para frame
frm.addWindowListener( wquit );
// registra el listener con el frame
frm.setSize( 150, 100 );
}
}
A continuacin se presenta la misma estructura, pero en un estilo muy particular, poco

didctico a mi entender, en donde se crea una clase annima. En todo caso una explicacin
extensa sobre el particular aparece en Horstmann, CoreJava2, Volumen 1, pg. 327-330.
//se usa una clase interna anonima para crear el window listener.
188
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
miFrame.setTitle("Baby Swing Program");

miFrame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
} // end windowClosing
} // end clase anonima
);
} // end main
El evento de capturar el cierre de windows es uno de los tantos eventos que se analizarn,
dentro de un contexto de una estructura que pretende ser estandar.
Estuctura de una Aplicacin Swing.
Convengamos en que una aplicacin Swing que muestra una interfaz grfica para cuando se
ejecuta no es ms que un objeto de una clase derivada de JFrame. Basado en lo anterior, el
cdigo mostrado a continuacin puede ser una propuesta vlida para la mayora de las
aplicaciones que inician su ejecucin visualizando una ventana principal:
public class estrucFrame extends JFrame {
public estrucFrame() {
super("Titulo de la Aplicacion");
// Aqu, agrega los componentes.
}
JFrame miframe = new estrucFrame();
WindowListener l = new WindowAdapter() {
System.exit(0);
}
};
miframe.addWindowListener(l);
miframe.pack();
miframe.setVisible(true);
}
}
A manera de comentario, digamos que esta aplicacin es una subclase de JFrame y todo el
trabajo involucrado en la creacin de la interfaz de usuario del frame(o marco) se realiza en el
mtodo constructor estrucFrame(). Con el mtodo super(cadena); se pretende
proporcionar el texto para la barra de ttulo del marco. Luego la interfaz de usuario deber
construirse dentro de este constructor; aqu se pueden agregar los componentes a los
contenedores, y estos ltimos al marco.
public estrucFrame() {
super("Titulo de la Aplicacion");
// Aqu, agrega los componentes.
}
189
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
Dentro de main() se usa el constructor estrucFrame() para crear una nueva instancia que le
llame miframe, de la clase JFrame, la que ser la ventana principal de la aplicacin. Notar que
el nombre del archivo es estructFrame.java.
JFrame miframe = new estrucFrame();
Este cdigo es casi estandar dentro del manejo de eventos, y lo que hace es manejar la tarea de
cerrar la aplicacin para cuando se cierre el marco o pulse con el mouse sobre la porcin cierre
de ventana en el marco que se genero. Recordar que dentro del sistema de manejo de eventos
de Java2, si una clase desea responder a un evento de usuario debe implementar las
interfaces que maneja los eventos. Estas interfaces se llaman escuchadores de eventos, una de
ellas es WindowListener.
System.exit(0);
}
};
miframe.addWindowListener(l);
/* recordar que despus de crear un componente y poder asociarle un listener se necesita

llamar a los mtodos del componente, en este caso addWindowListener(l), es decir llama a
todos los componentes JWindow y JFrame;*/
La siguiente declaracin llama al mtodo pack() del marco y lo redimensiona al tamao ms
pequeo para que contenga todos sus componentes. Usando pack() Ud. se asegura que podr
agregar componentes (nos referimos Button u otros) al marco con la certeza que habr espacio
suficiente para ellos. En general el mtodo pack de la ventana objeto JFrame, redimensiona la
ventana al tamao ms pequeo posible que permita contener a todos los componentes que se
hallan incrustado. Nosotros lo veremos en la prxima lectura, de cmo hacerlo.
Volviendo al cdigo, digamos que sta ltima declaracin hace visible el marco a travs de su
mtodo setVisible(bolean). Si el argumento hubiese sido false, el marco se hara
invisible (oculto) como ya se pudo dar cuenta.
miframe.setVisible(true);
Al ejecutarlo no vera nada super-extra-especial, sino solamente esto.
Ahora para darle el tamao que Ud. desee al windows, reemplace la lnea miframe.pack()
por miframe.setSize(400, 120); por ejemplo
190
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
Notar la importancia de la POO y su aplicacin a los eventos. Esto es, la aplicacin se ejecuta
y queda a la espera de las acciones que pueda emprender el usuario de la misma. En el ejemplo
tan simple que acabamos de presentar, la nica accin que puede tomar el usuario es cerrar la
ventana, por ejemplo, haciendo clic en el botn cerrar, lo que origina el evento
correspondiente Cmo responde Java a este evento? Ejecutando el mtodo windowClosing
asociado con l de forma predeterminada. Por lo tanto, nosotros podemos redefinir este
mtodo y programar las acciones a tomar; en este caso, salir del sistema con
System.exit(0). Es evidente, que se pueden producir otros eventos; por ejemplo: la ventana
se abre, se minimiza, vuelve a su estado normal, etc. Lo que tiene que saber es que Java
siempre responder a cada evento invocando a su mtodo asociado. Lgicamente esa tarea
hay que programarla y para poder hacerlo hay que saber cmo manejar ese evento. Segn ha
podido ver anteriormente, los eventos se manejan a travs de un conjunto de mtodos
predeterminados en todos los componentes, que pueden ser frame, panel, etiquetas, botn y
otros. Pero para que un componente pueda responder a los eventos que sobre l pueden
ocurrir, tiene que tener asociado el manejador o escuchador de esos eventos. Java 2
proporciona varios manejadores o escuchadores de eventos, como se muestran en la tabla.
191
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
Tabla Resumen de trato a los Eventos

Interface
Metodos
actionPerformed
Parametros/Accesos
ActionEvent
Eventos generados
por
Button
ActionListener
getActionCommand
getModifiers
AdjustamentListener adjustmentValueChan AdjustmentEvent
ged
getAdjustable
getAdjustmentType
getValue
ItemListener
itemStateChanged
ItemEvent
getItem
getItemSelectable
getStateChange
TextListener
textValueChanged
TextEvent
ComponentListener
List
MenuItem
TexField
Scrollbar
Checkbox
CheckboxMenuItem
Choice
List
TextComponent
componentMoved
componentHidden
componentResized
componentShown
conponentAdded
ComponentEvent
getComponent
Component
ContainerEvent
Container
componentRemoved
getChild
getContainer
FocusListener
focusGained
focusLost
FocusEvent
isTemporary
KeyListener
keyPressed
keyReleased
keyTyped
KeyEvent
Component
getKeyChar
getKeyCode
getKeyModifiersText
getKeyText
isActionKey
MouseListener
mousePressed
mouseReleased
mouseEntered
mouseExited
mouseClicked
MouseEvent
getClickCount
getX
getY
getPoint
translatePoint
isPopupTrigger
Component
MouseMotionListener mouseDragged
mouseMoved
MouseEvent
Component
WindowListener
WindowEvent
getWindow
Window
ContainerListener
windowClosing
windowOpened
windowIconified
windowDeiconified
windowClosed
windowActivated
windowDeactivated
Component
192
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
La jerarqua de clases se visualiza as:
Jerarqua de los EventListener-Interfaces.
193
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
Mtodo para el Mouse
Significado
mouseClicked
Un sensor del Maus fue pulsado y luego dejado.
mouseEntered
El puntero del Maus ocupa la Componente.
mouseExited
El puntero del Maus abandona la Componente.
mousePressed
Un sensor del Maus fue pulsado.
mouseReleased
Un sensor del Maus fue soltado.
ActionListener.
Permite a un componente responder a las acciones que ocurren sobre l; por

ejemplo, un clic sobre un botn. Este manejador se puede asociar con componentes JButton,
JTextField,
JCheckBox,
JRadioButton
y
JComboBox, invocando al mtodo
addActionListener.
AdjustmentListener.
Permite a una barra de desplazamiento responder a las acciones que se

producen sobre ella. Este manejador se puede asociar con JScrollBar, invocando al mtodo
addAdjustmentListener.
ItemListener.
Permite a un componente responder a los cambios que se producen al actuar

sobre l; por ejemplo, cuando se selecciona una casilla de verificacin. Este manejador se
puede asociar con componentes JButton, JCheckBox, JRadioButton y JComboBox,
invocando al mtodo addItemListener.
KeyListener.
Permite a un componente responder a las acciones procedentes del teclado. Este

manejador se puede asociar con todos los componentes, invocando al mtodo
addKeyListener.
MouseListener.
Permite a un componente responder a las acciones del ratn: pulsar y entrar o

salir en un rea del mismo. Este manejador se puede asociar con todos los componentes,
invocando al mtodo addMouseListener.
MouseMotionListener.
Permite a un componente responder a los movimientos del ratn. Este

manejador se puede asociar con todos los componentes, invocando al mtodo
addMouseMotionListener.
WindowListener.
Permite a una ventana responder a las acciones que ocurren sobre ella; por
ejemplo, minimizarla, abrirla, moverla, etc. Este manejador se puede asociar con componentes
JFrame y JWindow, invocando al mtodo addWindowListener.
En el siguiente programa se ejemplifica en detalle cada uno de los mtodos, usando window
listener que captura y reporta sobre todos los eventos del window.
194
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
Interface
WindowListener
Metodos
windowClosing
windowOpened
windowIconified
windowDeiconified
windowClosed
windowActivated
windowDeactivated
Parametros/Accesos
WindowEvent
getWindow
Eventos generados por

Window
Como ya se ha mencionado, en Java cualquier clase que implementa una interface, por
ejemplo WindowListener debe implementar TODOS los mtodos. En este caso, se deben
implementar los 7-mtodos.
Instrumentalizando la interface WindowListener
miFrame.setTitle("Programa de Reporte");
miFrame.addWindowListener(new WindowReporter()); // nuevo
} // end main
/**
* Un window listener que reporta todos los eventos window a la consola.
*/
class WindowReporter implements WindowListener {
/* Esta clase implement todos los metodos requeridos por la interface
WindowListener. Todo metodo trata un tipo de window event.
Todo metodo toma un
parametro, el cual es un objeto que contiene informacion sobre el evento. Notar que
no se usan eventos como Objetos, que tambin son factibles de implementar.*/
/* Llama al evento window que se muestra por primera vez.
* parametro e es un objeto con informacion sobre el evento
*/
public void windowOpened(WindowEvent e) {
System.out.println("window fue abierto por primera vez.");
} // end windowOpened
/*
* Llamada al evento en respuesta a un requerimiento del usuario con respecto a cerrar el window.
* parametro e es un objeto con informacion sobre el evento.
*/
System.out.println("usuario solicita un requerimiento, cerrar window.");
System.exit(0);
195
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
} // end windowClosing
/*
* Llamada al evento despus que el requerimiento del usuario con respecto a
cerrar el window se ha cumplido. */
public void windowClosed(WindowEvent e) {
System.out.println("window ha sido cerrado.");
} // end windowClosed
/*
* Llamada al evento para cuando window es minimizado.
*/
public void windowIconified(WindowEvent e) {
System.out.println("window ha sido minimizado.");
} // end windowIconified
/*
* Llamada al evento en respuesta a un requerimiento del usuario con respecto a
restaurar el window, luego de haber sido minimizado.
*/
public void windowDeiconified(WindowEvent e) {
System.out.println("window ha sido restaurado.");
} // end windowDeiconified
/*
que window, sea activado.
*/
public void windowActivated(WindowEvent e) {
System.out.println("window ha sido activado.");
} // end windowActivated
/*
desactivar window.
*/
public void windowDeactivated(WindowEvent e) {
System.out.println("window ha sido desactivado.");
} // end windowDeactivated
} // end class WindowReporter
Pero no debera este programa llamarlo a confusin, pues si Ud. desea solamente terminar el
programa, debera hacer algo como sigue:
class WindowReporter implements WindowListener {
public void windowOpened(WindowEvent e) {}
public void windowClosing(WindowEvent e) {System.exit(0);}
public void windowClosed(WindowEvent e) {}
public void windowIconified(WindowEvent e) {}
public void windowDeiconified(WindowEvent e) {}
public void windowActivated(WindowEvent e) {}
public void windowDeactivated(WindowEvent e) {}
196
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
Otra alternativa es hacer lo que ya se ha realizado antes y es la incorporacin de la clase

Adapter si posee, y digo si posee pues en la interface ActionListener no es necesaria, al
tener solamente un mtodo, de manera que no es necesario incluir una clase Adapter. En tal
caso lo anterior quedara reducido a:
class WindowReporter extends WindowAdapter {
public void windowClosing(WindowEvent e){
System.exit(0);
}
Donde s existe una clase Adapter es en, ComponentListener( cuyo nombre es

ComponentAdapter),
ContainerListener,
FocusListener,
MouseListener, MouseMotionListener y WindowListener.(cambie
Adapter. en las otras)
KeyListener,
Listener por
Ahora si hubiera ms de un componente asociado con un escuchador de eventos, tendremos

que utilizar las capacidades proporcionadas por el objeto ActionEvent que se pasa como
argumento. Por ejemplo:
public void actionPerformed (ActionEvent e) {
Object obj = e.getSource(); // objeto que produjo el evento e.
if (obj == botn) //por ejemplo.
mostrarMensaje();
else if (... )
//
}
Otra tcnica que puede ser til es proceder en funcin de la clase del componente. Por
ejemplo:
if (obj instanceof JButton) //por ejemplo.
mostrarMensaje(e);
else if (obj instanceof JTextField)
//hacer otra cosa.
}
Si ahora, por ejemplo, escribimos un mtodo mouseClicked() que queremos sea obedecido
cuando el ratn pulse el botn en una rea particular de la pantalla, debemos asegurarnos que:
a. Este asociado con un objeto listener. Podemos escoger cualquier objeto que desee
como el objeto que escucha con tal de que ste instrumente la interface de
MouseListener. Esto significa que debe tener los cinco mtodos: mouseClicked,
mouseEntered, mouseExited, mousePressed y mouseReleased.
197
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
b.
Se identifique la fuente del evento. Esto es, que el objeto que maneja el componente de
la interface el ratn pulse sobre el botn. En todos nuestros ejemplos, la fuente de
cada evento ser una componente de la interface de algn tipo.
c.
La declaracin tiene que ser incluida en la parte de la estructura del programa que
registra el objeto que escucha con el objeto fuente. Si c es el componente que es la
fuente del evento, y l es el objeto listener entonces la declaracin es
c.addMouseListener(l);
Una vez que esta declaracin se ha realizado, cualquier evento del ratn causado por pulsar el
botn en componente c se pasar al objeto l, y su mtodo mouseClicked obedecer. Los
objetos e sern pasados a cada objetos cada vez. Por ejemplo, si definimos un objeto
MouseListener para contener el mtodo mouseClicked que reaccionar al click sobre el
mouse, este objeto debe tener los 5-mtodos de la interface MouseListener listados
anteriormente. As debemos definir no solamente mouseClicked, sino tambin
mousePressed, mouseReleased, aunque no se ocupen. Cmo hacer esto?. Muy similar a lo
planteado antes, ya sea declarar
public void mousePressed(MouseEvent e) { }
y de la misma manera, mouseReleased, mouseEntered y mouseExited. O bien, si Ud.

quiere evitar el trabajo de definir cada vez los mtodos que correspondan, como en este caso
4-mtodos, la librera de Java2 tiene una clase llamada MouseAdapter para este propsito. La
definicin de las clases listener son de esta forma,
public class MiMouseListener extends MouseAdapter {
public void mouseClicked(MouseEvent e)
{ Responde a los click del mouse representado por e.
}
}
El nombre MiMouseListener puede ser cualquier nombre que Ud. proponga. Los otros
nombres deben ser como los que se muestran - MouseAdapter, mouseClicked y MouseEvent,
por estar as definidos en la clase.
Como Ud. habr observado los ejemplos vistos han implementado una sola interface, pero esto
es posible de generalizarlo, es decir, poder a travs de una declaracin manejar eventos de
accin y de texto, por ejemplo, tal como se muestra a continuacin.
public class Suspenso extends JFrame
implements ActionListener, TextListener
198
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
Para concluir este segmento, veamos algunas herramientas que ofrece Java. Como Ud. habr
notado siempre el frame aparece por defecto en la posicin esquina superior-izquierda de su
pantalla, pero esto puede cambiar. Si Ud. se da cuenta el centrado es dependiente del sistema,
pues la resolucin de la pantalla es una informacin que el sistema posee. En Java se tiene una
clase Toolkit que posee un mtodo llamado getScreenSize() que retorna el tamao del
screen como un objeto Dimension, en el programa llamado d, con variables instanciadas
d.height y d.width.
import java.awt.*;
class CentroFrame extends Jframe {
public CentroFrame() {
setTitle("Frame Centrado");
addWindowListener(new WindowAdapter() {
System.exit(0);
}
} );
//fragmento usado para obtener el tamao de la pantalla(screen)
Toolkit tk = Toolkit.getDefaultToolkit();
Dimension d = tk.getScreenSize();
int pantallaHeight = d.height;
int pantallaWidth = d.width;
setSize(pantallaWidth / 2, pantallaHeight / 2);
setLocation(pantallaWidth / 4, pantallaHeight / 4);
}
}
public class CentrarFrame {
JFrame frame = new CentroFrame();
frame.show();
}
}
Y por ltimo, Ud. habr observado que en los ejemplos vistos en la barra del frame siempre
aparece por defecto la taza de caf, propio de Java, que tambin se puede cambiar. Basta
incluir la declaracin
/*reemplazamos el icono de defecto por algun.gif,dado que
dependiente del sistema se usa tk,para incrustar el icono.*/
tambin
es
Image imagen = tk.getImage("algun.gif");

setIconImage(imagen);
Como Ud. habr observado en la Tabla Resumen de trato a los Eventos aparece en la columna
Eventos generados por, el concepto de Component y Container , estos se refieren a que un
Component es un elemento de la Interface de usuario, tales como Button, Text field, o
scrollbar, mientras que Container es un rea de la pantalla o componente que puede contener
199
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
componentes, tales como windows o un panel. En general digamos que todos los componentes
Swing son subclases de la clase JComponent.
Como Ud. podr recordar, a la clase estrucFrame, luego de ralizada su ejecucin se obtuvo
una simple ventana con su ttulo, esto es porque no tena ningn componente, como Button o
algn otro que se pudiera haber incrustado
TIPOS DE EVENTOS
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
/**
* keyDemo, para visualizar el uso de
KEY_PRESS
KEY_RELEASE
KEY_ACTION
KEY_ACTION_RELEASE
*/
import java.awt.*;
class keyDemoPanel extends JPanel
implements KeyListener
{ public keyDemoPanel()
{ addKeyListener(this);
}
public void keyPressed(KeyEvent evt)
{ int keyCode = evt.getKeyCode();
int d;
if (evt.isShiftDown())
d = 5;
200
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
else
d = 1;
if (keyCode == KeyEvent.VK_LEFT) add(-d, 0);
else if (keyCode == KeyEvent.VK_RIGHT) add(d, 0);
else if (keyCode == KeyEvent.VK_UP) add(0, -d);
else if (keyCode == KeyEvent.VK_DOWN) add(0, d);
}
public void keyReleased(KeyEvent evt)
{}
public void keyTyped(KeyEvent evt)
{ char keyChar = evt.getKeyChar();
int d;
if (Character.isUpperCase(keyChar))
{ d = 5;
keyChar = Character.toLowerCase(keyChar);
}
else
d = 1;
if (keyChar == 'h') add(-d, 0);
else if (keyChar == 'l') add(d, 0);
else if (keyChar == 'k') add(0, -d);
else if (keyChar == 'j') add(0, d);
}
public boolean isFocusTraversable() { return true; }
public void add(int dx, int dy)
{ end.x += dx;
end.y += dy;
Graphics g = getGraphics();
g.drawLine(start.x, start.y, end.x, end.y);
g.dispose();
start.x = end.x;
start.y = end.y;
}
private Point start = new Point(0, 0);
private Point end = new Point(0, 0);
}
class keyDemoFrame extends JFrame
{ public keyDemoFrame()
{ setTitle("keyDemo");
setSize(300, 200);
{ System.exit(0);
}
} );
Container contenPane = getContentPane();
contenPane.add(new keyDemoPanel());
}
}
public class keyDemo
{ JFrame frame = new keyDemoFrame();
frame.show();
}
}
201
Dr. Eric Jeltsch F.
Capitulo 7: Eventos
Eventos de Ratn
Son los eventos generados por acciones sobre el ratn dentro de los lmites 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 manipulacin de barras de desplazamiento
(scrollbars).
SCROLL_LINE_UP
SCROLL_LINE_DOWN
SCROLL_PAGE_UP
SCROLL_PAGE_DOWN
SCROLL_ABSOLUTE
Eventos de Lista
Son los eventos generados al seleccionar elementos de una lista.
LIST_SELECT
LIST_DESELECT
Eventos Varios
Son los eventos generados en funcin de diversas acciones.
ACTION_EVENT
LOAD_FILE
SAVE_FILE
GOT_FOCUS
LOST_FOCUS
202
Dr. Eric Jeltsch F.
Captulo 8: Swing
C A P T U L O 8.
Swing
Digamos que muchos de los componentes Swing estn basados en un patrn de diseo
denominado MVC, "Modelo-Vista-Controlador", o en ingls (Model -View-Controller). El
concepto de este patrn de diseo se basa en tres elementos:
Modelo: Almacena el estado interno en un conjunto de clases.
Vista: Muestra la informacin del modelo
Controlador: Cambia la informacin del modelo (delegado).
Una fcil manera de entender MVC, es considererar: el modelo como los datos, el view es el
window sobre la pantalla, y el controller es la relacin entre los dos. No es menester de este
tutorial explicar todo el funcionamiento de este nuevo diseo, pero si se quiere profundizar en
l consulte [Morgan, 1999].
En el Cap. 7 se dieron los pasos preliminares para entender la filosofa que estaba detrs de los
eventos, con la tarea especfica de cerrar la ventana para cuando el usuario pulse, el icono
respectivo. La idea es ahora estructurar la forma de cmo trabajar con Swing respecto al
diseo de una interfaz de usuario. Recordemos que todos los elementos de Swing son parte del
paquete javax.swing, y como tal se debe utilizar el encabezado import javax.swing.*;.
La forma de utilizar un componente Swing no difiere en nada de cmo se hizo con un objeto
de cualquier otra clase. Es decir, se crea el componente invocando al constructor de su clase,
luego se establece que deber realizar, para finalmente aadirlo a un contenedor.
Por ejemplo, se desea crear un botn de pulsacin, luego se establece que la tecla aceleradora
es la C, adems de una descripcin abreviada. Esto se visualiza as.
//crear un botn
MiBoton = new JButton(Pulse aqu);
//Pulsar Alt+C ser equivalente a pulsar el botn.
MiBoton.setMnemonic(KeyEvent.VK_C);
//asignarle una descripcin
MiBoton.setTollTipText(botn de pulsacin.);
Los componentes ms comunes son las llamadas: etiquetas, botones, campo de texto de una
lnea o de varias, casillas de verificacin, botones de opcin, listas, barras de desplazamiento,
cuadros de dilogo estndar y otros.
Para relacionarlo con el cap. 7, digamos que el siguiente segmento de programa, asocia al
componente de la clase JButton, un manejador de eventos de accin. De esta forma el botn
podr responder al evento click, mediante el mtodo actionPerformed.
203
Dr. Eric Jeltsch F.
Captulo 8: Swing
ActionListener al=new ActionListener(){

//este mtodo se ejecuta para cuando se haga click sobre el boton.
public void actionPerformed(ActionEvent e){
//proceso a ejecutar.
}
};
boton.addActionListener(al);
Ahora si hubiera ms de un componente asociado con un escuchador de eventos, tendremos

que utilizar las capacidades proporcionadas por el objeto ActionEvent que se pasa como
argumento. Por ejemplo:
if (obj == botn) //por ejemplo.
mostrarMensaje();
else if (... )
//
}
Otra tcnica que puede ser til es proceder en funcin de la clase del componente. Por
ejemplo:
if (obj instanceof JButton) //por ejemplo.
mostrarMensaje(e);
else if (obj instanceof JTextField)
//hacer otra cosa.
}
Como Ud. habr observado en Cap.7 aparece en Tabla Resumen de trato a los Eventos la
columna Eventos generados por, el concepto de Component y Container , estos se refieren a
que un Component es un elemento de la Interface de usuario, tales como Button, Text field, o
scrollbar, mientras que Container es un rea de la pantalla o componente que puede contener
componentes, tales como windows o un panel. En general digamos que todos los componentes
Swing son subclases de la clase JComponent. Como Ud. podr recordar, a la clase
estrucFrame, luego de ralizada su ejecucin se obtuvo una simple ventana con su ttulo, esto
es porque no tena ningn componente, como Button o algn otro que se pudiera haber
incrustado.
Los contenedores son componentes Swing utilizados para ubicar otros componentes. En
general, se tiene una jerarqua de contenedores, ellos son contenedores de nivel intermedio, de
nivel superior y controles. La siguiente figura nos muestra algo al respecto, en donde se tiene
un marco, con un panel
204
Dr. Eric Jeltsch F.
Captulo 8: Swing
Marco(Frame)
Panel
Marco(Frame)
Panel
Botn
Etiqueta
En general, para agregar a un marco los componentes que hemos denominado controles, como
son la etiqueta y el botn, hay que utilizar un contenedor intermedio. La figura anterior
muestra que realmente existe una jerarqua de contenedores que nos ayudar a colocar
adecuadamente los controles. La raz de esa jerarqua es el contenedor de nivel superior
definido por el marco de la ventana. Analizando esa figura se observa:
205
Dr. Eric Jeltsch F.
Captulo 8: Swing
Un marco (objeto de la clase JFrame). Se corresponde con la ventana marco principal. Es el

contenedor de nivel superior. Los contenedores correspondientes a JDialog y JApplet son
tambin de nivel superior. Cada contenedor de nivel superior tiene de forma predeterminada
un panel raz (en la figura no se pinta) al que se puede acceder por medio del mtodo
getContentPane( ). Se trata de un panel de contenido que permite ubicar otros componentes
(paneles y controles). Por ejemplo, la siguiente sentencia aade el objeto panel al panel raz
predeterminado:
getContentPane().add(panel, BorderLayout.CENTER);
Un panel (objeto de la clase JPanel). Se corresponde con la vista o rea de trabajo de la

ventana marco principal. Es el contenedor de nivel intermedio llamado panel de contenido. Su
propsito es simplificar la colocacin de controles. Un panel de contenido puede incluir a su
vez otros paneles de contenido. La siguiente sentencia es tpica en el afn de crear un panel de
este tipo:
JPanel panel = new JPanel ();
Una etiqueta (objeto de la clase JLabel) y un botn (objeto de la clase JButton). Esta clase de
componentes es lo que genricamente llamamos controles. Cada uno de ellos realiza una
operacin especfica cara al usuario. Anteriormente, en este mismo captulo, ya vimos cmo
crearlos. Para aadirlos a un panel, utilizaremos el mtodo add. Por ejemplo:
panel.add(botn) ;
Para organizar los controles que se aaden a un contenedor, Java proporciona los llamados
administradores de diseo. Un administrador de diseo est pensado para mostrar varios
componentes a la vez en un orden preestablecido. De forma predeterminada cada contenedor
tiene asignado un administrador de diseo. Swing proporciona seis administradores de diseo,
sin embargo se tienen tambin componentes predefinidas como las que se muestran:
206
Dr. Eric Jeltsch F.
Captulo 8: Swing
FlowLayout. Diseo en flujo. Coloca los componentes en el contenedor de izquierda a

derecha (igual que se coloca el texto en un prrafo). Es el administrador de diseo
asignado de forma predeterminada a los contenedores de nivel intermedio.
207
Dr. Eric Jeltsch F.
Captulo 8: Swing
GridBagLayout. Diseo tipo rejilla. Coloca los componentes en el contenedor en filas y

columnas. A diferencia de GridLayout, que explicaremos a continuacin, permite que un
componente pueda ocupar ms de una columna.
BorderLayout. Diseo con lmites. Divide un contenedor en cinco secciones

denominadas: norte, sur, este, oeste y centro. Es el administrador de diseo que tienen
asignado de forma predeterminada los contenedores de nivel superior. Los componentes se
colocarn en una seccin u otra segn decidamos.
CardLayout. Diseo por paneles. Este diseador permite colocar en el contenedor grupos
diferentes de componentes en instantes diferentes de la ejecucin (similar a los paneles con
pestaas).
GridLayout. Diseo por rejilla. Coloca los componentes en el contenedor en filas y

columnas.
208
Dr. Eric Jeltsch F.
Captulo 8: Swing
BoxLayout. Diseo en caja. Coloca los componentes en el contenedor en una nica fila o
columna, ajustndose al espacio que haya.
Cuando queramos asignar un determinado administrador de diseo a un contenedor diferente

de los predeterminados, primero hay que crearlo y despus asignrselo invocando a su mtodo
setLayout. Por ejemplo, la siguiente sentencia asigna al contenedor panel un administrador de
diseo de tipo GridLayout con 0 filas y 1 columna (los controles se colocarn en columna).
panel.setLayout(new GridLayout(0,1));
Como agregar componentes a un marco de Swing?.
Un JFrame est subdividido en varios paneles diferentes, el panel principal con el que trabaja
es el panel de contenido, que representa toda el rea de un marco al que se pueden agregar
componentes. Para agregar componentes debemos hacer lo siguiente:
209
Dr. Eric Jeltsch F.
Captulo 8: Swing
Crear un objeto JPanel(que es la versin Swing de un panel).

Agregar todos los componentes(que pueden ser contenedores) al JPanel a travs del
correspondiente mtodo add(componente).
Convertir este JPanel en el panel de contenido con el mtodo
setContentPane(Contenedor). El objeto JPanel debe ser el nico argumento.
El siguiente ejemplo usa la estructura antes descrita, agregando a la aplicacin un botn

rotulado al panel de contenido del marco. El botn se crear desde la clase JButton, que es la
versin Swing de un botn seleccionable.
Ejemplo
import java.awt.GridLayout;
public class Swinger extends JFrame {
public Swinger() {
super("Swinger");
String nota = "Interactue conmigo.";
JButton miButton = new JButton(nota);
JPanel pane = new JPanel();
pane.add(miButton);
setContentPane(pane);
}
//este segmento es casi estandar, para cerrar la aplicacin.
JFrame frame = new Swinger();
System.exit(0);
}
};
frame.addWindowListener(l);
frame.pack();
frame.setVisible(true);
}
}
Tal vez lo nico novedoso en este programa es el segmento,

String nota = "Interactue conmigo.";
JButton miButton = new JButton(nota);
/* crendose un objeto JButton usando string como rtulo.
*/
pane.add(miButton);
/*
*/
se crea un objeto JPanel, al cual se le agrega este botn.

210
Dr. Eric Jeltsch F.
Captulo 8: Swing
La ejecucin se visualiza as,
Como ya se di cuenta los botones de Swing forman parte del cuerpo de la clase JButton. Los
cuales pueden tener una etiqueta o rtulo de texto, como AWT, una etiqueta de icono o una
combinacin de ambos. En el caso de icono, basta considerar en el programa base
Swinger.java, en donde reemplaza lo bold por esto.
ImageIcon miIcon= new ImageIcon(hola.gif);
JButton miButton = new JButton(miIcon);
pane.add(miButton);
SetContentPane(pane)
No olvidar que en Java se tiene una clase Toolkit que posee un mtodo llamado
getScreenSize() que retorna el tamao del screen como un objeto Dimension, en el
programa llamado d, con variables instanciadas d.height y d.width, con el fin de centrar la
aplicacin.
Notar que el botn interactua conmigo, no gatilla ningn evento, es decir, NO se le ha
asociado ningn evento que pueda realizar para cuando el usuario pulse el botn. Veamos que
esto puede cambiar.
Hasta el momento, podra esperarse, el de continuar dando ejemplos con las distintas
herramientas etiquetas, botones, campo de texto de una lnea o de varias, casillas de
verificacin, botones de opcin, listas, barras de desplazamiento, cuadros de dilogo estndar
y otros., pero lo que deseo es, lograr la comunin entre los eventos, vistos en Cap. 7 y los
componentes y controles, que de alguna forma se han mencionado y ejemplificado con
JButton, aqu en Cap. 8. No obstante al final de esta seccin daremos ms ejemplos que
resumen muchas de las componentes aqu mencionadas.
Se sabe que dentro del sistema de manejo de eventos de Java2, si una clase desea responder a
un evento de usuario debe implementar la interfaces que maneja los eventos, estas interfaces
se llaman escuchadores de eventos o listener. Existe una lista de ellos dada en Cap. 7. Por
ejemplo, ActionListener() es un evento que se genera cuando un usuario realiza una accin
sobre un componente, por ejemplo, pulsar sobre un botn. Existen varias otras, y la idea es
aplicarla en algunas aplicaciones concretas. El paquete java.awt.event contiene todos los
escuchadores de eventos bsicos, para utilizarlos basta declarar
211
Dr. Eric Jeltsch F.
Captulo 8: Swing
Adems, es posible declarar eventos que puedan manejar eventos de accin y de texto, lo que
se logra al considerar,
public class Suspenso extends Jframe
implements ActionListener, TextListener
{
//...
}
Componentes Listener
Al convertir una clase en un escuchador de eventos, establece un tipo especfico de evento
para ser escuchado por esa clase, aunque esto ltimo puede que jams suceda si no agrega al
componente un escuchador de evento coincidente. A lo que ese escuchador de evento generar
los eventos cada vez que se use el componente. Por eso despus de crear un componente, para
asociarle un listener deber llamar a alguno de los siguientes mtodos del componente. Por
ejemplo, addActionListener() para los componentes de JButton, JCheckBox,
JComboBox, JTextField y JRadioButton.
La siguiente declaracin por ejemplo crea un objeto JButton y le asocia un escuchador de

evento de accin:
JButton miButton = new JButton (miBoton);
MiButton.addActionListener(this);
Note que todos los mtodos agregados toman un argumento: A saber, el objeto escuchador de
evento de esa clase. Por medio de this Ud. indica que la clase actual es el escuchador de
evento.
Mtodos Manejadores de Eventos
Cuando Ud. asocia una interfaz a una clase, la clase debe manejar todos los eventos
contenidos en la interfaz. En el caso de los escuchadores de eventos, cuando tiene lugar el
evento de usuario correspondiente, el sistema de ventanas llama a cada mtodo en forma
automtica. La interface ActionListener tiene un solo mtodo. Todas las clases que
ActionListener implementa deben tener un mtodo con una estructura como la siguiente:
{
//...maneje el evento en este sector
}
212
Dr. Eric Jeltsch F.
Captulo 8: Swing
El siguiente ejemplo instrumentaliza al botn de manera que cada vez que se pulse el botn
respectivo, se cambiar el titulo del frame por el nombre del botn pulsado.
Ejemplo
import java.awt.*;
public class tuBoton extends Jframe implements ActionListener {
JButton b1 = new JButton("Eric");
JButton b2 = new JButton("Jeltsch");
public tuBoton() {
super("Super Botn");
//escuchadores de eventos de accin a los botones
b1.addActionListener(this);
b2.addActionListener(this);
pane.add(b1);
pane.add(b2);
}
JFrame frame = new tuBoton();
System.exit(0);
}
};
frame.pack();
}
//la instrumentalizacin del evento asociado al boton.
public void actionPerformed(ActionEvent evt) {
Object fuente = evt.getSource();
if (fuente == b1)
setTitle("Eric");
else if (fuente == b2)
setTitle("Jeltsch");
repaint();
}
}
En la ejecucin Ud. podr apreciar que cada vez que pulse algunos de los botones, se le
asociar el nombre del mismo al nombre del frame.
Tras de pulsar, Eric
213
Dr. Eric Jeltsch F.
Captulo 8: Swing
Tras de pulsar, Jeltsch
El mtodo getSource() del objeto evt se usa para determinar la fuente del evento, el que
procede a llamar a repaint() para dibujar nuevamente el marco. Otro mtodo que sirve es
getActionCommand() en el objeto ActionEvent. Si en el ejemplo anterior, reemplaza
setTitle("Eric"); por System.exit(0); notara que al pulsar Eric la aplicacin se cierra.
Si en el ejemplo anterior, reemplaza la siguiente declaracin
JOptionPane.showMessageDialog(null,"Ud.presiono:"+ evt.getActionCommand());
por setTitle("Eric"); obtendr el siguiente mensaje
Otra aplicacin asociada a pintar el panel de algn color de su preferencia, luego de pulsado el
boton correspondiente, se puede apreciar en el ejemplo siguiente.
import java.awt.*;
class ButtonPanel extends JPanel implements ActionListener {
public ButtonPanel() {
amaButton = new JButton("Amarillo");
azulButton = new JButton("Azul");
rojoButton = new JButton("Rojo");
add(amaButton);
add(azulButton);
add(rojoButton);
amaButton.addActionListener(this);
azulButton.addActionListener(this);
rojoButton.addActionListener(this);
}
{ Object source = evt.getSource();
Color color = getBackground();
if (source == amaButton) color = Color.yellow;
214
Dr. Eric Jeltsch F.
Captulo 8: Swing
else if (source == azulButton) color = Color.blue;

else if (source == rojoButton) color = Color.red;
setBackground(color);
repaint();//en general, no es necesario.
}
private JButton amaButton;
private JButton azulButton;
private JButton rojoButton;
}
class ButtonFrame extends JFrame
{ public ButtonFrame()
{ setTitle("Y mas Botones...");
setSize(300, 200);
{ System.exit(0);
}
} );
Container contentPane = getContentPane();
contentPane.add(new ButtonPanel());
}
}
public class ButtonDemo
{ JFrame frame = new ButtonFrame();
frame.show();
}
}
Como ya hemos adelantado, con los mtodos existen una serie de eventos entre ellos: Eventos
de Accin, Eventos de Ajuste, Eventos de Enfoque, Eventos de Elemento, Eventos de
Tecla, Eventos de Ratn, Eventos de Movimiento de Ratn, Eventos de Ventana, los
cuales no son excluyentes, es decir existen Eventos que pueden ser de Accin como de
Elemento al mismo tiempo. Veremos a continuacin algunos de ellos.
Eventos de Accin: Estos eventos ocurren cuando un usuario termina una accin por medio
de uno de los siguientes componentes(JButton, JCheckBox, JComboBox, JTextField,
JRadioButton). Para poder manejar estos eventos, se tiene que implementar la interfaz
ActionListener, que por lo general la hemos declarado en ya sea de una clase
TextFieldTrato o CheckBoxTrato, que estn asociados a como tratar los eventos. Adems
se debe llamar al mtodo addActionListener() de cada componente que genere un evento
de accin, a no ser que quiera ignorar los eventos de accin de ese componente.
215
Dr. Eric Jeltsch F.
Captulo 8: Swing
JTextField y JPasswordField
Ejemplo.
import java.awt.*;
public class TextFieldDemo extends JFrame {
private JTextField text1, text2, text3;
private JPasswordField password;
public TextFieldDemo() {
super( "Demo de JTextField y JPasswordField" );
Container c = getContentPane();
c.setLayout( new FlowLayout() );
// construccin de textfield de tamao fijo
text1 = new JTextField( 10 );
c.add( text1 );
// construccin de textfield con texto fijo
text2 = new JTextField( "Ingrese el texto" );
c.add( text2 );
// construccin de textfield con texto fijo de 20
//elementos visibles y ningn evento a la vista.
text3 = new JTextField( "text field no editable", 20 );
text3.setEditable( false );
c.add( text3 );
// construccin de textfield texto fijo
password = new JPasswordField( "Texto Oculto" );
c.add( password );
TextFieldTrato tra = new TextFieldTrato();
text1.addActionListener( tra );
password.addActionListener( tra );
setSize( 325, 100 );
show();
}
{
TextFieldDemo app = new TextFieldDemo();
app.addWindowListener(
new WindowAdapter() {
{
System.exit( 0 );
}
}
);
}
// clase interna para tratar los eventos
private class TextFieldTrato implements ActionListener {
216
Dr. Eric Jeltsch F.

public void actionPerformed( ActionEvent e )
String s = "";
Captulo 8: Swing
{
if ( e.getSource() == text1 )
s = "text1: " + e.getActionCommand();
else if ( e.getSource() == text2 )
else if ( e.getSource() == text3 )
else if ( e.getSource() == password ) {
JPasswordField pwd =
(JPasswordField) e.getSource();
s = "password: " +
new String( pwd.getPassword() );
}
JOptionPane.showMessageDialog( null, s );
}
}
}
JCheckBox
Ejemplo.
import java.awt.*;
public class CheckBoxDemo extends JFrame {
private JTextField t;
private JCheckBox bold, italic;
public CheckBoxDemo() {
super( "JCheckBox Demo" );
c.setLayout(new FlowLayout());
t = new JTextField( "Mire el cambio de estilo", 20 );
t.setFont( new Font( "TimesRoman", Font.PLAIN, 14 ) );
c.add( t );
// crea objeto checkbox
bold = new JCheckBox( "Bold" );
c.add( bold );
italic = new JCheckBox( "Italic" );
c.add( italic );
CheckBoxTrato tra = new CheckBoxTrato();
bold.addItemListener( tra );
italic.addItemListener( tra );
setSize( 275, 100 );
show();
}
217
Dr. Eric Jeltsch F.
Captulo 8: Swing

CheckBoxDemo app = new CheckBoxDemo();
public void windowClosing( WindowEvent e ) {
System.exit( 0 );
}
}
);
}
private class CheckBoxTrato implements ItemListener {
private int valBold = Font.PLAIN;
private int valItalic = Font.PLAIN;
public void itemStateChanged( ItemEvent e ) {
if ( e.getSource() == bold )
if ( e.getStateChange() == ItemEvent.SELECTED )
valBold = Font.BOLD;
else
valBold = Font.PLAIN;
if ( e.getSource() == italic )
if ( e.getStateChange() == ItemEvent.SELECTED )
valItalic = Font.ITALIC;
else
valItalic = Font.PLAIN;
t.setFont(new Font( "TimesRoman", valBold + valItalic, 14 ) );
t.repaint();
}
}
}
Este ejemplo tambin se considera tambin como Evento de Elemento, pues este tipo de
eventos suceden cuando se selecciona o no un elemento en cualquiera de los siguientes
componentes JButton, JCheckBox, JComboBox, JTextField, JRadioButton. La
diferencia radica en que para poder manejar estos eventos se tiene que implementar la interfaz
ItemListener desde una clase, tal como se hizo en el ejemplo recin visto. La interfaz
ItemListener tiene un solo mtodo llamado itemStateChanged() y para determinar el
elemento en el que ocurri el evento se debe llamar al mtodo getItem() en el objeto
ItemEvent, tambin puede usar el mtodo getStateChange().
Eventos de Ajuste
Los eventos de ajuste se dan cuando se mueve un componente JScrollBar por medio de las
flechas de la barra, el cuadro de desplazamiento o haciando click en cualquier parte de la
barra. Para manejar estos eventos, una clase debe implementar la interfaz
218
Dr. Eric Jeltsch F.
Captulo 8: Swing
AdjustmentListener(),
que posee adjustmentValueChanged(EventodeAjuste), como

mtodo y que toma la forma:
public void adjustmentValueChanged(AdjustmentEvent e)
{
//..
}
En este contexto se usa el mtodo getValue() en el objeto AdjustEvent(), que devuelve un

entero que representa el valor de la barra de desplazamiento.
Ejemplo
import java.awt.*;
public class buenAjuste extends JFrame implements AdjustmentListener {
BorderLayout borde= new BorderLayout();
JTextField valor = new JTextField();
JScrollBar bar = new
JScrollBar(SwingConstants.HORIZONTAL, 50, 10, 0, 100);
public buenAjuste() {
super("Buen Ajuste");
bar.addAdjustmentListener(this);
valor.setHorizontalAlignment(SwingConstants.CENTER);
valor.setEditable(false);
pane.setLayout(borde);
pane.add(valor, "South");
pane.add(bar, "Center");
}
JFrame frame = new buenAjuste();
System.exit(0);
}
};
frame.pack();
}
public void adjustmentValueChanged(AdjustmentEvent evt){
if (fuente == bar) {
int nuevoValor = bar.getValue();
valor.setText("" + nuevoValor);
}
repaint();
}
}
219
Dr. Eric Jeltsch F.
Captulo 8: Swing
En setText() las comillas vacas se denomina cadena null, y estn concatenadas al entero
nuevoValor para convertir el argumento en una cadena. Como podr recordar, si concatena
una cadena con un tipo diferente, Java siempre manejar el resultado como cadena, la cadena
null es un mtodo abreviado para cuando se quiera desplegar algo que todava no es una
cadena.
220
Dr. Eric Jeltsch F.
Captulo 9:
CAPTULO 9
Swing: Eventos de Ratn y Movimientos del Ratn
Los eventos de Ratn se generan por diferentes interacciones del usuario, es decir, un click
del ratn, un ratn entrando al rea de los componentes, o saliendo del rea. Cualquier
componente puede generar estos eventos, los que se implementan desde una clase por medio
de la interfaces MouseListener, la cual tiene 5-mtodos. A saber mouseCliked(),
mouseEntered(), mouseExited(), mousePressed(), mouseReleased(). Cada uno de
ellos toma la forma, por ejemplo
public void mouseReleased(MouseEvent e) {
//..
}
Los mtodos que funcionan para MouseEvent son: getClickCount(), getPoint(),

getX(), getY().
Por otra parte, los eventos de movimiento de ratn, ocurren cada vez que se mueve el ratn
en un componente, y como cualquier evento necesita de un soporte, se debe entonces de
implementar la interfaces MouseMotionListener desde una clase. En esta interfaces hay 2mtodos mouseDragged() y mouseMoved(). Donde toman la forma, por ejemplo
public void mouseDragged(MouseEvent e) {
//..
}
A diferencia de las otras interfaces escuchadoras de eventos que ha manejado hasta ahora, la
interfaces MouseMotionListener no tiene mtodos propios de manera que puede utilizar los
mismos mtodos anteriores.
Ejemplo:
import java.awt.*;
public class MouseDemo extends JFrame
implements MouseListener, MouseMotionListener {
private JLabel statusBar;
public MouseDemo() {
super( "Demo para Eventos del Mouse" );
statusBar = new JLabel();
getContentPane().add( statusBar, BorderLayout.SOUTH );
// aplicacion listener para los eventos propios del mouse.
addMouseListener( this );
addMouseMotionListener( this );
setSize( 275, 100 );
show();
221
Dr. Eric Jeltsch F.
Captulo 9:
}
// tratar los eventos en MouseListener.
public void mouseClicked( MouseEvent e )
{
statusBar.setText("Click en [" + e.getX() + ", " + e.getY() + "]");
}
public void mousePressed( MouseEvent e )
{
statusBar.setText("Presiono en [" + e.getX() +", " + e.getY() + "]" );
}
public void mouseReleased( MouseEvent e )
{
statusBar.setText( "Soltado en [" + e.getX() + ", " + e.getY() + "]" );
}
public void mouseEntered( MouseEvent e )
{
statusBar.setText( "Mouse en window" );
}
public void mouseExited( MouseEvent e )
{
statusBar.setText( "Mouse fuera de window" );
}
// tratar los eventos de MouseMotionListener.
public void mouseDragged( MouseEvent e )
{
statusBar.setText( "Arrastrar a [" + e.getX() +", " + e.getY() + "]" );
}
public void mouseMoved( MouseEvent e )
{
statusBar.setText( "Movido a [" + e.getX() + ", " + e.getY() + "]" );
}
{
MouseDemo app = new MouseDemo();
{
System.exit( 0 );
}
}
);
}
}
222
Dr. Eric Jeltsch F.
Captulo 9:
Notar que:
statusBar = new JLabel();
getContentPane().add( statusBar, BorderLayout.SOUTH );
es para definir statusBar como JLabel e incrustarlo en el panel de contenidos. Despus

descutiremos en detalle la expresin BorderLayout.SOUTH.
Otra variante interesante es la aplicacin siguiente en la cual no se usan los mtodos
mouseMoved o nuestro conocido MouseMotionListener, pues ahora se considera esta
interfaces como una subclase de otra superior que es MouseMotionAdapter, esta clase define
ambos mouseMoved y mouseDragged.
Ejemplo:
import java.awt.*;
public class Pintar extends JFrame {
private int xValor = -10, yValor = -10;
public Pintar()
{
super( "Un lpiz particular" );
getContentPane().add(
new Label( "Vaya a Windows y pulse el mouse para pintar" ),
BorderLayout.SOUTH );
addMouseMotionListener( new MouseMotionAdapter() {
public void mouseDragged( MouseEvent e ) {
//xValor e yValor almacenan las coordenadas
//del evento mouseDragged
xValor = e.getX();
yValor = e.getY();
repaint();
}
}
);
setSize( 300, 150 );
show();
}
public void paint( Graphics g ) {
//sacandole punta al lpiz.
g.fillOval( xValor, yValor, 20, 20 );
}
{
Pintar app = new Pintar();
{
System.exit( 0 );
}
}
);
223
Dr. Eric Jeltsch F.
Captulo 9:
}
}
*
Utilizar esta misma idea para detectar cuando se ha pulsado el botn izquierdo , derecho o centro. Los mtodos
asociados al evento son isMetaDown() y isAltDown().
Eventos de Tecla
Los eventos de tecla ocurren cuando se presiona una tecla sobre el teclado. Cualquier
componente puede generar estos eventos, y para dar soporte a los eventos, se tiene que
implementar la interfaces KeyListener desde una clase. En la interfaces KeyListener hay tres
eventos: keyPressed(), keyReleased() y keyTyped() que toman la forma usual, por ejemplo
public void keyReleased(keyEvent evt)
{
//...
}
El mtodo getKeyChar() de KeyEvent, devuelve el carcter de la tecla asociada con el evento.

Ejemplo:
import java.awt.*;
public class TeclaDemo extends Jframe
implements KeyListener {
private String linea1 = "", linea2 = "";
private String linea3 = "";
private JTextArea textArea;
public TeclaDemo()
{
super( "Demo para los eventos de Tecla" );
textArea = new JTextArea( 10, 15 );
textArea.setText( "Pulse cualquier tecla de la consola..." );
textArea.setEnabled( false );
// admitir frame para procesar los eventos de Tecla o Key
addKeyListener( this );
getContentPane().add( textArea ); //otra variante
setSize( 350, 100 );
show();
}
public void keyPressed( KeyEvent e )
{
linea1 = "Tecla presionada: " +
e.getKeyText( e.getKeyCode() );
seteaLineas2y3( e );
}
224
Dr. Eric Jeltsch F.
Captulo 9:
public void keyReleased( KeyEvent e )

{
linea1 = "Tecla soltada: " +
e.getKeyText( e.getKeyCode() );
}
public void keyTyped( KeyEvent e )
{
linea1 = "Tecla tipeada: " + e.getKeyChar();
}
private void seteaLineas2y3( KeyEvent e )
{
linea2 = "Esta tecla " +
( e.isActionKey() ? "" : "no " ) +
"es una accin key";
String temp =
e.getKeyModifiersText( e.getModifiers() );
linea3 = "Modifica tecla presionada: " +
( temp.equals( "" ) ? "no" : temp );
textArea.setText(
linea1 + "\n" + linea2 + "\n" + linea3 + "\n" );
}
{
TeclaDemo app = new TeclaDemo();
{
System.exit( 0 );
}
}
);
}
}
Eventos de Ventana
Los eventos de Ventana suceden cuando un usuario abre o cierra un objeto de Ventana tal
como un JFrame o JWindow. Cualquier componente puede generar estos eventos y se tiene que
implementar la interfaces WindowListener, desde una clase, para dar soporte a los eventos.
Existen 7-mtodos en esta interfaces. A saber, windowActivated(), windowClosed(), windowClosing(),
windowDeactivated(), windowDeiconified(), windowIconified(), windowOpened(), los que toman la forma
por ejemplo,
225
Dr. Eric Jeltsch F.
Captulo 9:
public void windowOpened(WindowEvent evt)

{
//..
}
Los mtodos windowClosing(), windowClosed() son semejantes, pero se llama uno al cerrar la
Ventana, y al otro una vez cerrada. De hecho para detener el cierre de una Ventana puede
utilizar un mtodo windowClosing().
LAYOUT MANAGERS
Por lo general los Layout Managers estn considerados para arreglar componentes GUI desde
el punto de vista diseo, es decir ofrece herramientas o capacidades que son de uso para
determinar la posicin exacta y tamao de todo componente GUI. Algunos de los ms bsicos
son FlowLayout, BorderLayout y GridLayout, pero hay otros como ya se menciono en Cap. 8.
FlowLayout situa los elementos en forma secuencial de izquierda a derecha, en el orden que
ellos fueron agregados.
BorderLayout dispone los componentes en cinco reas: Norte, Sur, Este, Oeste y Centro.
GridLayout dispone los componentes en filas y columnas.
En el siguiente ejemplo mostraremos la disposicin de 3- objetos botones tras la aplicacin de
FlowLayout. Cada boton tiene un evento propio que es definido al interior de la clase que
implementa ActionListener. La estructura es muy simple, se definen los botones y seteamos el
label asociado a cada uno de ellos,
izq = new JButton( "Izq" );
centro = new JButton( "Centro" );
der = new JButton( "Der" );
luego agregamos o incrustamos al panel o contenedor c a cada uno de ellos, por ejemplo,
c.add( izq );
finalmente le agregamos la necesidad de responder al evento asociado, por ejemplo,

izq.addActionListener()
Ejemplo:
import java.awt.*;
226
Dr. Eric Jeltsch F.
Captulo 9:
public class FlowLayoutDemo extends JFrame {

private JButton izq, centro, der;
private Container c;
private FlowLayout layout;
public FlowLayoutDemo()
{
super( "Demo para FlowLayout" );
layout = new FlowLayout();
c = getContentPane();
c.setLayout( layout );
izq = new JButton( "Izq" );
izq.addActionListener(
new ActionListener() {
//cada boton tiene un evento de accin
{
layout.setAlignment( FlowLayout.LEFT );
//realinear los componentes atachados, usando //layoutContainer que es un mtodo de la interface //LayoutManager para
especificar que el panel de contenido //deber reordenarse segn el ajuste que le de el FL
layout.layoutContainer( c );
}
}
);
c.add( izq );
centro = new JButton( "Centro" );
centro.addActionListener(
{
layout.setAlignment( FlowLayout.CENTER );
// realinear los componentes atachados
}
}
);
c.add( centro );
der = new JButton( "Der" );
der.addActionListener(
{
//setAlignment cambia los alineamientos para el FL
layout.setAlignment( FlowLayout.RIGHT );
// realinear los componentes atachados
}
}
);
c.add( der );
setSize( 300, 75 );
show();
227
Dr. Eric Jeltsch F.
Captulo 9:
}
FlowLayoutDemo app = new FlowLayoutDemo();
public void windowClosing( WindowEvent e ) {
System.exit( 0 );
}
}
);
}
}
BorderLayout dispone los componentes en cinco reas: Norte, Sur, Este, Oeste y Centro.
Ejemplo:
import java.awt.*;
public class BorderLayoutDemo extends JFrame
implements ActionListener {
private JButton b[];
private String nombres[] =
{ "Norte", " Sur", "Este",
" Oeste", " Centro" };
private BorderLayout layout;
public BorderLayoutDemo()
{
super( "Demo para BorderLayout" );
//especifica el nmero de pixeles de distancia entre los //componentes
layout = new BorderLayout( 5, 5 );
c.setLayout( layout );
// instancia para objeto JButton
b = new JButton[ nombres.length ];
for ( int i = 0; i < nombres.length; i++ ) {
b[ i ] = new JButton( nombres[ i ] );
b[ i ].addActionListener( this );
}
// orden no interesa, pero notar la forma de accesar al //contenedor c
c.add( b[ 0 ], BorderLayout.NORTH );
// North posiciones
c.add( b[ 1 ], BorderLayout.SOUTH ); // South "
c.add( b[ 2 ], BorderLayout.EAST ); // East "
c.add( b[ 3 ], BorderLayout.WEST ); // West "
c.add( b[ 4 ], BorderLayout.CENTER ); // Center "
setSize( 300, 200 );
show();
}
228
Dr. Eric Jeltsch F.
Captulo 9:

{ /*cuando usamos el click de un botn particular en el layout el mtodo actionPerformed() es llamado, ocultando el botn
que genero el evento*/
for ( int i = 0; i < b.length; i++ )
if ( e.getSource() == b[ i ] )
b[ i ].setVisible( false );
else
b[ i ].setVisible( true );
// relayout el contenido del panal
layout.layoutContainer( getContentPane() );
}
{
BorderLayoutDemo app = new BorderLayoutDemo();
{
System.exit( 0 );
}
}
);
}
}
GridLayout dispone los componentes en filas y columnas.

Ejemplo:
import java.awt.*;
public class GridLayoutDemo extends JFrame
implements ActionListener {
private JButton b[];
private String nombres[] =
{ "uno", "dos", "tres", "cuatro", "cinco", "seis" };
private boolean hola = true;
private Container c;
private GridLayout grid1, grid2;
public GridLayoutDemo()
{
super( "Demo GridLayout" );
//2 filas y 3 columnas con una separacin de 5 pixeles //hacia arriba y hacia abajo.
grid1 = new GridLayout( 2, 3, 5, 5 );
//3-filas y 2-columnas sin separacin entre ellos, o //asumido por defecto
grid2 = new GridLayout( 3, 2 );
c = getContentPane();
c.setLayout( grid1 );
229
Dr. Eric Jeltsch F.
Captulo 9:
// crea y agrega buttons

b = new JButton[ nombres.length ];
for (int i = 0; i < nombres.length; i++ ) {
b[ i ] = new JButton( nombres[ i ] );
b[ i ].addActionListener( this );
c.add( b[ i ] );
}
setSize( 300, 150 );
show();
}
{
if ( hola )
else
hola = !hola;
//recomputa el layout contenedor basado sobre el layout //manager actual
c.validate();
}
{
GridLayoutDemo app = new GridLayoutDemo();
{
System.exit( 0 );
}
}
);
}
}
Panel
Complejos GUI requieren que cada componente sea situado en una posicin determinada, esto
a manudo se soluciona disponiendo de un layout especfico con mltiples paneles. Los paneles
son creados con JPanel que es una subclase de JComponent. Por otra parte notar que la clase
JComponent hereda la clase java.awt.Container, de manera que JPanel es un Container para todos los
efectos, es decir puede tener componentes incluyendo otros paneles, accesados a ellos. En el
siguiente ejemplo se define un objeto botonPanel de JPanel que setea un GridLayout de una fila y
cinco columnas, notar que los botones estn situados al sur del mundo. JPanel se adecua a las
componentes, redimensione el window para ver como el layout manager afecta afecta al
tamao de JButton, por ejemplo.
import java.awt.*;
230
Dr. Eric Jeltsch F.
Captulo 9:
public class PanelDemo extends JFrame {

private JPanel botonPanel;
private JButton botones[];
public PanelDemo()
{
super( "Demo para Panel" );
botonPanel = new JPanel();
botones = new JButton[ 5 ];
botonPanel.setLayout(
new GridLayout( 1, botones.length ) );
for ( int i = 0; i < botones.length; i++ ) {
botones[ i ] = new JButton( "Boton " + (i + 1) );
botonPanel.add( botones[ i ] );
}
c.add( botonPanel, BorderLayout.SOUTH );
setSize( 425, 150 );
show();
}
{
PanelDemo app = new PanelDemo();
{
System.exit( 0 );
}
}
);
}
}
231
Dr. Eric Jeltsch F.
Captulo 10:
C A P I T U L O 10
GUI Avanzado (con Swing)
En las lecturas 7-8-9 se entregaron los pasos preliminares para entender la filosofa que estaba
detrs de las apariencias grficas en el diseo de una interfaz de usuario. Convengamos en que
el proceso de generar una interfaz de usuario, se puede realizar con herramientas de
java.awt.* o de javax.swing.*. Para tal efecto, veamos la relacin entre las clases que lo
componen, para formarse una idea de su interrelacin entre las clases.
Un JFrame est subdividido en varios paneles diferentes, el panel principal con el que trabaja
es el panel de contenido, que representa toda el rea de un marco al que se pueden agregar
componentes. Para agregar componentes debemos hacer lo siguiente:
Crear un objeto JPanel(que es la versin Swing de un panel).

Agregar todos los componentes(que pueden ser contenedores) al JPanel a travs del
correspondiente mtodo add(componente).
Convertir este JPanel en el panel de contenido con el mtodo
setContentPane(Contenedor). El objeto JPanel debe ser el nico argumento.
Complejos GUI requieren que cada componente sea situado en una posicin determinada, esto
a menudo se soluciona disponiendo de un layout especfico con mltiples paneles. Los paneles
son creados con JPanel que es una subclase de JComponent. Por otra parte notar que la clase
JComponent hereda la clase java.awt.Container, de manera que JPanel es un Container para todos los
232
Dr. Eric Jeltsch F.
Captulo 10:
efectos, es decir puede tener componentes incluyendo otros paneles, accesados a ellos. En el
siguiente ejemplo se define un objeto botonPanel de JPanel que declara un GridLayout de una fila y
cinco columnas, notar que los botones estn situados al sur del mundo. JPanel adecua a las
componentes, redimensionando el window para ver como el layout manager afecta al tamao
de JButton. Una forma tpica de incorporar botones en un JPanel es como sigue.
Container contenidoPanel= getContentPane();
JPanel miPanel= new JPanel();
miPanel.add(Boton_Amarillo);
miPanel.add(Boton_Verde);
miPanel.add(Boton_Azul);
contenidoPanel.add(miPanel, South)
En el ejemplo final, de la lectura anterior, llamada PanelDemo.java, se muestra un panel que

incluye cinco botones dispuestos al sur. Una variante, con el fin de optimizar la forma de
escribir o de accesarlos al panel se uso un array de botones, pero esto no tiene porque siempre
una condicin.
La idea ahora es incorporarle otras cualidades sobre el panel, que actua como pizarra para
cuando Ud. gatille un evento al presionar algn botn. En el ejemplo siguiente consideramos
una estructura de manera que al presionar un botn rotulado genere una figura geomtrica tan
sofisticada como nosotros queramos, es decir, crearemos una subclase de JPanel.En general la
idea es usar JPanel como una pizarra, es decir un rea dedicada para dibujar, la que puede
recibir eventos del mouse y a menudo extenderla para crear nuevos componentes. La idea es
evitar o entregar otra alternativa en la situacin de combinar componentes Swing GUI y el
pintado sobre una misma ventana o applet, que usualmente genera conflictos en el despliegue
de la figura. Entonces con la creacin de esta subclase de JPanel podremos incrustar figuras que
en el despliegue de la ventana no se van a entorpecer. Una estructura de este tipo de pizarra
debera usar el mtodo paintComponent().Se visualiza as:
public void paintComponent(Graphics g)
{ super.paintComponent(g);
// su cdigo de pintado ad-doc
}
La clase Pizarra, definida en archivo Pizarra.java, me permite incorporar este mtodo.

Desgraciadamente JFrame NO es subclase de JComponent, por tal motivo no contienen el mtodo
233
Dr. Eric Jeltsch F.
paintComponent(). De
utiliza repaint().
import java.awt.*;
Captulo 10:
manera que para dibujarlo directamente sobre subclases de este tipo se
public class Pizarra extends JPanel {

public final static int CIRCULO = 1, CUADRADO = 2;
private int figura;
public void paintComponent( Graphics g )
{
//para asegurarse que el pintado se realice, y el
//mecanismo Swing quede intacto. Si la versin de esta
//superclase no es llamada la componente tpica de GUI no
//sera desplegada apropiamente sobre la superficie.Tampoco
//le resultara si la llama despus de realizar la
//declaracin de pintado
super.paintComponent( g );
if ( figura == CIRCULO )
g.fillOval( 50, 10, 60, 60 );
else if ( figura == CUADRADO )
g.fillRect( 50, 10, 60, 60 );
}
public void draw( int s )
{
figura = s;
repaint();
}
}
En otro archivo de nombre PizarraTest.java testeo el pintado que contiene paintComponent().

import java.awt.*;
public class PizarraTest extends JFrame {
private JPanel buttonPanel;
private Pizarra miPanel;
private JButton circulo, cuadrado;
public PizarraTest() {
super( "Panel como Pizarra" );
miPanel = new Pizarra();
//en versiones Java 1.0 y Java 1.1, esta forma se asocia a la clase canvas
miPanel.setBackground( Color.yellow );
cuadrado = new JButton( "Cuadrado" );
cuadrado.addActionListener(
234
Dr. Eric Jeltsch F.
Captulo 10:
{
miPanel.draw( Pizarra.CUADRADO );
}
}
);
circulo = new JButton( "Circulo" );
circulo.addActionListener(
{
miPanel.draw( Pizarra.CIRCULO );
}
}
);
buttonPanel = new JPanel();
buttonPanel.setLayout( new GridLayout( 1, 2 ) );
buttonPanel.add( circulo );
buttonPanel.add( cuadrado );
c.add( miPanel, BorderLayout.CENTER );
c.add( buttonPanel, BorderLayout.SOUTH );
setSize( 300, 150 );
show();
}
PizarraTest app = new PizarraTest();
{
System.exit( 0 );
}
}
);
}
}
235
Dr. Eric Jeltsch F.
Captulo 10:
A veces tendr que usar en la construccin de su pequeo sistema o de la interfaz de usuario

que esta construyendo, el ingreso de la informacin que va ms all que una lnea de una cierta
magnitud, la cual podemos hacer con JtextField. Sin embargo, tal como se planteaba, si la
informacin consta de varias lneas, lo aconsejable es usar JTextArea(), de manera que cuando
Ud. utilice esta rea de componentes en su programa y as el usuario pueda entrar cualquier
nmero de lneas de texto, usando solamente ENTER para separarlas. En el constructor de la
componente JTextArea() debe especificar el nmero de filas y columnas para el texto de rea.
Esta API se encuentra en javax.swing.JTextArea.
JTextArea
Por ejemplo, la siguiente declaracin considera 8-lneas de 40-columnas, que es incrustada en
el Panel.
miAreadeTexto=new JTexArea(8, 40);//tambin admite texto.
miAreadeTexto=new JTexArea(String texto, int 8, int 40);
getContentPane().add(miAreadeTexto);
En Swing el rea de texto no tiene una barra de desplazamiento(scrollbar), sin embargo eso no
es dificultoso, basta insertar miAreadeTexto dentro del panel asociado a la barra llamado
ScrollPane. Esta API se encuentra en javax.swing.JScrollPane.
miAreadeTexto=new JTexArea(8, 40);
JScrollPane miscrollPane= new JScrollPane(miAreadeTexto);
getContentPane().add(miAreadeTexto);
Ejemplo
import java.awt.*;
class TextAreaFrame extends JFrame implements ActionListener {
public TextAreaFrame() {
JPanel p = new JPanel();
botonInsercion = new JButton("Insercion");
236
Dr. Eric Jeltsch F.
Captulo 10:
p.add(botonInsercion);
botonInsercion.addActionListener(this);
botonToken = new JButton("Token");
p.add(botonToken);
botonToken.addActionListener(this);
botonNoToken = new JButton("No Token");
p.add(botonNoToken);
botonNoToken.addActionListener(this);
getContentPane().add(p, "South");
miTextArea = new JTextArea(8, 40);
miScrollPane = new JScrollPane(miTextArea);
getContentPane().add(miScrollPane, "Center");
setTitle("TextArea Demo");
setSize(300, 300);
{ System.exit(0);
}
} );
}
if (fuente == botonInsercion)
//void append(String nuevoText), pega el texto ingresado al
//final del texto real en el rea de texto.
miTextArea.append("Hola amigos, nos vemos!!. ");
else if (fuente == botonToken)
//void setLineWrap(boolean b), tokenizador si es true.
{ miTextArea.setLineWrap(true);
//validate() recomputa el tamao y el Layout de sus
//componentes en un Container
miScrollPane.validate();
}
else if (fuente == botonNoToken)
{ miTextArea.setLineWrap(false);
miScrollPane.validate();
}
}
//declaracin obligada, en caso contrario no reconoce las
//variables .
private JButton botonInsercion;
private JButton botonToken;
private JButton botonNoToken;
private JTextArea miTextArea;
private JScrollPane miScrollPane;
}
public class TextAreaTest {
{ JFrame f = new TextAreaFrame();
237
Dr. Eric Jeltsch F.
Captulo 10:
f.show();
}
}
Tambin es posible de incorporarles Labels y Componentes Label. Basta con construir un

componente JLabel con el texto conveniente, ellos NO reaccionan ni gatillan nada frente a un
requerimiento del usuario. El constructor para este tipo de situaciones especifica el texto
inicial o icono y opcionalmente, el alineamiento de sus componentes. Esta ltima se realiza a
travs de la interface SwingConstants, la que especifica LEFT, RIGHT, CENTER, NORTH,
EAST, etc...Una declaracin tpica es
JLabel miLabel= new JLabel(Texto, SwingConstants.LEFT);
Ejemplo
import java.awt.*;
class TextEditFrame extends JFrame{
public TextEditFrame() {
setTitle("TextEditTest");
setSize(400, 400);
{ System.exit(0);
}
} );
Container contPanel = getContentPane();
JPanel miPanel = new JPanel();
JButton botonReemplazo = new JButton("Reemplazo");
miPanel.add(botonReemplazo);
botonReemplazo.addActionListener(new ActionListener()
{ public void actionPerformed(ActionEvent evt)
{ String f = desde.getText();
int n = miTextArea.getText().indexOf(f);
238
Dr. Eric Jeltsch F.
Captulo 10:
if (n >= 0 && f.length() > 0)

miTextArea.replaceRange(a.getText(), n,
n + f.length());
}
});
desde = new JTextField(8);
miPanel.add(desde);
miPanel.add(new JLabel("por"));
a = new JTextField(8);
miPanel.add(a);
miTextArea = new JTextArea(8, 40);
miScrollPane = new JScrollPane(miTextArea);
contPanel.add(miPanel, "South");
contPanel.add(miScrollPane, "Center");
}
private JScrollPane miScrollPane;
private JTextArea miTextArea;
private JTextField desde, a;
}
public class TextEditTest {
JFrame f = new TextEditFrame();
f.show();
}
}
Border
Sobre el panel es posible de incorporar una forma de bordes, lo que hace, que la distribucin
del panel o las secciones del mismo sean delimitadas. Swing ofrece una herramienta llamada
border para este propsito. Ud. lo encuentra en java.awt.swing.border que proporciona la
interfaces Border . Ahora veremos algunos usos comunes para esta herramienta, llamando al
mtodo static BorderFactory(). Existe una variedad de formas y estilos, algunos de ellos son:
Lowered bevel, Raised bevel, Etched, Line, Matte y Empty(que es para crear un espacio en blanco
alrededor del componente.) Una estructura tpica de declaracin de cmo agregar un borde
etched con un titulo al panel es:
Border etched = BorderFactory.createEtchedBorder();
Border titulo=BorderFactory.createTitledBorder(etched,mi Titulo);
MiPanel = setBorder(titulo);
239
Dr. Eric Jeltsch F.
Captulo 10:
Ejemplo
import java.awt.*;
import javax.swing.border.*;
class BorderFrame extends JFrame implements ActionListener{
public BorderFrame() {
JPanel botonesPanel = new JPanel();
grupo = new ButtonGroup();
addRadioButton(botonesPanel, grupo, "Lowered bevel", true);
addRadioButton(botonesPanel, grupo, "Raised bevel", false);
addRadioButton(botonesPanel, grupo, "Etched", false);
addRadioButton(botonesPanel, grupo, "Line", false);
addRadioButton(botonesPanel, grupo, "Matte", false);
addRadioButton(botonesPanel, grupo, "Empty", false);
Border etched = BorderFactory.createEtchedBorder();
Border titulo = BorderFactory.createTitledBorder(etched,"Tipos de Borde");
botonesPanel.setBorder(titulo);
getContentPane().add(botonesPanel, "South");
setDemoPanel();
setTitle("Demo para Bordes");
setSize(600, 200);
addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
} );
}
public void addRadioButton(JPanel botonesPanel,
ButtonGroup g, String botonNombre, boolean v)
{JRadioButton button = new JRadioButton(botonNombre, v);
button.addActionListener(this);
g.add(button);
botonesPanel.add(button);
button.setActionCommand(botonNombre);
}
setDemoPanel();
}
public void setDemoPanel() {
JPanel miPanel = new JPanel();
Border bordes = null;
String comando = grupo.getSelection().getActionCommand();
if (comando.equals("Lowered bevel"))
bordes = BorderFactory.createLoweredBevelBorder();
else if (comando.equals("Raised bevel"))
bordes = BorderFactory.createRaisedBevelBorder();
else if (comando.equals("Etched"))
bordes = BorderFactory.createEtchedBorder();
else if (comando.equals("Line"))
bordes
= BorderFactory.createLineBorder(Color.blue);
else if (comando.equals("Matte"))
bordes = BorderFactory.createMatteBorder(10, 10,
10, 10, Color.blue);
else if (comando.equals("Empty"))
bordes = BorderFactory.createEmptyBorder();
miPanel.setBorder(bordes);
240
Dr. Eric Jeltsch F.
Captulo 10:
getContentPane().add(miPanel, "Center");
validate();
}
private JPanel miPanel;
private ButtonGroup grupo;
}
public class BorderTest
{ JFrame frame = new BorderFrame();
frame.show();
}
}
Un pequeo resumen de las libreras SWING/AWT

abstract class AbstractButton
void addActionListener(ActionListener l)
Icon getIcon()
String getText()
void setIcon(Icon defaultIcon)
void setIconTextGap(int iconTextGap)
void setText(String texto)
class ActionEvent
Object getSource()
String getActionCommand()
interface ActionListener
void actionPerformed(ActionEvent e)
class BorderLayout
constantes: CENTER, EAST, NORTH, SOUTH, WEST
constructores:BorderLayout()BorderLayout(int hgap, int vgap)void setHgap(int hgap)
241
Dr. Eric Jeltsch F.
Captulo 10:
void setVgap(int vgap)

class Box
static Box createHorizontalBox()
static Box createVerticalBox()
class BoxLayout (opcional)
constantes: X_AXIS, Y_AXIS
constructor: public BoxLayout(Container target,int axis)
class Color
constantes: black, blue, cyan, darkGray, gray, green, lightGray, magenta, orange,
pink, red, white, yellow
constructor: Color(int red, int green, int blue)
abstract class Component
Color getBackground()
Font getFont()
Color getForeground()
int getHeight()
int getWidth()
void repaint()
void setBackground(Color c)
void setEnabled(boolean b)
void setFont(Font f)
void setForeground(Color c)
void setVisible(boolean b)
abstract class Container
Component add(Component comp)
Component add(Component comp, int index)
// segunda forma para BorderLayout, use constantes
void remove(Component comp)
void remove(int index)
void setLayout(LayoutManager manager)
class FlowLayout
constantes: CENTER, LEFT, RIGHT
constructores:
FlowLayout()
FlowLayout(int align)
FlowLayout(int align, int hgap,int vgap)
void setAlignment(int align)
void setHgap(int hgap)
class Font
constantes: BOLD, ITALIC, PLAIN
constructor:Font(String name, int style,int size)
nombre de font standard: Serif, SansSerif, Monospaced
class Frame
void setTitle(String titulo)
void setMenuBar(MenuBar mb)
class GridLayout
constructores:
GridLayout(int rows, int cols)
GridLayout(int rows, int cols,
int hgap, int vgap)
void setHgap(int hgap)
class ImageIcon
constructor:
ImageIcon(String filename)
class JButton
constructores:
JButton()
JButton(String text)
JButton(Icon icon)
JButton(String text, Icon icon)
242
Dr. Eric Jeltsch F.
Captulo 10:
abstract class JComponent

void setActionCommand(String accionComand)
void setPreferredSize(Dimension prefeSize)
// use new Dimension(width, height)
class JDialog (opcional)
contiene ms metodos usados por JFrame:
void setModal(boolean b)
class JFrame
constructores:
JFrame()
JFrame(String titulo)
Container getContentPane()
void setContentPane(Container c);
void setBounds(int x, int y, int width, int height)
void setDefaultCloseOperation(int operacion)
operacion = EXIT_ON_CLOSE para salir del programa, para cuando frame es closed
void setJMenuBar(JMenuBar menubar)
class JLabel
constantes: LEFT, CENTER, RIGHT
constructores:
JLabel()
JLabel(String text)
JLabel(String text, int horizontalAlignment)
JLabel(Icon image)
JLabel(String text, Icon icon, int horizontalAlignment)
Icon getIcon()
String getText()
void setHorizontalAlignment(int alinear)
void setIcon(Icon icon)
void setIconTextGap(int iconTextGap)
class JMenu
constructores:
JMenu()
JMenu(String text)
Component add(Component c)
void addSeparator()
void remove(Component c)
class JMenuBar
constructor:
JMenuBar()
JMenu add(JMenu c)
class JMenuItem
constructores:
JMenuItem()
JMenuItem(String text)
JMenuItem(String text, int mnemonic)
JMenuItem(Icon icon)
JMenuItem(String text, Icon icon)
class JPanel
constructores:
JPanel()
JPanel(LayoutManager layout)
class JTextArea
constructores:
JTextArea()
JTextArea(int rows, int columns)
JTextArea(String text)
JTextArea(String text, int rows, int columns)
void append(String str)
void setLineWrap(boolean wrap)
abstract class JTextComponent
String getText()
243
Dr. Eric Jeltsch F.
Captulo 10:
void setEditable(boolean b)
void setText(String t)
class JTextField
constantes: LEFT, CENTER, RIGHT
constructores:
JTextField()
JTextField(int columns)
JTextField(String text)
JTextField(String text, int columns)
void setHorizontalAlignment(int alinear)
interface LayoutManager
metodos para usar internamente para cuando se implementan layout managers
class Window
void addWindowListener(WindowListener l)
void pack()
244
Dr. Eric Jeltsch F.
Captulo 11:
C A P T U L O 11
GUI Avanzado (con Swing)
En las lecturas 7-8-9-10, se entregaron los pasos preliminares para entender la filosofa que
estaba detrs de las apariencias grficas en el diseo de una interfaz de usuario. Convengamos
en que el proceso de generar una interfaz de usuario, se puede realizar con herramientas de
java.awt.* o de javax.swing.*. Para tal efecto, veamos la relacin entre las clases que lo
componen, para formarse una idea de su interrelacin entre las clases. No obstante se trabaja
con javax.swing, por una serie de ventajas que esta ofrece.
Menu
Una observacin importante es que la clase JFrame ampla la clase Frame de AWT, de manera
que JFrame, JWindow y JDialog difieren de sus homlogos del AWT en que utilizan un panel de
contenido separado para agregar y disear componentes GUI, este panel es un objeto Container
al que se accede a travs del mtodo getContentPane(), mtodo que lo hemos visto en accin en
varios ejemplos hasta ahora. Los mens de Swing, al igual que las ventanas de Swing, son
anlogos a los AWT la diferencia fundamental es que las clases JMenuBar, JMenu, JMenuItem,
JCheckBoxMenuItem y JRadioButtonMenuItem son todas ellas subclases de JComponent y por tanto de
la clase Component, esto significa que los mens de Swing constituyen componentes que se
pueden usar por cualquiera de las clases Container. Otra caracterstica interesante de los mens
245
Dr. Eric Jeltsch F.
Captulo 11:
de Swing es la propiedad de incorporar imgenes de iconos en los mens. El ejemplo siguiente

muestra el uso de los mens en Swing, la metodologa es la misma que se ha venido viendo,
de manera que aunque el cdigo podr resultar grande en nmero de lneas, pero su estructura
es muy simple. Otra herramienta de inters es el uso de JSeparator que se utiliza como separador
de mens. La lgica en la generacin de cdigos esta dada por considerar que los elementos
de men se agregan a los mens, mientras que estos ltimos se agregan a la barra de mens.
Adems se agregan radio-botones al correspondiente grupo de botones. La barra de mens se
logra por medio del mtodo setJMenuBar() de la clase JFrame.
Aqu se aprecia un Menu tpico de una GUI.
La barra de menu que podemos apreciar contiene una variedad de menus, la que se encuentra
al tope de la pantalla en Windows. Toda barra de menu tiene uno o ms menus, organizados
por tpicos, en donde los archivos en este caso son: Archivo, Editar, Otro, etc. Por otra parte,
al interior de cada uno de los menu se realizan acciones individuales tales como: Abrir,
Imprimir, Cortar y Copiar, los que son mostrados para cuando Ud. activa el menu apropiado.
En este caso se aprecia un SubMenu, Chequear, Radio1, Radio2 y Planta, la que a su vez
tiene incorporado un archivo .gif para hacerlo ms didctico. Estas son algunas de las ventajas
que ofrece Swing para trabajar con Menu, situacin ltima que en AWT no es factible, no
obstante, se puede trabajar de la misma manera en AWT, salvo restricciones, como las que se
han comentado. Ya en la version Java 1.1 fue AWT totalmente elaborada incluyendo los
(event handling,). JDK-Version 1.1 fue una segunda Biblioteca para programar interfaces
grficas presentada como: SWING. La que se realiza sobre AWT
Clase Menu en AWT

El paquete AWT contiene cuatro clases principales para tratar los menus:
java.awt.Menu
java.awt.MenuBar
java.awt.MenuItem
java.awt.PopupMenu
Para usar menus en su aplicacin Ud. necesita agregar las instancias de las tres clases, una
para MenuBar con uno o ms Menus, todos con varios MenuItems.
246
Dr. Eric Jeltsch F.
Captulo 11:
La clase java.awt.MenuComponent es superclase de todas estas clases. MenuComponent

extiende java.lang.Object. Los menus, barra de menu, y menu items no son componentes y
no pueden ser agregadas a los contenedores en forma habitual.
java.lang.Object
|
+---java.awt.MenuComponent
|
+---java.awt.MenuBar
|
+---java.awt.MenuItem
|
+---java.awt.Menu
|
+---java.awt.PopupMenu
Ambas MenuBar y MenuItem extienden MenuComponent. Menu extiende MenuItem. Adems,

MenuBar implementa la interface java.awt.MenuContainer.
La Clase MenuComponent es la raz de la jerarqua de clases Menu. Un MenuBar representa un

resumen de los Menu. Objetos de esta clase forman el punto de partida de la estructura de
Menu.
247
Dr. Eric Jeltsch F.
Captulo 11:
Dentro de un MenuBar pueden ser organizados muchos MenuItem. Cada objeto Menu
corresponde a la clase Menu de AWT. Por ejemplo, aqu se describe un sistema, del cual se
puede apreciar como se correlacionan las actividades con las clases respectivas.
Hola Window Help
MenuBar
Menu
Hola
Window
Diga Hola
MenuItem
Help
Mover
instance Of
Menu
Deshab Diga Hola

arriba
Habi Diga Hola
MenuItem
abajo
Luz(on/off)
CheckboxMenuItem
Creando Menus
Es fcil construir un menu, el orden tpico es
1.Crear un nuevo MenuBar.
2.Crear un nuevo Menu.
3.Agregar items al Menu.
4.Si es necesario repita etapas 2 y 3.
5.Agregar el MenuBar al Frame.
Los constructores que Ud. necesita son muy simples. Por ejemplo, para crear un objeto nuevo
MenuBar, basta con declarar:
MenuBar miMenubar = new MenuBar();
Para crear un nuevo Menu use el constructor Menu(String titulo). Pasando el titulo al
menu que Ud, desee. Por ejemplo, para crear los menus Archivo y Editar, basta con declarar,
Menu miArchivoMenu = new Menu("Archivo");
Menu miEditarMenu = new Menu("Editar");
248
Dr. Eric Jeltsch F.
Captulo 11:
MenuItems
son creados en forma similar con el constructor MenuItem(String menutext).

Pasando el titulo del menu que Ud. quiera, por ejemplo,
MenuItem Cortar = new MenuItem("Cortar");
Tambin puede crear MenuItems al interior de los menus, por ejemplo: Cortar, Copiar, Pegar,
Limpiar y seleccionar todos los MenuItems:
Menu editMenu = new Menu("Edit");
editMenu.add(new MenuItem("Cortar"));
editMenu.add(new MenuItem("Copiar"));
editMenu.add(new MenuItem("Pegar"));
editMenu.add(new MenuItem("Limpiar"));
editMenu.addSeparator();
editMenu.add(new MenuItem("Seleccionar Todos"));
El mtodo addSeparator() agrega una lnea horizontal al menu. Esto es usado para separar
logicamente las funciones del menu. Luego podr incorporar al Menu, las barras del Menu
usando MenuBares(Menu m), por ejemplo,:
miMenubar.add(ArchivoMenu);
miMenubar.add(EditarMenu);
Finalmente, para cuando la barra de menu estime que esta copada, se procede a incorporarla al
Frame usando el mtodo frame setMenuBar(MenuBar mb).
Dado un Frame f , este es un ejemplo: f.setMenuBar(miMenuBar);
Ejemplos
import java.awt.Frame;
public class AWT_Ej1 {
Frame wnd = new Frame("Simple Ventana");
wnd.setSize(400,300);
wnd.setVisible(true);
} //end main()
} //class AWT_Ej1, genera una ventana simple sin la posibilidad de cerrar.
import
import
import
import
java.awt.Frame;
java.awt.Window;
java.awt.event.WindowAdapter;
java.awt.event.WindowEvent;
public class AWT_Ej2 {

Frame wnd = new Frame("Simple Ventana, pero se cierra!");
wnd.addWindowListener( new WindowCierreAdapter() );
wnd.setSize(400,300);
wnd.setVisible(true);
} //main()
249
Dr. Eric Jeltsch F.
Captulo 11:
} //class AWT_Ej2, genera una ventana simple con la posibilidad de cerrar.

class WindowCierreAdapter extends WindowAdapter {
public void windowClosing( WindowEvent we) {
Window wnd = we.getWindow();
wnd.setVisible(false);
wnd.dispose();
System.exit(0);
} //windowClosing()
} //class WindowCierreAdapter
Clase JMenu en Swing

La clase JMenuBar contiene los mtodos necesarios para manejar una barra de men, que es a
su vez un contenedor de mens.
La clase JMenu contiene los mtodos para manejar los mens, por ejemplo cuando un men es
cliqueado el men se expande para mostrar una lista de los items men. Hacer click sobre un
men genera un evento y por tal motivo deberemos contar con escuchadores o listener.
La clase JMenuItem contiene los mtodos para manejar items de men, pudiendo ser un
submen que proporciona a su vez ms mens.
La clase JCheckBoxMenuItem contiene los mtodos para manejar items de men segn una
forma particular de chequeo.
La clase JRadioButtonMenuItem muestra una forma de circulo relleno para optar por alguna
opcin dentro de un men.
Creando Menus
JMenuBar miMenuBar = new JMenuBar();
Si quiere agregarle mtodos, bastar con una declaracin del tipo:

MiFrame.setJMenuBar(miMenuBar);
Ahora, si desea para cada men crear un objeto men,

JMenu editarMenu= new JMenu(Edit);
Pudiendo agregar menu items, por ejemplo, separadores,

JMenuItem archivoNew = new JMenuItem("New");
editarMenu.add(archivoNew);
editarMenu.addSeparator();
o submens a objetos men, por ejemplo, en este mismo contexto,

JMenu opcionMenu=...;
editarMenu.add(opcionMenu);
para luego accesarlo a la barra del men,

MiMenuBar.addMenu(editarMenu);
El efecto de seleccionar un men, significa que se gatilla una accin representada por los
eventos, por eso que se necesita instalar un escuchador o listener para cada men items. Algo
parecido a, ArchivoNew.addActionListener(this), si Ud. se da cuenta esta forma de construccin
para cuando se tienen varios mens y submens es muy tedioso, de ah que es recomendable
250
Dr. Eric Jeltsch F.
Captulo 11:
usar un procedimiento que lo realice. Nosotros mostramos dos modalidades. En este ejemplo
se muestra la primera modalidad en donde se realiza:
una inicializacin de las variables globales que toman parte en el programa,

luego continua con la declaracin de la barra de men (Archivo), creando cada uno de los
componentes de cada segmento, en el ejemplo, me refiero a (Sobre y Exit),
incorporandole de inmediato un addActionsListener(), que va a realizar el despliegue de un
mensaje para cuando el escuchador apropiado haya escuchado este evento(Sobre) o se
saldr si escucho (Exit). Esto as construdo se incorpora a la barra de man. De la misma
manera se crea (Formato), que tiene otras habilidades, como (Colores) y (Fuentes).
Se crean las clases ItemTrato y EstiloTrato que implementaran la inteface apropiada de
ActionListener e ItemListener con los mtodos actionPerformed() e ItemStateChanged().
Ejemplo:
import java.awt.*;
public class MenuTest extends JFrame {
private Color colorValor[]={Color.black,Color.blue,Color.red,Color.green};
private JRadioButtonMenuItem colorItems[], fonts[];
private JCheckBoxMenuItem estiloItems[];
private JLabel desplegar;
private ButtonGroup miFontGroup, miColorGroup;
private int estilo;
public MenuTest() {
super( "Usando JMenus" );
JMenuBar miBar = new JMenuBar(); // crea menubar
setJMenuBar( miBar );// setea el menubar para JFrame
// crea los archivos del Menu , entre ellos Sobre y
//Exit como menu item
JMenu miFileMenu = new JMenu( "Archivo" );
JMenuItem sobreItem = new JMenuItem( "Sobre..." );
sobreItem.addActionListener(
{
JOptionPane.showMessageDialog( MenuTest.this,
"Este es un ejemplo\nde usos de menus",
"Sobre", JOptionPane.PLAIN_MESSAGE );
}
}
);
miFileMenu.add( sobreItem );
JMenuItem exitItem = new JMenuItem( "Exit" );
exitItem.addActionListener(
{
251
Dr. Eric Jeltsch F.
Captulo 11:
System.exit( 0 );
}
}
);
miFileMenu.add( exitItem );
miBar.add( miFileMenu ); // los agrega al File menu
// crea el otro segmento de menu, y sus submenus como menu
//items.
JMenu formatMenu = new JMenu( "Formato" );
// crea Color como submenu, inicializando colores.
String colores[] = { "Black", "Blue", "Red", "Green" };
JMenu colorMenu = new JMenu( "Color" );
colorItems = new JRadioButtonMenuItem[ colores.length ];
miColorGroup = new ButtonGroup();
ItemTrato itemTrato = new ItemTrato();
for ( int i = 0; i < colores.length; i++ ) {
colorItems[ i ] = new JRadioButtonMenuItem( colores[ i ] );
colorMenu.add( colorItems[ i ] );
miColorGroup.add( colorItems[ i ] );
colorItems[ i ].addActionListener( itemTrato );
}
colorItems[ 0 ].setSelected( true );
formatMenu.add( colorMenu );
formatMenu.addSeparator();
// crea Font como submenu, inicializando fuentes.
String fontNombres[] = { "TimesRoman", "Courier", "Helvetica" };
JMenu fontMenu = new JMenu( "Fuentes" );
fonts = new JRadioButtonMenuItem[ fontNombres.length ];
miFontGroup = new ButtonGroup();
for ( int i = 0; i < fonts.length; i++ ) {
fonts[ i ] = new JRadioButtonMenuItem( fontNombres[ i ] );
fontMenu.add( fonts[ i ] );
miFontGroup.add( fonts[ i ] );
fonts[ i ].addActionListener( itemTrato );
}
fonts[ 0 ].setSelected( true );
fontMenu.addSeparator();
String estiloNombres[] = { "Bold", "Italic" };
estiloItems = new JCheckBoxMenuItem[ estiloNombres.length ];
EstiloTrato estiloTrato = new EstiloTrato();
for ( int i = 0; i < estiloNombres.length; i++ ) {
estiloItems[ i ] = new JCheckBoxMenuItem( estiloNombres[ i ] );
fontMenu.add( estiloItems[ i ] );
estiloItems[ i ].addItemListener( estiloTrato );
}
formatMenu.add( fontMenu );
miBar.add( formatMenu ); // agrega formato al menu
252
Dr. Eric Jeltsch F.
Captulo 11:
desplegar = new JLabel("Muestras de Texto", SwingConstants.CENTER );

desplegar.setForeground( colorValor[ 0 ] );
desplegar.setFont(
new Font( "TimesRoman", Font.PLAIN, 72 ) );
getContentPane().setBackground( Color.cyan );
getContentPane().add( desplegar, BorderLayout.CENTER );
setSize( 500, 200 );
show();
}
{
MenuTest app = new MenuTest();
{
System.exit( 0 );
}
}
);
}
class ItemTrato implements ActionListener {
{
for ( int i = 0; i < colorItems.length; i++ )
if ( colorItems[ i ].isSelected() ) {
desplegar.setForeground( colorValor[ i ] );
break;
}
for ( int i = 0; i < fonts.length; i++ )
if ( e.getSource() == fonts[ i ] ) {
desplegar.setFont( new Font(
fonts[ i ].getText(), estilo, 72 ) );
break;
}
repaint();
}
}
class EstiloTrato implements ItemListener {
public void itemStateChanged( ItemEvent e )
{
estilo = 0;
if ( estiloItems[ 0 ].isSelected() )
estilo += Font.BOLD;
if ( estiloItems[ 1 ].isSelected() )
estilo += Font.ITALIC;
desplegar.setFont( new Font(
desplegar.getFont().getName(), estilo, 72 ) );
253
Dr. Eric Jeltsch F.
Captulo 11:
repaint();
}
}
}
Como otra forma de construir mens he considerado, setupEventos(), que es una estructura en
donde depsito todos los eventos, tal como se muestran en el siguiente ejemplo. Existe otra
forma, ms elegante en el texto de Core Java2 de Hortsmann, pg 489, de cmo organizar los
mens y submens.
Ejemplo
import java.awt.*;
import javax.swing.event.*;
public class SwingWin extends JFrame {
public static int WIDTH = 300;
public static int HEIGHT = 300;
public static String TITULO = "SwingWin";
Container miframeContainer;
// Swing componentes
JTextField miTextField = new JTextField(50);
254
Dr. Eric Jeltsch F.
Captulo 11:
JMenu archivoMenu = new JMenu("File");

JMenuItem archivoNew = new JMenuItem("New");
JMenuItem archivoOpen = new JMenuItem("Open");
JMenuItem archivoSave = new JMenuItem("Save");
JMenuItem archivoExit = new JMenuItem("Exit");
JMenu editarMenu = new JMenu("Edit");
JMenuItem editarCut = new JMenuItem("Cut");
JMenuItem editarCopy = new JMenuItem("Copy");
JMenuItem editarPaste = new JMenuItem("Paste");
JMenu especialMenu = new JMenu("Special");
JCheckBoxMenuItem especialCheck1 = new JCheckBoxMenuItem("Check 1");
JCheckBoxMenuItem especialCheck2 = new JCheckBoxMenuItem("Check 2",true);
JSeparator miSeparador = new JSeparator();
JRadioButtonMenuItem especialRadio1 = new JRadioButtonMenuItem("Radio 1");
JRadioButtonMenuItem especialRadio2 = new JRadioButtonMenuItem("Radio 2");
ButtonGroup miButtonGroup = new ButtonGroup();
public SwingWin() {
super(TITULO);
//el constructor SwingWin invoca a miGui()para construir la //GUI del programa y a setupEventos()para conectar eventos //a
su cdigo de manejo de eventos.
miGUI();
setupEventos();
setSize(WIDTH,HEIGHT);
show();
}
void miGUI() {
//el mtodo setupMenuBar es invocado por el constructor //miGUI(), para configurar la barra de mens del programa.
setupMenuBar();
layoutComponentes();
}
void setupMenuBar() {
archivoMenu.add(archivoNew);
archivoMenu.add(archivoOpen);
archivoMenu.add(archivoSave);
archivoMenu.add(archivoExit);
editarMenu.add(editarCut);
editarMenu.add(editarCopy);
editarMenu.add(editarPaste);
especialMenu.add(especialCheck1);
especialMenu.add(especialCheck2);
especialMenu.add(miSeparador);
miButtonGroup.add(especialRadio1);
miButtonGroup.add(especialRadio2);
especialMenu.add(especialRadio1);
especialMenu.add(especialRadio2);
miMenuBar.add(archivoMenu);
miMenuBar.add(editarMenu);
miMenuBar.add(especialMenu);
setJMenuBar(miMenuBar);//organiza el cuento.
}
//este mtodo invoca al mtodo getContentPane() de la clase //Jframe con el fin de obtener el container del frame
public void layoutComponentes() {
miframeContainer = getContentPane();
miframeContainer.setLayout(null);
miTextField.setBounds(150,150,100,20);
miframeContainer.add(miTextField);
}
//este mtodo configura los manipuladores de eventos de la //ventana y de cada uno de los elementos de men.
255
Dr. Eric Jeltsch F.
Captulo 11:
void setupEventos() {
addWindowListener(new WindowTrato());
archivoNew.addActionListener(new MenuItemTrato());
archivoOpen.addActionListener(new MenuItemTrato());
archivoSave.addActionListener(new MenuItemTrato());
archivoExit.addActionListener(new MenuItemTrato());
editarCut.addActionListener(new MenuItemTrato());
editarCopy.addActionListener(new MenuItemTrato());
editarPaste.addActionListener(new MenuItemTrato());
especialCheck1.addItemListener(new ItemTrato());
especialCheck2.addItemListener(new ItemTrato());
especialRadio1.addItemListener(new ItemTrato());
especialRadio2.addItemListener(new ItemTrato());
}
SwingWin app = new SwingWin();
}
public class WindowTrato extends WindowAdapter {
System.exit(0);
}
}
public class MenuItemTrato implements ActionListener {
public void actionPerformed(ActionEvent e) {
String cmd = e.getActionCommand();
if(cmd.equals("Exit")) System.exit(0);
else miTextField.setText(cmd);
}
}
public class ItemTrato implements ItemListener {
public void itemStateChanged(ItemEvent e) {
AbstractButton boton = (AbstractButton) e.getItem();
String miLabel = boton.getText();
if(boton.isSelected()) miLabel += " true";
else miLabel += " false";
miTextField.setText(miLabel);
}
}
}
Esta es una parte de su ejecucin.
256
Dr. Eric Jeltsch F.
Captulo 11:
Como ya lo han visto Swing puede considerar label como rotulos en los mens, pero esto no
es todo pues tambin considera iconos o ambos, basta con declarar una expresin del tipo,
JMenuItem editarItem = new JMenuItem(Cut, new ImageIcon(cut.gif)); otras interfaces posibles de
generar son
257
Dr. Eric Jeltsch F.
Captulo 11:
Cuyo cdigo est en miMenuSimple.java.

import java.awt.*;
public class miMenuSimple extends JMenuBar implements ActionListener {
String[] archivoItems = new String[] { "Nuevo", "Abrir", "Salvar", "Exit" };
String[] editarItems = new String[] { "Cortar", "Copiar", "Pegar" };
char[] archivoCortito = { 'N','A','S','E' };
char[] editarCortito = { 'T','C','P' };
public miMenuSimple() {
JMenu archivoMenu = new JMenu("Archivo");
JMenu editarMenu = new JMenu("Editar");
JMenu otroMenu = new JMenu("Otro");
JMenu subMenu = new JMenu("SubMenu");
JMenu subMenu2 = new JMenu("SubMenu2");
// Ensamblar el archivo menu con abreviaciones.
for (int i=0; i < archivoItems.length; i++) {
JMenuItem item = new JMenuItem(archivoItems[i], archivoCortito[i]);
item.addActionListener(this);
archivoMenu.add(item);
}
// Ensamblar el archivo menus con los aceleradores de teclado.
for (int i=0; i < editarItems.length; i++) {
JMenuItem item = new JMenuItem(editarItems[i]);
item.setAccelerator(KeyStroke.getKeyStroke(editarCortito[i],
java.awt.Event.CTRL_MASK, false));
editarMenu.add(item);
}
// Insertar un separador en el men Editar
editarMenu.insertSeparator(1);
// Ensamblar los submens de Otro Menu
JMenuItem item;
subMenu2.add(item = new JMenuItem("Extra 2"));
258
Dr. Eric Jeltsch F.
Captulo 11:
subMenu.add(item = new JMenuItem("Extra 1"));
subMenu.add(subMenu2);
// Ensamblar Otro Menu en si mismo
otroMenu.add(subMenu);
otroMenu.add(item = new JCheckBoxMenuItem("Chequear"));
otroMenu.addSeparator();
ButtonGroup buttonGroup = new ButtonGroup();
otroMenu.add(item = new JRadioButtonMenuItem("Radio 1"));
buttonGroup.add(item);
otroMenu.add(item = new JRadioButtonMenuItem("Radio 2"));
buttonGroup.add(item);
otroMenu.addSeparator();
otroMenu.add(item = new JMenuItem("Planta",
new ImageIcon("image.gif")));
// Finalmente agrega todos los mens al menubar
add(archivoMenu);
add(editarMenu);
add(otroMenu);
}
public void actionPerformed(ActionEvent event) {
System.out.println("Menu item [" + event.getActionCommand() +
"] fue presionado.");
}
public static void main(String s[]) {
JFrame frame = new JFrame("Un Simple Menu");
//frame.addWindowListener(new BasicWindowMonitor());
frame.setJMenuBar(new miMenuSimple());
frame.pack();
}
}
Para concluir al menos en esta parte les mostrare el ltimo ejemplo en el mismo contexto de lo
tratado hasta ahora, la nica novedad es la herramienta llamada Look andFeel, que es capaz de
simular interfaces de Motif, Windows que son interfaces grficas de sistemas propietarios.
Al archivo le he llamado SwingLF.java
import java.awt.*;
import javax.swing.event.*;
import javax.swing.border.*;
import com.sun.java.swing.plaf.motif.*;
import javax.swing.plaf.metal.*;
import com.sun.java.swing.plaf.windows.*;
public class SwingLF extends JFrame {
public static int WIDTH = 450;
public static int HEIGHT = 450;
259
Dr. Eric Jeltsch F.
Captulo 11:
public static String TITULO = "SwingLF";

//defino mi contenedor
Container miframeContainer;
// defino los Swing componentes
JPanel[] paneles = new JPanel[6];
//botones de chequeo
JCheckBox checkbox1 = new JCheckBox("Check 1");
//botones de seleccin
JRadioButton radioButton1 = new JRadioButton("Radio 1");
//campos de texto
JTextField textField1 = new JTextField("Text field 1",15);
JTextField textField2 = new JTextField("Text field 2",15);
//barras deslizantes
JSlider slider1 = new JSlider(0,0,100,25);
JSlider slider2 = new JSlider(0,0,100,75);
//botones que cambian el look
JButton metalButton = new JButton("Metal");
JButton motifButton = new JButton("Motif");
JButton windowsButton = new JButton("Windows");
//construyo la barra de men
//construyo los componentes de la barra Archivo
JMenu archivoMenu = new JMenu("Archivo");
JMenuItem archivoNuevo = new JMenuItem("Nuevo");
JMenuItem archivoAbrir = new JMenuItem("Abrir");
JMenuItem archivoSalvar = new JMenuItem("Salvar");
JMenuItem archivoSalir = new JMenuItem("Salir");
//construyo los componentes de la barra Editar
JMenu editarMenu = new JMenu("Editar");
JMenuItem editarCortar = new JMenuItem("Cortar");
JMenuItem editarCopiar = new JMenuItem("Copiar");
JMenuItem editarPegar = new JMenuItem("Pegar");
//clases LookAndFeel
MetalLookAndFeel metalLF = new MetalLookAndFeel();
MotifLookAndFeel motifLF = new MotifLookAndFeel();
WindowsLookAndFeel windowsLF = new WindowsLookAndFeel();
public SwingLF() {
//SwingLF carretero
super(TITULO);
miGUI();
setupEventos();
setSize(WIDTH,HEIGHT);
show();
}
//miGUI carretera
void miGUI() {
setupMenuBar();
layoutComponentes();
}
void setupMenuBar() {
archivoMenu.add(archivoNuevo);
archivoMenu.add(archivoAbrir);
archivoMenu.add(archivoSalvar);
archivoMenu.add(archivoSalir);
miMenuBar.add(archivoMenu);
260
Dr. Eric Jeltsch F.
Captulo 11:
editarMenu.add(editarCortar);
editarMenu.add(editarCopiar);
editarMenu.add(editarPegar);
miMenuBar.add(editarMenu);
setJMenuBar(miMenuBar);
}
public void layoutComponentes() {
for(int i=0;i<paneles.length;++i)
paneles[i] = new JPanel();
paneles[0].setBorder(new TitledBorder("Checkboxes"));
paneles[0].setLayout(new GridLayout(3,1));
paneles[0].add(checkbox1);
paneles[1].setBorder(new TitledBorder("Radio Buttons"));
paneles[1].add(radioButton1);
paneles[2].setBorder(new TitledBorder("Text Fields"));
paneles[2].add(textField1);
paneles[2].add(textField2);
paneles[3].setBorder(new TitledBorder("Sliders"));
paneles[3].add(slider1);
paneles[3].add(slider2);
paneles[4].add(metalButton);
paneles[4].add(motifButton);
paneles[4].add(windowsButton);
miframeContainer = getContentPane();
miframeContainer.setLayout(new GridLayout(3,2)); for(inti=0;i<paneles.length;++i) miframeContainer.add(paneles[i]);
}
void setupEventos() {
addWindowListener(new WindowTrato());
archivoSalir.addActionListener(new MenuItemTrato());
metalButton.addActionListener(new ButtonTrato());
motifButton.addActionListener(new ButtonTrato());
windowsButton.addActionListener(new ButtonTrato());
}
SwingLF app = new SwingLF();
}
public class WindowTrato extends WindowAdapter {
System.exit(0);
}
}
public class MenuItemTrato implements ActionListener {
System.exit(0);
}
}
public class ButtonTrato implements ActionListener {
String cmd = e.getActionCommand();
if(cmd.equals("Motif")) {
try {
261
Dr. Eric Jeltsch F.
Captulo 11:
UIManager.setLookAndFeel(motifLF);
SwingUtilities.updateComponentTreeUI(SwingLF.this);
}catch(Exception ex){
System.out.println(ex);
}
}else if(cmd.equals("Metal")) {
try {
UIManager.setLookAndFeel(metalLF);
}
}else if(cmd.equals("Windows")) {
try {
UIManager.setLookAndFeel(windowsLF);
}
}
}
}
}
262
Dr. Eric Jeltsch F.
Captulo 11:
Actividades on-line:
Qu cambios debera darle al cdigo para que la interfaz se viese as?
De la misma manera pero ahora, quisiera que se viera as,
263
Dr. Eric Jeltsch F.
Captulo 11:
JSlider
Una declaracin ms o menos tpica de JSlider son estructuras del tipo,
JSlider miJSlider = new JSlider( SwingConstants. HORIZONTAL, 0, 200, 10);
indica que cada tick marcado representa 10 como valor en el rango de valores soportado por
JSlider,
miJSlider.setMajorTickSpacing(10);
indica si la tabla milimetrada se muestra o se oculta,

miJSlider.setPaintTicks(true);
Ejemplo
JSlider slider = new JSlider(JSlider.VERTICAL, 0, 50, 25);//10
slider.setMinorTickSpacing(4);//3
slider.setMajorTickSpacing(20);//10
slider.setPaintTicks(true);
slider.setPaintLabels(true);
slider.setLabelTable(slider.createStandardLabels(10));
add(slider, BorderLayout.CENTER);
264
Dr. Eric Jeltsch F.
Captulo 11:
265

Libro Java

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Libro Java

Enviado por

Direitos autorais:

Formatos disponíveis

Escuela de Ingeniera en Computacin

LECTURAS PARA PROGRAMACIN ORIENTADA A

Dr. Eric Jeltsch F.

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

Ingeniera en Computacin, Universidad de La Serena

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

un conjunto de mtodos como IngresarDinero, RetirarDinero, AbonarIntereses, SaldoActual,

cuyo significado sera que, Transferencia es el mensaje que el objeto cuenta_del_cliente2

Mecanismos Bsicos de la Poo

Ingeniera en Computacin, Universidad de La Serena

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

Ingeniera en Computacin, Universidad de La Serena

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

Ingeniera en Computacin, Universidad de La Serena

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

Ingeniera en Computacin, Universidad de La Serena

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

Ingeniera en Computacin, Universidad de La Serena

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

// importar la clase System

public class CApGrados {

while (gradosCent <= limSuperior) // while ... hacer:

Ingeniera en Computacin, Universidad de La Serena

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

Herencia Simple en Java

Ingeniera en Computacin, Universidad de La Serena

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

En el ejemplo, Empleado se caracteriza por un nombre (String) y por un nmero de empleado y

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

Nota: La discusin acerca de los constructores la veremos un poco ms adelante.

En la prctica, se muestra otro ejemplo de herencia simple.

Ingeniera en Computacin, Universidad de La Serena

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

Por medio de la abstraccin conseguimos no detenernos en los detalles, sino generalizar y

Ingeniera en Computacin, Universidad de La Serena

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

La clase abstracta se declara simplemente con el modificador abstract en su declaracin. Los

Ingeniera en Computacin, Universidad de La Serena

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

Esta caracterstica permite implementar mltiples formas de un mismo mtodo, dependiendo

Ingeniera en Computacin, Universidad de La Serena

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

System.out.println("Dentro de B llamando a callme()");

Ingeniera en Computacin, Universidad de La Serena

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

Ingeniera en Computacin, Universidad de La Serena

Dr. Eric Jeltsch F.

Captulo I: Programacin Orientada a Objetos

Empleado otroEmp = (Empleado) otro;