Notas de Introduccion al Lenguaje de

Programacion Java

Jorge L. Ortega Arjona

Departamento de Matematicas
Facultad de Ciencias, UNAM

Septiembre 2004
2
Indice general

1. Introduccion 7

2. Programacion Basica en Java 11

2.1. Codificacion Java . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.1. Archivos .java . . . . . . . . . . . . . . . . . . . . . . 11
2.1.2. Comentarios . . . . . . . . . . . . . . . . . . . . . . . 11
2.2. Identificadores . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3. Valores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3.1. Valores enteros . . . . . . . . . . . . . . . . . . . . . . 17
2.3.2. Valores de punto flotante . . . . . . . . . . . . . . . . 17
2.3.3. Valores booleanos . . . . . . . . . . . . . . . . . . . . 18
2.3.4. Valores caracter . . . . . . . . . . . . . . . . . . . . . 18
2.3.5. Valores de cadenas de caracteres . . . . . . . . . . . . 19
2.3.6. Valor nulo . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.4. Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.4.1. Tipos Primitivos . . . . . . . . . . . . . . . . . . . . . 20
2.4.2. Tipos de Referencia . . . . . . . . . . . . . . . . . . . 21
2.4.3. Conversion Automatica de Tipos . . . . . . . . . . . . 21
2.5. Entornos (Scope) . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.6. Declaracion de Variables . . . . . . . . . . . . . . . . . . . . . 24
2.7. Inicializacion de Variables . . . . . . . . . . . . . . . . . . . . 26
2.7.1. Variables de Clase e Instancia . . . . . . . . . . . . . . 26
2.7.2. Variables Parametro . . . . . . . . . . . . . . . . . . . 27
2.7.3. Variables Parametro de Manejo de Excepciones . . . . 27
2.7.4. Variables Locales . . . . . . . . . . . . . . . . . . . . . 27
2.7.5. Variables Finales . . . . . . . . . . . . . . . . . . . . . 28
2.8. Arreglos de Variables . . . . . . . . . . . . . . . . . . . . . . . 30
2.9. Expresiones Primarias . . . . . . . . . . . . . . . . . . . . . . 34
2.10. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

3
 2.10.1. Operadores de Incremento Posfijo . . . . . . . . . . . 37
2.10.2. Operadores Unarios . . . . . . . . . . . . . . . . . . . 38
2.10.3. El operador new . . . . . . . . . . . . . . . . . . . . . 39
2.10.4. El operador cast . . . . . . . . . . . . . . . . . . . . . 39
2.10.5. Operadores Artimeticos . . . . . . . . . . . . . . . . . 40
2.10.6. Operador concatenacion de cadenas de caracteres . . . 41
2.10.7. Operadores de corrimiento . . . . . . . . . . . . . . . . 41
2.10.8. Operadores relacionales . . . . . . . . . . . . . . . . . 42
2.10.9. Operadores Logicos a bit . . . . . . . . . . . . . . . . 42
2.10.10.AND y OR booleanos . . . . . . . . . . . . . . . . . . 43
2.10.11.Operador condicional . . . . . . . . . . . . . . . . . . 43
2.10.12.Operadores de asignacion . . . . . . . . . . . . . . . . 43
2.11. Enunciados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.11.1. El enunciado if . . . . . . . . . . . . . . . . . . . . . 45
2.11.2. El enunciado switch . . . . . . . . . . . . . . . . . . . 46
2.12. Ciclos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.12.1. El ciclo while . . . . . . . . . . . . . . . . . . . . . . . 48
2.12.2. El ciclo do . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.12.3. El ciclo for . . . . . . . . . . . . . . . . . . . . . . . . 49
2.13. Control de ejecucion . . . . . . . . . . . . . . . . . . . . . . . 51
2.13.1. break . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.13.2. continue . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.13.3. return . . . . . . . . . . . . . . . . . . . . . . . . . . 52

3. Programacion Orientada a Objetos en Java 53

3.1. Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.1.1. Declaracion de clases . . . . . . . . . . . . . . . . . . . 53
3.1.2. Publico, Privado y Protegido . . . . . . . . . . . . . . 55
3.1.3. Variables de Instancia . . . . . . . . . . . . . . . . . . 56
3.1.4. Variables Estaticas o de clase . . . . . . . . . . . . . . 57
3.1.5. Clases de alto nivel . . . . . . . . . . . . . . . . . . . . 58
3.1.6. Clases anidadas . . . . . . . . . . . . . . . . . . . . . . 59
3.1.7. Clases finales . . . . . . . . . . . . . . . . . . . . . . . 68
3.1.8. Clases abstractas . . . . . . . . . . . . . . . . . . . . . 69
3.2. Metodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
3.2.1. Declaracion de Metodos . . . . . . . . . . . . . . . . . 70
3.2.2. Metodos Estaticos o de clase . . . . . . . . . . . . . . 74
3.2.3. Constructores . . . . . . . . . . . . . . . . . . . . . . . 76
3.2.4. Inicializadores Estaticos . . . . . . . . . . . . . . . . . 79
3.2.5. this . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

4
 3.2.6. Redefinicion de Metodos . . . . . . . . . . . . . . . . . 82
3.2.7. Metodos Finales . . . . . . . . . . . . . . . . . . . . . 85
3.2.8. Expresiones de invocacion a Metodos . . . . . . . . . . 85
3.2.9. Busqueda de nombre modificado para miembros de
una clase . . . . . . . . . . . . . . . . . . . . . . . . . 93
3.2.10. Metodos abstractos . . . . . . . . . . . . . . . . . . . . 95
3.2.11. Metodos heredados de la clase Object . . . . . . . . . 96
3.3. Herencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
3.3.1. Palabras Clave private, protected, y Herencia . . . 103
3.3.2. Constructores y Herencia . . . . . . . . . . . . . . . . 106

4. Topicos Especiales en Java 109

4.1. Paquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
4.2. Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
4.2.1. Declaracion de Interfaces . . . . . . . . . . . . . . . . 115
4.2.2. implements . . . . . . . . . . . . . . . . . . . . . . . . 117
4.3. Excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
4.3.1. Clases de Excepcion . . . . . . . . . . . . . . . . . . . 122
4.3.2. try, catch y finally . . . . . . . . . . . . . . . . . . 125
4.3.3. Propagacion de Excepciones . . . . . . . . . . . . . . . 130
4.3.4. Declaracion throws . . . . . . . . . . . . . . . . . . . 131
4.3.5. El enunciado throw . . . . . . . . . . . . . . . . . . . 135
4.4. Hebras de Control (Threads) . . . . . . . . . . . . . . . . . . 139
4.4.1. La clase Thread . . . . . . . . . . . . . . . . . . . . . 141
4.4.2. Metodos Sincronizados . . . . . . . . . . . . . . . . . . 145
4.4.3. El enunciado synchronized . . . . . . . . . . . . . . . 150
4.5. Ventanas (Windows) . . . . . . . . . . . . . . . . . . . . . . . 152
4.5.1. Un Programa Simple con Interfaz Grafica . . . . . . . 153
4.5.2. Descripcion de la Ventana . . . . . . . . . . . . . . . . 156
4.5.3. El Area de Dibujo . . . . . . . . . . . . . . . . . . . . 160
4.5.4. Entrada de Caracteres . . . . . . . . . . . . . . . . . . 166
4.5.5. Menues, Archivos e Imagenes . . . . . . . . . . . . . . 171

A. Entrada por Teclado 179

A.1. La clase KeyboardInput . . . . . . . . . . . . . . . . . . . . . 179

5
6
Captulo 1

Introduccion

Java es un lenguaje de programacion de alto nivel, orientado a obje-

tos, multi-hebra, usado para escribir tanto programas autocontenidos como
applets, estos ultimos como parte de los documentos HTML (hypertext
markup language) que se encuentran disponibles en paginas WWW. Los ap-
plets permiten a las paginas de red tener un contenido ejecutable accesible
con un navegador habilitado con Java.

Java tiene varias ventajas y caractersticas utiles para el programador:

Una vez que el compilador e interprete de Java han sido portados
a una nueva plataforma, un programa Java puede ejecutarse en tal
plataforma sin cambios.
Java es un lenguaje fuertemente tipificado: el compilador hace varias
verificaciones, tal como comparar los tipos de los argumentos que se
pasan a los metodos para asegurar que se ajustan a los tipos de los
parametros formales.
El interprete hace muchas verificaciones durante el tiempo de ejecu-
cion, tal como asegurar que el ndice de un arreglo no salga de sus
limites, o que una referencia a un objeto no sea nula.
No son posibles ni fugas de memoria (memory leak, un bloque de
memoria que todava se considera reservado en memoria aun cuando
no haya referencias a el) ni apuntadores colgantes (dangling point-
ers, una referencia a un bloque de memoria que ha sido liberado), ya
que el recolector de basura (garbage collector) de Java recolecta toda
la memoria ocupada por objectos inalcanzables. No es necesario un
procedimiento free(), susceptible a errores.

7
 No hay aritmetica de apuntadores: las unicas operaciones permitidas
sobre las referencias a un objeto son asignacion de otra referencia a
objeto y comparacion con otra referencia. Por lo tanto, el programador
tiene menor posibilidad de escribir codigo susceptible a errores que
modifique un apuntador.

Java viene acompanado de una biblioteca de herramientas para la

creacion de ventanas, conocida como AWT, que se utiliza por apli-
caciones y applets para la implementacion de interfaces graficas de
usuario.

Se encuentran disponibles muchos libros que describen el lenguaje Java

(y que se han usado como referencias para las presentes notas) como son:

1. The Java Programming Language.

Ken Arnold and James Gosling.
Addison-Wesley, 1996.

2. Java Essentials for C and C++ Programmers.

Barry Boone.
Addison-Wesley, 1996.

3. Core Java.
Gary Cornell and Cay S. Horstsmann.
Prentice-Hall, 1996.

4. Java in a Nutshell.
David Flanagan.
OReilly, 1996.

Varios vienen acompanados de un CD-ROM que contiene los ejemplos

de los programas del libro y una copia del Java Development Kit (JDK) de
Sun Microsystems. Mas aun, el JDK y su documentacion asociada pueden
obtenerse en forma gratuita en el sitio ftp.javasoft.com, mantenido por
JavaSoft, que es una subsidiaria de Sun Microsystems.

El JDK consiste de un compilador, un interprete (JVM o Java Vir-

tual machine), y las bibliotecas de clases del sistema. Existen varias ver-
siones de JDK para los mas populares y conocidos sistemas operativos
(MS-Windows, Linux, Solaris, MacOS System, etc.). Para informacion sobre
nuevos desarrollos sobre JDK puede hallarse en la pagina de JavaSoft, en:
http://www.javasoft.com y http://www.sun.com.

8
 Estas notas dan una introduccion al lenguaje de programacion Java.
Su objetivo es servir al estudiante como una referencia sencilla y rapida al
lenguaje. Su enfoque considera primero presentar elementos de programacion
basica (como son identificadores, tipos, variables arreglos, operaciones, enun-
ciados de control, etc.) que Java tiene en comun con otros lenguajes de
programacion. En seguida, se presenta como Java presenta los conceptos
de programacion Orientada a Objetos (principalmente, clases, metodos y
herencia). Finalmente, se introducen varios topicos especiales exclusivos del
lenguaje Java, que utilizan la programacion basica y orientada a objetos
(temas como paquetes, interfaces, excepciones, hebras de control y ven-
tanas). Sin embargo, estas notas no describen las bibliotecas de clases de
Java. Estas estan extensivamente descritas en la documentacion de JDK que
se encuentra disponible en las paginas de Web anteriormente mencionadas.

Jorge L. Ortega Arjona

Septiembre 2004

9
10
Captulo 2

Programacion Basica en Java

2.1. Codificacion Java

Un programa en Java consiste de una serie de declaraciones de clases e
interfaces, cada una de las cuales se compone de declaraciones de metodos y
variables. Estas declaraciones se presentan formando un texto o codigo que
es almacenado en un archivo fuente. Aun cuando las declaraciones de varias
clases y/o interfaces pueden ser almacenadas en el mismo archivo fuente,
tpicamente cada declaracion se almacena en un archivo separado. Esto no
se debe solo a preferencia, sino que tambien se relaciona con la forma en que
las clases de Java se cargan cuando un programa se ejecuta.

2.1.1. Archivos .java

Los archivos fuente siempre tienen nombres con la terminacion .java.
La primera parte del nombre del archivo es el nombre de la clase o interfaz
declarada en el propio archivo. Por ejemplo, una clase Test se almacenara
en un archivo Test.java. Si un archivo contiene la declaracion de mas de
una clase o interfaz, el archivo debe ser nombrado a partir de una de ellas,
la cual debe ser la unica clase o interfaz publica (public) en el archivo.

2.1.2. Comentarios
Los comentarios en Java tienen tres formas:

// Este es un comentario de una sola linea

/* Este es un comentario
multilinea */

11
 /** Este es un comentario
para documentacion */

Los comentarios para documentacion se reconocen mediante la herramien-

ta javadoc, la cual lee los comentarios de documentacion y automaticamente
genera paginas HTML conteniendo una version limpiamente formateada de
la informacion de los comentarios. Cada pagina documenta una clase y lista
cada variable miembro junto con cualquier informacion o comentario pro-
visto. Las bibliotecas de Java se documentan usando los comentarios para
documentacion y la herramienta javadoc.

Los comentarios para documentacion empiezan con una marca /** y

terminan con */. Pueden extenderse por multiples lneas, pero no pueden ser
anidados. Solo los comentarios para declaracion inmediatamente antes de la
declaracion de clases, interfaces, variables miembro y metodos se reconocen
por javadoc como comentarios para documentacion. En cualquier otro lado,
un comentario para documentacion se considera solo como un comentario
multilnea.

Dentro de un comentario para documentacion pueden aparecer varias

etiquetas que permiten procesar la informacion del comentario en formas
especficas por la herramienta javadoc. Cada etiqueta se marca por un
smbolo @, y debe comenzar en una lnea aparte. Las siguientes etiquetas
se encuentran disponibles:

@author. Nombre del o los autores del codigo que se comenta. El nom-
bre del autor se escribe simplemente como texto:

@author Daniel Lopez

Pueden utilizarse varias etiquetas con diferentes autores, o varios nom-

bres pueden ser considerados en la misma etiqueta:

@author Daniel Lopez, Javier Jimenez

@deprecated. Se usa para indicar que la siguiente clase o metodo se

ha cambiado de una version anterior del codigo, y sera removida en
versiones futuras. La etiqueta puede ser seguida de una corta expli-
cacion:

12
@deprecated No sera disponible en siguientes versiones

Idealmente, @deprecated debe seguirse de una etiqueta @see que diri-

ja al lector al punto de reemplazo. Esta etiqueta es adicionalmente
reconocida por el compilador de Java, lo que genera un mensaje de
advertencia (warning) si el codigo se utiliza.

@exception. Provee de informacion sobre las excepciones que pueden

arrojarse a partir de un metodo. Un nombre de excepcion puede apare-
cer despues de la etiqueta seguida de un comentario de texto.

@exception IndexOutOfBoundsException Intento de accesar

un elemento invalido

Un comentario para documentacion puede contener varias etiquetas

@exception.

@param. Provee informacion sobre parametros de metodos y construc-

tores. La etiqueta es seguida del nombre del parametro y de un co-
mentario:

@param size Tamano de una estructura de datos

Estas etiquetas solo deben aparecer en comentarios precediendo meto-

dos y constructores. Idealmente, debe haber una etiqueta por cada
parametro, presentandose en el mismo orden de los parametros.

@return. Documenta el valor de retorno de un metodo.

@return El indice de un elemento identificado

El comentario es texto simple. Un comentario para documentacion

debe solo contener una etiqueta @return, ya que solo puede haber un
solo valor de retorno.

@see. Provee una referencia cruzada a otra clase, interfaz, metodo,

variable o URL. Las siguientes son referencias validas:

13
 @see java.lang.Integer
@see Integer
@see Integer#intValue
@see Integer#getInteger(String)
@see <a href="info.html">Vease aqui para mayor informacion</a>

Las clases e interfaces pueden ser referenciadas tanto por su nom-

bre como por el nombre completo del paquete al que pertenecen. Las
variables y metodos miembro pueden referenciarse mediante anadir su
nombre al nombre de la clase siguiendo el smbolo #. Los URLs pueden
aparecer si se hace un formato utilizando las etiquetas <a>...</a> de
HTML. Multiples etiquetas @see pueden aparecer en el mismo comen-
tario.

@since. Se usa para establecer cuando una caracterstica particular

fue incluida (por ejemplo, desde cuando se ha hecho disponible). La
etiqueta se sigue por un texto dando la informacion requerida:

@since JDK1.0

@version. Se utiliza para dar informacion sobre la version de la re-

vision actual del codigo siendo comentado. El formato para la infor-
macion sobre la version no esta especificada, y se deja al programador.
Una convencion no oficial que se esta utilizando cada vez mas es aquella
en que el numero de la version se sigue por la fecha de liberacion (re-
lease date):

@version 1.2 20.8.1997

Solo una etiqueta de version puede aparecer dentro de un comentario.

El texto incluido en un comentario para documentacion puede tambien

marcarse con etiquetas HTML usadas para controlar la apariencia del tex-
to, incluyendo <code>...</code> (que delimita el texto utilizando la letra
para codigo de programacion), y <p> (que indica el comienzo de un nuevo
parrafo, y que se utiliza frecuentemente tambien como delimitador de la for-
ma <p>...</p>). Consultese libros sobre HTML para detalles referentes a
la notacion de ese lenguaje.

La siguiente declaracion de una clase ilustra el uso de los comentarios

para documentacion:

14
/** Esta es una clase de prueba para mostrar el uso de comentarios para
documentacion.
@author Daniel Lopez
@see java.lang.String
@version 1.0 10.8.1997
*/

public class Comment1 {

/** Retorna el argumento multiplicado por 2.

@param x El valor entero a ser duplicado.
@return El argumento del metodo multiplicado por 2.
@deprecated Sera removido en la siguiente version de la clase.
@see #multiplyByTwo
*/
public int times2 (int x) {
return x*2;
}

/** Retorna el argumento multiplicado por 2, reemplazando

la version anterior de este metodo.
@param x El valor entero a ser duplicado.
@return El argumento del metodo multiplicado por 2.
*/
public int multiplyByTwo (int x) {
return 2*x;
}

/** La funcion main usada para probar la clase.

@param args argumentos de linea de comando (no usados)
*/
public static void main(String[] args) {
Comment1 test = new Comment1();
int n = test.times2(5);
n = test.multiplyByTwo(10);

System.out.println(s);
}

/** Una cadena de caracteres utilizada por la funcion

<code>main</code>.
*/

static String s = "Hello";

}

15
2.2. Identificadores
Un identificador (o simplemente un nombre) en Java es basicamente una se-
cuencia de caracteres alfabeticos o dgitos que comienza con un caracter alfabetico.
Los identificadores pueden incluir tambien el subrayado (underscore: ) y $ (aun
cuando $ no debe ser utilizado en codigo normal).

Ejemplos son:

result, PI, xyz123, unNombreMuyLargoQueResultaDificilDeEscribir

Los identificadores no pueden incluir espacios ni ser ninguna de las palabras
clave o literales de Java, ya que tales palabras clave o literales tienen un significado
particular dentro del lenguaje. Estas son:

abstract default implements protected throws

boolean do import public transient
break double instanceof return try
byte else int short void
case extends interface static volatile
catch final long super while
char finally native switch
class float new synchronized
const for package this
continue if private throw

Algunos compiladores de Java tambien reconocen const y goto como palabras

clave o reservadas. Ademas, unos cuantos valores literales tienen nombres que deben
considerarse tambien como reservados. Estos son true, false y null.

16
2.3. Valores
Los valores en Java pueden ser de los siguientes tipos:

Numeros enteros: int y long

Numeros de punto flotante: float y double
Valores booleanos: boolean
Caracteres: char
Cadenas de caracteres: String
Referencia nula: null

Un valor puede ser utilizado en cualquier expresion donde su uso sea del tipo
correcto.

2.3.1. Valores enteros

Los valores decimales de tipo int (32 bits) pueden escribirse como sigue:

0, 123, -456, 555665, 2354545, -3456345

Los valores octales de tipo int son precedidos por un cero (0), seguido por
dgitos en el rango de 0 a 7:

00, 0123, 0777, -045233, 023232, -01

Los valores hexadecimales del tipo int se preceden por 0x o 0X. Los dgitos
hexadecimales pueden representarse por cifras del 0 al 9 y de A a F (o a a f):

0x0, 0X12F, -0xffed, 0XFFFF, 0x12def1, 0xff342232

Los valores de tipo long (64 bits) se denotan por anadirles una L o l a cualquier
representacion de un entero:

0L, 0l, 1223434545L, 0xffeeL, 077L, -34543543l,

-045l, -0XC0B0L

2.3.2. Valores de punto flotante

La representacion de numeros de punto flotante incluyen un punto decimal. Por
defecto, todo numero con punto decimal se considera de tipo double:

1.2345, 1234.432353, 0.1, 3.4, .3, 1., -23.4456

Solo si el numero cuenta con el sufijo F o f sera de tipo float:

1.23f, 2.34F, 0f, .2F, -4.5687F, -4423.223f

17
 Un sufijo D o d puede de forma similar implicar tipo double.

Los numeros de punto flotante pueden ser escritos utilizando el formato con
exponente, mediante el uso de e o E, considerando las reglas anteriormente senaladas
al anadir f, F, d y D:
4.54003e+24, 5.3453E-22, 1.2e5f, -1.978748E+33D, 2.5444e+9f
Los valores de punto flotante no pueden ser escritos utilizando notaciones octal
o hexadecimal.

2.3.3. Valores booleanos

Existen dos valores booleanos: true y false. Estos son considerados como
palabras clave, por lo que tales nombres no pueden ser utilizados con otro proposito
dentro de un programa.

2.3.4. Valores caracter

Un valor caracter representa un solo caracter, el cual es limitado por comillas
sencillas:
a, A, !, 3, {,
Los caracteres que no tienen representacion visible (como por ejemplo, lnea
aparte o tabulador) requieren una secuencia que se denota mediante el uso de \
seguido por un caracter:
\b: borrado de caracter (backspace)
\f: alimentacion de pagina (formfeed)
\n: lnea aparte (newline)
\r: retorno de carro (carriage return)
\t: tabulador (tab)
Algunos signos de puntuacion requieren tambien secuencias especiales:
\\: diagonal invertida (backslash)
\: comilla sencilla (single quote)
Las secuencias pueden utilizarse tambien para especificar codigo octal represen-
tando caracteres directamente. Los codigos validos van de 000 a 377, y no requieren
ser precedidos por el cero:
\123, \167, \023
Las secuencias Unicode tambien pueden ser utilizadas como valores caracter.
Notese, sin embargo, que dado que las secuencias son procesadas primero, pueden
darse algunas sorpresas. Por ejemplo, si en Unicode el caracter representando ali-
mentacion de lnea aparece en un valor caracter (\u000a) sera traducido a un fin
de lnea en el texto del programa, y no la alimentacion de lnea que se esperaba.

18
2.3.5. Valores de cadenas de caracteres
Los valores de cadenas de caracter se encierran en comillas dobles, y se almace-
nan como objetos String cuando el programa se ejecuta. Pueden incluir caracteres
especiales (comunmente, la lnea aparte):

"Esta es una cadena", "Hola Mundo\n", "Uno\tDos\tTres"

2.3.6. Valor nulo

Este valor aparece simplemente como null, y como los valores booleanos, se
considera efectivamente como una palabra reservada.

19
2.4. Tipos
Un tipo es un nombre que representa un conjunto de valores. Java tiene dos
categoras de tipos: tipos primitivos y tipos de referencia. Por cada tipo hay un
conjunto de operadores para los valores de tal tipo (por ejemplo, +, -, *, etc.).

Java es un lenguaje fuertemente tipificado, lo que significa que toda expresion,

valor y objeto debe tener un tipo, y que el uso de tipos debe ser consistente. El com-
pilador de Java refuerza el uso correcto de tipos mediante una rigurosa verificacion
de tipos.

2.4.1. Tipos Primitivos

Los tipos primitivos reflejan los tipos basicos que se soportan directamente por
el procesador de una computadora tpica, haciendolos los tipos mas eficientes a
ser usados. Las operaciones sobre estos tipos usualmente se mapean directamente
a instrucciones del procesador. Dicho eso, Java define cuidadosamente una repre-
sentacion estandar para cada uno de estos tipos, de tal modo que se comporten
exactamente igual en cualquier maquina que soporte la Maquina Virtual de Java
(Java Virtual Machine, o JVM). La mayora de los procesadores actuales consideran
tales representaciones directamente. Los tipos primitivos se representan como sigue:

boolean. El tipo boolean simplemente tiene dos valores: true y false.

byte. Enteros de 8 bits signados con complemento a 2, con rango de valores
entre -128 y 127.
short. Enteros de 16 bits signados con complemento a 2, con rango de valores
entre -32768 y 32767.
int. Enteros de 32 bits signados con complemento a 2, con rango de valores
entre -2147483648 y 2147483647.
long. Enteros de 64 bits signados con complemento a 2, con rango de valores
entre -9223372036854775808 y 9223372036854775807.
char. Valores de 16 bits no signados, de 0 a 65535, representando caracteres
Unicode.
float. Valores de punto flotante de precision sencilla, con formato IEEE 754
de 32 bits, con un rango de valores entre 1.40239846e-45 y 3.40282347e+38.
double. Valores de punto flotante de doble precision, con formato IEEE
754 de 64 bits, con un rango de valores entre 4.9406564581246544e-324 y
1.79769313486231570e+308

Hay otros tres valores especiales de tipo flotante: infinito positivo (positive
infinity), infinito negativo (negative infinity) y no un numero (not a number,
o NaN). Estos se generan cuando una operacion de punto flotante sobrepasa la
capacidad de la computadora (overflow), u ocurre una division entre cero.

20
 Los operadores definidos para cada uno de estos tipos primitivos se describen
mas adelante.

La biblioteca de clases de Java provee (en el paquete java.lang) una clase

por cada tipo primitivo descrito anteriormente, lo que permite que estos tipos se
representen mediante objetos. Las clases son Boolean, Byte, Short, Integer, Long,
Character, Float y Double.

Existe aun un tipo mas que pertenece a los tipos primitivos del lenguaje. Este
es el tipo void (void es una palabra reservada). No existen valores de tipo void,
as que no tiene representacion. El unico uso de void es para la declaracion de
metodos que no retornan ningun resultado (o para ser mas precisos, retornan un
valor de tipo void para el cual no hay representacion, y por lo tanto, no requiere
forma de almacenamiento en memoria).

2.4.2. Tipos de Referencia

En Java, hay tres tipos de referencia: clases, interfaces y arreglos. Toda expre-
sion que haga referencia a un objeto tiene un tipo de referencia. Los objetos en
s mismos pueden conformarse de uno o mas tipos de referencia.

Una clase se crea cuando se declara, utilizando la palabra clave class. El

nombre del tipo sera el mismo que el nombre de la clase.
Una interfaz se crea cuando se declara, utilizando la palabra clave interface.
El nombre del tipo sera el mismo que el nombre de la interfaz.
Un arreglo se especifica cuando se declara un nombre determinado por un
tipo, precedido (o en ocasiones, seguido) de corchetes ([]). Por ejemplo, int
[] i; tiene un tipo array de int.

Los nombre de los tipos son en realidad identificadores.

Por ultimo, el tipo de referencia String se da para un reconocimiento espe-

cial dentro del lenguaje debido a la necesidad de soportar valores de cadenas de
caracteres, aun cuando existe una clase String en las bibliotecas de clases.

2.4.3. Conversion Automatica de Tipos

Java provee de una variedad de conversiones automaticas entre tipos que per-
mite una mayor flexibilidad al escribir expresiones. Por ejemplo: es posible asignar
un valor de tipo int a una variable de tipo long. Esto permite que todo int se
convierta en long sin perdida de informacion. La asignacion opuesta, de long a int,
no se permite pues puede potencialmente perderse informacion, ya que el rango de
long es mayor que el rango de int. Las conversiones como esta pueden forzarse uti-
lizando el mecanismo de cast en las expresiones, siempre y cuando el programador
sea consciente de que potencialmente puede perderse informacion.

21
 Los siguientes tipos de conversion automatica se soportan:

Conversiones de Ampliacion de Primitivas: Estas convierten de un tipos a otro

considerando que no hay perdida de informacion. Las conversiones permitidas
son:

byte short, int, long, float o double

short int, long, float o double
int long, float o double
long float o double
float double

Conversiones de Ampliacion de Referencias: Estas permiten que una referen-

cia de una subclase sea tratada como una referencia del tipo de su superclase.
Conversiones de Cadenas de Caracteres: cuando el operador + (concatenacion
de cadenas) tiene un argumento de tipo String, cualquier otro argumento
puede ser convertido a tipo String.

Las conversiones se realizan principalmente durante operaciones de asignacion,

y cuando los valores se pasan como parametros o argumentos de un metodo. Esto
permite al programador escribir enunciados como:

short a = 12;
long b = a;

Es posible hacer esto aun cuando a primera vista a y b son de tipos dife-
rentes. Cuando este codigo es compilado, el compilador insertara las conversiones
necesarias automaticamente y sin comentarios. La mayor parte del tiempo esto no
causara problemas, pero ocasionalmente puede generar sorpresas, particularmente
en el caso de las conversiones de referencias.

Se habla del uso de conversiones cuando se utiliza la frase compatibilidad por

asignacion (assignment compatible), de tal forma que en el ejemplo inicial, todo
int es compatible por asignacion con todo long.

22
2.5. Entornos (Scope)
Un programa puede tener los siguientes entornos:

Entorno Global. Los nombres declarados en este entorno son accesibles para
cualquier enunciado dentro de todo el programa. Solo los nombres de pa-
quetes (packages) son globales.
Entorno de Paquetes. Un paquete (package) define un entorno y una unidad
de encapsulacion. Los nombres declarados dentro de un paquete pueden ser
globales para el paquete mismo, y pueden hacerse publicos (public), de tal
modo que puedan ser accesados por los usuarios del paquete. Los paquetes
no pueden ser anidados, es decir, estar uno dentro de otro, pero un paquete
puede usar cualquier otro.
Entorno de Unidad de Compilacion. Una unidad de compilacion es, en efecto,
un sinonimo de archivo fuente. Los nombres pueden ser globales solo dentro
del archivo. Todos los contenidos de cualquier archivo son siempre parte de
un paquete.
Entorno de Clase. Los nombres dentro de una clase son accesibles a cualquier
parte de la misma clase o de sus subclases si son declarados publicos (public)
o protegidos (protected). Mas aun, si los nombres son declarados como
publicos, pueden ser accedidos por los usuarios de la clase, o si no se les
especifica como publicos, protegidos o privados (private), pueden ser acce-
didos por otras clases dentro del mismo paquete.
Entorno Local. Un enunciado compuesto (aquel enunciado delimitado por {
y }, y que contiene una secuencia de otros enunciados) define un entorno
local. Los cuerpos de metodos y enunciados de control son tambien entornos
locales. Los entornos locales pueden ser anidados a cuantos niveles como sea
necesario (por ejemplo, un entorno local puede ser declarado dentro de otro
entorno local). Los nombres declarados en un entorno local son unicamente
accesibles dentro de tal entorno o en cualquiera de sus entornos anidados. Mas
aun, los nombres son solo utilizables desde el punto textual de declaracion y
hasta el fin del entorno, es decir, no puede usarse un nombre antes de que
haya sido declarado en el texto (notese la diferencia con el entorno de clase).

Los entornos son siempre anidados entre s, siendo el entorno global el de mas
externo nivel. Un nombre declarado en un entorno anidado o contenido es accesible
por el entorno anidado o contenido, a menos que sea oculto por otra declaracion
que use el mismo nombre.

23
2.6. Declaracion de Variables
La sintaxis basica para declarar variables es:

tipo identificador;
o
tipo identificador = expresion;

El primero representa una variable con inicializacion por defecto, y el segun-

do es una variable inicializada explcitamente. En ciertos puntos del programa, la
declaracion de variables se precede por una o mas de las palabras clave:

final, static, transient, volatile

Es posible declarar dos o mas variables del mismo tipo en la misma declaracion:

tipo identificador1, identificador2, ...;

Las variables dentro de la lista pueden a su vez ser inicializadas.

Existen en Java dos categoras de variables:

1. Variables de un tipo primitivo que directamente contienen una representacion

de un valor de tal tipo primitivo.
2. Variables de tipo de referencia que guardan una referencia a un objeto con-
formado con el nombre del tipo de la variable null (que es la referencia
nula).

La declaracion de una variable introduce tal variable al entorno actual, dandole

un nombre y tipo. Todas las variables deben ser declaradas antes de ser usadas.

Ademas de las dos categorasde variables, varios tipos de variables pueden ser
identificadas basandose en cuando son declaradas:

Variables de Clase. Son aquellas declaradas como estaticas (static) dentro de

una clase. Estas variables se comparten por todas los objetos como instancias
de tal clase.
Variables de Instancia. Son declaradas dentro de una clase. Cada objeto,
como instancia de la clase, tiene su propia copia de cada variable de instancia
declarada.
Parametros de metodos y constructores. Se declaran dentro de la lista de
parametros de un metodo o constructor.
Parametros de manejo de excepciones. Se declaran dentro de la lista de
parametros de la clausula catch.
Variables Locales. Se declaran dentro del entorno local, usualmente un enun-
ciado compuesto, e incluso en el cuerpo de los metodos.

24
 Una variable se declara mediante especificar su tipo y su nombre, donde el nom-
bre es un identificador, siguiendo las reglas de construccion de identificadores. Por
ejemplo, las siguientes variables son declaradas con una inicializacion por defecto:

int j;
long d;

Ademas, en la situacion adecuada, una variable puede ser declarada como

final, static, transient o volatile, con la siguiente intencion:

final. La variable es considerada como constante, as que su valor no puede

ser cambiado.
static. La variable es una variable de clase, compartida por las instancias
de la clase.
transient. Una variable de instancia es declarada para no ser parte del
estado persistente de los objetos (por ejemplo, si el estado del objeto es
salvado, el valor de la variable transitoria no se incluye).
volatile. Se necesita cuando una variable de instancia se usa por hebras de
control (threads) para prevenir que el optimizador del compilador lo accese.

De todas estas, la palabra clave final es la mas importante, ya que da a Java

un mecanismo para declarar constantes. Variables de instancia, variables locales,
parametros de metodos y parametros de manejo de excepciones pueden ser declara-
dos como final.

Es posible declarar varias variables en la misma declaracion, usando una lista

separada por comas:

int a, b, c;

El nombre de una variable es un identificador. Por convencion, las variables

usualmente comienzan con una letra minuscula, y debe reflejar el proposito de la
variable. Por lo tanto, nombres de variables como position, weight o color se
prefieren sobre p, w, o c.

25
2.7. Inicializacion de Variables
Los requerimientos de inicializacion de variables varan dependiendo del tipo
de variable.

2.7.1. Variables de Clase e Instancia

La practica general es explcitamente inicializar estas variables. Sin embargo,
para cumplir el requerimiento de que toda variable debe ser siempre inicializada,
Java provee valores por defecto de los tipos primitivos y de referencia cuando se
declaran sin inicializacion explcita. El programador por lo tanto tiene la alternativa
de confiar en los valores por defecto o proveer de una expresion de inicializacion
explcita. Se utilizan los siguientes valores por defecto:

byte: (byte) 0
short: (short) 0
int: 0
long: 0l
float: 0.0f
double: 0.0d
char: \u0000 (el caracter nulo)
boolean: false
tipos de referencia: null

Si una variable de referencia es inicializada a ser null, mantiene tal valor sin
referenciar ningun objeto, hasta ser inicializada o definida.

Las variables de clase e instancia pueden ser explcitamente inicializadas en tres

formas:

1. Mediante dar una expresion de inicializacion seguida de un signo = despues

del nombre de la variable:

int i = 100;
char c = d;
float f = 10.345;

2. Por el uso de un inicializador de instancia, el cual es un enunciado compuesto

colocado inmediatamente despues de la declaracion de la variable, y que
contiene enunciados que inicializan la variable:

int i;
{i = 100 * 2 + 5}

26
 3. Por asignacion en el cuerpo de un constructor.

En el caso de una lista de variables en la declaracion, cada variable de la lista

puede explcitamente inicializarse usando expresiones de inicializacion separadas:

int a = 10, b, c = 5;

2.7.2. Variables Parametro

Estas variables son siempre inicializadas para ser una copia del argumento (el
valor usado en el metodo correspondiente o llamada a constructor). No hay control
del programador sobre este mecanismo. Notese que son objetos que se pasan por
referencia, de tal modo que el objeto referenciado es copiado, y no se trata del
propio objeto.

2.7.3. Variables Parametro de Manejo de Excepciones

Estas variables siempre se inicializan como copia del valor arrojado por una
excepcion.

2.7.4. Variables Locales

Todas las variables locales deben, ya sea directa o indirectamente, ser explcita-
mente inicializadas antes de ser usadas. Esto debe hacerse por una expresion de
inicializacion o inicializador:

{
int i = 10;
...
}

o por una asignacion hecha de la variable antes de ser usada en cualquier otra
expresion:

{
int i;
... // donde no hay enunciados que utilicen i
i = 10; // asigna un valor a i
... // i puede ser ahora usada
}

El compilador de Java verifica que una inicializacion o asignacion apropiada haya

sido hecha antes del uso de la variable, reportando un error si no se ha realizado de
esta manera.

27
2.7.5. Variables Finales
Normalmente una instancia final o variable local se inicializan como parte de
una declaracion, como se muestra anteriormente. Sin embargo, una variable final
vaca (blank final) se permite tambien, en la cual la inicializacion es diferida. Antes
de usar una variable final vaca, esta debe ser inicializada por asignacion, tras lo
cual no podra ser modificada.

El siguiente programa muestra algunas variables locales inicializadas y usadas.

Notese el uso de la variable final vaca:

import java.util.Date;
import java.util.Vector;

public class Var1 {

public static void main(String [] args) {
// Inicializacion de variables con expresiones
int i = 1;
String s = "Hola";
Date d = new Date();
final Vector v = new Vector(); // v es una constante
int j; // j se declara pero no se inicializa aqui
// j no puede usarse aqui
j = 4; // j se asigna aqui antes de ser usada
// j puede usarse aqui. Si no ha sido asignada
// el compilador reportara un error en esta linea

System.out.println(j);

final int q; // Declaracion de variable final vacia

// Aqui no debe usarse q aun
q = 10; // Inicializacion de q
// Aqui, el valor de q no puede modificarse
// por asignacion

// q = 20; // Error, si se quita el comentario

// A continuacion, la declaracion e inicializacion de

// tres variables en el mismo enunciado. Notese que
// para inicializar valores float, tales valores
// deben incluir f o F, o el compilador asumira que son
// doubles, por lo que habra un error de tipos

float a = 1.0f, b = 2.0f, c = 3.0f;

}

28
 // Declaracion e inicializacion de una variable de clase
static int m = 10;

// Declaracion e inicializacion de una variable de instancia,

// usando un enunciado inicializador
int n;
{ n = m * 2 }
}

29
2.8. Arreglos de Variables
Los arreglos son contenedores de objetos y pueden almacenar un numero fijo
de elementos (o valores) que pueden ser accesados mediante indexado del propio
arreglo. Una variable del arreglo mantiene una referencia al objeto arreglo que es
creado por una expresion de inicializacion del arreglo. Los corchetes se utilizan para
denotar arreglos:
int [] x = ...;
donde se declara una variable x a ser una variable de tipo array de int.

Como en el caso de las variables simples, los arreglos pueden declararse e ini-
cializarse en expresiones de la forma:

tipo [ ] identificador;
o
tipo [ ] identificador = expresion de inicializacion del arreglo;
o
tipo identificador [ ];
o
tipo identificador [ ] = expresion de inicializacion del arreglo;

Arreglos multidimensionales pueden ser declarados mediante repetir pares de

corchetes ([ ]) para la dimension requerida.

Inicializadores de arreglos tambien son premitidos:

tipo identificador [ ] = { lista de inicializacion};

Esto, en realidad, es la abreviacion de:

tipo identificador [ ] = new tipo [ ] { lista de inicializacion};

El tamano del arreglo no se especifica en la declaracion del tipo arreglo, pero

se requiere cuando la variable es inicializada. El tamano debe expresarse siempre
mediante un valor (o variable) de tipo entero int:
char [] x = new char[10];
Esta expresion crea un arreglo de diez objetos de tipo char. Una vez creado, el
tamano del arreglo no puede cambiarse, pero la variable arreglo puede ser reasig-
nada para referenciar un arreglo del mismo tipo, pero tamano diferente. El ejemplo
anterior muestra que declarar una variable arreglo es diferente de realmente crear
una variable arreglo. Como las variables sencillas, las variables arreglo deben ser
siempre inicializadas antes de ser usadas.

Pueden declararse arreglos de cualquier tipo (incluso, tipo arreglo), sobre los
cuales el compilador de Java realiza una verificacion de tipos para asegurarse que
los valores del tipo correcto se almacenan en el arreglo:

30
 String [] palabras = new String[100];

Despues de que un arreglo se ha creado, es posible determinar el numero de

elementos que puede contener utilizando la expresion:

int longitud = palabras.length;

donde length es una variable de instancia que representa el tamano o longitud del
arreglo.

Arreglos multidimensionales pueden declararse mediante anadir conjuntos de

corchetes. Por ejemplo, considerense las siguientes declaraciones e inicializaciones
para arreglos de dos, tres y cuatro dimensiones:

int [][] dosD = new int [10][10];

// arreglo de 10 por 10

float [][][] tresD = new float [8][10][12];

// arreglo de 8 por 10 por 12

boolean [][][][] cuatroD = new boolean [4][8][12][16];

// arreglo de 4 por 8 por 12 por 16

Un arreglo multidimensional es efectivamente una arreglo de arreglos (y de

arreglos, de arreglos, etc.), as que cada dimension se representa por otro objeto
arreglo.

El tamano de un arreglo mutidimensional puede tambien determinarse por la

variable length:

int longitud = dosD.length;

En este caso, se retorna el numero de los elementos de la primera dimension (el

cual es de 10, utilizando la declaracion anterior de dosD). La longitud de las demas
dimensiones, que se representa por objetos arreglo, puede encontrarse usando una
expresion de indexacion para retornar un elemento del arreglo, y preguntando por
su longitud:

int longitud = dosD[1].length; // longitud de la segunda

// dimension

Cuando se declaran arreglos multidimensionales, debe pensarse cuidadosamente

en el tamano total y la resultante cantidad de memoria usada por el arreglo. Es
facil declarar un arreglo que use una gran cantidad de memoria.

En los ejemplos anteriores se ha definido el tamano del arreglo mediante valores

enteros. De hecho, una expresion entera con valor puede ser usada para especificar
el tamano de un arreglo:

31
 double [][] d = new double [renglones][columnas];

Los arreglos multidimensionales se almacenan en forma de renglones. Para un

arreglo bidimensional. Esto significa que la primera dimension indica el numero de
renglones, y la segunda dimension la longitud de cada renglon (o sea, el numero de
columnas). Para arreglos con mas dimensiones, se aplica el mismo principio basico.

De la misma manera en que las variables de tipos primitivos pueden ser ini-
cializadas directamente, tambien lo son los elementos de un arreglo. El siguiente
ejemplo muestra la sintaxis necesaria:

int [] n = {1,2,3,4,5};

Una lista de inicializacion se delimita por llaves ({ }), con un valor para cada
elemento del arreglo separado por comas. Notese que las llaves aqu no denotan un
enunciado compuesto. El ejemplo anterior crea un arreglo de tamano 5, determina-
do por la longitud de la lista de inicializacion, e inicializa cada elemento siguiendo
el orden descrito por los valores de inicializacion. Cuando se usa una lista de ini-
cializacion o usando new, la creacion del arreglo es implcita, por lo que no requiere
ser hecha por el programador.

Los arreglos multidimensionales pueden ser inicializados mediante listas anidadas

de inicializacion:

int [][] m = { {1,2,3,4},{4,5,6,7} };

Esto crea un arreglo de 4 por 4 con el primer renglon inicializado por los valores
1, 2, 3, y 4, y el segundo renglon por 4, 5, 6 y 7. Si se da un conjunto incompleto
de elementos:

int [][] m = { {1,2},{4,5,6,7} };

la inicializacion del arreglo sera aun valida, pero dara un arreglo de tamanos dis-
pares, unicamente con las posiciones de los elementos inicializados a ser accesibles.
El intento de accesar cualquier elemento en una posicion no inicializada genera una
excepcion.

Basado en la sintaxis anterior, es posible hacer inicializaciones de arreglos anoni-

mos (anonymous arrays), lo que permite la declaracion e inicializacion de arreglos
fuera de una declaracion de variables. Por ejemplo, el siguiente enunciado declara
un arreglo anonimo y lo muestra utilizando un comando de impresion a pantalla:

System.out.println(new char [] {h,o,l,a});

Lo que hace que la palabra hola aparezca en la pantalla. En general, la declaracion

e inicializacion de un arreglo anonimo puede aparecer en cualquier momento en que
se hace una referencia a un arreglo del mismo tipo:

32
 int [] n; // Inicializacion por defecto
...
n = new int [] {5,6,7}; // Creacion de un arreglo anonimo y
// asignacion como referencia de n

Si un arreglo no es directamente inicializado, cada elemento del arreglo es ini-

cializado automaticamente al valor por defecto dependiendo de su tipo.

El siguiente ejemplo provee de mas ejemplos de declaracion e inicializacion de

arreglos:

public class Arreglo1 {

public static void main(String[] args) {
int [] i = new int [5]; // Un arreglo de 5 elementos
i = new int [10]; // Es posible asignar un nuevo
// arreglo a i
// Inicializacion de arreglos de cadenas de caracteres
String [] palabras = {"Hello","World"};

// Inicializacion de arreglos 2D de valores double

double [][] matrix = {{1.2, 4.7, 3.4 },
{0.6, -4.5, 9.2},
{10.9, 0.47, -0.98} };
}
}

Finalmente, queda aun el tema de indexado en arreglos. Sin embargo, este tema
se difiere para cubrirse en la seccion de operadores.

33
2.9. Expresiones Primarias
Las expresiones primarias son bloques basicos para la construccion de progra-
mas, que permiten la busqueda de valores que seran manipulados por otras expre-
siones. Las siguientes son expresiones primarias:

Las palabras clave this y super (que seran descritas mas adelante), as como
el valor null

Un valor literal

Una expresion con parentesis:

( expresion )

Una expresion de campo, usando .:

identificador
o
expresion.identificador
o
paquete.identificador

Una expresion indexada de arreglo:

termino [expresion entera]

en donde un termino es cualquier expresion, excepto una expresion de alo-

cacion

Una expresion de llamada de metodo (que sera descrita mas adelante)

Una expresion de alocacion

new tipo ( lista de argumentos)

o
new tipo [ expresion entera ]

Las expresiones de campo permiten el acceso a variables campo o miembro

de los objetos, clases y paquetes, y seran descritan tambien mas adelante. Una
expresion de campo puede usar un caracter ., como en:

objeto.variable;

34
 En este ejemplo, el lado izquierdo es esencialmente una referencia a objeto, y
el caracter . se utiliza para seleccionar una variable con nombre perteneciente
a tal objeto (como se define por su clase).

null evalua la referencia nula y puede ser usado para probar la variable de un
tipo referencia para ver si tiene el valor null:

if (variable == null ) ...

Las expresiones con parentesis permiten la agrupacion de expresiones juntas

en la misma forma en que las expresiones matematicas se agrupan. Mas aun, esto
da un control explcito del orden en que las sub-expresiones de una expresion son
evaluadas. Por ejemplo, normalmente la expresion a + b * c podra ser evaluada
por precedencia de operadores mediante hacer primero la multiplicacion. Usando
los parentesis, es posible forzar la adicion primero: (a + b ) * c. El valor de una
expresion con parentesis es la misma que el valor de la expresion dentro de ella,
as como su tipo.

Las expresiones de indexacion de arreglos se utilizan para localizar elementos

de un arreglo usando la notacion de corchetes. Cuando se usan en una expresion
que evalua una referencia a objeto arreglo (comunmente, una variable de algun tipo
de arreglo), el valor de retorno es una variable que puede ser asignada o buscarse
su valor. Una expresion de indexado de arreglos tpica tiene la forma:

a[1] = 10; // Asigna un valor a una variable indexada

x = a[2]; // Busca el valor de una variable indexada

Para evaluar una expresion de indexacion, primero la expresion o identificador

de la variable a la izquierda de un corchete de apertura ( [ ) es evaluada para
obtener la referencia del objeto arreglo. Si tal evaluacion retorna un valor null, se
genera una excepcion NullPointerException. De otro modo, la expresion dentro
de los corchetes, que debe evaluarse como de tipo int, se evalua para obtener un
ndice entero. El valor del ndice debe ser dentro del rango de cero a la longitud
del arreglo menos uno (el indexado de arreglos comienza en cero, es decir, los
arreglos tienen origen cero). Si el valor del ndice se encuentra dentro del rango, la
variable indexada (un elemento del arreglo) se retorna. Si esto no es as, se genera
la excepcion ArrayIndexOutOfBoundsException.

El indexado de un arreglo multidimensional sucede de la misma manera, me-

diante repetidamente evaluar las expresiones de indexacion de izquierda a derecha.
Por ejemplo:

int [][][] a = ...;

...
a[1][2][3] = 24;

La primera expresion de indexacion a[1] arroja una expresion del tipo int
[][] para la cual la segunda expresion puede ser evaluada. Esta, a la vez, arroja

35
una expresion de tipo int [], la cual retorna el valor requerido de la variable
cuando la expresion de indexacion del tercer arreglo es evaluado.

Las expresiones de alocacion usan la palabra clave new para crear un objeto o
arreglo. La palabra new es seguida por el tipo (ya sea un tipo referencia o primitivo)
y opcionalmente una lista de parametros en parentesis (que pueden estar vacos),
o la creacion de un arreglo utilizando corchetes.

36
2.10. Operadores
Los operadores con mas alta precedencia dentro de una expresion son siempre
aplicados primero. La siguiente lista muestra la precedencia de todos los operadores,
indexado de arreglos, seleccion de campo (usando .), cast y new. La lista va de
la mas alta a la mas baja precedencia. Operadores en el mismo renglon tienen la
misma precedencia:

[] . () ++ --
++ -- + - ~ !
new cast
* / %
+ -
<< >> >>>
< > >= <= instanceof
== !=
&
^
|
&&
||
?
= += -= *= /= %= >>= <<= >>>= &= ^= |=

2.10.1. Operadores de Incremento Posfijo

Java cuenta con dos operadores posfijos de incremento (++) y decremento (--).
Dado que son posfijos, aparecen despues del operando, incrementandolo o decre-
mentandolo en una unidad. El operando debe tratarse de una variable o elemento
de un arreglo. Ambos operandos pueden ser utilizados con tipos entero o de punto
flotante. Por ejemplo:

byte i = 1;
float j = 10.4;
i++; // incrementa i
j--; // decrementa j
// aqui, i == 2 y j == 11.4

Sin embargo, lo que no es obvio dentro de la explicacion anterior es que el valor

de la expresion de incremento o decremento es el valor original de la variable. El
valor actualizado sera disponible la siguiente vez que la variable es utilizada. Por
ejemplo:

37
 int i = 1;
int j = i++; // j se asigna el valor de 1
int k = i; // k se asigna el valor de 2
Esencialmente, estos dos operadores generan efectos colaterales por actualizar
el valor de la variable tras retornar el valor original de la variable.

2.10.2. Operadores Unarios

Los operadores unarios son:
incremento (++) y decremento (--) prefijo
+ y - unarios
el operador complemento por bit ()
el operador complemento logico (!)
Los operadores prefijos ++ y -- pueden utilizarse para tipos enteros y de punto
flotante, es decir, el operando debe ser una variable o un elemento de un arreglo de
tipo entero o punto flotante. Como las versiones posfijas, estos dos operandos tienen
efectos colaterales al incrementar o decrementar una variable en una unidad. Sin
embargo, a diferencia de los operadores posfijos, el valor de una expresion prefija
++ o -- se trata del valor actualizado de la variable. Por ejemplo:
int i = 1;
int j = ++i; // j se asigna el valor de 2
int k = i; // k se asigna el valor de 2
El operador unario + esta disponible para tipos numericos y retorna el valor
de la expresion a la que se aplica sin realizar ninguna operacion (similarmente a la
operacion matematica). Si el tipo del operando es byte, short, o char, al aplicar
+ arroja un tipo int, tras la apropiada conversion de tipos.

El operador unario - esta tambien disponible para tipos numericos, y su apli-

cacion resulta en una negacion aritmetica. Para los tipos enteros, esto se realiza
mediante primero convertir el valor del operando a su equivalente int, y restandolo
entonces de cero. Notese que, debido a la representacion en complemento a dos,
este operador no puede producir un valor positivo al negar un valor negativo entero
mas grande. Para tipos de punto flotante, el operador unario - cambia unicamente
el signo del operando.

El operador complemento por bit puede aplicarse a tipos de datos enteros,

convirtiendolos en tipo int si es necesario. El valor entero es entonces tratado como
una coleccion de bits, cambiando cada cero por un uno y cada uno por un cero. Por
ejemplo:
Antes 11110000110011001010101011111100
Despues 00001111001100110101010100000011

38
 Este operador se utiliza para realizar operaciones de bit (bitwise) sobre numeros
binarios. Es util cuando se requiere operaciones a nivel de bit, como manipulaciones.
Se utiliza como herramienta de programacion de sistemas mas que de programacion
de aplicaciones. Por ejemplo, el siguiente metodo utiliza y el operador de bit &
para retornar un patron de bits con los cuatro bits menos significativos (los cuatro
ultimos) forzados a ser cero:

int maskLastFour(int x){

return x & ~0xf;
}

El operador complemento logico ! se aplica a valores booleanos y realiza una

negacion booleana: si el valor del operando es true, el resultado arroja un valor
false; si es false, arroja un valor de true. Este operador es frecuentemente uti-
lizado en expresiones booleanas asociadas con enunciados if y ciclos while, como
por ejemplo:

boolean ready = false;

while(!ready) {
...
if (...) ready = true;
...
}

Este tipo de programacion puede mejorarse con enunciados de control de flujo

explcitos, como lo muestra el siguiente ejemplo, el cual realiza la misma accion de
control de flujo:

while(true){
...
if (...) break;
...
}

2.10.3. El operador new

El operador new es utilizado para crear nuevos objetos a partir de una clase. El
argumento de new debe tener un identificador de tipo. Si se especifica un identifi-
cador de clase, new puede ser seguido por una lista de parametros que se utilizan
por el constructor. Si un tipo arreglo es especificado, la dimension o dimensiones
del arreglo deben ser dadas. Como palabra reservada, new se discute en detalle en
otros puntos del texto.

2.10.4. El operador cast

Un cast permite cambiar del tipo de una expresion, siempre y cuando el cambio
no viole las reglas de compatibilidad de tipos. Estas reglas restringen las operaciones

39
cast posibles a aquellas que preserven la intencion de los valores, previniendo de
aquellas operaciones que modifiquen substancialmente el valor, como sera un cam-
bio de double a boolean.

Una operacion de cast valida se muestra en el siguiente ejemplo:

float f = 2.3;
int n = (int)f;

La operacion de cast aparece en la segunda lnea como (int)f. El operando es

f, mientras que el operador prefijo consiste en un nombre de tipo entre parentesis.
Tal nombre provee del tipo al que el operando debe ser cambiado. El ejemplo utiliza
un cast para asignar un valor float a una variable int. La asignacion directa de un
float a un int no es posible, pero el cast forza a permitirlo. Notese, sin embargo,
que la operacion cast resulta en una perdida de informacion, ya que todos los
valores decimales del valor float se pierden: el cast provoca el truncamiento del
valor. Por lo tanto, en el ejemplo anterior, n sera inicializado al valor de 2.

Donde es posible, la validez de una operacion cast es verificada durante la

compilacion (compile-time), resultando en un mensaje de error si no es valida. Sin
embargo, algunos tipos de cast requieren ser verificados en tiempo de ejecucion
(run-time), ya que la informacion durante compilacion resulta insuficiente para de-
terminar si un cast es siempre una operacion valida. Si durante tiempo de ejecucion
la verificacion falla, se genera una excepcion.

2.10.5. Operadores Artimeticos

Los operadores aritmeticos son:

Adicion (+)
Sustraccion (-)
Multiplicacion (*)
Division (/)
Residuo ( %)

Todas estas son operaciones que requieren dos datos, realizando esencialmente
las operaciones aritmeticas obvias de adicion, sustraccion, multiplicacion y division.
El operador residuo ( %) es menos familiar, pero simplemente retorna el residuo
entero de una operacion de division.

El aplicar estos operadores puede resultar en una sobrecapacidad (overflow) o

una subcapacidad (underflow), lo que significa que los valores resultantes no pueden
ser representados por el hardware. Si esto ocurre, los valores resultantes se retornan
utilizando tantos bits como sean disponibles, y no arrojan ninguna excepcion. Esto
provoca que el valor parezca ser valido, pero no representa el resultado correcto.

40
 Las operaciones de punto flotante (aquellas que involucran tipos float y double)
son algo mas complicadas, ya que pueden representar los valores mediante NaN (No-
un-numero o not-a-number), que se usa cuando no es posible representar un valor
numerico.

2.10.6. Operador concatenacion de cadenas de caracteres

El smbolo para el operador concatenacion de cadenas de caracteres es + (aun
otra sobrecarga de este smbolo). El operador es seleccionado cuando uno o ambos
operandos son de tipo String. Si solo un operando es de tipo String, entonces el
otro operando es convertido a tipo String. Para los tipos primitivos, esto se lleva
a cabo utilizando conversion automatica. Para los tipos de referencia, la conversion
se realiza mediante invocar la referencia del objeto al metodo toString. Todas las
clases heredan el metodo toString de la clase Object, y generalmente se elabo-
ran para retornar la representacion en cadenas de caracteres apropiada para las
instancias de la clase.

El operador concatenacion se usa frecuentemente en enuncidados de salida:

System.out.println("El valor de i es: " + i);

Este enunciado funciona sin importar el tipo de la variable i.

2.10.7. Operadores de corrimiento

Los operadores de corrimiento son los siguientes:

corrimiento a la izquierda (<<)

corrimiento a la derecha (>>)

corrimiento sin signo a la derecha (>>>)

Comunmente, estos operadores de corrimiento se aplican a datos de tipo int,

que pueden ser manipulados al considerarlos como conjuntos de bits individuales:

int a = 1000;
...
a << 5; // a se recorre 5 bits a la izquierda

a >> 10; // a se recorre 10 bits a la derecha,

// propagando su bit de signo

a >>> 2; // a se recorre 2 bits a la derecha,

// sin propagar su bit de signo

41
2.10.8. Operadores relacionales
Los siguientes operadores relacionales se encuentran disponibles:

igual a (==)

no igual a (!=)

menor que (<)

mayor que (>)

mayor o igual que (>=)

menor o igual que (<=)

objeto como instancia de un tipo (instanceof)

Todos estos operadores arrojan un valor boolean, dependiendo si se cumple o

no la relacion que representan. Normalmente, se utilizan dentro de los enunciados
if y switch, o en los ciclos while, do y for, para controlar su ejecucion (como se
explica mas adelante).

2.10.9. Operadores Logicos a bit

Las tres operaciones logicas se realizan a nivel de bit:

AND logico a nivel bit (&)

OR logico a nivel bit (|)

XOR logico a nivel bit (^)

Cada una de estas operaciones permiten evaluar las operaciones logicas AND,
OR o XOR considerando los operandos como conjuntos de bits individuales. Por
ejemplo, el siguiente codigo imprime una direccion IP de 32 bits que se contiene en
una variable int llamada ip address, como 4 octetos decimales:

for (int i = 3; i >= 0; i--) {

int octeto = (ip_address >>> (i*8)) & 0xFF;
System.out.print(octeto);
if (i != 0)
System.out.print(".");
}
System.out.println();

42
2.10.10. AND y OR booleanos
Los operadores booleanos son:
AND condicional booleano (&&)
OR condicional booleano (||)

Estos operadores requieren dos operandos, y pueden ser aplicados a operandos

del tipo boolean. Del mismo modo, retornan un resultado tipo boolean.

La diferencia crucial entre los operadores && y ||, y los operadores & y |, recae en
la forma en que evaluan sus operandos. && y || primero evaluan su operador del lado
izquierdo. Si el valor del operando es suficiente para determinar el valor de toda la
expresion, la evaluacion del lado derecho no se realiza. Esto significa que cuando
una operacion && se aplica, el operando del lado derecho se evalua solo cuando el
operando del lado izquierdo tiene el valor de true. Si el operando izquierdo tiene el
valor false, el valor de la expresion entera debe ser false, y no es necesario evaluar
el lado derecho para determinar el resultado. Una situacion similar se aplica para la
operacion ||. Si el operando de la izquierda es true, entonces la expresion completa
debe ser true, y el operando de la derecha no necesita ser evaluado.

2.10.11. Operador condicional

El operador condicional es unico, ya que se trata de un operador ternario (toma
tres argumentos). Esencialmente, se comporta como una version comprimida del
enunciado if, y permite la eleccion en la evaluacion de dos expresiones. La estruc-
tura es como sigue:

expresionBooleana ? expresionTrue : expresionFalse

Existen tres operandos: el primero, delante del caracter ?, es una expresion

booleana. El segundo y tercero siguen despues, y se separan entre s por :. Ambas
representan expresiones del mismo tipo, o al menos de tipos compatibles.

Una expresion que usa este operador se evalua como sigue: primero, la expresion
booleana es evaluada. Si tiene el valor true, la expresion inmediatamente despues
de ? se evalua y su resultado se retorna como el resultado del operador. Si por el
contrario, tiene el valor false, la expresion despues de : se evalua y retorna su
resultado como el resultado del operador condicional.

2.10.12. Operadores de asignacion

El operador basico de asignacion es =. Este es un operador binario (con dos
argumentos), que permite asignar el valor del operando de la derecha a una variable
o elemento de arreglo que representa el operando de la izquierda. La asignacion
esta sujeta a las conversiones de tipo implcitas y a las reglas del cast.

43
 Los otros operadores de asignacion son todos binarios, y combinan la asignacion
con varias operaciones aritmeticas o de bit:

+=, -=, *=, /=, %=, |=, &=, ^=, <<=, >>=, >>>=

Cada operador primero realiza la operacion aritmetica, logica o de corrimien-

to indicada, y en seguida realiza la asignacion a la variable correspondiente. Por
ejemplo:

a += 100; // Significa lo mismo que a = a + 100

x *= 2; // Significa lo mismo que x = x * 2

44
2.11. Enunciados
2.11.1. El enunciado if
if (ExpresionBooleana)enunciado
o
if (ExpresionBooleana)enunciado
else enunciado

El enunciado if permite una seleccion en tiempo de ejecucion del programa

acerca de que lneas de codigo se ejecutan o se omiten de la ejecucion. En el caso de
que la evaluacion de la expresion booleana sea verdadera (true), el codigo que sigue
se ejecuta, y en caso contrario (que se evalue como false), se omite. Por otro lado,
el enunciado if puede extenderse mediante anadirle una parte llamada else, que
corresponde a una secuencia de codigo que se ejecuta en caso de que la evaluacion
de la expresion booleana sea false.

El siguiente ejemplo es un programa completo que utiliza el enunciado if:

class IfTest1 {
public static void main (String [] args) {
int a = 1;
int b = 2;
if (a < b ) {
System.out.println("a < b");
}
else {
System.out.println("a >= b");
}
}
}

La condicion de un enunciado if puede ser cualquier expresion booleana, y

puede incluir llamadas a funciones.

class IfTest2 {
public static boolean f (int x, int y) {
return (x < y );
}
public static void main (String [] args) {
int a = 1;
int b = 2;
if (f(a,b)) {
System.out.println("f retorna true");
}
else {

45
 System.out.println("f retorna false");
}
}
}

2.11.2. El enunciado switch

switch (Expresion) {
case constante char/byte/short/int : secuencia de enunciados break;
...
default :secuencia de enunciados
}

Ademas del enunciado if para la seleccion de codigo, existe otro enunciado

llamado switch que permite escoger una entre varias opciones de secuencias de
codigo a ser ejecutado. Su funcionamiento se basa en considerar una expresion que
se va secuencialmente comparando con cada valor constante propuesto (o case)
como resultado de su evaluacion. Si el resultado es verdadero (true) se ejecuta el
codigo correspondiente a esa opcion. La evaluacion se lleva a cabo en el orden en
que los valores propuestos se escriben. Si se desea que el codigo correspondiente
a un solo un valor propuesto sea ejecutado, es necesario anadir un enunciado de
control de flujo break para que la estructura switch no evalue los demas valores
propuestos. Al final, se anade una opcion que recoge cualquier otra posibilidad de
resultado de la evaluacion de la expresion, bajo la etiqueta default.

El siguiente programa recibe un entero y da como salida el nombre del da

correspondiente al entero, considerando el rango de 1 a 7, y asumiendo 1 como
domingo:

class Switch1 {
public static void main (String[] args) {
KeyboardInput input = new KeyboardInput();
System.out.print("Escriba un numero entre 1 y 7: ");
int day = input.readInteger();
switch (day) {
case 1: System.out.println("Domingo"); break;
case 2: System.out.println("Lunes"); break;
case 3: System.out.println("Martes"); break;
case 4: System.out.println("Miercoles"); break;
case 5: System.out.println("Jueves"); break;
case 6: System.out.println("Viernes"); break;
case 7: System.out.println("Sabado"); break;
default:System.out.println(day + " no es dia"); break;
}
}
}

46
 Si un entero entre 1 y 7 se da como entrada, el nombre del correspondiente
da de la semana se escribe en pantalla, utilizando el switch para seleccionarlo.
Si el numero es mayor que 7 o menor que 1, el mensaje por defecto (default) se
despliega. Cualquiera que sea la entrada, solo el mensaje cuya etiqueta corresponda
a la entrada se despliega.

El enunciado switch puede utilizar tipos char, byte, short, e int. El siguiente
ejemplo funciona con char:

class Switch2 {
public static void main(String [] args) {
KeyboardInput input = new KeyboardInput();
System.out.print("Escriba una vocal y presione retorno: ");
char c = input.readCharacter();
switch(c) {
casea : System.out.println("Se escribio a"); break;
casee : System.out.println("Se escribio e"); break;
casei : System.out.println("Se escribio i"); break;
caseo : System.out.println("Se escribio o"); break;
caseu : System.out.println("Se escribio u"); break;
default: System.out.println("No es una vocal"); break;
}
}
}

47
2.12. Ciclos
2.12.1. El ciclo while
while ( expresion booleana)enunciado

El ciclo while se utiliza para ejecutar repetidamente una secuencia de lneas

de codigo, mientras la evaluacion de una condicion booleana se mantenga como
verdadera (true). El siguiente programa ilustra el uso basico de los ciclos while,
mostrando dos ciclos que usan la variable n para determinar cuando terminar.
El primer ciclo incrementa n y cuenta hacia arriba mientras que el segundo ciclo
decrementa n y cuenta hacia abajo.

public class While1 {

public static void main (String[] args) {
int n = 0;
while (n < 10) {
System.out.println("Contando hacia arriba " + n);
n++;
}
while (n > 0) {
System.out.println("Contando hacia abajo " + n);
n--;
}
}
}

2.12.2. El ciclo do
do enunciado while (Expresion booleana) ;

En ocasiones, es necesario que un codigo que potencialmente puede ser cclico

se ejecute al menos una sola vez, en cuyo caso el ciclo do puede utilizarse. El ciclo
do permite que las lneas de codigo que encierra se ejecuten al menos una vez, antes
de realizar la evaluacion de la expresion booleana. Si tal evaluacion resulta con un
valor verdadero (true), entonces el ciclo se vuelve a repetir. En caso contrario, la
ejecucion continua con la siguiente instruccion. El siguiente ejemplo muestra dos
ciclos do tpicos:

public class Do1 {

public static void main (String[] args) {
int n = 0;
do {
System.out.println("Contando hacia arriba " + n);
n++;
} while (n < 10 );

48
 do {
System.out.println("Contando hacia abajo " + n);
n--;
} while (n > 0);
}
}

2.12.3. El ciclo for

for (Expresion inicial;Expresion booleana;Expresion de actualizacion)
enunciado

El ciclo for permite la repeticion controlada de una secuencia de lneas de codi-

go. La repeticion se controla mediante una serie de expresiones: la expresion inicial
debe dar como resultado un valor con el cual el ciclo for comienza su iteracion;
la expresion booleana determina la condicion de terminacion del ciclo, es decir, la
ejecucion continua en el ciclo si la evaluacion de la expresion booleana es verdadera
(true) y termina si es falsa (false); la expresion de actualizacion permite cambiar
el valor dado por la expresion inicial, idealmente hasta que la expresion booleana
se evalua como falsa.

El primer ejemplo es equivalente a los ejemplos para los ciclos while y do:

public class For1 {

public static void main (String[] args){
for (int i = 0; i < 10; i++) {
System.out.println("Contando hacia arriba " + i);
}
for (int i = 10; i > 0; i--) {
System.out.println(Contando hacia abajo " + i);
}
}
}

Un uso tpico del ciclo for es en conjuncion con el indexado de un arreglo (o

vector). La variable del ciclo es usada para indexar el arreglo:

public class For2 {

public static void main (String[] args) {
int[] x = new int[10];
for (int i = 0; i < 10; i++) {
x[i] = i;
}
for (int i = 0; i < 10; i++) {

49
 System.out.println(x[i]);
}
}
}

Finalmente, el siguiente ejemplo muestra un programa que toma una cadena

dada como argumento del programa, e imprime una version convirtiendo los carac-
teres de mayusculas a minusculas:

public class For 3 {

public static void main (String[] args) {
if (args.length == 0 ){
System.out.println("No hay cadena que transformar");
}
else {
for (int i = 0; i < args.length; i++ ) {
String s = args[i];
char[] result = new char[s.length()];
for (int j = 0; j < s.length(); j++) {
result[j] = Character.toLowerCase(s.charAt(j));
}
System.out.println(result);
}
}
}
}

50
2.13. Control de ejecucion
2.13.1. break
break;
o
break etiqueta;

El enunciado break puede ocurrir en cualquier parte dentro de los enunciados

switch, for, while o do, y causa que la ejecucion salte al enunciado siguiente a
partir del enunciado mas interno donde se aplica. Intentar utilizar el enunciado
break fuera de cualquiera de los enunciados mencionados causa un error en tiempo
de compilacion.

El siguiente ejemplo muestra el uso basico de break para terminar un ciclo

cuando una variable tiene cierto valor. En este caso, el ciclo continua pidiendo al
usuario que escriba un dgito hasta que se da como entrada un 5.

public class Break1 {

public static void main(String[] args){
KeyboardInput in = new KeyboardInput();
while (true) {
System.out.print("Escriba un digito: ");
int n = in.readInteger();
if (n == 5) {
System.out.println("Escribio un 5. Termina");
break;
}
}
}
}

La expresion boolena del ciclo while tiene el valor de true, de tal modo que
tal ciclo potencialmente es infinito. Usando el enunciado break se provee de una
forma conveniente de salir de un ciclo sin introducir una variable booleana.

2.13.2. continue
continue;
o
continue etiqueta;

El enunciado continue puede ocurrir dentro de los enunciados switch, for,

while o do, y causa que la ejecucion salte al final del cuerpo del ciclo, listo para
iniciar la siguiente iteracion. Un intento de utilizar continue fuera de los enunciados
provocara un error en tiempo de compilacion.

51
 El siguiente ejemplo usa continue para mostrar que parte del cuerpo de un
ciclo puede saltarse facilmente si es necesario.

public class Continue1{

public static void main (String[] args){
KeyboardInput in = new KeyboardInput();
for (int i = 0; i < 10; i++) {
System.out.print("Escriba un digito: ");
int n = in.readInteger();
if (n == 0) {
System.out.println("Division entre cero");
continue;
}
System.out.println("100/" + n + " = " + 100.0/n);
}
}
}

Como dividir entre cero no puede producir un resultado valido, el enunciado

continue se utiliza para saltar el enunciado que contiene la division (si la division
entre cero continuara, el resultado sera el valor que representa infinito). Notese
como se ha utilizado la constante double 100.0 (en lugar de la constante int
100) para forzar el uso de artimetica flotante en la division.

2.13.3. return
return;
o
return expresion;

Un enunciado return puede aparecer en cualquier parte del cuerpo de un meto-

do y en multiples lugares. Un metodo no-vaco debe contener al menos un enunciado
return. El siguiente ejemplo incluye un metodo min que retorna el mnimo de dos
argumentos:

public class Return1 {

private static int min (int a, int b){
if (a < b) return a;
else return b;
}
public static void main( String[] args) {
System.out.println("El menor de 5 y 8 es: " + min(5,8));
}
}

52
Captulo 3

Programacion Orientada a
Objetos en Java

3.1. Clases
3.1.1. Declaracion de clases
La declaracion de una clase introduce un nuevo tipo de referencia del mismo
nombre. Una clase describe la estructura y comportamiento de sus instancias u
objetos en terminos de variables de instancia y metodos. La accesibilidad de las
variables y metodos puede ser explcitamente controlada, permitiendo a la clase
actuar como una unidad de encapsulacion.

class identificador{
declaraciones del constructor
declaraciones de metodos
declaracion de metodos estaticos
declaracion de variables de instancia
declaraciones de variables estaticas
}

Una clase se introduce por la palabra clave class, la cual se sigue de un iden-
tificador que da nombre a la clase. Por convencion, el nombre de una clase siempre
comienza con mayuscula. El cuerpo de la clase se delimita entre llaves, y puede
contener una serie de declaraciones de variables, metodos, clases o interfaces. La
palabra clave class puede precederse de los modificadores, como se muestra en las
secciones subsecuentes.

El nombre de la clase introduce un nuevo nombre de tipo de referencia, per-

mitiendo la declaracion de variables de ese tipo. Un tipo de variable de referencia
mantiene una referencia a un objeto o instancia de la clase. Un objeto se crea usando

53
el operador new en una expresion de alojamiento en memoria, como por ejemplo:
Stack s = new Stack();
Una clase actua como una unidad de encapsulacion y crea un entorno de clase.
Todas las clases son declaradas dentro de un paquete (package), el cual puede ser el
paquete anonimo por defecto (default anonymous package). Ademas, normalmente
una clase esta contenida en un archivo fuente o unidad de compilacion, que es parte
de un paquete. Ambos, el paquete y el archivo, proveen entornos. En general, a
menos que este anidada, cada clase se declara en un archivo fuente por separado,
pero es posible tambien tener varias declaraciones de clases en el mismo archivo.

El nombre del archivo fuente que contiene la declaracion de una clase debe ser el
mismo que el nombre de la clase que contiene, con la extension .java. Por ejemplo,
la clase Stack debe ser almacenada en un archivo con el nombre Stack.java. Si hay
varias clases dentro del mismo archivo fuente, el archivo debe nombrarse a partir
de la unica clase publica que contiene. Si esto no se hace correctamente, el archivo
fuente no podra ser compilado.

El entorno de clase permite que cualquier expresion dentro de la declaracion

de una clase pueda usar cualquier variable de instancia o metodo declarado en la
clase. El orden de las declaraciones no es importante, a diferencia del orden de los
entornos. Una consecuencia significativa del entorno de clase es que las variables y
metodos de cualquier objeto de una clase son accesibles a cualquier metodo de la
propia clase (vease el ejemplo siguiente). Esto significa que aun cuando los obje-
tos son en general fuertemente encapsulados, dentro de su clase la encapsulacion
depende de su entorno de clase.

El siguiente ejemplo ilustra la declaracion de una clase, apuntando los efectos

del entorno de clase:

class ClassScope {
// Una variable privada solo accesible dentro del entorno de
// la clase
private int n = 1;

// El siguiente metodo ilustra que las variables privadas de

// cualquier objeto de la clase ClassScope pueden ser accesadas
// por un metodo de ClassScope
public void alter(final ClassScope c) {
// c es le parametro, no el objeto que llama al metodo, pero
// la variable n puede ser aun accesada.
c.n = 123;
}

// El siguiente metodo despliega el valor de un objeto usando

// el valor de la variable privada n

54
 public String toString() {
return new Integer(n).toString();
}
}

// La siguiente clase prueba el comportamiento de la clase ClassScope

public class ScopeTest {

public static void main (String [] args) {
// Es correcto crear objetos ClassScope y usar sus metodos
// publicos
ClassScope a = new ClassScope();
ClassScope b = new ClassScope();

// Notese que la variable privada n perteneciente al objeto

// referenciado por b puede ser modificada por un metodo
// llamado por un objeto de la misma clase referenciada
// por a
a.alter(b);

System.out.println("Objeto a: " + a);

System.out.println("Objeto b: " + b);

// Sin embargo, no es posible romper la encapsulacion de

// un objeto ClassScope desde aqui. El no comentar
// la siguiente linea causaria un error de compilacion.
// Esto es cierto aun cuando se coloque esta linea en
// cualquier metodo a~adido a esta clase
// a.n = 123;
}
}

3.1.2. Publico, Privado y Protegido

Cualquier declaracion dentro del entorno de una clase puede precederse de una
de las siguientes palabras clave (conocidas tambien como modificadores de acceso):

public, protected, private

El uso de los modificadores de acceso es opcional, y puede ser omitido. Las

palabras clave tienen el siguiente significado:
public hace que una declaracion sea accesible por cualquier clase.
protected hace una declaracion accesible por cualquier subclase de la clase
que se declara, o a cualquier clase dentro del mismo paquete (notese que esta

55
 semantica difiere de aquella utilizada en C++. Sin embargo, parece ser que
C++ esta en lo correcto, mientras que Java parece tenerlo errado).
private hace una declaracion accesible solo dentro de la clase en que se
declara.
Si no se provee ninguna de estas tres palabras clave, se dice que la declaracion
tiene accesibilidad por defecto (default accesibility), lo que significa que es accesible
por cualquier otra clase dentro del mismo paquete. Notese, sin embargo, que tal
declaracion no es accesible a cualquier subclase dentro de un paquete diferente, por
lo que se concluye que la accesibilidad por defecto se controla estrictamente por el
entorno de paquete.

Como conclusion, las siguientes declaraciones (por ejemplo) pueden aparecer

dentro de una clase:

public void metodo1() {...}

private int metodo2() {...}
protected int x = 1;
private Stack s;
float metodo3() {...}
String t = "Hola";

3.1.3. Variables de Instancia

Las variables de instancia deben ser escogidas de tal forma que representen el
estado de los objetos de una clase. Pueden ser de cualquier tipo, incluyendo aquel
de la clase dentro de la cual se declaren (de esta forma, los objetos de la clase
pueden mantener referencias a otros objetos de la misma clase). Por convencion,
una variable de instancia comienza con una letra minuscula.

Las reglas para la inicializacion requieren que las variables de instancia sean
inicializadas cuando se declaran, o se hace una inicializacion por omision. Tambien,
es necesario que el programador decida si se trata de una variable publica, privada,
protegida o de acceso por defecto.

Una variable de instancia puede ser declarada como final, lo que significa que
es una constante y no puede ser cambiada por asignacion. Esto resulta muy util
si la variable debe ser publica y debe tambien siempre ser usada sin cambio en el
valor inicial de la variable.

El siguiente programa declara varias variables de instancia:

class Class1{
public String hello = "hello";
public final String world = "world";
protected int count = 0;
private float length = 2.34f;

56
 long size = 12356L;
}

En este caso la clase solo consiste de declaraciones de variables de instancia.

Esto es legal, pero normalmente solo se usa si sus instancias u objetos se utilizan
como simples estructuras de datos que son parte de la infraestructura de otra clase.

3.1.4. Variables Estaticas o de clase

Una variable estatica pertenece a una clase y no es parte del estado de los
objetos individuales de la misma. Solo existe una copia de cada variable estatica.
Las variables estaticas son llamadas frecuentemente variables de clase.

Las variables de clase tienen varios usos distintos:

Como variables compartidas por todas las intancias de la clase. Como tales,
pueden describirse como globales dentro del entorno de la clase, y son
tpicamente declaradas como privadas.
Como variables accesibles a todos los clientes de la clase. As, son efectiva-
mente globales para un programa entero, y necesitaran ser declaradas como
publicas. Tales variables, al poderse actualizar por cualquier trozo de codigo,
representan un gran peligro y por lo tanto son extremadamente raras.
Como constantes declaradas como final. Tpicamente tales constantes son
hechas publicas para ser usadas en cualquier sitio dentro de un programa.
Muchas bibliotecas de Java hacen uso de tales variables declaradas como
public static final. Por convencion sus nombres se escriben con letras
mayusculas.
Una variable estatica puede ser accesada por cualquier metodo o cualquier
metodo estatico del mismo entorno de clase simplemente usando su nombre. Los
clientes fuera del entorno de la clase necesitan usar una expresion de campo usando
el nombre de la clase, como por ejemplo:

Integer.MAX_VALUE;

que accesa a la variable MAX VALUE declarada en la clase Integer.

La siguiente clase declara y usa algunas variables estaticas:

import java.util.Vector;

class Static1 {
// Constantes accesibles publicamente
public final static int UP = 1;
public final static int DOWN = 2;

// Variable de clase publicamente accesible que puede ser

57
 // modificada por asignacion
// NO SE HAGA ESTO EN UN PROGRAMA REAL,
// A MENOS QUE *REALMENTE* SEA NECESARIO
public static String s = "default";

// Variables de clase privadas

private static float f = 3.141f;
private static Vector v = new Vector();

// Variables estaticas que pueden ser accesadas desde un metodo

// No es posible decir realmente si son variables de clase o de
// instancia por su uso
public void test() {
int i = UP;
s = "hello";
v.addElement(s);
}

public static void main (String args[]) {

// Las variables estaticas pueden accederse desde un
// metodo estatico
s = "hello";
v.addElement(s);
Static1 s1 = new Static1();
s1.test();
}
}

Este codigo muestra que las variables estaticas pueden ser directamente acce-
sadas por ambos tipos de metodos, normales y estaticos.

3.1.5. Clases de alto nivel

Una clase de alto nivel es una clase ordinaria declarada al nivel del entorno
de paquete (package scope level), el mas alto nivel en el que una clase puede
ser declarada, y por lo tanto, se le llama clase de alto nivel. Las clases de alto
nivel pueden opcionalmente ser declaradas como public, abstract o final, con
los siguientes significados:

public. Una clase publica es globalmente accesible, y puede ser utilizada

por cualquier otra clase. Para ser utilizada por una clase en otro paquete,
es necesario declarar un enunciado de importacion (import statement) en
el archivo fuente conteniendo la clase, a menos que la clase pertenezca al
paquete por defecto. Un archivo fuente unico puede solo tener una clase o
interfaz publica.

58
 abstract. Una clase abstracta no puede tener intancias u objetos, y es
disenada para que se herede de ella.

final. Una clase final no puede ser heredada, es decir, no puede tener sub-
clases

Si una clase de alto nivel no es declarada como publica, solo puede ser accesada
por las otras clases dentro del mismo paquete. De otra manera, las clases de alto
nivel se comportan tal y como se ha descrito.

3.1.6. Clases anidadas

Una clase anidada o interna se declara dentro de un entorno anidado en otra
clase. Hay diferentes tipos de clases anidadas: clases anidadas de alto nivel, clases
miembro, clases locales, y clases anonimas. Las clases anidadas no pueden ser
declaradas usando los modificadores native, synchornized, transient o volatile.

Clases anidadas de alto nivel

Una clase anidada de alto nivel es una clase estandar declarada dentro del
entorno de una clase de alto nivel. Esto permite que el nombre de la clase sea sujeto
a las reglas de entorno y encapsulacion de clase. En particular, una clase anidada
puede ser declarada como privada, de tal modo que solo es accesible dentro de la
clase en que se le declara.

Las clases anidadas de alto nivel pueden ser decladas como publicas, requiriendo
que su nombre sea cualificado por el nombre de la clase donde estan anidadas, y si
son usadas por otras clases:

ClaseExterna.ClaseInterna c = new ClaseExterna.ClaseInterna();

Esto puede ser util si el entorno del nombre de la clase anidada necesita ser
restringido. Sin embargo, de manera mas comun, las clases anidadas de alto nivel
son declaradas protegidas o privadas, y actuan como bloques de construccion de las
estructuras de datos internas de la clase donde estan anidadas. Por ejemplo, una
clase de listas ligadas puede tener una estructura interna consistente en una cadena
de objetos nodo. Cada nodo podra ser una instancia de una clase anidada de alto
nivel. La clase se hace privada ya que no hay necesidad de que los clientes de la
lista sepan acerca de ella o intenten usarla; simplemente, funciona como una pieza
de la estructura interna.

Una clase anidada de alto nivel puede accesar variables estaticas declaradas en
su clase residente aun cuando sean declaradas como privadas, pero no tiene acceso
a las variables de instancia. Clases anidadas de alto nivel pueden contener aun mas
clases anidadas de alto nivel.

59
 El siguiente ejemplo usa una clase anidada de alto nivel llamada CountedString.
Los objetos de la clase asocian una cuenta con una cadena de caracteres, de tal mo-
do que la clase StringCounter puede usarlas para contar el numero de veces que
una cadena de caracteres se anade usando el metodo addString. Notese que las
variables de instancia de CountedString no son privadas y pueden ser directamente
accesadas por la clase residente. Esta decision se hace debido a que la clase anidada
se usa como bloque de construccion, y no requiere una fuerte encapsulacion.

import java.util.Vector;

class StringCounter {

private static class CountedString {

public CountedString(String s) {
item = s;
}
String item;
int count = 1;
}

// Si el argumento String ya existe, incrementa el contador.

// De otra forma, a~ade un nuevo objeto CountedString con
// valor count = 1
public void addString(String s) {
CountedString tmp = searchFor(s);
if (tmp == null) {
items.addElement(new CountedString(s));
}
else {
tmp.count++;
}
}

// Retorna el numero de veces que una cadena ha sido a~adida

public int getCount(String s) {
CountedString tmp = searchFor(s);
return tmp == null ? 0 : tmp.count;
}

// Metodo auxiliar privado

// Si una cadena ha sido a~adida, retorna su objeto
// CountedString. De otra manera, retorna null
private CountedString searchFor(String s) {
for (int i = 0; i < items.size(); i++) {
CountedString c = (CountedString)items.elemtAt(i);

60
 if ((c.item).equals(s)) return c;
}
return null;
}

public static void main(String[] args) {

StringCounter c3 = new StringCounter();
c3.addString("hello");
c3.addString("world");
c3.addString("hello");
c3.addString("world");
c3.addString("hello");
c3.addString("world");
c3.addString("hello");
c3.addString("world");
c3.addString("hello");
c3.addString("world");

System.out.println("hello ha sido a~adida " +

c3.getCount("hello") + " veces");

System.out.println("world ha sido a~adida " +

c3.getCount("hello") + " veces");
}

private Vector items = new Vector();

}

Clases miembro
Una clase miembro es una variedad de clase anidada o interna que no es declara-
da como estatica. Un objeto de una clase miembro es directamente asociado con el
objeto de la clase residente que lo ha creado, y automaticamente tiene referencia
implcita a el. Como resultado, el objeto de la clase miembro tiene acceso directo a
las variables de instancia del objeto de la clase residente.

Las clases miembro comparten las caractersticas estandar de las clases anidadas,
pero no pueden ser declaradas estaticas, ni pueden declarar variables estaticas,
metodos, o clases anidadas de alto nivel. Una clase miembro no puede tener el mis-
mo nombre de ninguna de las clases residentes o de paquetes (lo cual es diferente
de las reglas acerca de los nombres de variables y metodos).

Las palabras clave this, new, y super tienen una sintaxis extendida para usarse
en clases miembro:

nombreDeLaClase.this

61
 referenciaAObjeto.new
referenciaAObjeto.super

Un objeto de una clase miembro (u objeto miembro) tiene una referencia im-
plcita al objeto de la clase residente que lo ha creado, el cual es automaticamente
anadido por el compilador de Java. Esto permite el acceso al estado del objeto de
la clase residente. El acceso en la direccion contraria (de la clase residente a la clase
miembro) respeta la encapsulacion del objeto de la clase miembro, de tal modo que
sus variables y metodos privados no pueden ser accesados directamente.

Los objetos miembro son tpicamente usados para crear estructuras de datos,
cuyos objetos necesitan saber que objeto los contiene, y ayudan a accesar tales
estructuras de datos. El ejemplo principal de esto son los objetos de enumeracion,
los cuales iteran a traves de estructuras de datos privadas.

Para dar soporte a las clases miembro se provee de muchos otros tipos de
expresiones extra. La primera es una extension a las expresiones con this. Una
expresion como:

x = this.yes;

sera solo valida si yes es una variable de instancia declarada por la clase miembro,
y no si yes es declarada por la clase residente. Si yes pertenece a la clase residente,
entonces tiene que ser accesada usando una expresion como:

x = TestClass.this.yes;

donde TestClass es el nombre de la clase residente.

Las clases anidadas pueden declararse formando diferentes niveles, y a cualquier

profundidad, pudiendo utilizar el mecanismo de this para la anidacion. Por ejem-
plo, la clase C es anidada en B, la cual es anidada en la clase A:

class A {
class B {
class C {
...
int c;
void f() {
A.this.a; //Variable declarada en la clase A
B.this.b; //Variable declarada en la clase B
this.c; //Variable declarada en la clase C
}
}
...
int b;

62
 }
...
int a;
}

Esto permite que las variables declaradas en cada clase residente puedan ser
accesadas mediante nombrar la clase en una expresion this. Notese que una expre-
sion como:

A.B.C.this.a;

no es valida, dado que la clase residente debe ser nombrada directamente.

La siguiente expresion adicional involucra al operador new. Los objetos de las

clases miembro pueden solo ser creados si tienen acceso a un objeto de la clase
residente. Esto ocurre por defecto si el objeto de la clase miembro se crea por un
metodo de instancia perteneciente a su clase residente. De otra forma, es posible
especificar un objeto de la clase residente usando el operador new de la siguiente
forma:

B b = a.new B(); // Notese la sintaxis referenciaAObjeto.new

donde el operador new se precede por la referencia al objeto, seguido por el operador
punto. Esto significa crear un nuevo objeto miembro B usando el objeto referenciado
por la variable a (la cual debe ser una instancia de la clase residente correcta). El
nuevo objeto miembro tendra entonces acceso al estado del objeto referenciado por
a.

La sintaxis de esta forma de expresion new puede ser sorpresiva al principio.

Si una clase C esta anidada en una clase B, la cual esta anidada en una clase A,
entonces es posible escribir el siguiente enunciado valido:

A.B.C c = b.new C(); // donde b es referencia a un objeto de B

Esto significa declarar una variable llamada c de tipo C la cual esta anidada
en B, que a la vez esta anidada en A (notese la parte A.B.C). Entonces crea un
nuevo objeto C dada una referencia de un objeto de tipo B. Notese que se usa una
expresion b.new C(), y no algo como b.new A.B.C(). Esto se debe a que la clase
de un objeto a ser creado se da relativo a la clase del objeto residente. La seccion
de ejemplos ilustra mas adelante esta sintaxis.

La tercera y final adicion a los tipos de expresiones se refiere a super, y se cubre

en una seccion posterior.

Una consecuencia del acceso de una clase miembro a su clase residente es que
las reglas de entorno se vuelven mas complicadas, ya que ahora hay dos formas de

63
considerar un nombre: (a) usando la jerarqua de herencia, y (b) usando la jerarqua
de contencion de objetos residentes.

El siguiente ejemplo muestra el uso basico de las clases y objetos miembro:

class Class5 {
private class Member {
// Este metodo muestra que las variables de instancia
// privadas del objeto de la clase residente pueden ser
// accesadas
public void test() {
i += 10;
System.out.println(i);
System.out.println(s);
}
}

// Este metodo crea un objeto de la clase Member el cual

// tiene acceso al estado privado del objeto que lo crea
public void test() {
Member n = new Member();
n.test();
}

public static void main (String[] args) {

Class5 c5 = new Class5();
c5.test();
}

private int i = 10;

private String s = "hello";
}

Clases Locales
Una clase local es aquella declarada dentro del entorno de un enunciado com-
puesto, es decir, es local al cuerpo del metodo o inicializador de instancias en que
se encuentra, como si fuera una variable local. Con ciertas restricciones, una clase
local es tambien una clase miembro, ya que es creada dentro del objeto de una
clase residente. As como cualquier clase miembro tiene acceso a datos miembros
en cualquier clase residente, una clase local tiene acceso a cualquier variable de
parametro o local (sujeto al orden de declaracion) que se declaran en el mismo
entorno, siempre y cuando tengan el modificador final.

Si una referencia al objeto de una clase local permanece despues de que su

entorno de creacion ha sido terminado (por ejemplo, como referencia de retorno de

64
un metodo), entonces el objeto local permanece en existencia, manteniendo acceso
a los parametros finales o variables locales finales de su entorno de creacion.

El nombre de una clase local no puede ser el mismo de su clase o paquete

residente. Las clases locales no pueden incluir variables, metodos o clases estaticas.
Ademas, no pueden ser declaradas como publicas, protegidas, privadas o estaticas.
De hecho, una clase local puede usar la sintaxis extendida que se presenta para las
clases miembro respecto a la referencia this, pero no para new y super.

Las clases locales son esencialmente clases miembro declaradas en un entorno

local y, como resultado, estan sujetas a reglas y restricciones adicionales. La nue-
va caracterstica mas importante de las clases locales es su habilidad de accesar
variables y parametros finales en su entorno de declaracion. Esto da una limitada
capacidad a los objetos de las clases locales de retener el estado del entorno local
despues de haber salido del entorno.

Tpicamente, una clase local es declarada en un metodo como implementando

un tipo interfaz, y cuando un objeto de la clase se retorna desde un metodo. Esto
permite que el entorno de declaracion de la clase sea limitado a un area de accion
mnima, pero aun es posible generar objetos utiles.

El siguiente ejemplo muestra como las clases locales pueden accesar variables
de su entorno residente y de su objeto residente:

class Class8 {
public void f (final String h, String w) {
int j = 20;
final int k = 30;

class Local {
public void test() {
System.out.println(h); // h es local
// System.out.println(w); ERROR!
// No es posible imprimir w, dado que
// w no es final

// System.out.println(j); ERROR!
// Tampoco puede imprimirse j, dado que
// no es final

System.out.println(k); // k es final

// System.out.println(i); ERROR!
// i aun no ha sido declarada

System.out.println(name);

65
 // Como una clase miembro, las variables de
// instancia del objeto residente pueden ser
// accesadas. No necesitan ser finales.
}
}

Local l = new Local();

l.test();

final int i = 10;

}

public static void main (String[] args) {

Class8 c8 = new Class8();
c8.f("hello","world");
}

private String name = "Class8";

}

Clases Anonimas
Una clase anonima es una clase local que no tiene nombre. Se declara como
parte de una expresion new, y debe ser o una subclase o implementar una interfaz:

new NombredelaClase( Listadeargumentos) { Cuerpo de la clase}

new NombredelaInterfaz( ) { Cuerpo de la clase}

NombredelaClase es el nombre de la superclase de la clase anonima, mientras

que NombredelaInterfaz es el nombre de la interfaz de la cual la clase anonima debe
conformarse. La lista de argumentos es una lista de parametros que es utilizada
para llamar al constructor coincidente de la superclase.

El cuerpo de la clase puede definir metodos, pero no puede definir constructores

(dado que no pueden ser nombrados). Las restricciones impuestas a las clases locales
tambien son validas para las clases anonimas. Al igual que las clases locales, las
clases anonimas tienen las propiedades basicas de las clases miembro, y sus objetos
tienen una referencia implcita al objeto donde son creados.

El principal uso de las clases anonimas es directamente definir un objeto usando

una extension de la sintaxis para new. Esto permite que una sola instancia de un
tipo especfico de objeto sea creada exactamente donde es necesaria sin declarar
una clase completa para ella. La clase anonima debe, sin embargo, explcitamente
ser una subclase o implementar una interfaz. Si implementa una interfaz, la clase
sera una subclase de Object.

66
 Cuando una clase anonima se declara como subclase, la intencion es que los
metodos heredados sean sobreescritos (overriden) y especializados. Hay pocas ra-
zones para anadir otros metodos publicos, dado que no pueden ser llamados. Sin
embargo, se pueden anadir metodos privados.

Como una clase anonima no tiene constructores, depende de la inicializacion

directa de variables de instancia y de inicializadores de instancia para inicializar
sus variables de instancia.

El siguiente programa ilustra el uso de las clases anonimas:

interface Thing {
void test(final String s);
}

class Subclass {
public void doSomething() {
System.out.println("Do something");
}
}

class Class 10 {
// Retorna un objeto creado usando una clase anonima que
// implementa la interface
public Thing i1() {
Thing t = new Thing() {
public void test (final String s) {
System.out.println(s);
}
}; // Notese el punto y coma aqui
return t;
}

// Una version mas corta del ultimo metodo, eliminado la

// variable local

public Thing i2() {

return new Thing() {
public void test (final String s) {
System.out.println(s);
}
}; // Notese el punto y coma aqui
}

// Retorna un objeto creado con una clase anonima que es una

// subclase de una clase

67
 public Subclass f1() {
Subclass t = new Subclass() {
public void doSomething() {
something();
}
private void something() {
System.out.println(name);
}
String name = "Anonymous 1";
};
return t;
}

// Una version mas simple de f1

public Subclass f2() {
return new Subclass() {
public void doSomething() {
something();
}
private void something() {
System.out.println(name);
}
String name = "Anonymous 2";
};
}

public static void main(String[] args) {

Class10 c10 = new Class10();
Thing t1 = c10.i1();
t1.test("hello");
Thing t2 = c10.i2();
t2.test("world");
Subclass t3 = c10.f1();
t3.doSomething();
Subclass t4 = c10.f2();
t4.doSomething();
}
}

3.1.7. Clases finales

La declaracion de una clase final se precede por el modificador final. Una
clase final no puede tener subclases. Sin embargo, normalmente una clase debe
poder tener subclases si su disenador lo considera as, y ha verificado que esto

68
tenga sentido. Si hay alguna duda o no se desea tener subclases, la clase debe
ser declarada como final, permitiendo al compilador verificar que la generacion
de subclases no sea hecha. Una consecuencia de declarar una clase final es que el
compilador no puede optimizar su codigo. En particular, no es posible redefinir
metodos de subclases, as que es factible realizar un ligado estatico en lugar de un
ligado dinamico, que es mas costoso.

El siguiente codigo es una descripcion de una clase final simple:

public final class Example {

// Declaraciones de metodos y variables usuales
}

// ERROR. No puede declararse la siguiente clase

class Subclass extends Example {
...
}

3.1.8. Clases abstractas

Una clase abstracta (abstract class) es un contenedor para declarar metodos y
variables compartidos para usarse por subclases y para declarar una interfaz comun
de metodos y variables accesibles. La declaracion de una clase abstracta incluye el
modificador abstract antes de la palabra clave class.

Una clase declarada como abstract puede incluir cualquier variable estandar y
declaracion de metodos, pero no puede ser usada en una expresion. Puede tambien
incluir declaraciones de metodos abstractos. La clase define un tipo, as que las
variables del tipo pueden ser declaradas y pueden mantener referencias a objetos
de una subclase.

Una subclase de una clase abstracta puede ser tambien abstracta. Sin embargo,
en general es una clase concreta (es decir, disenada para tener instancias u objetos).

69
3.2. Metodos
3.2.1. Declaracion de Metodos
La declaracion basica de un metodo es de la siguiente forma:

modificadores tipo nombre(lista de parametros) {

Secuencia de enunciados
}

Los modificadores son opcionalmente uno, pudiendo ser public, private o

protected. Ademas, puede anadrseles los modificadores abstract, final, native
y synchronized. El cuerpo del metodo es un enunciado compuesto delimitado por
llaves, que contiene una secuencia de enunciados.

Un metodo puede arrojar excepciones, que se declaran mediante una clausula

throws:

modificadores tipo nombre(listadeparametros) throws listadenombresdetipos{

Secuencia de enunciados
}

La lista de nombres de tipos que sigue a la palabra clave throws es una lista
separada por comas de uno o mas nombres de los tipos de excepciones que pueden
ser arrojadas.

Esto es tambien el caso para los metodos declarados como abstract:

modificadores abstract tipo nombre(listadeparametros) ;

modificadores abstract tipo nombre ( listadeparametros) throwsnombredetipo;

Si un metodo retorna un tipo arreglo, entonces la siguiente variacion de la

sintaxis puede ser utilizada:

modificadores tipo nombre(listadeparametros) []{

Secuencia de enunciados
}
con un par de corchetes tras la lista de parametros. Aun cuando lo anterior repre-
senta una sintaxis legal, es mucho mas comun colocar los corchetes donde realmente
pertenecen, siguiendo el nombre del tipo de retorno:

modificadores tipo[]nombre(listadeparametros) {
Secuencia de enunciados
}

Los arreglos con mas de una dimension simplemente requieren conjuntos extra
de corchetes, exactamente como en una declaracion de variables.

70
 Los metodos son procedimientos llamados o invocados por un objeto especfico
utilizando una llamada de campo o una expresion de llamada a metodo. Hay dos
tipos de metodos: aquellos que no retornan valor (void) y aquellos que son de
retorno de valor (value-returning).

Los metodos de retorno vaco (o metodos void) se declaran con tipo de retorno
void. El cuerpo de un metodo void simplemente realiza un procesamiento, que
tendra el efecto colateral de cambiar el estado del objeto para el cual fue invocado, y
termina sin explcitamente retornar un valor, aun cuando puede usarse el enunciado
return sin argumento:

void f(){
a = 4; // Supongase que a es una variable de instancia
return;
}

Los metodos con retorno de valor (o metodos no-void) se declaran con un tipo
de valor de retorno diferente a void. El cuerpo del metodo debe contener al menos
un enunciado return, retornando un valor del tipo que coincida con o pueda ser
convertido al tipo especificado de retorno:

int f(){
return a * 10; // Supongase que a es una variable accesible
}

Como un valor debe ser retornado por un metodo con retorno de valor, el com-
pilador verifica que todas las salidas posibles de un metodo resultan en la ejecucion
de un enunciado return. En el siguiente ejemplo este no es el caso, ya que cuando
x tiene un valor mayor que 9 el control pasa al final del cuerpo del metodo sin al-
canzar el enunciado return. Como resultado, el compilador no aceptara el metodo
hasta que otro enunciado return sea anadido:

int f(){
// Cuidado: esto no compilara
if (x < 10) // x es una variable de instancia
return value;
// ERROR: debe haber un enunciado return aqui
}

Los metodos pueden ser sobrecargados (overloaded), lo que significa que dos o
mas metodos en la misma clase pueden tener el mismo nombre, siempre y cuando
tengan una lista de parametros diferente. Por ejemplo:

int f(int a) {...}

char f(float g) {...}
String f(String a, String b) {...}
double f (int a, int b, int c, int d) {...}

71
 Todos estos metodos se llaman f, pero pueden distinguirse por su diferente lista
de parametros (en una llamada a un metodo, el numero y tipos de los argumentos
son utilizados para determinar cual metodo debe usarse). Los tipos de retorno no
se toman en cuenta, y pueden diferir como se muestra aqu.

El siguiente programa consiste de una clase que declara varios metodos:

class Class1 {
// Asigna todos los elementos de un arreglo con un valor dado
public int [] fill(int [] array, int value){
for (int i = 0; i < array.length; i++) {
array[i] = value;
}
return array;
}

// Notese el parametro con modificador "final"

public int f(final int i) {
if (i > 0) {
return i;
// El intentar una asignacion a i genera un error
// i = 0; // Error!
}
return 0;
}

// El siguiente metodo solo puede ser utilizado por una

// hebra de control (thread) en un momento dado, para un
// objeto en particular
public synchronized woid assignString(final String s) {
name = s;
}

public static void main(String []args) {

Class1 c = new Class1();
int[] array = new int[10];

array = c.fill(array, 5);

c.assignString("world");
int n = c.f(-1);
}

private String name = "hello";

}

72
 El siguiente ejemplo muestra una serie de metodos sobrecargados max, que re-
tornan el maximo de entre dos valores. Cada metodo trabaja con tipos primitivos
diferentes.
class Class2{
public byte max(final byte a, final byte b){
return a > b ? a : b;
}
public short max(final short a, final short b){
return a > b ? a : b;
}
public int max(final int a, final int b){
return a > b ? a : b;
}
public long max(final long a, final long b){
return a > b ? a : b;
}
public float max(final float a, final float b){
return a > b ? a : b;
}
public double max(final double a, final double b){
return a > b ? a : b;
}
public char max(final char a, final char b){
return a > b ? a : b;
}

public static void main(String[] args) {

Class2 maxObject = new Class2();

byte a = maxObject.max((byte)3, (byte)5);

short b = maxObject.max((short)3, (short)5);
int c = maxObject.max(3,5);
long d = maxObject.max(3l,5l);
float e = maxObject.max(3.4f,5.6f);
double f = maxObject.max(3.4,5.6);
char g = maxObject.max(a,z);
}
}
Notese que cada metodo max tiene diferentes tipos de parametros y tambien
que retorna un tipo diferente de resultado. Esta clase solo declara metodos, y efec-
tivamente, conjunta un conjunto de funciones (metodos con retorno de valor). Este
estilo de clase se utiliza para crear objetos-funcion (function objetcs), los cuales
permiten a los metodos ser tratados como objetos, as como ser almacenados y
pasados como parametros.

73
3.2.2. Metodos Estaticos o de clase
Un metodo estatico o de clase pertenece a una clase, y no es parte de la imple-
mentacion de objetos o instancias individuales. Los metodos estaticos pueden ser
llamados directamente en lugar de invocarse mediante un objeto.

La declaracion de un metodo estatico es similar a la declaracion de un metodo

estandar. La declaracion basica de un metodo estatico tiene la siguiente forma:

modificadores static tipo nombre(listadeparametros){

Secuencia de enunciados
}

El cuerpo del metodo es un enunciado compuesto delimitado por llaves, y conte-

niendo una secuencia de enunciados. Los modificadores son opcionalmente public,
private o protected (como se han descrito anteriormente), y cero o mas palabras
clave como final, native, o synchronized. Los metodos estaticos no pueden ser
declarados como abstract, y en realidad puede considerarseles mas bien como de
tipo final, aun cuando no son explcitamente especificados como tales.

Los metodos estaticos pueden arrojar excepciones, y por lo tanto, pueden ser
declarados usando la clausula throws:

modificadores statictipo nombre(listadeparametros) } throws nombresdetipo{

Secuencia de enunciados
}

La lista de nombres de tipo que sigue a la palabra clave throws es una lista
separada por comas de uno o mas nombres de tipos de excepciones que pueden ser
arrojadas.

Los metodos estaticos estan sujetos por mucho a las mismas reglas que los
metodos estandar, con las siguientes excepciones:
Un metodo estatico pertenece a una clase, y no a sus objetos o instancias.
Un metodo estatico puede ser llamado tanto directamente como por un objeto
de la misma clase.
Un metodo estatico no puede accesar ningun variable o metodo de instancia
(dado que no pertenece a ninguna instancia), pero puede accesar cualquier
variable o metodo estatico.
La palabra clave this no puede ser usada sobre metodos estaticos.
A pesar de estas restricciones, un metodo estatico puede ser declarado y uti-
lizado como sea requerido.

Hay un uso especial de los metodos estaticos en la forma del static main.
Cuando una clase declara un metodo public static main, este provee de un punto

74
de inicio para la ejecucion de un programa utilizando esa clase. Todos los ejemplos
de programas vistos hasta ahora incluyen tal metodo. Este metodo se hace cargo
de establecer el estado inicial del programa, creando el conjunto inicial de objetos,
y haciendo las llamadas a los metodos apropiados para continuar la ejecucion.

Cualquier clase puede tener un metodo main. Cuando un programa se ejecuta

usando java, el nombre de la clase que contiene el metodo main a ser ejecutado se
da como sigue:

java MyClass

donde, en este caso, el primer metodo a ser ejecutado es el main de la clase MyClass.

Un metodo estatico main toma un argumento de tipo arreglo de String, llamado

args, y contiene cualquier argumento del comando de lnea.

La siguiente clase declara y usa metodos estaticos:

class Static2 {
public static void g(final int i) {
System.out.println("En static void g(i = " + i + ")");
}

public static void f(){

System.out.println("En static void f()");
g(10);
// No es posible llamar aqui un metodo sin objeto
// test(); // ERROR!
}

// Un metodo de instancia llamando a un metodo de clase

public void test(){
g(5);
}

public static void main(String args[]){

f();
g(10);
// Crear una instancia de Static2
Static2 s2 = new Static2();
s2.f(); // Notese, esto se puede hacer!
s2.test();
}
}

75
 Notese que en la lnea s2.f();, un metodo estatico es llamado como un metodo
de instancia. Parece indistinguible de un metodo de instancia, pero sin embargo, es
una llamada a metodo estatico.

3.2.3. Constructores
Un constructor se declara como cualquier metodo, contando con una lista de
parametros. Sin embargo, la declaracion de un constructor no tiene tipo de retorno,
y su nombre debe coincidir con el nombre de la clase dentro de la cual es declarado.
El constructor tiene la siguiente forma:

nombredelconstructor (listadeparametros) {
Secuencia de enunciados
}

Un constructor puede ser declarado opcionalmente como public, protected o

private. No se permite ningun otro modificador.

Un constructor tambien puede arrojar excepciones, utilizando la clausula throws:

nombredelconstructor (listadeparametros) throws listadenombresdetipos {

Secuencia de enunciados
}

En cualquier momento que un objeto es creado, un metodo constructor es lla-

mado automaticamente. Esto se garantiza de siempre suceder y no puede evitarse,
sin importar como las variables de instancia sean inicializadas. Una clase puede
declarar uno o mas metodos constructores, permitiendose la sobrecarga de construc-
tores siempre y cuando los metodos constructores difieran en su lista de parametros.

Un constructor con una lista de parametros vaca se conoce como constructor

por omision (default constructor). Si una clase no tiene explcitamente declarado
ningun constructor, el compilador de Java automaticamente creara un construc-
tor por omision publico (con lista de parametros vaca). Si una clase declara ex-
plcitamente cualquier constructor, con cualquier lista de parametros, entonces el
compilador no generara automaticamente un constructor por omision.

Un objeto se crea mediante una expresion de alojamiento, usando la palabra

clave new, como por ejemplo:

Vector v = new Vector();

Vector w = new Vector(10);

La palabra clave new se sigue por el nombre de una clase y opcionalmente por
una lista de parametros actuales. La lista de parametros actuales se hace coincidir
con aquellas provistas por los constructores de la clase, a fin de determinar cual

76
constructor llamar. Una lista vaca de parametros coincide con el constructor por
omision. Siempre y cuando se encuentre una coincidencia, el constructor sera llama-
do. Antes de que el cuerpo del constructor sea ejecutado, el constructor de cualquier
superclase sera ejecutado, seguido de cualquier inicializacion de variables de instan-
cia declaradas en la clase. Esto permite que el cuerpo del constructor sea escrito
con el conocimiento de que toda otra inicializacion sera realizada antes. La buena
practica dicta que el cuerpo del constructor solo realice inicializaciones relevantes
a su clase, y no intente inicializar variables de sus superclases.

Como las variables de instancia y de clase pueden ser inicializadas por ex-
presiones o bloques de inicializacion, puede no haber necesidad de explcitamente
declarar ningun constructor, y la clase puede simplemente depender del construc-
tor por omision generado por el compilador de Java. Sin embargo, los constructores
son la unica forma general y efectiva de parametrizar la creacion de objetos, de
tal modo que la creacion e inicializacion pueda ser ajustada para cada situacion
en particular. Por ejemplo, la clase String del paquete java.lang provee de los
siguientes constructores. Cada uno crea un objeto de tipo String a partir de un
conjunto diferente de argumentos:

String()
String(byte[])
String(byte[],int)
String(byte[],int,int)
String(byte[],int,int)
String(byte[],int,String)
String(byte[],String)
String(char[])
String(char[],int,int)
String(String)
String(StringBuffer)

Los constructores publicos, incluyendo el constructor por omision generado por

el compilador, permiten a las instacias de la clase ser creadas en cualquier parte del
programa. La mayora de las clases de alto nivel, si no todas, incluyen un constructor
publico.

Los constructores pueden ser tanto protegidos como privados, dando una forma
de limitar el acceso a algunos o todos los constructores, y por lo tanto, controlando
cuales otras partes de un programa pueden crear instancias de una clase. En par-
ticular, si todos los constructores se hacen privados, entonces solo los metodos de
la misma clase pueden crear objetos de la clase. Esto puede en realidad ser muy
util; algunas clases pueden declarar unicamente metodos estaticos, y no necesitar
instancias, o bien puede requerirse que una clase no permita a sus clientes crear
objetos utilizando new.

77
 Cuando un objeto deja de referenciarse, es destruido por el recolector de basura
(garbage collector) que es parte del sistema de ejecucion de Java. Un metodo llamado
finalize puede ser definido para ser llamado justo antes de la destruccion.

El siguiente ejemplo tiene tres constructores sobrecargados, cada uno de los

cuales inicializa las variables de instancia en una forma especfica. Todos son publi-
cos, as que cualquiera de ellos puede ser usado por el codigo de sus clientes:

import java.util.vector;

class Constructor1 {

// Constructor por Omision

public Constructor1 (){
// La asignacion de esta variable no es realmente
// necesaria, pues la inicializacion por defecto
// es correcta
v = new Vector();
}

// Crear un vector con un tama~o dado

public Constructor1(int size) {
initialSize = size;
v = new Vector(size);
}

// Crear un vector dado su tama~o e inicializar todos sus

// elementos con un argumento String
public Constructor1 (int size, String val) {
initialSize = size;
v = new Vector(size);
for (int i = 0; i < size; i++){
v.addElement(val);
}
}

public static void main(String[] args){

// Crear un objeto con el constructor por omision
Constructor1 c1 = new Constructor1();

// Otros constructores
Constructor1 c2 = new Constructor1(10);
Constructor1 c3 = new Constructor1(10,"Hello");
}

78
 // Variables de instancia que seran inicializadas por defecto
// a menos que sean asignadas por un constructor
private int initialSize;
private Vector v;
}

3.2.4. Inicializadores Estaticos

Un inicializador estatico (static initializer) es una secuencia de enunciados que
se ejecutan cuando se carga una clase. Puede ser utilizado para inicializar variables
estaticas y realizar otra inicializacion necesaria mas bien por una clase que por los
objetos de la clase.

La declaracion de una clase puede contener uno o mas inicializadores, con-

sistiendo en un enunciado compuesto que se precede por la palabra clave static:

static { Secuencia de enunciados}

Solo las variables estaticas declaradas antes del inicializador se encuentran en

el entorno dentro del enunciado compuesto.

Cuando un programa se ejecuta, las clases se cargan en memoria como se vayan

necesitando (en lugar de tenerlas todas antes de la ejecucion). Cargar una clase sig-
nifica buscar el archivo .class, que contiene el codigo de los metodos y hacer todas
las inicializaciones estaticas. Las variables estaticas y los inicializadores estaticos se
inicializan o ejecutan a fin de que sean escritos dentro de la declaracion de la clase.
Considerese el siguiente ejemplo:

class Example {
...
static int i = 10;

static int j;
static { j = i * 10; }

static String h = "hello";

static { h = h + "world" ; }
...
}

La variable i es inicializada al principio, seguida de una inicializacion por de-

fecto de j a cero (dado que no hay expresion de inicializacion directa). Entonces, a
j se le asigna un valor en el inicializador estatico, seguido de la inicializacion de h,
y finalmente, la evaluacion de otro inicializador estatico que asigna un nuevo valor
a h. Notese que un inicializador estatico no puede referirse a variables estaticas
declaradas despues de s mismo, as que el sigueinte programa generara un error:

79
class Example {
...
static { j = i * 10; } // Error: referencia ilegal

static int i = 10;

static int j;
...
}

3.2.5. this
this es una variable final que se declara automaticamente en los constructores,
metodos de instancia e inicializadores de instancias, y se inicializa para mantener
una referencia al objeto creado por el constructor, metodo o inicializador que lo
invoca. this es de tipo referencia al objeto.

this puede ser usado como cualquier otra variable de tipo referencia a clase,
sin olvidar que no se permite su asignacion dado su atributo final. Esto significa
que dentro de un metodo es posible escribir enunciados usando el operador punto
como:

{
...
this.x = 10;
this.f();
...
}

donde x es una variable de instancia y f es un metodo, ambos declarados dentro de

la misma clase. Esto tiene exactamente el mismo resultado que simplemente escribir
en forma mas familiar:

{
...
x = 10;
f();
...
}

Es decir, estos enunciados son en realidad una abreviatura de escribir una ver-
sion mas larga.

80
 Algunas veces usar la forma larga puede ser util. Por ejemplo, cuando el nombre
de una variable de instancia queda oculto por el nombre de un parametro dentro
de un entorno anidado:

class Example {
...
void f (int x) { // el parametro x oculta la variable de instancia
this.x = x; // this.x es usado para tener acceso a
// la variable de instancia oculta
}

...
private int x = 10;
}

Otro uso comun de this es pasar la referencia del objeto actual a un metodo
de otra clase:

{
...
A a = new A();
...
a.f(this) ; // Pasa this al metodo f de la clase A
...
}

this es tambien importante cuando se usa en conjuncion con los constructores,

ya que permite que un constructor llame a otro. Una expresion formada por this
seguido de una lista de parametros en parentesis llamara al constructor con la lista
de parametros coincidente. Por ejemplo, si una clase tiene dos constructores, uno
por omision y otro tomando un argumento int, entonces lo siguiente es posible:

public Test() {
this(10); // Llama al constructor con int
}

Aqu, la expresion this(10) resulta en una llamada al constructor tomando un

int como argumento. Notese que la expresion this debe aparecer como el primer
enunciado en el cuerpo de un constructor, y que tal llamada a un constructor solo
puede hacerse desde otro constructor, no desde un metodo de instancia o de clase.

Las llamadas a constructores usando this no pueden ser recursivas. Por ejem-
plo, el siguiente constructor no compilara:

public Test(int x) {
this(10); // Error: Llamada recursiva al mismo constructor
}

81
3.2.6. Redefinicion de Metodos
Una subclase puede redefinir un metodo heredado mediante proveer una nue-
va definicion del metodo que tenga el mismo nombre, el mismo numero y tipo de
parametros, y el mismo tipo de resultado de retorno que el metodo heredado. El
metodo heredado se oculta al entorno de la subclase. Cuando el metodo es invoca-
do por un objeto de la subclase, el metodo redefinido es ejecutado usando ligado
dinamico.

Un metodo redefinido es declarado en una subclase como cualquier otro metodo,

pero debe tener el mismo nombre, el mismo numero de parametros del mismo tipo,
y el mismo tipo de retorno que el metodo de la superclase.

Los metodos privados no pueden ser redefinidos, as que que un metodo coinci-
dente de la subclase se considera completamente separado. Por otro lado, el acceso
de un metodo redefinido publico (public), protegido (protected) o por defecto (si
no hay modificador) debe tener el mismo acceso que el metodo de la superclase, o
hacerse mas accesible (por ejemplo, de protected a public). Un metodo redefinido
no puede hacerse menos accesible.

Los metodos estaticos no pueden ser redefinidos. Los metodos de instancia no

pueden redefinirse por un metodo estatico.

La redefinicion de metodos depende del ligado dinamico (dynamic binding), de

tal modo que el tipo del objeto para el cual un metodo es invocado determina cual
version de un metodo redefinido se llama. As, en una expresion como:

x.f(); // donde f es un metodo redefinido

la version de f que se llama depende de la clase del objeto que se referenca por x
cuando la llamada al metodo es evaluada en tiempo de ejecucion, y no en el tipo
de la variable x. La mayor consecuencia de esto es que una variable de tipo de una
superclase puede asignarse a una referencia a un objeto de la subclase, pero cuando
se llama a los metodos, el ligado dinamico asegura que los metodos redefinidos de
la subclase sean llamados. Por tanto, la misma expresion evaluada a diferentes mo-
mentos durante la ejecucion de un programa puede resultar en llamados a diferentes
metodos. Los metodos estaticos no pueden usar ligado dinamico.

Es importante recordar que el nombre, los tipos de los parametros y el tipo de

retorno (comunmente llamado method signature o signatura del metodo) de un
metodo redefinido debe coincidir exactamente. Si no, entonces ocurre la sobrecarga
de metodos, en la que el metodo tiene mas de un significado entre las dos clases.

La regla que la accesibilidad de un metodo redefinido debe ser igual o incremen-

tarse es necesaria para preservar la substitutibilidad. Si el objeto de una subclase
debe ser usado donde un tipo de la superclase ha sido especificado, entonces debe
soportar al menos la misma interfaz publica (o protegida, o por defecto). Remover
un metodo de la interfaz prevendra la substitucion.

82
 El uso del ligado dinamico es parte esencial de la programacion Orientada a Ob-
jetos, pero puede hacer difcil averiguar cual metodo sera llamado al leer el codigo
fuente. Dada una expresion como x.f() o solo f() (que realmente es this.f()), el
programador debe primero determinar el tipo de x o this, y entonces inspeccionar
la clase correspondiente, superclases y subclases, para averiguar que clase de meto-
do es f, y si es redefinido. El programador debe tambien determinar los tipos de
objetos que pueden ser referenciados por x. Esto puede ser tardado y confuso, pero
considerar esto es importante. Es claro que un buen ambiente de desarrollo puede
dar soporte para esta busqueda, pero esto no significa que el comentario no deba
hacerse.

El siguiente programa ilustra una variedad de metodos redefinidos y el uso del

ligado dinamico:

class Superclass {
// Metodo que puede ser redefinido
public void f(int x){
System.out.println("Superclass f: " + x);
// Siempre llama al metodo g declarado en esta clase,
// ya que g es privado
g();
}

// No se puede redefinir el siguiente metodo

private void g(){
System.out.println("Superclass g");
}

// Metodo que puede ser redefinido

protected void h(){
System.out.println("Superclass h");
}

public void k(){

System.out.println(Superclass k");
// Siempre llama a Superclass g, ya que g no puede ser
// redefinido
g();
// Llama a h dependiendo del tipo de objeto (el tipo de
// this) usando ligado dinamico
h();
// Siempre llama a s en esta clase, ya que s es
// estatico
s();
}

83
 public static void s() {
System.out.println("Superclass static s");
}
}

class Subclass extends Superclass {

// Metodo redefinido. Debe ser publico
public void f(int x) {
System.out.println("Subclass f: " + x);
// Llama a g en esta clase
g();
}

// Nueva version de g, que no redefine la version de

// Superclass
private void g(){
System.out.println("Subclass g");
}

// Metodo redefinido del heredado h con acceso incrementado

// El hacer el acceso de este metodo privado o por defecto
// generaria un error
public void h(){
System.out.println("Subclass h");
}

public static void s() {

System.out.println("Subclass static s");
}
}

class Override {
public static void main (String[] args) {
Superclass superclass = new Superclass();
// Llama a la version de f en Superclass
superclass.f(1);
superclass.h();
superclass.k();
superclass.s();

Subclass subclass = new Subclass();

// Llama a la version redefinida de f y h en Subclass
subclass.f(2);
subclass.h();

84
 // Llama a la version de k en Superclass, ya que no
// esta redefinida
subclass.k();

// Llama a la version de s en Subclass

subclass.s();

// Ahora, pone una variable de tipo Superclass a una

// referencia a objeto de tipo Subclass
superclass = subclass;

// Llama a las versiones de f y h en Subclass

superclass.f(3);
superclass.h();

// Llama a k para un objeto de Subclass

superclass.k();

// Llama a la version de s en Superclass, ya que este

// metodo es estatico y no puede ser dinamicamente
// ligado, por lo que el metodo depende el tipo de la
// referencia
superclass.s();
}
}

3.2.7. Metodos Finales

Un metodo final de instancia no puede ser redefinido (pero aun puede ser so-
brecargado). Un metodo final estatico no puede ser re-declarado en una subclase.
Una declaracion de metodo final incluye al modificador final.

Los metodos finales previenen de que un metodo que tiene el mismo nombre y
los mismos tipos de parametros sea declarado en una subclase (el tipo del resultado
es ignorado). Esto toma en cuenta tanto variables estaticas como de instancia. Sin
embargo, el modificador final no previene que los metodos sean sobrecargados en
una subclase.

Al igual que las clases estaticas, los metodos estaticos potencialemente permiten
al compilador hacer optimizaciones en las llamadas a metodos.

3.2.8. Expresiones de invocacion a Metodos

Una expresion de invocacion o llamada a un metodo determina cual metodo es
llamado en base al nombre del metodo y sus parametros. Una serie de reglas se usan

85
para determinar exactamente cual metodo es invocado. Un metodo (que puede ser
estatico) se invoca mediante una expresion que consiste en una identificacion de
metodo seguida de una lista de parametros actuales o argumentos:

identificadordemetodo( lista de argumentos);

La lista de argumentos puede estar vaca, pero el parentesis debe estar presente.

El metodo a ser invocado puede ser identificado de varias formas:

Usando el nombre del metodo directamente, si el metodo esta declarado en
el entorno de la misma clase o superclase:

identificador ( lista de argumentos);

Usando una expresion de campo (el operador punto) con la referencia de un

objeto:

expresionprimaria.identificador(lista de argumentos);

donde la expresion primaria antes del punto debe evaluarse como referencia
a objeto que puede entonces ser usada para seleccionar el nombre del metodo
a ser invocado. Tal nombre debe ser accesible, lo cual generalmente significa
que debe ser publico, protegido, o declarado en la clase actual. El metodo
puede ser estatico.
Usando una expresion de campo con el nombre de una clase o interfaz:

nombredeclaseointerfaz.identificador(lista de argumentos);
Esto permite invocar metodos estaticos o de instancia mediante especificar
cual clase o interfaz debe ser usada para hallar el metodo.
A fin de invocar un metodo, se usa un proceso llamado viga de metodo
(method lookup). Este es usado para determinar exactamente cual metodo llamar,
y que la llamada no sea ambigua. En algunos casos, un proceso viga de metodo
completo puede ser producido por el compilador, permitiendo exactamente deter-
minar cual metodo llamar en tiempo de compilacion. Esto es lo que se llama ligado
estatico (static binding): la invocacion del metodo se liga o asocia con un metodo
durante la compilacion.

En otros casos, sin embargo, no es posible para el compilador hacer el proceso

viga completo durante la compilacion, ya que la informacion necesaria y completa
no esta disponible sino hasta tiempo de ejecucion, es decir, en el momento en que
el metodo es invocado. Para superar este problema, se utiliza el ligado dinamico
(dynamic binding), donde el ligado se completa justo antes de que la llamada al
metodo tenga lugar, y el tipo exacto de objeto del que se invoca el metodo es

86
conocido. El ligado dinamico es particularmente asociado con los tipos de referencia
y herencia, ya que una referencia de un tipo superclase puede referirse a un objeto
de cualquiera de un numero de tipos de las subclases.

Para entender como funciona un viga de metodo, la primera cuestion a consi-

derar son los metodos sobrecargados, sin considerar los metodos heredados. Si una
llamada se hace a una coleccion de metodos sobrecargados, debe ser posible selec-
cionar al menos uno para ser llamado. Esto se hace mediante comparar los tipos
de los argumentos (parametros actuales) con los tipos de los parametros formales
declarados para el metodo. Declaraciones donde no hay coincidencia entre tipos de
parametros actuales y formales se eliminan de la busqueda. Si queda un solo meto-
do tras la eliminacion, la invocacion ya no es ambigua, y la expresion de llamada
es valida. Si queda mas de un metodo, esto significa un error.

Desafortunadamente, determinar si el tipo de un argumento y un parametro

son coincidentes es complicado debido a los varios tipos de conversion implcita,
conocidas como compatibilidades por asignacion. Por ejemplo, un metodo que toma
un argumento double puede ser invocado con un argumento int, ya que el tipo
int es compatible por asignacion con double. Dado esto, considerese que hacen las
invocaciones a f en el siguiente ejemplo:

class Example {
...
public void f(int x) { ...}
public void f(double x) { ... }
...
public void test(){
f(10); // Argumento int
f(1.1); // Argumento double
}
}

Potencialmente, cuando f es llamada con un argumento int, cualquier metodo

puede ser llamado. En tales casos, se hace un intento por encontrar la coincidencia
mas significativa. La llamada f(10) es una coincidencia directa para f(int x),
as que este es el metodo invocado. Invocar el metodo f(double x) requerira una
conversion implcita, y por lo tanto, la invocacion es menos especfica. La llamada
f(1.1) no implica propiamente un problema, ya que es la unica coincidencia dado
que double no puede ser convertido a int automaticamente.

En seguida, considerese el siguiente caso:

class Example {
public void f(int x, double y) { ... }
public void f(double x, int y) { ... }
...

87
 public void test() {
f(1.0,1);
f(1,1);
f(1,1.0);
}
}

En este ejemplo, la primera llamada f(1.0,1) es valida ya que f(int x,

double y) sera rechazada debido a que double no es compatible por asignacion con
int, dejando solo el otro metodo que coincide exactamente. La llamada f(1,1.0)
es tambien valida por razones similares, resultando en una llamada a f(int x,
double y). Sin embargo, la llamada f(1,1) es invalida ya que cualquier version de
f puede ser llamada, y ambas requieren una conversion implcita. Ningun metodo
resulta ser especfico con respecto a la llamada. Al compilar la clase anterior, la lla-
mada f(1,1) tendra que ser removida, o uno de los dos parametros explcitamente
propuesto como double.

Notese que es muy posible declarar un conjunto de metodos sobrecargados que

son potencialmente ambiguos respecto a las invocaciones de metodos. El compilador
de Java se quejara solo si encuentra una expresion de llamada ambigua. Si no, el
codigo compilara sin notificacion de ambiguedad potencial.

Los ejemplos anteriores usan los tipos primitivos int y double explotando el
hecho de que un int es compatible por asignacion con un double. Un razonamiento
analogo se aplica para el uso de cualquier tipo y sus compatibles por asignacion.
En particular, no se olvide que al tratar con referencias, un subtipo es compatible
por asignacion con su supertipo.

Invocar un metodo sobrecargado es una extension al comportamiento de llamar

un metodo no-sobrecargado (un metodo no-sobrecargado puede ser considerado
como un metodo sobrecargado con una sola posibilidad de eleccion). Las reglas para
compilar una invocacion a un metodo donde no hay metodos heredados involucrados
pueden resumirse como sigue:

1. Localizar todos los metodos con el nombre requerido que se encuentran en

el entorno, incluyendo tanto metodos estaticos como de instancia. Si no se
encuentra un metodo, se reporta un error.
2. Hagase coincidir los tipos de los parametros actuales con los tipos de los
parametros formales, eliminando todos aquellos metodos que difieren en uno o
mas tipos de parametros, y en donde no es posible una conversion automatica
de tipos. Si solo un metodo coincide, la invocacion es valida y el metodo
es seleccionado. Si mas de un metodo coincide, o ningun metodo coincide,
reporta un error.
3. Tomese los metodos remanentes y considere las conversiones automaticas
para cada parametro. Si un metodo puede ser invocado con un menor numero

88
 de conversiones que otro, aquel con mayor numero de conversiones es elimi-
nado. Tras la eliminacion, si un metodo permanece como el mas especfico,
la invocacion es valida y el metodo es seleccionado. Si dos o mas metodos
permanecen entonces la invocacion es ambigua, y se reporta un error.

La herencia introduce una complicacion extra a la invocacion de metodos, con

respecto a los metodos heredados pero sobrecargados y los metodos redefinidos. Si
una subclase declara uno o mas metodos con el mismo nombre de uno o mas metodos
de la superclase, entonces, a menos que ocurra una redefinicion, todos los metodos
sobrecargaran al mismo nombre del metodo. Esto significa que al intentar resolver
cual metodo sobrecargado llamar debe tomarse en cuenta los metodos heredados y
los metodos de la subclase. Mas aun, la sobrecarga del nombre de un metodo en las
subclases que aun no han sido escritas debe tomarse en cuenta tambien.

El proceso viga de metodo se modifica para lidiar con estas cuestiones mediante
cambiar la definicion de lo que significa metodo mas especfico al tratar con
metodos heredados o sobrecargados, y mediante depender del ligado dinamico.

Dada una expresion para invocar un metodo que resulte en la identificacion de

dos metodos potenciales que sobrecargan al mismo nombre, el metodo mas especfico
es aquel que:

Es declarado en la misma clase o en una subclase de la clase donde el otro es

declarado, y
Tiene cada parametro como compatible por asignacion con los parametros
correspondientes del otro metodo.

Para ilustrar esto, considere el siguiente ejemplo:

class A {
void f(double d){ ... }
}

class B extends A {
void f(int i) { ... }
}

...

B b = new B();
b.f(1); // Que metodo se llama?

El metodo f(int) en la clase B sobrecarga al metodo heredado f(double) en

la clase A. La llamada de b.f(1) podra potencialmente invocar cualquier metodo.
Sin embargo, por las reglas anteriores, f(int) resulta mas especfico, ya que se
encuentra declarado en la subclase. Por lo tanto, f() declarado en la clase B es

89
seleccionado, lo que no es claramente notorio solamente al inspeccionar el codigo. Sin
embargo, si el ejemplo se cambia como sigue, la llamada resultara ahora ambigua:

class A {
void f(int i){ ... } // Notese el cambio de tipo
}

class B extends A {
void f(double d) { ... } // Notese el cambio de tipo
}

...

B b = new B();
b.f(1); // Ambiguo

Aun cuando podra parecer que f(int) debiera coincidir, falla respecto a la
regla 1, mientras que f(double) falla en la regla 2, y ningun metodo se puede
considerar como mas especfico. Resulta todo en un mensaje de error:

Reference to f is ambiguous. It is defined in void f(double) and

void f(int).

La aplicacion de la regla del mas especfico puede revisarse de nuevo consideran-

do un metodo con dos argumentos:

class A {
void g(double d, int i) { ... }
}

class B extends A {
void g(int i, double d) { ... }
}

...

B b = new B();
b.g(1,1.0); // OK
b.g(1.0,1); // OK
b.g(1,1); // Ambiguo

En este ejemplo, las dos primeras llamadas a g no representan un problema,

ya que el unico metodo sobrecargado en cada caso puede hacerse coincidir, y no es
necesario utilizar la regla del mas especfico (por ejemplo, b.g(1,1.0) no coincide
con g (double, int), ya que double no es compatible por asignacion con int).
La tercera invocacion, sin embargo, es ambigua dado que ambas declaraciones de g

90
podran coincidir con ella, pero de acuerdo con la regla, ninguna resulta la mas es-
pecfica. Intercambiar las declaraciones de los dos metodos no hace mayor diferencia
en este caso.

Los mismos principios se aplican cuando los argumentos son de tipos referencia:

class X { ... }
class Y extends X { ... }

class A {
void h(X x) { ... }
}

class B extends A {
void h(Y y) { ... }
}

...

B b = new B();
X x = new X();
Y y = new Y();

b.h(x); // OK
b.h(y); // OK

Aqu ambas llamadas al metodo h son validas. Con la primera, solo hay un
metodo que puede coincidir: h(X) en la clase A. Con el segundo, ambos metodos h
podran coincidir, pero la regla dice que h(Y) en la clase B resulta el mas especfico,
y es el que termina siendo llamado.

Si las declaraciones se intercambiaran:

class X { ... }
class Y extends X { ... }

class A {
void h(Y y) { ... }
}

class B extends A {
void h(X x) { ... }
}

...

91
 B b = new B();
X x = new X();
Y y = new Y();

b.h(x); // OK
b.h(y); // Ambiguo

la segunda llamada a h se vuelve ambigua, ya que ambos metodos podran coincidir,

pero ninguno resulta el mas especfico.

Una vez que la sobrecarga de metodos ha sido resuelta, se debe considerar la

redefinicion de metodos. Si el metodo seleccionado puede ser redefinido, entonces
la llamada al metodo podra necesitar ser dinamica. Dado que ningun metodo no-
privado o no-estatico puede ser redefinido (a menos que la clase o el metodo sea
final), entonces todas las llamadas deben ser dinamicas. No debe olvidarse que
subclases redefiniendo un metodo pueden ser anadidas al programa en cualquier
momento sin recompilar las superclases, as que el ligado dinamico debe lidiar con
objetos de clases que podran solo existir en el futuro.

El ligado dinamico trabaja utilizando codigo para hallar la clase del objeto por
el que un metodo es invocado, verificando que la clase declara un metodo redefinido
con el nombre, tipo de parametros y tipo de retorno correctos, y entonces invocando
al metodo. Aun cuando esto suena lento y costoso para ejecutarse, la informacion
para hacer la coincidencia esta codificada para reducir el tiempo extra al mnimo.
Los archivos .class contienen la informacion, as que la verificacion puede hacerse
una vez que una clase es cargada.

En resumen, el proceso general para compilar la invocacion o llamada a un

metodo es como sigue:

1. Determinar donde comenzar la busqueda de un metodo, mediante encontrar

el tipo de expresion denotando el tipo del objeto para el cual el metodo es
invocado, y usar la clase correspondiente.
2. Localizar todos los metodos (de instancia o estaticos) que son accesibles (es
decir, private, protected, public, etc. que sean apropiados) con el nombre
que coincida con el metodo invocado. Esto implica una busqueda en el entorno
local y los entornos anidados (si los hay), el entorno de la clase y de las
superclases. Si no se encuentra una declaracion se reporta un error.
3. Eliminar todos los metodos cuyos parametros formales, en numero o tipo, no
coinciden con los parametros actuales de la invocacion. Si solo hay un metodo
tras la eliminacion, se continua con el paso 5. Si no queda ningun metodo, se
reporta un error.
4. Aplicar la regla del mas especfico y determinar si un metodo es mas especfico
que el resto. Si queda solo un metodo, se sigue con el paso 5. Si no queda
ningun metodo, se reporta un error.

92
 5. Determinar si la invocacion al metodo necesita ser dinamica, y si as es,
generar una llamada dinamica a metodo, y en caso contrario, una llamada
estatica.

3.2.9. Busqueda de nombre modificado para miembros de

una clase
Los objetos de clases miembro, locales y anonimas estan contenidas dentro
de un objeto u objetos (si las clases se encuentran profundamente anidadas) de
clases residentes. Esto crea una jerarqua de contencion (containment herarchy)
de objetos que es diferente de la jerarqua de herencia entre clases. La jerarqua de
contencion representa otro conjunto de entornos, donde es necesario buscar cuando
la busqueda de una variable o metodo toma lugar.

La sintaxis para las clases miembro, locales o anonimas se encuentra descrita

en otro punto de estas notas. Sin embargo, notese que la sintaxis extendida para el
uso de this puede usarse para accesar explcitamente variables y metodos en los
objetos contenedores:

nombredeclase.this.nombredevariable
nombredeclase.this.nombredemetodo

Como hay dos distintas jerarquas en que buscar por nombres de variables y
metodos, hay un problema potencial si el nombre se encuentra en ambas. La jerar-
qua de herencia se busca primero, seguida de la jerarqua de contencion. Si el mismo
nombre con el mismo tipo se encuentra en ambas jerarquas, ambas declaraciones
son accesibles, y se reporta un error. Estos conflictos pueden resolverse utilizando
la sintaxis extendida de this para excplcitamente nombrar la clase que declara el
nombre a ser usado. Por ejemplo, si ambas jerarquas declaran una variable accesible
x dentro del entorno, entonces una expresion como:

A.this.x

puede ser usada para acceder a x, donde A es el nombre de la clase que declara la
variable que necesita ser accesada.

El siguiente programa ilustra el uso de clases miembro y herencia. Notese que

la clase miembro es tambien una subclase de una clase no-miembro, as que existen
dos jerarquas de herencia, en una de las cuales la clase miembro pertenece, y la
otra en que es parte la clase contenedora. El objeto de la clase miembro tambien
sera parte de una jerarqua de contencion definida por la clase contenedora y su
superclase. Notese el comentario indicando el conflicto que ocurre entre la jerarquas
de herencia de la clase miembro y la jerarqua de contencion.

class A {
public void f() {
System.out.println(name + " f");

93
 }
protected static String name = "A";
}

class Superclass {
public void name(){
System.out.println(name);
}
protected static String name = "Superclass";
protected String vname = "Superclass instance variable";
}

class Subclass extends Superclass {

private class Member extends A {
// Las clases miembro pueden heredar
public void show() {
// Esta es una variable de instancia
// Su uso esta bien, ya que la variable de
// instancia name oculta cualquier otra variable
// heredada o contenida
System.out.println(name);

// Las variables pueden ser explicitamente usadas

// en cada entorno usando la sintaxis this

System.out.println(Subclass.this.name);
System.out.println(Superclass.this.name);
System.out.println(A.this.name);
System.out.println(Subclass.this.vname);
System.out.println(Superclass.this.vname);

// No hay conflicto aqui, ya que solo la jerarquia

// de contencion tiene vname
System.out.println(vname);

// Los metodos del objeto contenedor pueden ser

// llamados
Subclass.this.name();
Superclass.this.name();

// Si this es omitido, entonces los metodos en el

// objeto contenedor todavia pueden ser accesados.
// Ya que no se hereda el metodo name, tampoco hay
// conflicto
name();

94
 // Lo siguiente es ambiguo, dado el conflicto
// entre name por herencia y por contencion
// f(); // ERROR!
A.this.f();
Subclass.this.f();
}

public void test() {

System.out.println(name + " test");
}

private String name = "Member";

}

public void name() {

System.out.println(name);
}

public void test() {

Member m = new Member();
m.show();
}

public void f() {

System.out.println("Subclass:f");
}

protected static String name = "Subclass";

protected String vname = "Subclass intance veriable";
}

class Lookup1 {
public static void main(String[] args) {
Subclass subclass = new Subclass();
subclass.test();
}
}

3.2.10. Metodos abstractos

Un metodo puede ser declarado como abstracto, de tal modo que pueda ser
redefinido por las subclases. Un metodo abstracto no tiene cuerpo. Su declaracion
termina con punto y coma, y no un enunciado compuesto:

95
 modificadores abstract tipo nombredelmetodo(lista de parametros);

La lista de parametros es una secuencia de cero o mas parametros separados

por comas. Cada parametro consiste en un nombre de tipo seguido por un identi-
ficador (por ejemplo, int x). El identificador debe estar presente aun cuando no
sea utilizado. Un metodo que redefine a un metodo abstracto no requiere utilizar
los mismos nombres de identificadores.

Una clase que declara uno o mas metodos abstractos debe ser declarada como
clase abstracta. Los metodos privados y estaticos no pueden ser abstractos, ya que
no hay manera de redefinirlos.

Los metodos abstractos permiten que una clase abstracta especifique la interfaz
completa de un metodo publico o protegido, aun cuando no puede proveer un cuerpo
para el metodo. Las reglas del lenguaje aseguran que las subclases concretas deben
proveer de un implementacion completa para cada metodo abstracto heredado. Las
subclases abstractas de una clase abstracta pueden escoger entre implementar un
metodo abstracto heredado o anadir metodos abstractos adicionales.

3.2.11. Metodos heredados de la clase Object

La clase Object es la base de toda la jerarqua de herencia en Java, y declara
implementaciones por omision de un pequeno numero de metodos que pueden ser
redefinidos por sus subclases, es decir, toda clase que se implementa en Java. Para
que los objetos de las subclases tengan un comportamiento correcto, el programador
debe asegurarse que la implementacion por omision sea adecuada, o proveer una
version redefinida mejor.

La clase Object declara los siguientes metodos que pueden ser redefinidos por
las subclases:

public boolean equals (Object obj);

public String toString ();
public final native int hashCode();
protected native Object clone();
protected void finalize();

Estos metodos tambien soportan arreglos.

De los cinco metodos que pueden ser redefinidos, tres son publicos y pueden
ser invocados por cualquier objeto o instancia de cualquier clase. Los otros dos son
protegidos, y necesitan ser redefinidos como metodos publicos para que puedan ser
invocados en la clase que los declara.

96
boolean equals(Object obj)
El metodo equals es usado para comparar el objeto que lo llama con el objeto
en su argumento. La implementacion por defecto retorna true si los dos objetos son
en realidad el mismo objeto (usando el operador ==). Una subclase debe redefinir
este metodo a fin de comparar los valores de los dos objetos, en general mediante
sistematicamente comparar uno a uno los valores de sus variables de instancia.

El metodo equals de una subclase debe enfocarse en comparar el estado anadi-

do por la clase, e invocar super.equals() para obtener el estado de su superclase
comparado. Notese, sin embargo, que una subclase directa de la clase Object no
requiere invocar al metodo Object.equals().

El programador necesita decidir como comparar dos objetos de la misma clase.

Puede ser suficiente tan solo comparar todas las variables de instancia (especial-
mente, si todas ellas son de tipo primitivo). Sin embargo, las variables de referencia
a otros objetos requieren que cada uno de los objetos a los que se hace referencia sea
comparado completamente, dependiendo que en sus clases haya implementada una
version de equals apropiada. Por tanto, una comparacion completa puede resultar
en toda una serie de invocaciones y ejecuciones de metodos equals de un numero
de clases. El programador debe tomar en cuenta que esta operacion puede consumir
tiempo operacional de ejecucion.

El metodo equals implementa una relacion de equivalencia. La documentacion

de JDK define un conjunto riguroso de reglas para lo que significa igualdad, las
cuales el programador debe considerar cuando redefine equals:
Es reflexiva: para cualquier valor de referencia x, x.equals(x) debe retornar
true.
Es simetrica: para cualesquiera valores de referencia x y y, x.equals(y) debe
retornar true si y solo si y.equals(x) retorna true.
Es transitiva: para cualquier valores de referencia x, y y z, si x.equals(y)
retorna true, y y.equals(z) retorna true, entonces x.equals(z) debe re-
tornar true.
Es consistente: para cualesquiera valores de referencia x y y, multiples in-
vocaciones de x.equals(y) consitentemente retornan true o false. Para
cualquier valor de referencia x, x.equals(null) debe retornar siempre false.
El metodo equals para la clase Object implementa la relacion de equivalencia
mas discriminante posible entre objetos, es decir, que para dos referencias x y y,
este metodo retorna true si y solo si x y y se refieren al mismo objeto (x == y
tiene el valor de true).

Es importante implementar equals correctamente si los objetos instancia de

una clase son usados por otras clases o metodos que dependen de la relacion de
igualdad.

97
String toString()
Este metodo es utilizado para obtener una cadena de caracteres representando
el valor del objeto para el cual se invoca. Por defecto, el metodo de la clase Object
retorna una cadena como:

ClassName@1cc7a0

Este es el nombre de la clase del objeto, seguido por una @, que se sigue por
el valor hexadecimal del codigo hash del objeto (vease la siguiente seccion). Para
generar una cadena mas util, una subclase puede redefinir este metodo y retornar
cualquier cadena que sea una representacion razonable del valor del objeto.

El metodo toString es ampliamente usado por otros metodos para convertir

de tipo referencia de un objeto al tipo String, notablemente cuando se utilizan
flujos (streams), as que normalmente debe ser redefinido para hacer algo util.

int hashCode()
Un codigo hash es un valor entero unico que representa el valor de un objeto,
de tal modo que el valor del objeto completo puede ser relacionado con un entero.
Cada valor distinto que un objeto puede representar debe tener un codigo hash
relativamente unico (ya que el numero de valores es frecuentemente mayor que lo
que se puede representar mediante un int). Los codigos hash se usan como valores
clave en una tabla hash (como la que se implementa en la clase HashTable en
java.util).

La version por defecto de hashCode intentara generar un codigo hash para

cualquier objeto, pero puede terminar generando diferentes codigos hash para ob-
jetos diferentes representando el mismo valor. Si tal es el caso, entonces hashCode
debe ser redefinido para implementar una nueva funcion hash que genere codigos
hash correctos. La documentacion de JDK establece que el contrato general para
hashCode es:

En cualquier momento que se invoca el mismo objeto mas de una vez durante
la ejecucion de una aplicacion Java, el metodo hashCode debe consistentemente
retornar el mismo valor int. Este valor int no requiere permanecer consistente de
una ejecucion a otra. Si dos objetos son iguales de acuerdo con el metodo equals,
entonces llamar al metodo hashCode para cada uno de estos objetos debe producir
el mismo resultado int.

En la practica, solo aquellos objetos que pueden ser almacenados en una tabla
hash requieren del metodo hashCode. Los programadores generalmente dependen
de la implementacion por defecto de hashCode, en lugar de implementar una nueva
version que podra significar una dura labor.

98
Object clone()
El metodo clone crea una copia de un objeto. Por defecto, solo el objeto es
copiado, es decir, se copian los valores de sus variables primitivas. Sin embargo,
los valores de tipos referencia contenidos en el objeto no se copian. Esto se conoce
como copia superficial (shallow copy).

La debilidad potencial del metodo clone por defecto es que su uso puede resul-
tar en dos copias de un objeto, ambas referenciando o compartiendo una coleccion
de otros objetos. Si el estado de alguno de los objetos referenciados cambia, en-
tonces efectivamente tambien cambia el estado de todos los objetos que le hacen
referencia. Para sobrellevar esto, clone puede ser redefinido para relizar una copia
profunda (deep copy), en donde tanto el objeto a copiar como los objetos a los que
hace referencia son copiados. La redefinicion de clone tambien necesita ser hecha
publica, si se espera utilizarse en general.

Una copia profunda completa depende de clone o una operacion de copia simi-
lar, que requiere ser implementada correctamente por cada clase de los objetos
a los que se hace referencia. Como es el caso con equals, invocar a clone puede
resultar en una larga secuencia de metodos invocados, los cuales pueden usar mucho
del tiempo de ejecucion de un programa. Como resultado, es importante definir
cuidadosamente que significa copiar un objeto y que realmente debe hacerse.

Un metodo clone debe ser responsable de clonar el estado (es decir, el valor de
las variables) declaradas en su clase, y debe invocar a super.clone() para copiar el
estado de la superclase, a menos que tal clase sea Object, en cuyo caso la invocacion
al metodo clone por defecto puede no ser necesaria.

Si un objeto no puede ser clonado, la excepcion CloneNotSupportedException

puede ser arrojada, por lo que el metodo debe ser declarado con una clausula
throws. Ciertas clases no pueden redefinir clone, a favor de proveer otros metodos
para copiar o utilizar constructores (por ejemplo, la clase String de la biblioteca
de Java).

void finalize()
El metodo finalize es llamado automaticamente por el recolector de basura
cuando un objeto no es referenciado y puede ser desechado. La version por defecto
en la clase Object es un metodo con cuerpo vaco. El recolector de basura puede
ejecutarse en cualquier momento, por lo que no hay una forma confiable de deter-
minar cuando sera invocado finalize para un objeto en particular. Tpicamente,
sin embargo, el recolector de basura es normalmente invocado cuando la memoria
disponible para el programa en ejecucion disminuye.

finalize solo necesita ser redefinido si un objeto tiene un estado que no puede
ser correctamente manipulado simplemente con desecharlo. Por ejemplo, cuando

99
sus datos deban ser escritos a un archivo antes de desecharlo o podran perderse, o
una conexion de red que debe ser propiamente cerrada.

Un metodo finalize debe ser responsable de finalizar los objetos de la clase

en la que se encuentra declarado, y debe invocar super.finalize() para coordi-
narse con su superclase. Un metodo finalize puede ser declarado para arrojar
una excepcion si un error ocurre. Si una excepcion se arroja, sera atrapada por el
recolector de basura e ignorada, dejando al programa proseguir su ejecucion.

Para mayor informacion acerca de estos metodos pertenecientes a la clase

Object, refierase a la documentacion estandar de JDK.

100
3.3. Herencia
Una subclase hereda de una superclase mediante extenderla. La subclase toma
todas las declaraciones de variables y metodos de la superclase (aun cuando no todos
puedan ser accesibles) y puede anadir nuevas variables o metodos, o sobrecargar
(override) los existentes.

Una subclase hereda de una superclase usando la palabra clave extends:

class nombredelasubclase extends nombredelasuperclase {

declaraciones de variables y metodos
}

El cuerpo de una clase conteniendo declaraciones de variables y metodos es tal

y como se ha descrito anteriormente.

La herencia se aplica a las clases estandar de alto nivel, las clases anidadas de
alto nivel, las clases miembro, las clases locales y las clases anonimas.

Una clase puede heredar de cualquier otra clase que no es final. Los objetos de
la subclase contienen todas las variables de instancia declaradas por la superclase.
Tambien, todos los metodos declarados por la superclase pueden ser llamados desde
el objeto de la subclase. El hecho que la subclase tiene copias de las variables de
instancia de la superclase hace que esto ultimo sea razonable y permisible. Notese,
sin embargo, que las reglas de accesibilidad son respetadas, as que las variables y
metodos privados no son accesibles a los metodos e inicializadores de la subclase.
Una clase puede contener partes que algunos de sus propios metodos no pueden
accesar.

Crear subclases puede ser repetido tantas veces, o hasta tantos niveles, como se
desee; una subclase puede tener a la vez otra subclase, y esta otra, etc. Esto es a lo
que se refiere como una cadena de herencia. Sin embargo, es una buena practica
limitar el numero de niveles a menos de cinco.

Una clase puede solo tener una superclase, pero puede tener tantas subclases
como sea necesario. Una coleccion de clases en una relacion de herencia es referida
como una jerarqua de clases (class hierarchy). Debido a la regla de una sola
superclase, esta jerarqua forma un arbol.

Todas las clases heredan directa o indirectamente de la clase Object (es decir,
todas son inmediatamente subclases de Object o se encuentran en un nivel mas
abajo en una cadena jerarquica que comienza con Object). Esto es cierto aun
cuando una clase no haya sido explcitamente declarada como una subclase de
Object usando la palabra clave extends.

La relacion de herencia entre clases tambien se aplica a los tipos que las clases
definen, de tal modo que es posible hablar de supertipos y subtipos. Esto

101
permite compatibilidad para la asignacion o conversion entre tipos de referencia,
as que es posible asignar una referencia a un objeto de un subtipo a una variable
cuyo tipo es el supertipo. Esto tambien funciona para el paso de parametros y el
retorno de resultados de un metodo.

La herencia tiene el efecto de incrementar el numero de entornos que necesitan

ser revisados para verificar que una variable o metodo esta en un entorno, y si es
accesible.

Para las variables, la revision procede mediante checar la declaracion de los

identificadores de las variables en varios entornos. Tanto las declaraciones estaticas
como de instancia son verificadas. El orden de la busqueda es como sigue, y termina
cuando el identificador es hallado:
1. Verificar el entorno local y cualquier entorno anidado.
2. Verificar el entorno de clase.
3. Verificar cada entorno de superclases, a lo largo de la cadena de herencia.
Si en algun otro entorno se encuentra una declaracion del identificador de una
variable, se reporta un error. Si no se encuentra una declaracion en todos los en-
tornos, entonces tambien se reporta un error de declaracion de la variable. Si varias
variables en diferentes entornos son declaradas con el mismo identificador, entonces
la primera declaracion encontrada es utilizada, es decir, aquella en el entorno mas
cercano. Las declaraciones en entornos anidados se dice estan ocultas (hidden o
shadowed) del entorno anidado.

Si el nombre de la variable es parte de una expresion de campo con un nombre de

tipo del lado izquierdo (por ejemplo, Math.PI, que es una variable estatica double
en la clase Math del paquete java.lang de la biblioteca de Java, cuyo valor es
aproximadamente ), entonces la busqueda comienza en el entorno del nombre de
la clase.

El siguiente ejemplo muestra un uso muy simple de la herencia, e ilustra que meto-
dos de ambas subclase y superclase pueden ser invocados por los objetos de la sub-
clase. Tambien, notese que la referencia de la subclase es asignada a una variable
del tipo de la superclase.

class Superclass {
public void supermethod() {
System.out.println("Superclass");
}
}

// Esta clase hereda supermethod() de Superclass, asi que puede

// invocarlo a partir de objetos de la subclase

102
class Subclass extends Superclass {
public void submethod(){
System.out.println("Subclass");
}
}

class Inherit1 {
public static void main(String[] args) {
// Crea un objeto Superclass y llama al metodo
// supermethod()

Superclass superclass = new Superclass();

superclass.supermethod();

// Crea un objeto Subclass y llama a ambos metodos

// supermethod() y submethod()

Subclass subclass = new Subclass();

subclass.supermethod();
subclass.submethod();

// La asignacion en valida, pero no a la inversa

superclass = subclass;
}
}

3.3.1. Palabras Clave private, protected, y Herencia

Las variables y los metodos pueden ser declarados con el modificador public,
protected o private. Lo importante para el programador es si declarar metodos
o variables como public, protected, private o sin modificador de acceso. Todas
estas declaraciones tienen ventajas y desventajas. Los metodos y las variables pri-
vados no son accesibles a una subclase, aun cuando son parte de la infraestructura
de los objetos de la subclase. Los metodos y las variables protegidos son accesibles
a una subclase, y proveen una forma de abrir la encapsulacion dada por la clase en
una forma controlada.

La declaracion private ofrece una garanta de que ninguna otra clase, in-
cluyendo las subclases, pueden acceder al metodo o variable. Esto evita
cualquier dependencia directa en los detalles de las declaraciones. Por tanto,
si se realizan cambios a los metodos o variables privados en una clase, entonces
ninguna otra clase necesita ser editada. Sin embargo, esto puede requerir la
adicion de metodos de acceso a la superclase para accesar indirectamente sus
metodos o estado privado.

103
 La declaracion protected permite que una subclase (tal vez de un paquete
diferente) accese directa y eficientemente a su superclase cuando pueda ser
util para las variables de instancia de la subclase y para los metodos auxiliares
que no deban ser publicos. Esto permite una forma controlada de compartir.
Sin embargo, esto puede llevar a que en la subclase se utilice erronamente las
caractersticas heredadas y volverse innecesariamente dependiente de ellas.
La declaracion public hace accesible a la subclase y a todo lo demas. Esto es
esencial si la clase tiene instancias que proveen de un servicio util, pero puede
ser peligroso si mucho se hace publico, especialmente en el caso de variables
de instancia.
El acceso por omision es igual al acceso publico si una subclase se encuentra
en el mismo paquete, e igual al acceso privado si no.

Como una regla general, las declaraciones deben ser publicas si clientes no rela-
cionados deben usarlas, o de otra manera deberan hacerse privadas por omision a
menos que sea claro que las subclases necesitan acceso directo, en cuyo caso podran
ser protegidas. Como una superclase puede ser escrita antes que una subclase haya
sido pensada, las declaraciones protegidas requieren una planeacion cuidadosa.

Un punto a recordar acerca de las declaraciones protegidas es que en Java estas

son accesibles tanto a subclases como a clases en el mismo paquete. Esto hace
que el uso de declaraciones protegidas sea algo arriesgado, ya que hace que varias
clases tengan acceso a un elemento protegido, pero previendo cierta flexibilidad a
la apertura de la encapsulacion.

El siguiente ejemplo ilustra el uso de variables y metodos protegidos y privados.

class Superclass {
// Metodo que sera heredado pero no accesible a una subclase
private void f() {
System.out.println("f");
// Puede llamarse desde aqui a g y h
// g();
// h();
}

// Metodo que sera heredado y es accesible a una subclase y a

// otras clases dentro del mismo paquete
protected void g(){
System.out.println("g");
// Puede llamarse desde aqui a f y h
// f();
// h();
}

104
 // Metodo compartido que no es sobreescrito en la subclase
public void h() {
System.out.println("Shared");
// Puede llamarse desde aqui a f y g
// f();
// g();
}
public int i = 5;
protected int j = 10;
private int k = 20;
}

class Subclass extends Superclass {

public void test() {
i = 10; // Bien. Variable publica heredada
j = 20; // Bien. Variable protegida heredada
// k = 30; // ERROR. No se puede acceder una variable
// privada
// f(); // ERROR. f es privado en la superclase
g();
h();
}
}

class Inherit2{
public static void main(String[] args) {
Superclass superclass = new Superclass();
// superclass.f(); // ERROR. El metodo f es privado

// Se puede llamar a g ya que aun cuando el metodo es

// protegido, esta clase esta en el mismo paquete
superclass.g();
superclass.h();

Subclass subclass = new Subclass();

subclass.test();
// subclass.f(); // ERROR. El metodo f es heredado
// pero privado

// Puede llamarse a g ya que aunque el metodo es

// protegido esta clase esta en el mismo paquete
subclass.g();
subclass.h();
}
}

105
3.3.2. Constructores y Herencia
En Java, todas las clases existen como parte de una jerarqua de herencia.
Cuando un objeto es creado, un constructor debe ser invocado por cada superclase
y subclase de la jerarqua. Esto se refuerza por las reglas propias del lenguaje y el
compilador.

La palabra clave super puede ser usada para explcitamente llamar al construc-
tor de una superclase:

super(lista de argumentos);

La lista de argumentos es usada para seleccionar un constructor en particular.

Puede ser vaca, en cuyo caso el constructor por omision de la superclase es invocado.

Los constructores no son heredados, y no pueden ser redefinidos. Su sobrecarga

esta restringida al conjunto de constructores declarados en una clase.

El uso basico de constructores ha sido introducido anteriormente, y esta sec-

cion completa tal descripcion. Debe notarse que, aparte del constructor de la clase
Object, la cual no tiene superclase, todos los constructores necesitan invocar un
constructor de una superclase. De hecho, la clase Object depende de un constructor
por omision generado por el compilador, en lugar de declarar uno explcitamente. Es
interesante que la documentacion de JDK (y otras fuentes) muestran a Object co-
mo si tuviera un constructor por omision explcito. En caso de duda, inspeccionese
el codigo fuente de la clase Object.

Cuando se crea un objeto de una subclase, la siguiente secuencia de eventos

toma lugar:

1. El objeto es alojado en memoria y el constructor del objeto de la subclase es

invocado.
2. Antes de que cualquier enunciado del cuerpo del constructor sea ejecutado, un
constructor de la superclase es invocado o si el primer enunciado utiliza this
(vease a continuacion) entonces otro constructor en la subclase es invocado,
lo que repite este paso.
3. Cuando el constructor de la superclase (o this) retorna la llamada, las varia-
bles de instancia son inicializadas mediante un bloque inicializador de instan-
cias que se ejecuta en el orden en que las variables de instancia estan escritas.
4. El cuerpo del constructor es ejecutado.
5. La invocacion del constructor retorna un objeto inicializado.

Por tanto, crear un objeto resulta en una serie de llamadas a constructores e

inicilizaciones. Esto sucede automaticamente y no puede ser detenido. El progra-
mador puede, sin embargo, controlar cual metodo de la superclase es invocado por

106
el constructor utilizando la palabra clave super seguido por una lista de argumen-
tos. Si se usa tal enunciado, este debe aparecer como el primer enunciado dentro
del cuerpo del constructor:

public Example(int a, String b) {

super(a, 1, b); // Llamada al constructor de la superclase,
// que toma int, int, String como argumentos
}

Cualquier constructor de la superclase puede ser invocado (incluyendo al cons-

tructor por omision). No importa si el numero de parametros es diferente al dado por
el constructor de la subclase. Es claro que el constructor apropiado de la superclase
no debe ser privado.

Si super no es usado explcitamente, entonces una llamada implcita a super()

se inserta por el compilador como el primer enunciado del cuerpo del constructor,
a menos que una llamada explcita se haga a otro constructor en la misma clase
usando this. Por tanto, todos los constructores (excepto el de Object) que no usan
explcitamente super o this realmente consisten en lo siguiente:

public A() {
super();
...
// el resto del cuerpo del constructor
}

107
108
Captulo 4

Topicos Especiales en Java

4.1. Paquetes
Un paquete permite que una coleccion de clases sea agrupada en una sola unidad
y bajo un mismo nombre que tambien actua como un entorno. Hay dos partes de
la sintaxis de paquete: una para declarar los paquetes en s y otra para importar
clases de otros paquetes.

Un paquete se declara usando un enunciado de paquete (package statement)

que debe aparecer antes que ningun otro enunciado en un archivo fuente (tambien
conocido como unidad de compilacion). Tiene la forma:

package nombredelpaquete;

El nombre del paquete es un identificador o una serie de identificadores sepa-

rados por un punto (como por ejemplo java.awt.event).

Las clases se importan dentro de un paquete desde otro paquete usando un

enunciado de importacion. Estos vienen en dos variedades:

import nombredelpaquete.nombredelaclase;
o
import nombredelpaquete.*;

La primera forma importa una clase especfica nombrada, mientras que la se-
gunda forma es una abreviacion conveniente que permite que todas las clases de un
solo paquete sean importadas de una vez.

Para entender como los paquetes son usados es necesario darse cuenta de que los
nombres de los paquetes mapean a nombres de directorios dentro del almacenamien-
to de archivos locales (esto podra extenderse en el futuro a sitios de Internet). Cada
directorio contiene todos los archivos .class para las clases dadas en el paquete.
Las herramientas como el compilador de Java localizan estos directorios en forma

109
relativa a series de puntos fijos en el almacenamiento de archivos, que se almacenan
como rutas de archivos en una variable de ambiente llamada CLASSPATH (diferentes
ambientes de desarrollo pueden proveer mecanismos alternativos para las variables
de ambiente).

El mapeo del nombre de un paquete a un directorio especfico se hace mediante

primero tomar cada componente del nombre del paquete y mapearlo a una ruta
relativa apropiada para el almacenamiento de archivos en la maquina local. Por
ejemplo, un paquete llamado:

adts.containers.sorted

se mapeara a la ruta en Windows:

\adts\containers\sorted

o a la ruta en UNIX:

/adts/containers/sorted

La ruta generada es entonces anadida como entrada a la variable de ambiente

CLASSPATH para generar una ruta completa. La ruta completa es usada para buscar
en cada directorio por clases. Por ejemplo, cuando se usa Windows y la variable
CLASSPATH contiene:

.;D:\myclasses

se generan los siguientes nombres de directorios para el paquete antes mencionado:

.\adts\containers\sorted
D:\myclasses\adts\containers\sorted
C:\jdk1.1.3\lib\adts\containers\sorted

suponiendo que Java ha sido instalado en C:\jdk1.1.3.

Si se trata de un sistema UNIX, entonces para el CLASSPATH:

.:$HOME/lib/Java

resulta los siguientes nombres de directorios generados para el paquete antes men-
cionado:

./adts/containers/sorted
$HOME/lib/Java/adts/containers/sorted
/opt/jdk1.1.3/lib/adts/containers/sorted

110
esto suponiendo que Java ha sido instalado en el directorio /opt/jdk1.1.3.

El archivo con el mismo nombre de la clase que se busca debe encontrarse en

uno de esto directorios. Si un archivo .class es encontrado, entonces se utiliza.
Si un archivo .class no es hallado, pero se encuentra un archivo .java, este es
compilado para crear una archivo .class, que puede entonces ser usado.

Notese que la sintaxis de la variable de ambiente CLASSPATH sigue la sintaxis

del sistema operativo: bajo Windows, el separador de ruta es un punto y coma (ya
que los dos puntos se usan como parte de la especificacion de la unidad de disco),
mientras que en UNIX se utilizan como separadores de ruta los dos puntos.

Es tambien posible especificar el nombre de un archivo .zip (un archivo conte-

niendo un numero de archivos en forma comprimida) en el CLASSPATH, as como si
se tratara de directorios conteniendo archivos .class. Si este es el caso, entonces
se buscan en el archivo .zip los archivos .class de forma analoga a la forma en
que los directorios se buscan para hallar archivos .class.

Cuando una clase es declarada para ser parte de un paquete usando el enunciado
package, se espera que el archivo .class coincidente se localice en el directorio
correspondiente. Durante el desarrollo de la clase, el archivo .java es generalmente
localizado en el mismo directorio por conveniencia. Los nombres de los paquetes
pueden tener tantos subdirectorios como se desee, pero mientras sean mas, mas
profunda sera la estructura del directorio.

Los enunciados de importacion (import statements) especifican ya sea una sola

clase, o todas las clases del paquete. El mismo mapeo de nombres de paquetes a
directorios es utilizada para localizar la clase o clases que se importan. Si el mapeo
falla, la compilacion falla tambien.

Si cualquier clase de otro paquete es usada en el paquete actual, debe ser im-
portada. Para todas las clases, incluyendo las clases de las bibliotecas de Java,
esto debe hacerse explcitamente, excepto para las clases en java.lang, las cuales
siempre se importan en forma implcita.

Para importar de otro paquete, una clase debe ser declarada publica (recuerdese
que solo una clase en el paquete puede ser publica). Las clases no-publicas son locales
a su paquete, dando un grado de control sobre la visibilidad de las clases.

Las clases en un paquete se declaran en una serie de archivos fuente, as que

un paquete se deriva a la vez de una coleccion de archivos fuente. Una clase puede
anadirse a un paquete mediante simplemente incluir el enunciado package al prin-
cipio de la clase. Notese, sin embargo, que una clase (y por lo tanto un archivo)
puede solo ser parte de un paquete unico, as que solo puede haber un enunciado
package en un archivo fuente.

111
 Los enunciados package se tratan en forma bastante casual, de tal modo que
una clase puede ser declarada para ser parte de cualquier paquete que el progra-
mador desee, hasta dentro de los paquetes de las bibliotecas de Java. La unica
restriccion en esto es que el directorio coincidente con el nombre del paquete debe
ser accesible y escribible, de tal modo que el archivo .class pueda colocarse ah.

Si una clase no es declarada dentro de un paquete (como son todos los ejemplos
de programas vistos hasta ahora), entonces pertenece a un paquete por omision sin
nombre, as que todas las clases realmente pertenecen a un paquete. Para propositos
de aprendizaje y prueba de un ejemplo, esto resulta muy conveniente, ya que todos
los archivos fuente de un programa pueden estar contenidos en el directorio actual
de trabajo, sin causar ningun conflicto con el proceso de mapeo de paquetes a di-
rectorios. Tan pronto como el programador comienza a usar paquetes, sin embargo,
la estructura apropiada de directorios debe colocarse.

112
4.2. Interfaces
La declaracion de interfaces permite la especificacion de un tipo de referencia
sin proveer una implementacion en la forma en que una clase lo hace. Esto provee
de un mecanismo para declarar tipos que son distintos de las clases, lo que da una
extension importante a la forma en que los objetos y la herencia se usan en Java.

Las interfaces explotan el concepto de conformacion de tipos (type confor-

mance). Un tipo puede ser especificado por un nombre y un conjunto de metodos
(cada uno de los cuales tiene un nombre, un conjunto de tipos de parametros y
un tipo de retorno). Un tipo puede conformarse con otro tipo si especifica el
mismo conjunto de metodos (o posiblemente mas), y cada metodo tiene el mismo
nombre, tipos de parametros y tipo de retorno. Mas aun, los dos tipos no tiene
que estar relacionados por herencia, dando una mayor libertad a que tipos pueden
conformarse con otros tipos.

Para ilustrar la idea basica, si Type1 se especifica como:

void f();
int g(String s);

y Type2 se especifica como:

void f();
int g(String s);
double h(int x);

entonces se dice que Type2 se conforma con Type1, ya que tiene todos los metodos
que Type1 posee. Esto se escribe frecuentemente como una relacion de la forma:

Type1 Type2

Si Type2 se conforma con Type1, entonces un valor de Type2 puede ser substi-
tuido por un valor de Type1, ya que soporta todos los metodos que un valor Type1
tiene.

La idea de substitutibilidad debe ser familiar a partir de observar las propiedades

de las clases y la herencia. La caracterstica crucial que las interfaces anaden es que
son definidas fuera de la jerarqua de herencia (no se olvide que todas las clases
heredan de la clase Object, lo que hace que todas pertenezcan a la misma unica
jerarqua de clases). Una vez definida, una interfaz puede ser implementada por
una clase que crea un nuevo tipo que se conforma al tipo de la interfaz. Mas aun,
cualquier clase puede implementar la interfaz, sin importar su disposicion en la
jerarqua de clases. La figura 4.1 ilustra la idea basica.

113
 Clase
Object

Interfaz

Figura 4.1: Clases e Interfaces

Es entonces posible declarar una variable del tipo de la interfaz y tener tal
variable como referencia a cualquier objeto de cualquier clase que implemente la
interfaz. El objeto se dice que se conforma a la interfaz, o se conforma al tipo. Mas
aun, una clase puede implementar varias interfaces de tal modo que los objetos de
tal clase pueden ser usados en cualquier momento en que los tipos de sus interfaces
sean especificados.

Esto, en efecto, provee de una conexion que permite a una clase especificar si
sus objetos pueden ser usados cuando una interfaz coincidente se provea, y puede
hacerlo sin necesidad de que la clase se encuentre en un sitio particular dentro de
la jerarqua de herencia. Esto tiene importantes consecuencias para el codigo del
programa, ya que puede ser escrito para usar un tipo interfaz, en el conocimiento de
que una clase solo tiene que implementar la interfaz para permitir que sus objetos
sean usados. Si el mismo codigo se escribe usando una clase, entonces solo los
objetos de la clase correspondiente y sus subclases pueden ser usados. Esto forzara
a la clase de cualquier otro objeto que pudiera ser utilizado en el futuro a ser una
subclase de la clase especfica.

Una cuestion comun en el diseno que las interfaces tambien atienden es la falta
de herencia multiple entre clases. Una clase puede tener solo una superclase, pero
puede requerir heredar de dos o mas clases repartidas en la jerarqua de herencia.
Esto permitira a los objetos de la clase substituir cualesquiera objetos de diferentes
superclases que les fueran especificados. Anadir interfaces resuelve el problema de
substitutibilidad, ya que una clase puede implementar varias interfaces. La herencia
de metodos y variables se resolvera mediante cambiar las relaciones de herencia
entre clases por asociaciones (lo que no es ideal, pero resulta practico).

Las bibliotecas de clases de Java hacen un gran uso de las interfaces para
especificar un conjunto de metodos que una clase debe proveer para que sus objetos
sean utilizados en ciertas situaciones. Un ejemplo es la interfaz Enumeration, la cual
especifica un tipo y un conjunto de metodos para iterar a traves de una estructura
de datos. Diferentes estructuras de datos requieren diferentes clases que provean los

114
iteradores, pero todas las clases pueden implementar la misma interfaz. Los clientes
de los iteradores deben entonces solo tener que usar una interfaz de Enumeration,
sin la necesidad de saber como un iterador particular funciona, o cual es su clase
real.

Un punto final acerca de la conformacion de tipos en Java que vale la pena

mencionar es que esta se basa unicamente en la coincidencia sintactica de nombres
de identificadores y nombres de tipos. No especifica el comportamiento de los meto-
dos de la interfaz ni verifica si la implementacion de esos metodos hace lo correcto.
Eso se deja para que el programador lo verifique.

4.2.1. Declaracion de Interfaces

Una declaracion de interfaz requiere el uso de la palabra clave interface,
especificando un tipo de referencia, consistente en un nombre de tipo, un conjunto
de declaraciones de metodos abstractos y un conjunto de variables finales estaticas
(constantes).

Una interfaz se declara usando la siguiente sintaxis:

modificadordeinterfaz interface identificador{

declaracion de metodos de la interfaz
declaracion de variables de la interfaz
}

El modificador opcional de la interfaz permite que una interfaz sea declarada

como publica (public). El modificadora abstract es permitido, pero es obsoleto y
debe evitar usarse.

Las variables de la interfaz pueden ser declaradas usando la declaracion estandar

de variables estaticas, y deben ser inicializadas. Los unicos modificadores permitidos
son public, static y private, pero son redundantes y no deben ser utilizados. Una
variable de interfaz puede ser inicializada por una expresion usando otra variable
de interfaz, siempre y cuando esta ultima haya sido declarada textualmente antes
de la inicializacion.

Los metodos de interfaz son siempre abstractos, y son declarados de la misma

forma que los metodos abstractos de las clases: sin cuerpo del metodo. Los unicos
modificadores permitidos son public y abstract, pero son tambien redundantes,
y no deben ser usados.

Una interfaz puede ser extendida por una o mas interfaces (algo parecido a la
herencia), usando la palabra clave extends.

115
 modificadordeinterfaz interface identificador
extends listadenombresdeinterfaces {
declaracion de metodos de la interface
declaracion de variables de la interfaz
}

La lista de nombres de interfaces puede ser un solo nombre de interfaz o una

lista separada por comas de nombres de interfaces. Una interfaz no puede extender
una clase.

Una interfaz puede ser anidada dentro de una clase de alto nivel o de otra inter-
faz, e implcitamente sera tratada como estatica, aun cuando puede ser declarada
como public, private o protected como las declaraciones de clases.

Una interfaz consiste de declaraciones de una secuencia de metodos abstractos

y variables estaticas y finales, como por ejemplo:

interface X {
int f(String s);
boolean g(double d, long l);

int SIZE = 10;

String word = "hello";
}

Cualquier metodo declarado sera implcitamente considerado como abstracto,

por lo que no es necesario explcitamente ser declarado como tal. Aun cuando
algunas versiones de Java todava permiten que aparezca la palabra clave abstract,
este no sera el caso en versiones futuras, y debe ser omitida. Notese que como los
metodos abstractos de las clases, los parametros deben ser nombrados aun cuando
solo su tipo es necesario.

Cualquier variable declarada es implcitamente constante y estatica (como las

variables de clase). Las variables pueden ser declaradas usando los modificadores
static y final, pero como los metodos, estos modificadores no deben ser utilizados.

Una interfaz puede estar vaca, de tal modo que solo declara el nombre de un
tipo:

interface Empty {
}

Una interfaz se declara en un archivo fuente (o unidad de compilacion) como

una clase. Puede ser declarada publica, en cuyo caso puede ser accesada por las
clases en otros paquetes. Si una interfaz es declarada publica, debe ser la unica

116
interfaz publica (o clase publica) en el mismo archivo fuente. Si no es publica, una
interfaz solo podra ser usada dentro del mismo paquete donde esta declarada.

Si una interfaz es declarada publica, entonces todos los metodos y variables

que declara son tambien publicos. De otra manera, todos ellos tienen un acceso por
defecto, y solo seran accesibles dentro del mismo paquete. Este comportamiento es
diferente al de las clases, as que vale la pena mencionarlo.

Una interfaz puede extender o heredar de una o mas interfaces (notese la difer-
encia con las clases):

interface C extends A, B { // Extiende las interfaces A y B

// declaraciones
}

Todos los nombres declarados en todas las interfaces se vuelven parte de la

interfaz que hereda, pero los nombres de las variables pueden ocultarse mediante
re-declaraciones de la interfaz que hereda. Las expresiones de campo pueden ser
utilizadas para acceder los nombres de las variables ocultas, pero solamente dentro
del mismo paquete, como por ejemplo:

A.x; // acceso a la variable x de la interfaz A

Esto no incluye a los metodos, ya que estos son declarados unicamente para ser
redefinidos, y no tienen cuerpo de metodo.

Una interfaz puede ser anidada dentro de una clase de alto nivel, lo cual permite
que el entorno de su nombre sea controlado por su clase anfitriona. Una interfaz
anidada es parte de su clase anfitriona, y es siempre tratada como estatica, por lo
que no es necesario que sea declarada como tal (una interfaz no-estatica no tiene
caso, ya que las interfaces no son parte de los objetos).

Una interfaz puede tambien ser anidada dentro de otra interface, como se
mostrara en un ejemplo posterior. No es claro si esto es realmente necesario o
no, pero puede hacerse.

4.2.2. implements
La palabra clave implements permite a una clase implementar (o mas bien,
conformarse a) una o mas interfaces.

El nombre de la clase en una declaracion de clase se sigue de la palabra clave

implements y una lista de uno o mas nombres de interfaces separados por comas:

modificadores class nombredeclase implements listadenombresdeinterfaces {

declaraciones
}

117
 El resto de la declaracion de la clase se hace en forma normal. Si la clase no
redefine todos los metodos declarados en la interfaz o interfaces a implementar,
entonces la clase debe ser declarada como abstracta.

Una clase puede implementar cualquier numero de interfaces, y tambien exten-

der una clase al mismo tiempo. Toda variable declarada en la interfaz se convierte
en una variable estatica de la clase. Cualquier metodo declarado en la interfaz debe
ya sea ser redefinido o la clase que implementa debe ser abstracta. Las subclases
de la clase deben ser tambien abstractas o redefinir el resto de los metodos.

Cuando se implementan dos o mas interfaces puede haber problemas con las
variables con un nombre igual que aparecen en varias interfaces, en cuyo caso
cualquier intento de utilizarlas directamente resultara ambiguo. Esto puede resol-
verse utilizando expresiones de campo:

X.y; // Use la variable estatica y de la interfaz X

Notese, sin embargo, que cuando las interfaces son heredadas por otras inter-
faces hay limitaciones para acceder a las variables de interfaz por parte de clases
en un paquete diferente al de la interfaz (vease el ejemplo mas abajo).

No hay ambiguedad con los metodos, ya que las interfaces solo contienen declara-
ciones de metodos abstractos. Sin embargo, si dos interfaces declaran el mismo
metodo, con la misma lista de argumentos y el mismo tipo de retorno, se espera
que el metodo sea redefinido de forma diferente. Por tanto, el metodo en la clase
que implementa a las interfaces necesitara implementar ambas redefiniciones en el
mismo metodo.

Un metodo declarado en una interfaz publica debe ser publico en la clase que
lo implementa, ya que la accesibilidad no puede decrementarse.

Si un conjunto complicado de declaraciones de interfaces heredadas se imple-

menta por una clase, es posible implementar la misma interfaz por dos o mas
diferentes rutas, como se muestra en la figura 4.2. Esto es permitido, y no intro-
duce ningun problema. Solo una copia existe de cualquier variable de interfaz que
es heredada por cualquiera de las dos o mas rutas.

118
 Clase
extends

Interfaz

implements

Figura 4.2: Interfaz implementada a traves de dos rutas

Los siguientes archivos fuente usan las interfaces declaradas en el paquete ITest.
El primero declara una clase en el mismo paquete, el cual tiene acceso a las variables
de interfaz ocultas.

package ITest;

// Esta clase se encuentra en el mismo paquete como

// todas las declaraciones de interfaces

public class Thing implements X {

public void f(int y) {
System.out.println("Thing:f " + y);

// La variable name esta declarada en una interfaz en el

// mismo paquete, por lo que es accesible pero ambigua a menos
// que se use en una expresion de campo nombrando a la
// interfaz que declara a la variable

System.out.println(X.name);
System.out.println(Y.name);

// El compilador puede generar mensajes de advertencia acerca

// de esto dos ultimos enunciados

// La siguiente linea es ambigua

// System.out.println(name); // ERROR
}

// Debe de redefinirse g y h

public void g() {

System.out.println("Thing:g ");

119
 }

public int h(int x) {

System.out.println("Thing:h " + x);
return x * 4;
}
}

El siguiente archivo fuente es un cliente del paquete ITest, y tambien contiene

al metodo main.

import ITest.*;

class A implements X {

// Puede tenerse una interfaz anidada

private interface Local { }

// Implementacion de la variable de interface

public void f(int x) {
System.out.println("A:f " + x);

// Uso de las variables de interface

System.out.println(f);
System.out.println(X.f); // Tambien se permite
System.out.println(m);
System.out.println(n);
System.out.println(p);

// name es declarada en una interfaz heredada no-publica, y

// no puede ser accesada fuera del mismo paquete

// System.out.println(name); // ERROR
// System.out.println(X.name); // ERROR

// Las variables de interfaz son finales, asi que no puede

// hacerse la siguiente asignacion

// SIZE = 5; // ERROR

// Esta clase miembro implementa una interfaz anidada

// declarada en la interfaz Example. Porque se querria hacer
// lo siguiente, es otra cosa

120
 class NestedClass implements Example.Nested {
public void z() {
System.out.println("NestedClass:z");
}
}

NestedClass nest = new NestedClass();

nest.z();
}

// Debe redefinirse g y h

public void g() {

System.out.println("A:g ");
}

public int h(int x) {

System.out.println("A:h " + x);
return x * 2;
}
}

class InterfaceTest {
public static void main (String[] args) {
A a = new A();
a.f(10);

Thing t = new Thing();

t.f(20);

// No es posible accesar una interfaz privada anidada

// A.Local l; // ERROR
}
}

121
4.3. Excepciones
Una excepcion ocurre cuando algo falla durante la ejecucion de un programa,
es decir, un evento excepcional ocurre que no permite al programa proceder nor-
malmente. Sin un manejo explcito, un programa en el cual ocurre una excepcion
termina abruptamente, perdiendo el estado de las variables, incluyendo todos los
datos que no han sido guardados en un archivo. Esto es parecido a la situacion de
un documento en el que se ha trabajado por horas y en el ultimo minuto desaparece
sin rastro.

El mecanismo de manejo de excepciones de Java permite que las excepciones

sean atrapadas (caught) y atendidas, idealmente mediante corregir el problema que
causo la excepcion y permitiendo que el programa continue sin perdida de datos.

4.3.1. Clases de Excepcion

Las clases de excepcion permiten que las excepciones sean representadas como
objetos. Un objeto excepcion almacena la informacion acerca de la causa de la
excepcion y puede pasarse como un valor a un manejador de excepciones que se
implementa en un bloque catch.

El conjunto estandar completo de clases de excepcion definida por las bibliotecas

de Java se describe en la documentacion de JDK API (vease la pagina ndice para
el paquete java.lang), y no se presenta aqu.

Todas las clases de excepcion deben ser directa o indirectamente subclases de la

clase Throwable, la cual define una interfaz con un metodo por omision de una clase
de excepcion. Throwable tambien define una variable privada String que puede ser
utilizada para almacenar un mensaje describiendo la causa de una excepcion. Esta
variable puede ser inicializada mediante un constructor, y accesarse va un metodo
publico.

El metodo publico de la interfaz de Throwable es como sigue:

// Constructor por omision

Throwable();

// Constructor con un argumento String describiendo el error

// La subclase definida por el programador debe proveer siempre
// una version de este constructor
Throwable(String);

// Metodo que retorna el String describiendo el error

String getMessage();

122
 // Metodo que retorna una version de String en el lenguaje local
// Este metodo debe ser redefinido por subclases, ya que el
// comportamiento por defecto es retornar el String de error
String getLocalizedMessage();

// Version redefinida del metodo toString() de la clase Object,

// que retorna informacion sobre la excepcion incluyendo el
// String de error. Puede ser redefinido, pero la version
// incluida en Throwable es bastante util
String toString();

// Los siguientes metodos despliegan un rastro de stack (las

// llamadas a metodos en progreso cuando ocurre la excepcion
void printStackTrace(); // Envia al stream estandar de error
void printStackTrace(PrintStream); // Envia de PrintStream
void printStackTrace(PrintWriter); // Envia a un print writer

// Ajusta el rastro en el stack si la excepcion vuelve a lanzarse

Throwable fillInStackTrace();

Las subclases pueden anadir tantas variables y metodos como sea necesario
para almacenar mas informacion acerca de la excepcion que se representa por sus
instancias.

Una clase de excepcion, a pesar de su nombre, es una clase ordinaria definida en

forma normal. Todas las clases de excepcion son, ya sea directa o indirectamente,
subclases de la clase Throwable de la biblioteca de clases de Java, que se define
en el paquete java.lang. El mismo paquete define toda una familia de subclases
de Throwable, que son usadas por los paquetes de la biblioteca. El programador
puede ya sea usar estas clases directamente para representar excepciones o, mas
comunmente, crear subclases para representar y definir sus excepciones.

La figura 4.3 muestra la jerarqua basica de clases de excepcion. La biblioteca

de clases de excepcion se dividen en dos categoras basadas en las bibliotecas de
clases Error, Exception y RuntimeException:

Error, RuntimeException y sus subclases representan serios errores causa-

dos en general por la Maquina Virtual de Java (Java Virtual Machine, o
JVM), la clase cargador (loader) o el ambiente de ejecucion (runtime envi-
ronment). Estas excepciones son en su mayora no-recobrables, y causan que
el programa termine o falle de una forma irrecuperable. Las excepciones de
error indican una falla en el sistema fuera del control del programa. Un pro-
grama en Java no necesita explcitamente tratar con estas excepciones, dado
que la terminacion abrupta es aceptable.

123
 Object

Throwable

Exception Error

... ...
otras subclases RuntimeException otras subclases

Estas excepciones deben

tratarse explicitamente ...
otras subclases

Figura 4.3: Jerarqua de Clases de Throwable

Las subclases de Exception, excepto RuntimeException y sus subclases,

representan errores causados por omisiones y fallas logicas iniciadas por el
programador. Una excepcion representada por una de estas clases debe ser
explcitamente tratada por el programa en Java. Las excepciones definidas
por el programador son casi siempre una subclase de Exception.
En la mayora de los casos, una clase de excepcion definida por el programador
es directamente una subclase de Exception. Las otras clases de excepcion no son,
en general, subclases (aun cuando podran serlo). Una clase de excepcion definida
por el programador generalmente define un constructor por omision incluyendo la
llamada a super con un mensaje apropiado tipo String. Un constructor que toma
un argumento String y que llama a super para pasar el argumento a Throwable
tambien aparece frecuentemente. En muchos casos, la subclase no necesita anadir
ningun nuevo metodo o variable, pero esta en libertad de hacerlo si puede usarlos
para proveer de informacion extra acerca de la causa de la excepcion.

El siguiente ejemplo muestra una clase de excepcion basica definida por el

programador. Frecuentemente, las clases de excepcion definidas por el programador
no son mas complicadas que:

class UserException extends Exception {

public UserException() {
super("Un mensaje adecuado");
}

public UserException(String msg) {

super(msg);
}
}

124
4.3.2. try, catch y finally
Las palabras clave try y catch proveen de un nucleo sintactico para manejar
excepciones. La palabra clave finally provee de un mecanismo para garantizar
que un bloque de codigo se ejecuta sin importar que otra cosa suceda.

Un bloque try consiste de lo siguiente:

try {
secuencia de enunciados
}

Este puede ser seguido por cero o mas bloques catch:

catch (parametro) {
secuencia de enunciados
}

Siguiendo a la palabra catch hay una declaracion de parametro que especifica

el tipo de objeto excepcion que cada bloque catch atrapa.

Un bloque opcional finally puede seguir a cualquier bloque catch:

finally {
secuencia de enunciados
}

El bloque try debe ser seguido de al menos un bloque catch o un bloque

finally. Un bloque basico try-catch puede conjuntarse como sigue:

try {
f(); // llamada a un metodo que puede arrojar una excepcion
}

catch (Exception e) {
System.out.println("Llamada a f() ha fallado");
// imprime el mensaje de la excepcion
System.out.println(e.getMessage());
}

El bloque try intenta ejecutar una llamada al metodo f(). Si una excepcion
ocurre mientras se ejecuta f(), entonces se crea y arroja (throw) un objeto excep-
cion. El bloque catch que sigue tiene entonces la oportunidad de atrapar (catch) la
excepcion arrojada, si el tipo del objeto excepcion es compatible por asignacion con
el tipo especificado como parametro del bloque catch. Si la excepcion es atrapada,
los enunciados en el bloque catch respectivo se ejecutan, y la ejecucion prosigue
con el enunciado siguiente al final del bloque try-catch. Si no ocurre ninguna ex-
cepcion, se salta el bloque catch y procede la ejecucion con el siguiente enunciado

125
al final del bloque try-catch. Por lo tanto, lo que sea que ocurra, el programa tiene
una oportunidad de seguir ejecutandose normalmente.

Hacer corresponder un objeto excepcion con el parametro de un bloque catch es

similar a una llamada a metodo. Si el tipo del objeto es compatible por asignacion,
el parametro de la excepcion se inicializa para mantener una referencia al objeto
excepcion, permitiendo que el objeto sea accesado dentro del entorno del bloque
catch. En el ejemplo anterior el parametro es de tipo Exception o cualquiera de
sus subclases.

Un bloque try puede ser seguido de varios bloques catch, cada uno tratando
una excepcion diferente:

try {
f(); // llamada al metodo que puede arrojar una excepcion
}

catch(UserException e) {
System.out.println("Llamada al metodo f ha fallado");
System.out.println(e.getMessage());
}

catch(Exception e) {
System.out.println("Llamada al metodo f ha fallado");
System.out.println(e.getMessage());
}

Cuando una excepcion es arrojada, el tipo del objeto se revisa contra el parametro
de cada bloque catch en el orden en que estan escritos. El primer bloque que coinci-
da se selecciona y ejecuta, y el resto son ignorados. En el ejemplo, esto significa que
el objeto excepcion se compara primero para ver si es instancia de UserException
o alguna de sus subclases. Si es as, entonces el bloque catch correspondiente es
ejecutado, o si no, se verifica la coincidencia con el siguiente bloque catch.

Notese que el segundo bloque es mas general, y atrapara mas tipos de excep-
ciones que el primero. Si el orden de los bloque catch se invierte, se da que:

try {
f(); // llamada al metodo que puede arrojar una excepcion
}

catch(Exception e) {
System.out.println("Llamada al metodo f ha fallado");
System.out.println(e.getMessage());
}

126
 catch(UserException e) {
System.out.println("Llamada al metodo f ha fallado");
System.out.println(e.getMessage());
}

lo que provoca que el segundo bloque no pueda ser alcanzado nunca, ya que el
primero siempre sera exitoso (UserException es compatible por asignacion con
Exception). El compilador de Java detecta esta situacion y reporta un error.

Un bloque finally puede seguir al bloque try-catch:

try {
f(); // llamada al metodo que puede arrojar una excepcion
}

catch(Exception e) {
System.out.println("Llamada al metodo f ha fallado");
System.out.println(e.getMessage());
}

finally {
g(); // Llama siempre a g, no importa lo que pase
}

Un bloque finally siempre se ejecuta, sin importar que pase con el bloque
try, aun si se arroja otra excepcion o se ejecuta un enunciado return. Esto provee
de un lugar para poner enunciados cuya ejecucion esta garantizada.

Normalmente, el programador desea utilizar un bloque catch para recobrar el

estado del programa, y dejarlo proseguir sin terminar. El bloque catch puede usar
cualquier variable y llamar a cualquier metodo en el entorno, y puede desplegar
un mensaje informando al usuario que ha habido un problema. Si otra excepcion
ocurre dentro de un bloque catch, no sera atrapada en el mismo bloque try-catch,
y tendera a propagarse.

Cuando un objeto excepcion es atrapado por un bloque catch, se tiene la

opcion de llamar a uno de los metodos de trazado de la pila del objeto, heredado de
Throwable, as como de usar el metodo getMessage() para obtener un mensaje.
Esto muestra una cadena de llamadas a metodos activos que se han hecho para
alcanzar el punto actual en el programa. Esta informacion puede ser usada para
revisar el programa.

Una traza de la pila se ve como sigue:

java.lang.NumberFormatException: abc
at java.lang.Integer.parseInt(Integer.java:229)
at java.lang.Integer.parseInt(Integer.java:276)

127
 at Exception1.convert(Exception1.java:14)
at Exception1.main(Exception1.java:29)

La primera lnea es el nombre de la clase de excepcion, seguido por el mensaje

de tipo String. Las siguientes lneas muestran cada llamada activa a metodo hasta
el metodo main (o un metodo Thread run, si la excepcion fue arrojada por una
hebra de control separada).

El siguiente ejemplo muestra el tpico bloque try-catch cuando se convierte de

un String representando un entero a su equivalente de tipo int. Esto llama a un
metodo de la biblioteca que arroja una excepcion si la conversion no puede hacerse.

class Exception1{
public int convert(String s) {
int result = 0;
try {
// Se usa un metodo de la biblioteca de clases Integer
// para convertir un String representando un entero a
// un valor int. parseInt arroja una exception si el
// valor String no es convertible a un int.
result = Integer.parseInt(s);
}

catch(NumberFormatException e) {
System.out.println("Falla en conversion de String: + e");
e.printStackTrace();
return result;
}

public static void main (String[] args) {

Exception1 e1 = new Exception1();
e1.convert("123");
e1.convert("abc");
}
}

El segundo ejemplo muestra el uso de multiples bloques catch y un bloque

finally.

class MyException extends Exception {

MyException(String s) {
super(s);
}
}

class Exception2 {

128
// Este metodo deliberadamente arroja una excepcion seleccionada por el
// argumento. Notese que NullPointerException e InterruptedException son
// clases de excepciones de la biblioteca. InterruptedException es una
// subclase directa de Exception, mientras que NullPointerException es una
// subclase de RuntimeException, la cual es subclase de Exception.
public void g(int x) throws Exception {
switch(x) {
case1 :
throw new MyException("Metodo g ha fallado");
case2 :
throw new NullPointerException("Metodo g ha fallado");
case3 :
throw new InterruptedException("Metodo g ha fallado");
default :
throw new Exception("Metodo g ha fallado");
}
}

public void f(int x) {

try {
if (x < 5) {
g(x);
}
System.out.println("Pasa llamada a g sin excepcion");
return;
}

catch (MyException e) {
System.out.println("MyException atrapado en metodo f: ");
System.out.println(e.getMesssage());
}

catch (Exception e) {
System.out.println("Exception atrapado en metodo f: ");
System.out.println(e.getMessage());
}

finally {
System.out.println("Se ha ejecutado f");
}
}

public static void main(String[] args) {

Exception2 e2 = new Exception2();
e2.f(1);

129
 e2.f(2);
e2.f(3);
e2.f(4);
e2.f(5);
}
}

4.3.3. Propagacion de Excepciones

Si una excepcion no es atrapada dentro de un metodo, se propaga ascendente-

mente sobre la cadena de llamadas a metodos activos hasta hallar un bloque catch
que lo maneje. Las excepciones no pueden ser olvidadas.

Las excepciones de las clases Error, RuntimeException, o de sus subclases no

tienen por que ser explcitamente manejadas y, si se arrojan, se propagan a traves de
la cadena de llamadas a metodos activos. No son necesarios los bloques try-catch
o declaraciones throws, aun cuando un metodo puede atrapar la excepcion si se
requiere.

Todas las demas excepciones deben siempre ser explcitamente tratadas usando
bloques try-catch y declaraciones throws. Cuando se usan estas excepciones, un
metodo puede retornar sin que la excepcion se atrape si el metodo mismo tiene una
declaracion throws y aun si no tiene ningun bloque catch, o que ninguno de los
bloques catch siguientes en el bloque try-catch pueda atrapar la excepcion. La
excepcion no atrapada se propaga de regreso al metodo original. Si hay un bloque
finally presente, este sera ejecutado antes de que la excepcion se propague.

Cuando una excepcion se propaga, cualquier bloque catch correspondiente a

un bloque try en el metodo que lo invoca tiene una oportunidad de atrapar la
excepcion. Si uno de ellos efectivamente la atrapa, entonces el bloque catch co-
rrespondiente se ejecuta, permitiendo que la ejecucion continue con el enunciado
siguiente al bloque try-catch, o con el enunciado siguiente del bloque finally
que se adecue. De otra manera, o si no hay bloques catch, la excepcion se propaga
de regreso hacia el metodo invocado anteriormente. Como parte de la propagacion,
un metodo sale del entorno, lo que provoca que todas las variables locales sean
destruidas.

Cuando cualquier excepcion (de cualquier categora) alcanza la cima de la ca-

dena de metodos activos (es decir, el metodo main o el metodo Thread run), un
manejador por omision lo atrapa y finaliza la hebra de control actual. Si tal hebra
de control es la unica, o es la hebra que ejecuta el main, el programa termina. Si
el main y otras hebras de control se encuentran aun activas entonces el programa
puede continuar su ejecucion, pero se encuentra bajo un serio riesgo.

130
4.3.4. Declaracion throws
Se requiere hacer una declaracion throws para cualquier metodo que arroje
o propague una excepcion que deba ser tratada explcitamente (por ejemplo, una
subclase de Exception excepto RuntimeException o alguna de sus subclases). La
declaracion enuncia el tipo o tipos de excepcion que pueden ser arrojadas por el
metodo.

Cualquier metodo estatico, metodo de instancia, metodo abstracto o declaracion

de constructor puede incluir una declaracion throws en seguida de la lista de
parametros y antes del cuerpo del metodo:

modificadores Nombredetipo NombredelMetodo(lista de parametros)

throws lista de nombres de tipos{
secuencia de enunciados
}

La lista de nombres de tipos especifica uno o mas nombres de clases o interfaces

separados por comas. El tipo de toda excepcion que puede ser arrojada o propagada
por el metodo deben ser incluidos. Las excepciones que se atrapan en el cuerpo del
metodo no necesitan ser listadas.

Cuando se trabaja con excepciones que deben ser tratadas explcitamente, un

metodo debe ya sea atrapar la excepcion o propagarla. La declaracion throws es-
tablece cuales tipos de excepciones seran propagadas.

Si un metodo invoca a otro metodo con una declaracion throws, se da alguno

de los siguientes casos:

El metodo es invocado desde un bloque try que tiene bloques catch capaces
de atrapar solo algunas de las excepciones que pueden ser arrojadas. El meto-
do que invoca no requiere ninguna declaracion throws respecto a la llamada
(pero puede requerir una declaracion de otras invocaciones).
El metodo se invoca de un bloque try con bloques catch que pueden atrapar
solo algunas de las excepciones que pueden ser arrojadas. Los demas tipos
de excepciones pueden ser propagados y deben aparecer en la declaracion
throws del metodo que invoca.
El metodo es invocado fuera de un bloque try y todos los tipos de excepciones
deben aparecer en el metodo que invoca en una declaracion throws.

Las excepciones de las clases Error, RuntimeException y sus subclases no

necesitan ser declarados en throws. Cualquier tipo especificado en una declaracion
throws debe ser de tipo Throwable o de sus subclases.

Los constructores siguen las reglas anteriores pero las expresiones new, que crean
objetos de la clase del constructor, no tienen que aparecer en el bloque try. Sin

131
embargo, si las excepciones arrojadas por un constructor no son atrapadas, pueden
provocar la terminacion de la hebra actual, o posiblemente del programa.

El siguiente programa incluye declaraciones throws y varios ejemplos de propa-

gacion de excpeciones:

// Se declaran dos subclases de la clase Exception para proveer

// de clases definidas por el usuario. Estas excepciones deben
// tratarse explicitamente

class MyException extends Exception {

MyException(String s) {
super(s);
}
}

class YourException extends Exception {

YourException(String s) {
super(s);
}
}

class Exception3 {
// Un constructor que arroja una excepcion
public Exception3(int x) throws MyException {
throw new MyException("Falla de constructor");
}

// Un metodo que puede arrojar dos tipos diferentes

// de excepciones, requiriendo que la declaracion throws
// liste ambas excepciones

public void h(int x) throws YourException, MyException {

if (x == 1) {
throw new YourException("Arrojada en h");
}
else {
throw new MyException("Arrojada en h");
}
}

132
// El siguiente metodo llama a h y puede tratar cualquier
// excepcion de tipo MyException que h pueda arrojar.
// Sin embargo, no puede atrapar excepciones del tipo
// YourException, propagandose en forma ascendente,
// y requiriendo una declaracion

public void g(int x) throws YourException {

try {
h(x);
}

catch (MyException e) {
System.out.println("Excepcion atrapada en g");
System.out.println(e.getMessage());
}

finally {
System.out.println("finally en g");
}
}

// Este metodo trata cualquier excepcion arrojada por la

// llamada a g y necesita una declaracion throws

public void f(int x) {

try {
g(x);
}

catch(Exception e) {
System.out.println("Excepcion atrapada en f");
System.out.println(e.getMessage());
}
}

// Los metodos r, s y t siguientes muestran que una excepcion o tipo

// Error no necesitan ser tratados exclicitamente, asi que no se
// provee ninguna declaracion throws

public void r() {

throw new Error("Error deliberado");
}
public void s() {
r();
}

133
 // Una excepcion de tipo Error puede ser aun atrapada usando un
// bloque try-catch

public void t () {
try {
s();
}

catch (Error e) {
System.out.println("Excepcion atrapada en t");
System.out.println(e.getMessage());
}
}

public static void main(String [] args) throws Exception {

// Prueba del tratamiento de excepciones

Exception3 e3 = new Exception3();

e3.f(1);
e3.f(2);
e3.t();

// El constructor tomando un int como argumento genera una

// excepcion que puede ser atrapada

try {
Exception3 e3b = new Exception3(1);
}

catch (Exception e){

System.out,println(e.getMessage());
}

// Sin embargo, la expresion new no necesita aparecer en un

// bloque try. Las excepciones arrojadas por el constructor
// pueden causar que el programa termine prematuramente

Exception3 e3c = new Exception3();

}
}

134
4.3.5. El enunciado throw
Un enunciado throw permite que una excepcion sea arrojada. La palabra clave
throw es seguida de una expresion del tipo Throwable, o uno de sus subtipos.

throw ExpresionThrowable;

El enunciado throw arroja una excpecion que sigue las reglas presentadas en
las secciones anteriores. Normalmente, se espera que la excepcion se propague en
forma ascedente al metodo invocado, de tal modo que el metodo que contiene el
throw tiene una declaracion throws. Las excepciones pueden ser arrojadas dentro
de un bloque try y atrapadas dentro del mismo metodo, si es necesario.

Una excepcion se crea usando una expresion new como parte del enunciado
throw, como por ejemplo:

throw new Exception("Algo ha fallado");

Un enunciado throw puede tambien ser usado para re-arrojar una excepcion que
ya haba sido atrapada. Esto permite que mas de un metodo dentro de la cadena de
metodos activos pueda tratar con la excepcion, tal vez cada uno haciendo su parte
para restaurar el estado del programa para que pueda continuar en forma segura
despues de que la excepcion ha sido tratada.

Una excepcion puede ser re-arrojada directamente desde un bloque catch:

try {
f();
}

catch (Exception e) {
throw e; // excepcion re-arrojada
}

El principal uso de throw es dentro de los metodos en bibliotecas y para dar

soporte a las clases al notificar a sus clientes que la llamada a un metodo ha fallado,
tpicamente cuando un objeto de una clase en la biblioteca ha sido usado erronea-
mente por el cliente (por ejemplo, si el cliente trata de sacar un valor de una pila
vaca). La presencia del enunciado throw en el metodo de la biblioteca forza al
programador a considerar la posibilidad de llamar al metodo que potencialmente
puede fallar mediante un bloque try-catch.

135
 El siguiente ejemplo (y el de la seccion anterior) muestra el uso de los enunciados
throw.

class Exception4 {
// Arroja una excepcion y la atrapa en el mismo metodo.
// Esto puede no ser muy util
public void f() {
try {
throw new Exception("Arrojada en f");
}

catch (Exception e) {
System.out.println(e.getMessage());
}
}

// El siguiente metodo arroja una excepcion, por lo que

// debe incluir una declaracion throws

public void g() throws Exception {

throw new Exception("Arrojada en g");
}

public void h() throws Exception {

try {
g();
}

catch (Exception e) {
// Imprime una traza para ver la cadena de metodos
// activos
e.printStackTrace();

// Reinicia el trazo, para que comience desde aqui

e.fillInStackTrace();

// Re-arroja la excepcion para permitir que otro metodo

// en la cadena de metodos activos la trate
throw e;
}
}

136
 // Atrapa la excepcion para prevenir mayor propagacion
public void k() {
try {
h();
}

catch (Exception e) {
e.printStackTrace();
}
}

// Algunos metodos extra para hacer mas profunda la traza

public void x() {

k();
}

public void y() {

x();
}

public static void main(String[] args) {

Exception4 e4 = new Exception4();
e4.f();
e4.y();
}
}

La salida de este programa (considerando que la salida de error estandar es

visible para el metodo printStackTrace) es:

Arrojada en f
java.lang.Exception: Arrojada en g
at Exception4.g(Exception4 java 23)
at Exception4.h(Exception4 java 10)
at Exception4.k(Exception4 java 47)
at Exception4.x(Exception4 java 58)
at Exception4.y(Exception4 java 63)
at Exception4.main(Exception4 java 70)
java.lang.Exception: Arrojada en g
at Exception4.h(Exception4 java 38)
at Exception4.k(Exception4 java 47)
at Exception4.x(Exception4 java 58)
at Exception4.y(Exception4 java 63)
at Exception4.main(Exception4 java 70)

137
 El metodo printStackTrace es declarado dos veces, as que hay dos trazas
de la pila comenzando con la lnea java.lang.Exception: Arrojada en g. Cada
traza muestra la cadena de metodos activos hasta el main. Notese que la primera
traza comienza a partir del metodo g, mientras que la segunda comienza desde
el metodo h, como resultado de la llamada al metodo fillInStackTrace, el cual
reinicia la traza en el metodo actual.

138
4.4. Hebras de Control (Threads)
Una hebra o hilo (thread) es un flujo de control en un programa, generalmente
caracterizado como una secuencia de invocaciones a metodos que se hacen cuando
la hebra se ejecuta. Todos los ejemplos anteriores han supuesto hasta ahora una
sola hebra que comienza su ejecucion con el metodo static main. Sin embargo,
un programa puede usar multiples hebras de control mediante tener una sola hebra
que genere nuevas hebras. Esto significa que en cualquier momento puede haber un
numero de secuencias de invocaciones a metodos en ejecucion.

La ejecucion de hebras es entremezclada (interleaved), de tal modo que puede

parecer que varias hebras se ejecutan simultaneamente, lo que permite que un pro-
grama realice varias cosas a la vez. Esto no es propiamente procesamiento paralelo,
ya que solo una hebra se encuentra activa en un momento dado y la Maquina Virtual
de Java unicamente tiene acceso a un solo procesador. Sin embargo, la hebra activa
puede ser intercambiada por otra, de tal modo que, de un momento a otro, dife-
rentes hebras se encuentran activas creando la ilusion de procesamiento paralelo.
A esto se le conoce frecuentemente como procesamiento concurrente (concurrent
processing) o multitarea (multitasking). En un procesamiento paralelo real, dos o
mas hebras se encuentran ejecutandose simultaneamente, lo que requiere de dos o
mas procesadores fsicos en una maquina.

Para ayudar a administrar multiples hebras y decidir cual debe estar activa,
las hebras tienen una prioridad. Una hebra con mayor prioridad tiene precedencia
sobre otra hebra de menor prioridad, y por lo tanto, tiene la oportunidad de eje-
cutarse primero. Cuando una hebra se detiene o se suspende (a lo que a veces se
le llama dormirse), otra hebra tiene la oportunidad de ejecutarse. La seleccion y
administracion de hebras se maneja por un proceso planificador (scheduler), el cual
mantiene una cola de hebras, cada una con su prioridad, y determina cual hebra
debe ejecutarse en un momento y cual debe ejecutarse despues, partiendo de un
conjunto de reglas. La regla principal es, como se menciona anteriormente, escoger
la hebra con mayor prioridad. Pero es posible que haya mas de una hebra con esta
misma prioridad, en cuyo caso se escoge aquella que se encuentre al frente de la
cola.

Algunas versiones de la Maquina Virtual de Java entremezclan automatica-

mente hebras con la misma prioridad (usando mecanismos como el round robin
global) de tal modo que cada hebra recibe una parte casi igual en la division del
tiempo de ejecucion. Sin embargo, otras versiones no hacen esto, lo que significa
que hebras con la misma prioridad pueden no tener la misma oportunidad de ejecu-
tarse. Esto, desafortunadamente, implica que un programa que usa ciertos aspectos
de hebras puede trabajar propiamente en un sistema pero no en otro. Conforme las
nuevas versiones de la Maquina Virtual de Java mejoren, esto pudiera remediarse
en el futuro.

139
 Una consecuencia del mecanismo de priorizacion y planificacion es que las he-
bras con baja prioridad podran no tener la oportunidad de ejecutarse nunca, ya que
siempre es posible que haya una hebra con mayor prioridad esperando en la cola. El
programador debe estar consciente de esto, y tomar las precauciones para asegurar
que todas las hebras tengan la oportunidad de ejecutarse tan frecuentemente como
sea posible para realizar su labor.

Otra caracterstica de la priorizacion de hebras es que una hebra en ejecucion

puede ser interrumpida (pre-empted) por otra hebra de mayor prioridad que comien-
za o regresa de su estado suspendido (despierta) e intenta ejecutarse. Esto provee
de un mecanismo importante para la respuesta rapida a eventos que causen el des-
pertar de la hebra con mayor prioridad, pero tambien requiere que el programador
planee en forma cuidadosa que hebra tiene que prioridad.

Todos los programas en Java, ya sean aplicaciones o applets, son en realidad

multihebra, aun cuando el codigo que el programador produce tenga una sola hebra.
Esto se debe a que la Maquina Virtual de Java usa hebras para proveer y admnistrar
varias actividades internas de mantenimiento, como por ejemplo, la recoleccion de
basura (garbage collection). La hebra que ejecuta el metodo main de un programa
es tan solo otra hebra generada por la Maquina Virtual de Java. El conjunto com-
pleto de las hebras que un programa usa puede ser visto utilizando el depurador
(debugger) de JDK, jdb, o su equivalente en ambientes comerciales.

Un programa se mantiene en ejecucion mientras que su hebra original o cualquiera

de las hebras que genere esten en existencia, aun cuando ninguna de ellas pueda ser
planificada para ejecutarse porque todas se encuentren bloqueadas o suspendidas
por alguna razon. Cuando todas las hebras en un programa han terminado, tambien
lo hace el programa; el estado de las hebras internas de la Maquina Virtual de
Java para propositos de mantenimiento del sistema de ejecucion no se toman en
cuenta para esto.

Las hebras son utiles para muchos propositos incluyendo el soporte de tecnicas
de programacion concurrente. Un buen numero de bibliotecas de clases de Java usan
hebras de control, tpicamente para permitir actividades lentas, poco frecuentes o
inconexas, que se realizan sin atravesarse en el flujo principal del programa. Por
ejemplo, la biblioteca AWT usa hebras para permitir a la interfaz grafica (GUI) de
un programa el ser manipulada o actualizada mientras que el programa continua
con su labor principal.

Las hebras tambien proveen de soluciones a problemas que de otra manera sera
muy difcil o imposible de programar. Esto incluye el manejo de eventos multiples
asncronos, como leer datos de diversas fuentes en una red, sin que el programa
principal se detenga esperando a que lleguen los datos.

140
4.4.1. La clase Thread
Las hebras de control se representan en Java como instancias de la clase Thread,
que se encuentra en el paquete de bibliotecas java.lang. La clase Thread provee
de una variedad de metodos para crear y manipular hebras. La informacion de la
clase Thread puede encontrarse en la seccion java.lang de la documentacion de
JDK.

Todas las hebras tienen un nombre, el cual si no es explcitamente dado, se

genera automaticamente por omision. Cada hebra es miembro de un grupo de hebras
(thread group), que es una instancia de la clase ThreadGroup, la cual puede tambien
ser dada explcitamente si no se desea el grupo por omision.

Las hebras pueden ser creadas usando una instancia de una clase que imple-
mente la interfaz Runnable, como se describe posteriormente. Esta interfaz declara
un metodo abstracto:

public interface Runnable {

public abstract void run();
}

La clase Thread puede ser usada en dos formas:

Declarando una subclase de Thread que redefina el metodo run. Cuando una
instancia de la subclase se crea e invoca al metodo start, una nueva hebra
comienza su ejecucion llamando al metodo run.

class MyThread extends Thread {

...
public void run () {
... // Codigo que implementa lo que haga la hebra
}
...
}

...

MyThread t = new MyThread(); // Crea una nueva hebra con

// prioridad por omision
t.start(); // Inicia la nueva hebra invocando al metodo run

141
 Declarando una clase que implemente la interfaz Runnable, de tal modo que
redefina al metodo run declarado en la interfaz. La clase no tiene que ser
una subclase de Thread. Una nueva hebra se inicia mediante primero crear
un objeto Thread, pasando como parametro al constructor de Thread una
instancia de la clase que implementa a Runnable, y se activa mediante invocar
el metodo start del objeto tipo Thread. Esto resulta en la creacion de la
hebra, seguido de la invocacion al metodo run de la clase que implementa
Runnable. La hebra termina cuando run termina.

class MyThreadedClass implements Runnable{

...
public void run () {
... // Codigo que implementa lo que haga la hebra
}
...
}

...

Thread t = new Thread(new MyThreadedClass());

t.start();

En ambos casos, una nueva hebra realmente comienza a ejecutarse cuando se

le incluye en la planificacion por el planificador de hebras. Esto significa que una
nueva hebra no necesariamente comienza a ejecutarse inmediatamente despues de
su creacion, y puede no ejecutar nada si un diseno pobre genera hebras de control
de alta prioridad que siempre se apropian del tiempo de procesador.

No hay diferencia en el comportamiento durante ejecucion (runtime behavior)

de las hebras, ya sea que fueran creadas por subclases de Thread o por instancias
de Thread que mantienen un objeto implementando la interfaz Runnable. Esta
distincion es, sin embargo, importante durante el diseno. Una subclase de Thread
no puede ser subclase de ninguna otra clase, ya que Java solo permite la herencia
de una sola superclase. Esto significa que las subclases de Thread solo pueden ser
usadas donde no se requiere la herencia de otra clase. De otra forma, una clase tiene
que implementar Runnable, lo que le permite heredar lo que sea necesario.

El siguiente ejemplo ilustra una simple subclase de Thread, mostrando un meto-

do run redefinido. Una sola hebra es creada e iniciada, que despliega una secuencia
de 25 mensajes. El flujo de control principal (que se ejecuta en la hebra por omision
del programa) tambien despliega una secuencia de 25 mensajes. Ambas hebras des-
pliegan sus prioridades, que deben ser iguales y dispuestas a 5. Como ambas hebras
se ejecutan con la misma prioridad, la salida del programa vara dependiendo de
cual Maquina Virtual de Java se utilice para ejecutarlo. Una maquina que soporte
la multitarea prevenida (pre-emptive multitasking) de hebras con misma prioridad

142
despliega ambos conjuntos de mensajes entremezclados. De otra manera, un con-
junto de mensajes aparecera antes que el otro.

class ThreadTest1 extends Thread {

// Metodo para desplegar un mensaje 25 veces
public void message(String s) {
for (int i = 0; i < 25; i++) {
System.out.println(s+": "+(i+1));
}
}

// El metodo run debe ser redefinido y se invoca cuando la

// hebra se inicia
public void run() {
System.out.println("Prioridad de la hebra: " + getPriority());
message("Salida de la hebra");
}

public static void main(String [] args) {

// Crea un nuevo objeto para ejecutar una hebra separada
// y un objeto para ejecutar el programa principal
Thread t = new ThreadTest1();
ThreadTest1 test = new ThreadTest1();

// Notese como una referencia a la hebra actual se obtiene

// usando un metodo estatico de la clase Thread
System.out.println("Prioridad del programa principal es: " +
Thread.currentThread().getPriority());

// Inicia la nueva hebra

t.start();

test.message("Salida del programa principal");

}
}

143
 Una salida entremezclada de este programa puede verse como se muestra en-
seguida. Esto vara de sistema a sistema dependiendo de las propiedades y velocidad
de la Maquina Virtual de Java utilizada:

Prioridad del programa principal es: 5

Salida del programa principal: 1
Salida del programa principal: 2
Salida del programa principal: 3
Prioridad de la hebra: 5
Salida de la hebra: 1
Salida del programa principal: 4
Salida del programa principal: 5
Salida de la hebra: 2
Salida de la hebra: 3
Salida del programa principal: 6
Salida del programa principal: 7
Salida de la hebra: 4
Salida de la hebra: 5
Salida de la hebra: 6
Salida de la hebra: 7
...

El siguiente ejemplo ilustra el uso de la interfaz Runnable. El programa funciona

como un reloj muy sencillo, imprimiendo la hora una vez por segundo. Tambien se
muestra el uso del metodo sleep de la clase Thread. Notese que el programa no
termina con el final del metodo main, sino que permanece en ejecucion dado que
hay una hebra aun en ejecucion.

import java.util.Date;

class TestThread2 implements Runnable {

// Despliega la hora actual cada segundo, repitiendose para siempre
public void run() {
while(true) {
System.out.println(new Date());
// Espera 1 segundo llamando a sleep, que tiene
// que estar en un bloque try. Cualquier excepcion
// que se arroje es ignorada
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException e) {
}
}
}

144
 public static void main(String[] args){
Thread t = new Thread(new TestThread2());

t.start();
System.out.println("Fin del programa principal");
}
}

4.4.2. Metodos Sincronizados

En un programa con hebras de control, los metodos que cambian el estado
de un objeto deben ser protegidos, ya que dos o mas hebras de control separadas
pueden intentar la ejecucion de un mismo metodo al mismo tiempo. Un metodo
sincronizado (synchronized method) puede solo ser ejecutado por una hebra si tal
hebra obtiene primero un candado (lock) sobre el objeto del que se invoca el
metodo. Para esto, los metodos de instancia y clase pueden ser declarados con el
modificador synchronized.

Una vez creadas, todas las hebras se ejecutan dentro del mismo programa y
tienen acceso a cualquier objeto del que se pueda obtener una referencia, lo que
lleva a la posibilidad de conflictos entre hebras como se describe antes. La solucion
a este problema se basa en candados para los objetos. Cada objeto tiene un candado
(un token) que puede retenerse por una sola hebra en cualquier momento dado.

Cuando una hebra ejecuta una invocacion a un metodo que ha sido declarado
como synchronized, primero intenta obtener el candado del objeto al que pertenece
el metodo invocado. Si se obtiene el candado, la hebra continua y ejecuta el meto-
do, reteniendo el candado hasta retornar del metodo. Si el candado no puede ser
obtenido, la hebra se bloquea, y se suspende su ejecucion. Cuando el candado se
libera, una de las hebras bloqueadas tiene la oportunidad de obtener el candado,
pero solo cuando el planificador de hebras se lo permite. Una hebra que retiene
el candado de un objeto puede invocar otros metodos sincronizados en el mismo
objeto, sin necesidad de liberar o re-obtener el candado.

Una vez que el candado de un objeto ha sido solicitado, ninguna otra hebra
de control puede ejecutar metodos sincronizados para tal objeto. Mas aun, una vez
que una hebra retiene el candado de un objeto, solo lo libera cuando la ejecucion
de los metodos sincronizados termina y el metodo que invoca no es sincronizado
para el mismo objeto, o cuando se invoca el metodo wait.

Es tambien posible tener metodos sincronizados estaticos. Como estos metodos

no se invocan para un objeto en particular, no es posible obtener un candado de
objeto. En lugar de eso, cada clase tiene un candado de clase (class lock), el cual
reemplaza al candado de objeto. Antes de que un metodo sincronizado estatico sea

145
ejecutado, la hebra de control que lo invoca debe obtener primero el candado de
clase. Aparte de esto, los metodos sincronizados estaticos se comportan de forma
muy semejante a los metodos sincronizados de instancia.

Debe tenerse cuidado que el uso de metodos sincronizados no lleve a situaciones

como abrazos mortales (deadlocks), en donde todas las hebras se bloquean tratan-
do de obtener los candados retenidos por otras hebras. Por ejemplo, considerese el
siguiente ejemplo:

// Declarado en una clase A

public synchronized void f(B b) {
b.x();
}

// Declarado en una clase B

public synchronized void g(A a) {
a.y();
}

...

A a = new A(); // Hebra 1

B b = new B(); // Hebra 2

...

// En la hebra 1
a.f(b);

...

// En la hebra 2
b.g(a);

Si a ejecuta la llamda al metodo f para un objeto de la clase A, primero debe

obtener el candado del objeto. Una vez que el metodo esta en ejecucion, la misma
hebra debe obtener el candado en un objeto de la clase B, a fin de realizar la llamda
b.x(), y sin liberar el candado que ya tiene. Una situacion similar se aplica para la
llamada de g a un objeto de la clase B. Ambos metodos f y g requieren de obtener
dos candados para terminar con exito.

El problema surge si f y g se ejecutan en dos hebras que trabajan con los

mismos objetos, como se muestra al final del ejemplo anterior. Si las llamadas de
f y g se entremezclan, entonces la hebra 1 podra comenzar a ejecutar el metodo
f y obtener el candado de a, mientras que la hebra 2 puede comenzar a ejecutar

146
el metodo g, obteniendo el candado de b, pero teniendo que suspenderse antes de
alcanzar la llamada al metodo a.y(). En ese punto, ninguna de las hebras puede
proceder, ya que cada una espera la liberacion de un candado que es mantenido
por la otra, lo que implica que un abrazo mortal ha sucedido.

El abrazo mortal puede ser difcil de detectar, y puede involucrar tres o mas
hebras. Ademas, puede ocurrir solo cuando el planificador de hebras produce un
orden especfico de acciones entre hebras en un tiempo particular y relativo de las
llamadas a los metodos. En general, la unica forma de evitar el abrazo mortal es
mediante diseno cuidadoso, y evitando llamadas a metodos que pudieran causar
conflictos. Depurar programas donde ocurren abrazos mortales es notoriamente
difcil, as que es mejor no permitir que el problema ocurra en primera instancia.

Una clase disenada para que sus objetos trabajen apropiadamente en presencia
de multiples hebras se conoce como clase segura para hebras (thread-safe class).
Tpicamente, la mayora de (si no todos) sus metodos publicos son sincronizados, a
menos que un metodo sea tan simple que no se vea afectado por el estado cambiante
del objeto debido a otra hebra. Si hacer un metodo completo sincronizado resulta
poco manejable, entonces puede utilizarse enunciados sincronizados en el metodo,
como se describe en la siguiente seccion.

El siguiente ejemplo ilustra la diferencia entre utilizar metodos sincronizados

y metodos ordinarios. Dos metodos, f y g, incrementan dos variables de instancia
inicializadas en cero antes de que cada prueba que realiza el programa se inicie.
Como g tiene el modificador synchronized, garantiza que las variables de instancia
siempre mantienen el mismo valor, ya que ambas variables comienzan con el mismo
valor y se incrementan juntas en el mismo metodo. El metodo f, sin embargo, no es
sincronizado, y la hebra que lo ejecute puede ser interrumpida, permitiendo que los
valores de las dos variables de instancia sean divergentes. Notese que este ejemplo
utiliza clases miembro y hebras de prioridad 8 para garantizar que la hebra de baja
prioridad no sea ejecutada.

class ThreadTest6 {
// Declara un conjunto de clases miembro que crean hebras
// que invocan a metodos test diferentes, con diferentes
// pausas
class MyThread1 extends Thread {
public void run() {
for (int i = 0; i < 10; i++) {
g();
}
}
}

147
class MyThread2 extends Thread {
public void run() {
setPriority(8);
for (int i = 0; i < 10; i++) {
g();
pause(700);
}
}
}

class MyThread3 extends Thread {

public void run() {
for (int i = 0; i < 100; i++) {
f(500);
}
}
}

class MyThread4 extends Thread {

public void run() {
setPriority(8);
for (int i = 0; i < 150; i++) {
f(100);
pause(200);
}
}
}

// Llamada al paquete de sleep, lo que hace al metodo

// mas facil
public void pause(int n) {
// Pausa por un tiempo semi-aleatorio
int r = (int)(Math.random() * n);
try {
Thread.currentThread().sleep(r);
}
catch (InterruptedException e) {
}
}

148
// Metodo no sincronizado. Las hebras pueden entremezclarse
// al ejecutar esto
public void f(int p) {
i++;
pause(p);
j++;
System.out.println("Metodo f: " + ((i==j)? "Igual" : "Diferente"));
}

// Las hebras no pueden entremezclarse al ejecutar el siguiente

// metodo
public synchronized void g() {
i++;
j++;
System.out.println("Metodo g: " + ((i==j)? "Igual" : "Diferente"));
}

// Ejecuta las pruebas

public void go() {
// Llama al metodo g. Notese que las variables i y j
// no divergen
System.out.println("Llamando al metodo g");
Thread t1 = new MyThread1();
Thread t2 = new MyThread2();

i = 0;
j = 0;

t1.start();
t2.start();

try {
t1.join();
t2.join();
}
catch(InterruptedException e) {
}

// Llama al metodo no sincronizado y notese que las

// variables i y j divergen
System.out.println("Llamando al metodo f");
Thread t1 = new MyThread3();
Thread t2 = new MyThread4();

i = 0;

149
 j = 0;

t1.start();
t2.start();
}

public static void main(String[] args) {

ThreadTest6 shared = new ThreadTest6();
shared.go();
}

private int i = 0;
private int j = 0;
}

4.4.3. El enunciado synchronized

El enunciado synchronized permite que un enunciado individual (incluyendo
un enunciado compuesto) pueda ser protegido mediante el candado de un objeto,
el cual debe ser obtenido antes de que el enunciado se ejecute.

El enunciado synchronized tiene la forma:

syncronized (referencia a objeto) enunciado

El enunciado puede ser un enunciado compuesto.

El enunciado synchornized se ejecuta para la primera hebra que obtenga el

candado del objeto referenciado por el valor en la expresion entre parentesis. Si se
obtiene el candado, el enunciado se ejecuta, y se libera el candado. De otra manera,
la hebra se bloquea y se forza a esperar hasta que el candado se haga de nuevo
disponible.

El siguiente programa usa el enunciado synchronized.

class ThreadTest7 {
class MyThread extends Thread {
public void run() {
for (int i = 0; i < 99; i++) {
synchronized(vals) {
vals[i] += vals[i+1];
}
}
}
}

150
 public void go() {
Thread t1 = new MyThread();
Thread t2 = new MyThread();

t1.start();
t2.start();

try {
t1.join();
t2.join();
}
catch(InterruptedException e) {
}

for (int i = 0; i < 100; i++) {

System.out.println(vals[i] + " ");
}
}

public static void main(String[] args) {

ThreadTest7 t7 = ThreadTest7();
t7.go();
}

private int[] vals = new int[100];

{
for (int i = 0; i < 100; i++) {
vals[i] = i;
}
}
}

151
4.5. Ventanas (Windows)
En la actualidad, muchos programas proveen de un formato grafico de interac-
cion con el usuario: las Interfaces Graficas de Usuario (Graphical User Interface o
GUI). Al usuario se le presentan una o mas ventanas (windows) que contienen
texto, dibujos, diagramas de varios tipos o imagenes. El usuario se comunica con el
programa mediante escribir en ares designadas, o moviendo el raton (mouse) a
una posicion en particular, y presionando un boton del mismo. Las acciones pueden
ser presionar un boton en pantalla, recorrer una ventana a traves de un diagrama
mas grande o area de texto, indicar un lugar en particular dentro de un dibujo
donde una accion o re-dibujado se requiere, etc.

En el pasado, uno de los problemas en crear un GUI haba sido la plataforma,

es decir, la computadora y ambiente de ventanas del sistema operativo. Aun al
escribir un programa en un lenguaje portable estandar como C, los diferentes sis-
temas operativos tenan (y en ocasiones, siguen teniendo) un conjunto de elementos
diferentes para los GUI, con diferentes comportamientos.

En esta seccion se describe como construir un GUI para un programa escrito

en Java. Java provee de un conjunto de elementos contenidos en las bibliotecas del
Abstract Windowing Toolkit (AWT), que permiten la construccion de GUIs con la
misma apariencia y comportamiento en varias plataformas. Esto se logra mendiante
un mapeo de los elementos de AWT a los elementos que provee el sistema operativo
en particular donde el programa se ejecuta.

Existen mas de cincuenta clases en las versiones actuales de AWT. No es el

objetivo de esta seccion describirlas en detalle, sino mas bien introducir un numero
de programas cortos que usan AWT para proveer de GUIs simples. Los ejemplos
aqu se basan en derivar nuevas clases de las clases provistas por AWT, por lo
que es importante considerar las caractersticas de la herencia en Java. Para mayor
informacion sobre AWT en Java, consultese la documentacion en lnea del lenguaje.

Hay diferencias significativas entre un programa con interfaz de texto y uno

con interfaz grafica. Principalmente, se refieren al rango de eventos que el progra-
ma puede manejar. Cuando un programa con interfaz de texto espera una entrada
por parte del usuario, la unica cosa que puede suceder es que el usuario eventual-
mente escriba una secuencia de caracteres. El programa interpreta la secuencia de
caracteres, decide si son o no validos, y toma la accion apropiada. Sin embargo,
en una interfaz grafica, es posible que haya varias areas de texto, o sea necesario
presionar con el raton en alguna parte de la ventana. Mas aun, se pueden presentar
al usuario mas de una ventana, todas conectadas al mismo programa. El usuario
puede decidir mover una de estas ventanas, obscureciendo u ocultando parcial o
totalmente las otras. El usuario puede intentar recobrar ventanas obscurecidas u
ocultas, y el sistema debe reconocer y redibujar las partes que se hacen visibles
de nuevo. El usuario puede redimensionar la ventana, haciendola mas grande o

152
pequena, y el sistema debe hacerse cargo de redibujar la interfaz grafica a su nuevo
tamano.

Una caracterstica central de un programa grafico es el ciclo de evento (event

loop). El programa espera que un evento ocurra, y cuando ocurre causa que una
accion apropiada suceda. Por ejemplo, si la ventana se expone tras haber sido oculta,
o si se cambia su tamano, es necesario invocar un metodo para que se redibuje la
ventana. Si un boton ha sido presionado, debe llamarse al metodo adecuado para
tratar este evento (presumiblemente, debe hacerse algun calculo, que requiere que
algo o todo de la ventana se redibuje). Despues de que la accion apropiada al evento
se realiza, el programa vuelve a esperar en el ciclo de evento.

El ciclo de evento esta dentro del codigo que implementa AWT, y no aparece
explcitamente como parte del cogido del programador. El programador debe con-
siderar normalmente el hacer ciertas inicializaciones que preparan a los componentes
graficos para desplegarse, y en seguida se coloca dentro del ciclo de evento de AWT.
El resto del programa es entonces una serie de fragmentos (tpicamente, metodos),
cada uno de los cuales es invocado por el ciclo de evento de AWT para tratar cierto
tipo de evento.

Hay aun otra caracterstica importante de la programacion grafica que se ilustra

en los siguientes ejemplos de programas. Normalmente, es necesario un metodo
que redibuje una parte de la ventana, basado en el estado de varias variables del
programa. En Java, este metodo es generalmente llamado paint. Cuando un evento
ocurre, la accion correspondiente debe normalmente registrar los detalles del evento,
y despues pedir a AWT que lleve a cabo el redibujado de la parte apropiada de la
pantalla en un tiempo determinado. Esta peticion se realiza mediante el metodo
repaint. Por ejemplo, un metodo invocado como resultado de presionar con el
boton del raton en cierta posicion simplemente registra la posicion, e invoca a
repaint. Esto permite que la accion se realice mas agilmente, lo que permite al
programa continuar recibiendo eventos como ocurran. Redibujar las parte de la
ventana con el metodo paint puede hacerse, pero en general es mas lento.

4.5.1. Un Programa Simple con Interfaz Grafica

Considerese el siguiente programa simple:

import java.awt.*;
import java.awt.event.*;

public class Simple extends Frame

implements WindowListener, ActionListener {

public Simple() {
// Prepara la ventana basica
setTitle("Simple");

153
 setBackground(Color.green);
setSize(500, 400);
addWindowListener(this);

// Prepara el area para un dibujo

Canvas c = new Canvas0();
add("Center", c);

// Prepara una area con botones

Panel p = new Panel();
p.setLayout(new FlowLayout());
Button quit = new Button("Quit");
p.add(quit);
quit.addActionListener(this);
add("South", p);
}

public static void main (String[] args) {

Simple s = new Simple();
s.setVisible(true);
}

public void actionPerformed(ActionEvent event) {

// Trata la entrada del boton quit
dispose();
System.exit(0);
}

public void windowClosing(WindowEvent event) {

dispose();
System.exit(0);
}

public void windowOpened(WindowEvent event) {}

public void windowIconified(WindowEvent event) {}
public void windowDeiconified(WindowEvent event) {}
public void windowClosed(WindowEvent event) {}
public void windowActivated(WindowEvent event) {}
public void windowDeactivated(WindowEvent event) {}
}

class Canvas0 extends Canvas {

public void paint(Graphics g) {

// Prepara algunas dimensiones para el area de dibujo

154
Dimension d = getSize();
int cx = d.width/2,
cy = d.height/2,
faceRadius = 50,
noseLength = 20,
mouthRadius = 30,
mouthAngle = 50,
eyeRadius = 5;

// Dibujar el marco
g.setColor(Color.black);
g.drawRoundRect(2, 2, d.width - 5, d.height - 5, 20, 20);

// Dibujar una cara

g.setColor(Color.red);
g.drawOval(cx - faceRadius, cy - faceRadius,
faceRadius * 2, faceRadius * 2);
g.setColor(Color.blue);
g.fillOval(cx - 30 - eyeRadius, cy - 20,
eyeRadius * 2, eyeRadius * 2);
g.fillOval(cx + 30 - eyeRadius, cy - 20,
eyeRadius * 2, eyeRadius * 2);
g.setColor(Color.red);
g.drawLine(cx, cy - (noseLength/2), cx, cy + (noseLength/2));
g.drawArc(cx - mouthRadius, cy - mouthRadius,
mouthRadius * 2, mouthRadius * 2,
270 - mouthAngle, mouthAngle * 2);

// Escribe texto
Font f1 = new Font("TimeRoman", Font.PLAIN, 14);
Font f2 = new Font("TimeRoman", Font.ITALIC, 14);
FontMetrics fm1 = g.getFontMetrics(f1);
FontMetrics fm2 = g.getFontMetrics(f2);
String s1 = "Hello, ";
String s2 = "World";
int w1 = fm1.stringWidth(s1);
int w2 = fm2.stringWidth(s2);
g.setColor(Color.black);
g.setFont(f1);
int ctx = cx - ((w1 + w2)/2);
int cty = cy + faceRadius + 30;
g.drawString(s1, ctx, cty);
ctx += w1;
g.setFont(f2);
g.drawString(s2, ctx, cty);

155
 }
}

La clase de Java que implementa una ventana independiente en la pantalla es

llamada Frame. La version de Frame del programa contiene un area donde se dibuja
una carita feliz, que es otra clase derivada de la clase Canvas. Se le anade un area
en la parte baja, Panel, que contiene un boton de salida Quit. Entonces, la clase
Simple se deriva de Frame, y provee de la descripcion basica de la ventana, ejecuta
el programa de inicio, y especifica la accion de presionar el boton Quit. La clase
Canvas0 se deriva de Canvas, y contiene la informacion para realizar el dibujo de
la cara y el texto que la acompana. Las clases y metodos de AWT se encuentran
en dos paquetes: java.awt y java.awt.event, por lo que se importan la principio
del programa.

4.5.2. Descripcion de la Ventana

El metodo constructor Simple() especifica las caractersticas principales de la
ventana:

Especifica el ttulo de la ventana, usando setTitle("Simple"). Si se omite

este paso, un ttulo por omision podra parecer, como Untitled o *****.
El metodo setBackground(Color.green) pinta de color verde el fondo de la
ventana. El argumento de este metodo es una instancia de la clase Color. Esta
clase provee de un numero de colores como constantes. Color.green especi-
fica el verde, pero las constantes pueden ser: black, blue, cyan, darkGray,
gray, green, lightGray, magenta, orange, pink, red, white, o yellow. De
hecho, es posible construir combinaciones de colores con la clase Color.
Especifica el tamano de la ventana con setSize(500, 400). Este metodo
toma dos parametros int, el primero especificando el ancho y el segundo
la altura, ambos en unidades de pixeles. Un pixel (o picture element) es
la unidad basica de resolucion de una pantalla; es el area de pantalla mas
pequena que puede ser direccionada, y es la unidad en que las coordenadas
dentro de una ventana se especifican, a partir de un origen en la esquina
superior izquierda. No debe omitirse este paso, ya que AWT necesita esta
informacion inicial para considerar la nueva ventana que se esta creando.
El metodo addWindowListener se discute mas adelante.
El area de dibujo se establece como una instancia de la clase Canvas. Esto
se declara como Canvas c = new Canvas0(). Se desea que el area de dibujo
aparezca con un boton en su parte inferior. Es posible indicar esto a AWT
mediante una posicion exacta, pero en general es posible arreglar los ele-
mentos utilizando posiciones relativas. Para esto, AWT provee de un numero

156
 de manejadores de presentacion (layout managers), los cuales hacen la la-
bor de posicionar los componentes de una grafica en un contenedor. La
presentacion por omision de las clases derivadas de Frame se conocen como
de borde (border). Se anade entonces un componente de dibujo mediante el
metodo add. Utilizando el manejador de presentacion, las posiciones relativas
se especifican como se muestra en la figura 4.4.

North

West Center East

South

Figura 4.4: Posiciones relativas del manejador de presentaciones de borde

De esta forma, se hace que el area de dibujo se coloque en la posicion Center,

y el grupo de botones va en la parte South. No es necesario llenar todas las
posiciones de la presentacion de borde.
Se especifica el boton Quit. Este se coloca en un panel, que es un com-
ponente general de ventanas que contiene otros componentes. Se declara co-
mo instancia de la clase Panel, mediante la lnea Panel p = new Panel().
Dentro del metodo setLayout, se especifica ademas que el panel debe tener
otro manejador de presentacion, llamado de flujo (flow), el cual arregla
los componentes en forma de renglon de izquierda a derecha, y en segui-
da, de arriba hacia abajo. Esto se hace mediante la lnea p.setLayout(new
FlowLayout()). Se crea entonces un boton etiquetado con la palabra Quit,
mediante crear una instancia de la clase Button con la etiqueta como argu-
mento de su constructor, y se anade al panel p utilizando el metodo add:
Button quit = new Button("Quit");
p.add(quit);
Finalmente, se anade el panel p a la clase derivada de Frame, posicionandolo
en la parte inferior de la ventana mediante add("South", p).
En este ejemplo, se utilizan los manejadores de presentaciones FlowLayout y
BorderLayout. Existen otros manejadores, pero tal vez el mas util pudiera ser el
manejador GridLayout, que arregla los componentes en forma matricial de ren-
glones y columnas. Por ejemplo:

p.setLayout(new GridLayout(2, 3)); // 2 renglones, 3 columnas

157
 Los componentes se anaden utilizando el metodo add sin argumentos adi-
cionales. Es por esto que los componentes deben anadirse en un orden especfi-
co para llenar renglones y columnas. En el ejemplo anterior, los componentes se
agregan utilizando las invocaciones al metodo add en el siguiente orden:

p.add(renglon0columna0);
p.add(renglon0columna1);
p.add(renglon0columna2);
p.add(renglon1columna0);
p.add(renglon1columna1);
p.add(renglon1columna2);

Esto genera una presentacion de la forma que se muestra en la figura 4.5.

Figura 4.5: Renglones y columnas en una GridLayout

Se puede ser todava mas especfico sobre como los componentes se acomodan,
por ejemplo, utilizando la presentacion GridBagLayout, o simplemente ir recursiva-
mente anadiendo un GridLayout anidado en otro GridLayout, y as sucesivamente.

Ahora bien, el metodo main de la clase Simple se encarga de:

Inicializar una variable de tipo local Simple con el constructor que se ha
descrito, mediante la lnea Simple s = new Simple().
En seguida, invoca al metodo setVisible, que despliega el objeto en pan-
talla, mediante la lnea s.setVisible(true). Finalmente, el objeto s entra
al ciclo de evento de AWT, esperando por eventos que ocurran.

El metodo actionPerformed de la clase Simple debe especificarse de tal modo

que defina que sucede cuando el boton Quit se presiona. Cuando se presiona un
boton, el systema AWT invoca al metodo actionPerformed, el cual pertenece a
la interfaz ActionListener. Por lo tanto, primero es necesario declarar la clase
Simple como implementacion de la interface:

158
public class Simple extends Frame implements ActionListener

Por cada boton que se anada, es necesario definir a AWT que clase contiene
el metodo actionPerformed. En general, la clase es aquella que contiene al cons-
tructor que establece al boton en un principio. De este modo, es posible utilizar la
palabra clave this como argumento del metodo addActionListener, aplicado al
boton que se desee utilizar:

quit.addActionListener(this);

Es necesario ahora escribir el metodo actionPerformed. Este tiene un solo

argumento, un objeto de tipo ActionEvent, el cual da los detalles de que sucede:

public void actionPerformed(ActionEvent) {

...
}

Por el momento, este ejemplo solo cuenta con un boton, de tal modo que si
este metodo es invocado, se asume que el boton Quit ha sido presionado. Si esto
sucede, es necesario salir del programa mediante invocar al metodo System.exit.
Ya que es una salida normal del programa, se da un argumento de valor cero. Sin
embargo, antes de hacer esto, es necesario asegurarse que todos los recursos que el
sistema usa en este objeto sean retornados, utilizando el metodo dispose:

dispose();
System.exit(0);

Finalmente, es necesario considerar un metodo windowClosing para asegurar

que siempre se pueda salir del programa si algo sale mal. Para esto, es necesario
implementar la interfaz WindowListener:

public class Simple extends Frame

implements WindowListener, ActionListener

Dado que se especifica que el metodo windowClosing debe encontrarse en esta

clase, se inserta en el enunciado del constructor:

addWindowListener(this);

159
 De este modo, el metodo windowClosing solo sale del programa:

public void windowClosing(WindowEvent event) {

dispose();
System.exit(0);
}

Desafortunadamente, el implementar la interfaz WindowListener involucra con-

siderar otros seis metodos para controlar varias otras cosas que pueden pasar a una
ventana. En el ejempo, se proveen de versiones vacas para estos metodos:

public void windowOpened(WindowEvent event) { }

public void windowIconified(WindowEvent event) { }
public void windowDeiconified(WindowEvent event) { }
public void windowClosed(WindowEvent event) { }
public void windowActivated(WindowEvent event) { }
public void windowDeactivated(WindowEvent event) { }

En general, para varios otros programas, es posible copiar simplemente las clases
derivadas de Frame (es decir, la clase principal) en cada programa en que se necesite
utilizar ventanas. Esto termina la discusion del codigo para la clase Simple. Ahora,
se comenta el codigo de la clase Canvas0.

4.5.3. El Area de Dibujo

La clase Canvas0 no contiene campos de instancia, y solo comprende al metodo
paint. Para esta clase, se utiliza el constructor por omision.

El metodo paint se invoca cuando la ventaja se despliega por primera vez, y en

cualquier momento en que AWT requiera redibujar (por ejemplo, si alguna parte
de o toda la ventana ha estado oculta y se revela otra vez, o cuando se cambie el
tamano de la ventana, etc.) se puede utilizar el metodo repaint.

Para poder dibujar el area correctamente es necesario conocer el tamano actual

de tal area. Esto se logra mediante el metodo getSize, el cual retorna una instancia
de la clase Dimension. De esta instancia, se extraen los valores width y depth, que
corresponden al ancho y altura del area de dibujo en pixeles. A partir de ellos, es
posible calcular el punto central del area (cx, cy), y dibujar una lnea alrededor
del borde del area.

El metodo paint tiene solo un argumento, del tipo Graphics:

public void paint (Graphics g)

160
 Cuando se dibujan lneas, se llenan areas de color, se escriben caracteres, etc.,
se invocan los metodos asociados con el objeto g. De este modo, se puede dibujar
un rectangulo con esquinas redondeadas mediante:

g.drawRoundRect(...argumentos...);

Hay una gran coleccion de metodos para dibujar de diferentes formas sobre el
area de dibujo. A continuacion, se listan los mas utiles, y se muestra un codigo para
la clase Canvas0. Cada uno se dibuja utilizando el color actual, que se modifica
cuando se requiera utilizando el metodo setColor.

El metodo drawLine dibuja una lnea del color actual (por ejemplo, la nariz
en el programa anterior). Los cuatro argumentos necesarios son, en orden,
las coordenadas x y y de los extremos de la lnea. Tales argumentos son
de tipo int, utilizando las unidades en pixeles, considerando el origen de
las coordenadas en la esquina superior izquierda del area. De este modo, la
siguiente invocacion dibuja una lnea como se muestra en la figura 4.6.

g.drawLine(10, 20, 30, 10);

(0,0)

(30,10)

(10,20)

Figura 4.6: Ejemplo de drawLine

161
El metodo drawRect dibuja un rectagulo en el color actual. Los primeros
dos argumentos de este metodo son las coordenadas x y y de la esquina
superior izquierda del rectangulo, mientras que el tercer y cuarto argumentos
se refieren respectivamente al ancho y altura del rectangulo en pixeles. As si
el tercer y cuarto argumentos son iguales, el rectangulo sera un cuadrado. El
siguiente codigo dibuja un rectangulo como se muestra en la figura 4.7.

g.drawRect(10, 5, 20, 15);

(0,0)

(10,5)

15

20

Figura 4.7: Ejemplo de drawRect

El metodo drawRoundRect dibuja un rectangulo en el color actual con es-

quinas redondeadas. Este metodo se usa en el ejemplo para dibujar una lnea
junto al borde del area de dibujo. Los primeros dos argumentos son las co-
ordenadas de la esquina superior izquierda, y el tercer y cuarto argumentos
son el ancho y altura del rectangulo, como en el metodo drawRect. Ahora
bien, este metodo requiere un quinto y sexto argumentos, que representan los
diametros horizontal y vertical respectivamente de los arcos de las esquinas
en pixeles.
El metodo drawOval dibuja un ovalo en el color actual. Es necesario imagi-
nar que el ovalo se encuentra inscrito dentro de un rectangulo. De este modo,
el metodo tiene por argumentos las coordenas x y y de la esquina superior

162
izquierda del rectangulo, y el tercer y cuarto argumentos corresponden al an-
cho y altura respectivamente del rectangulo, de manera semejante al metodo
drawRect. Si el tercer y cuarto argumentos son iguales, el ovalo sera un crcu-
lo. La siguiente llamada genera un ovalo como se muestra en la figura 4.8.

g.drawOval(10, 5, 20, 15);

(0,0)

(10,5)

15

20

Figura 4.8: Ejemplo de drawOval

En ocasiones, definir la posicion utilizando la esquina superior izquierda no es

el procedimiento mas conveniente, pero la mayora de los metodos en AWT
usan esta opcion. En el ejemplo, el calculo de las posiciones de los dibujos
siempre buscan localizar la esquina superior izquierda de las formas a partir
del punto central de la figura, lo que puede ser una forma mas logica de
especificar la posicion. Notese que en general el codigo del ejemplo se ha
escrito para aclarar como las posiciones, tamanos, angulos, etc. se especifican
en terminos de las varias dimensiones basicas que definen la cara.
El metodo drawArc dibuja parte de un ovalo o crculo. Es necesario, entonces,
especificar primero la esquina superior izquierda del ovalo, y el ancho y alto
del rectangulo que lo inscribe, como en el metodo drawOval. Los dos ultimos
argumentos (el quinto y sexto) especifican que parte del arco se dibuja. El
quinto argumento especifica un angulo que comienza de la posicion de cero

163
(0,0)

(10,5)
angulo2
angulo1
15

20

Figura 4.9: Ejemplo de drawArc

grados en la horizontal hacia el Este (como en la convencion matematica

normal) y termina donde se inicia propiamente el dibujo del arco. El arco se
dibuja en sentido antihorario, por cuanto grados se especifiquen en el sexto
argumento. Notese que el sexto argumento no es el angulo final: el angulo
final sera la suma del quinto y sexto argumentos, como se muestra en la figura
4.9

Utilizando este metodo se dibuja la sonrisa de la carita feliz considerando

el centro del area de dibujo, el radio del crculo que corresponde a la bo-
ca (mouthRadius), del cual la sonrisa es un arco, y el angulo de la boca
(mouthArc), de 50 grados, mediante el codigo:

g.drawArc(cx - mouthRadius,
cy - mouthRadius,
mouthRadius*2,
mouthRadius*2,
270 - mouthAngle,
mouthAngle*2);

Tambien es posible anadir algun texto a un dibujo en el area. Para mostrar

las capacidades de AWT en la escritura de caracteres, se escriben las palabras
Hello en tipo normal y World en cursivas. El metodo basico es drawString,

164
el cual escribe una cadena especificada de texto (como primer argumento)
en la posicion que se especifica (con el segundo y tercer argumentos, como
coordenadas). La siguiente llamada escribe un mensaje como se muestra en
la figura 4.10.

g.drawString("Happy Birthday", 10, 15);

(0,0)

Happy Birthday
base
(10,15)

Figura 4.10: Ejemplo de drawString

La primera coordenada se refiere a la posicion del extremo izquierdo del

primer caracter. La segunda coordenada es la posicion de la base sobre la
cual los caracteres se escriben; algunos caracteres (como por ejemplo, g, y,
j) pueden extenderse por debajo de la base.

La cadena de caracteres se dibuja en el color y tipo de letra actuales. Hasta

ahora, se ha considerado el concepto de color actual, pero en cuanto al tipo
de letra (o font) se requiere utilizar el metodo setFont para actualizarlo.
Este metodo requiere un argumento de tipo Font.

Las instancias de la clase Font se crean mediante invocar al constructor

adecuado. Por ejemplo:

Font f1 = new Font("TimesRoman", Font.PLAIN, 14);

165
 El primer argumento de esta invocacion es el nombre del tipo de letra. Otros
tipos de letra comunes son Helvetica, Courier, Dialogue y Symbol. Existen
otra cantidad de tipos de letra dependiendo de la plataforma utilizada.

El segundo argumento es el estilo del tipo de letra. Este debe ser uno de las
siguientes constantes: Font.PLAIN, Font.BOLD o Font.ITALICS. Las cons-
tantes corresponden a los estilos plano, en negrita y cursiva, respectivamente.
Es posible tambien usar expresiones mixtas, como por ejemplo Font.BOLD +
Font.ITALIC, para el segundo argumento, lo que genera un estilo en negrita
y cursiva, siempre y cuando se encuentre esta opcion disponible para el tipo
de letra especificado.

El tercer argumento se refiere al tamano en puntos del tipo de letra. Tamanos

tpicos son de 8 (para un tamano pequeno), 12 (de un tamano normal) o hasta
36 o mas (para tamanos grandes).

Si se desea posicionar una secuencia de cadenas de caracteres, tal vez con tipos
de letra variables, AWT espera que el programador especifique la posicion
de cada uno de ellos, y para esto es necesario que tanto espacio requiere una
secuencia particular de caracteres de un tipo de letra. La clase FontMetrics
provee tal informacion. Se establece una instancia de esta clase para un objeto
Graphics y para un objeto Font:

FontMetrics fm1 = g.getFontMetrics(f1);

A partir de esta instancia, es posible obtener el ancho de una cadena de

caracteres en el tipo de letra especificado, mediante:

int w1 = fm1.stringWidth("Se desea saber el espacio de esta cadena");

En el ejemplo del programa, se utilizan las longitudes de las cadenas para

calcular la coordenada ctx para el inicio de la cadena, para que el mensaje
este posicionado centralmente en la ventana, y se actualiza este valor para
obtener la posicion de la siguiente porcion de la cadena.

4.5.4. Entrada de Caracteres

En el programa previo, la unica forma en que el usuario puede comunicarse
con el programa es presionar un boton. Otro tipo deseable de comunicacion con el
programa es permitir al usuario escribir una secuencia de caracteres en un campo
de texto, para que el programa lo interprete.

166
 Supongase el ejemplo de un programa que permite escribir una temperatura en
grados Celsius en un campo de texto etiquetado como Celsius, y que utiliza un
boton que al ser presionado calcula la temperatura equivalente en grados Fahren-
heit en un campo de texto etiquetado como Fahrenheit. Similarmente, es posible
escribir en este campo de texto, y utilizar otro boton para convertirlo en grados
Celsius en el otro campo de texto. Es necesario considerar la validez de la cadena
de caracteres que se escribe.

Para este ejemplo, se utilizan de nuevo una clase Simple2 derivada de Frame,
con seis variables de instancia:

Una variable temp1, de una clase predefinida Temperature, que sirva para la
conversion.

Dos variables celsiusField y fahrField de tipo TextField. Esta clase

implementa una pequena area de texto en la que el usuario puede escribir una
secuencia de caracteres que el programa puede extraer y procesar de alguna
manera. Es necesario entonces declarar estas dos variables de forma que pueda
invocarse a los metodos asociados con ellas en el metodo actionPerformed.

Tres variables de la clase Button, llamadas toF, toC y quit, que permiten al
metodo actionPerformed checar que boton ha sido presionado.

La declaracion de Simple2 queda hasta ahora como sigue:

public class Simple2 extends Frame

implements WindowListener, ActionListener {

Temperature temp1;
TextField celsiusField, fahrField;
Button toF, toC, quit;
...
}

El constructor de la clase inicializa las variables:

public Simple2 () {
temp1 = new Temperature();
setTitle = ("Temperatura");
setBackground(Color.green);
setSize(400, 600);
addWindowListener(this);
...
}

167
 En la ventana que se define, es necesario crear los componentes graficos puestos
en forma de tres renglones. El primero y segundo renglones son muy similares,
requiriendo:

Un campo de texto en el medio, en el cual se pueda escribir la temperatura.

Este es la instancia de la clase TextField. El constructor de esta clase toma
dos argumentos: la cadena de caracteres a aparecer inicialmente en el campo
de texto (que normalmente puede ponerse en blanco), y un int que especifica
que tan ancho es el campo de texto en columnas. Lo mejor es considerar
este valor una o dos veces mas largo que el maximo numero de caracteres que
se espera. Para este ejemplo, se consideran 8 columnas.
Una cadena de caracteres a la izquierda de cada campo de texto, la cual
especifica que tipo de temperatura se trata. Se utiliza una instancia de la
clase Label, cuya funcion es desplegar una cadena de caracteres. Cuando
se construye una instancia de Label, es necesario dar como argumento una
cadena de caracteres (por ejemplo, Celsius en el primer renglon).
Un boton para invocar la conversion de la temperartura, como instancia de
la clase Button. Se le coloca una etiqueta para determinar su funcion (en el
primer renglon, se considera Convierte a F).

Procurando mantener los componentes de cada renglon juntos, se les coloca en

un panel p1 con un manejador de flujo:

Panel p1 = new Panel();

p1.setLayout(new FlowLayout());
p1.add(new Label("Celsius"));

celsiusField = new TextField(" ", 8);

p1.add(celsiusField);

toF = new Button("Convierte a F");

p1.add(toF);
toF.addActionListener(this);

Haciendo lo mismo con el segundo renglon, en un panel p2:

Panel p2 = new Panel();

p2.setLayout(new FlowLayout());
p2.add(new Label("Fahrenheit"));

fahrField = new TextField(" ", 8);

p2.add(fahrField);

168
toC = new Button("Convierte a C");
p2.add(toC);
toC.addActionListener(this);

Finalmente, se anade un tercer panel p3 para el boton Salir:

Panel p3 = new Panel();

p3.setLayout(new FlowLayout());
quit = new Button("Salir");
p3.add(quit);
quit.addActionListener(this);

Para poder utilizar estos tres paneles, es necesario declarar un nuevo panel p,
especificando un manejador de borde, y entonces anadir los tres paneles p1, p2 y
p3:

Panel p = new Panel();

p.setLayout(new BorderLayout());
p.add("North", p1);
p.add("Center", p2);
p.add("South", p3);
add("Center", p);

La ventana se ve similar a la figura 4.11.

El metodo main de la clase Simple2 se encarga de crear una instancia de la

clase, y llama al metodo setVisible para iniciar el proceso:

public static void main(String[] args) {

Simple2 f = new Simple2();
f.setVisible(true);
}

El metodo para windowClosing resulta ser igual que en el ejemplo anterior.

Ahora bien, para extraer la cadena de caracteres escrita en un campo de texto,

debe modificarse la estructura general del metodo actionPerformed. Sin embargo,
resulta un codigo muy similar al visto anteriormente. Dentro de este metodo se
prueba en secuencia cada etiqueta y cada boton que podra ser presionado, tomando
la accion correspondiente. A continuacion, se presenta la parte para convertir de
grados Celsius a grados Fahrenheit cuando el boton toF es presionado. La conversion
inversa es muy similar. El codigo es como sigue:

169
 Simple2
Panel p
Panel p1

Label TextField Button

Panel p2

Label TextField Button

Panel p3

Button

Figura 4.11: Ventana para Simple2

...
else if (event.getSource() == toF) {
String c1 = celsiusField.getText();
double c2 = 0.0;
boolean isValid;

try {
c2 = Double.valueOf(c1).doubleValue();
isValid = true;
}
catch (NumberFormatException e) {
isValid = false;
}

if(isValid) {
temp1.setCelsius(c2);
double f2 = temp1.getFahr();
f2 = ((double) Math.round(f2 * 100)) / 100;
String f1 = Double.toString(f2);
fahrField.setText(f1);
}
else {
celsiusField.setText(" ");
}
}
else ...

170
 En el codigo anterior, se realizan las siguientes acciones:
Se extrae la cadena del campo de texto Celsius usando el metodo getText,
y almacenandolo en la variable c1 de tipo String.
Se convierte la cadena en un valor double en un bloque try. Si los caracteres
escritos en el campo no son validos, la conversion falla, atrapandose en el
bloque catch como una excepcion. La variable booleana isValid registra si
la conversion es exitosa.
Si la entrada es valida, se convierte el valor Celsius a su equivalente Fahren-
heit redondeado a dos cifras decimales, y se le convierte de nuevo a una
cadena de caracteres para poder escribirse en el campo de texto utilizando el
metodo setText.
Si la entrada es invalida, se borra el contenido del campo de texto utilizando
una cadena en blanco.

4.5.5. Menues, Archivos e Imagenes

Los programas presentados hasta ahora en esta seccion para generar dibujos o
diagramas han utilizado los metodos drawAlgo contenidos en AWT. Sin embargo,
hay otra fuente de informacion visual para un programa, en forma de fotografas que
pueden obtenerse mediante digitalizacion, y que se almacenan en formatos estandar
como GIF y JPEG. Como parte de AWT, Java provee un conjunto de metodos
para el despliegue de tales fotografas, comunmente conocidas como imagenes.
La mayora de las maneras para manipular imagenes, como por ejemplo escalarlas
o cortarlas, van mas alla del objetivo de estas notas. Sin embargo, los dos ultimos
programas de este captulo tienen la intencion de mostrar como desplegar imagenes
con los metodos de AWT. Ademas, se introduce a algunas otras partes de AWT
que son utiles al escribir programas con ventanas. Estos son menues, dialogos para
archivos, y el manejo de los eventos del raton.

El primer programa, Simple3.java, permite al usuario seleccionar un archivo

que contiene una imagen. El programa entonces intenta desplegarlo en el centro
de una ventana. En lugar de tener todos los botones en despliegue continuo, se les
considera dentro de un menu localizado en una barra en la parte superior de la
ventana.

Colocando Menues
En una ventana como la desarrollada en secciones anteriores se anade un sistema
de menu. Este menu contiene dos botones: Cargar, que selecciona un archivo de
imagen a desplegar, y Salir. De hecho, se ha hecho comun en la mayora de los
disenos de interfaz a usuario considerar a este menu de funciones miscelaneas con
el nombre de Archivo (o File), que es lo que se pretende aqu. Para esto, es
necesario declarar variables de instancia de tipo MenuItem para los dos botones, de
tal modo que se sepa cual ha sido seleccionado:

171
public class Simple3 extends Frame
implements WindowListener, ActionListener{
Canvas3 canvas;
MenuItem load, quit;
...
}

El codigo que se anade al constructor de la clase Simple3 para incluir el menu es

como sigue:

Menu menu = new Menu("Archivo");

load = new MenuItem("Cargar");
menu.add(load);
load.addActionListener(this);
quit = new MenuItem("Salir");
menu.add(quit);
quit.addActionListener(this);
MenuBar menubar = new MenuBar();
menubar.add(menu);
setMenuBar(menubar);

En el codigo anterior, se crea un objeto de tipo Menu etiquetado con el nombre de

Archivo en una barra de menu. Se anaden dos botones en el menu con las etiquetas
adecuadas, y se registran para saber cuando cualquiera de ellos se selecciona. Se
crea la barra de menu, que es un objeto de tipo MenuBar, se le anade el menu, y
se utiliza el metodo setMenuBar para anadirlo a la instancia de Simple3 que se
encuentra en construccion. Notese que solo es posible anadir barras de menu a las
clases derivadas de Frame, por lo que no se permite tener menues conectados a
paneles arbitrarios.

Ahora es necesario especificar la accion a tomar cuando alguno de los botones

del menu se selecciona. Esto se maneja muy parecido a la forma en que se manejan
los botones en programas anteriores. Hay un metodo actionPerformed en la clase
Simple3, el cual verifica cual componente se ha seleccionado en la forma usual:

public void actionPerformed(ActionEvent event){

if(event.getSource()==quit) {
dispose();
System.exit(0);
}
else if(event.getSource()==load) {
loadFile();
}
}

172
 Hay una serie de otras caractersticas utiles de los menues. Supongase que se
declara las siguientes variables de instancia:

public class Simple3a extends Frame

implements WindowListener, ActionListener, ItemListener {
MenuItem buttonA1, buttonA2, buttonA3,
buttonA4, buttonA5, buttonA6, buttonA7, quit,
buttonB1p1, buttonB1p2, buttonB1p3,
buttonB2p1, buttonB2p2, buttonB2p3, buttonB2p4;
int noOfOptions = 7;
CheckboxMenuItem[] options = new CheckboxMenuItem[noOfOptions];
...
}

Entonces, es necesario definir la relacion entre todos estos componentes en el

constructor:

Menu menuA = new Menu("MenuA");

buttonA1 = new MenuItem("Boton A1");
menuA.add(buttonA1);
buttonA1.addActionListener(this);
buttonA2 = new MenuItem("Boton A2");
menuA.add(buttonA2);
buttonA2.addActionListener(this);
buttonA3 = new MenuItem("Boton A3");
menuA.add(buttonA3);
buttonA3.addActionListener(this);
menuA.addSeparator();
buttonA4 = new MenuItem("Boton A4");
menuA.add(buttonA4);
buttonA4.addActionListener(this);
buttonA5 = new MenuItem("Boton A5");
menuA.add(buttonA5);
buttonA5.addActionListener(this);
buttonA6 = new MenuItem("Boton A6");
menuA.add(buttonA6);
buttonA6.addActionListener(this);
buttonA7 = new MenuItem("Boton A7");
menuA.add(buttonA7);
buttonA7.addActionListener(this);
menuA.addSeparator();
menuA.add(new MenuItem("Salir"));

173
Menu menuB = new Menu("MenuB");
Menu menuB1 = new Menu("MenuB1");
buttonB1p1 = new MenuItem("Boton B1.1");
menuB1.add(buttonB1p1);
buttonB1p1.addActionListener(this);
buttonB1p2 = new MenuItem("Boton B1.2");
menuB1.add(buttonB1p2);
buttonB1p2.addActionListener(this);
buttonB1p3 = new MenuItem("Boton B1.3");
menuB1.add(buttonB1p3);
buttonB1p3.addActionListener(this);
menuB.add(menuB1);
Menu menuB2 = new Menu("MenuB2");
buttonB2p1 = new MenuItem("Boton B2.1");
menuB2.add(buttonB2p1);
buttonB2p1.addActionListener(this);
buttonB2p2 = new MenuItem("Boton B2.2");
menuB2.add(buttonB2p2);
buttonB2p2.addActionListener(this);
buttonB2p3 = new MenuItem("Boton B2.3");
menuB2.add(buttonB2p3);
buttonB2p3.addActionListener(this);
buttonB2p4 = new MenuItem("Boton B2.4");
menuB2.add(buttonB2p4);
buttonB2p4.addActionListener(this);
menuB.add(menuB2);

Menu menuC = new Menu("MenuC");

options[0] = new CheckboxMenuItem("Lunes");
options[1] = new CheckboxMenuItem("Martes");
options[2] = new CheckboxMenuItem("Miercoles");
options[3] = new CheckboxMenuItem("Jueves");
options[4] = new CheckboxMenuItem("Viernes");
options[5] = new CheckboxMenuItem("Sabado");
options[6] = new CheckboxMenuItem("Domingo");

for (int i = 0; i < noOfOptions; i++) {

options[i].addItemListener(this);
menuC.add(options[i]);
}

MenuBar menubar = new MenuBar();

menubar.add(menuA);
menubar.add(menuB);
menubar.add(menuC);

174
 En Menu A se tienen varios botones, por lo que usa el metodo addSeparator
para formar tres grupos de botones.
En Menu B se tienen dos sub-menues, Menu B1 y Menu B2, cada uno
con su propio conjunto de botones. Si se presiona el boton para Menu B1,
esto hace que aparezca el sub-menu con sus tres botones.
En Menu C se tienen un numero de checkboxes, cada uno de los cuales in-
dependientemente registra si una opcion ha sido checada (on) o no (off).
Dado que se tienen varios de estos, se declara un arreglo que los contenga,
el cual llama al constructor de cada uno, y los registra con un auditor,
anadiendolos finalmente al menu. Un metodo, el itemStateChanged de la
interfaz ItemListener, se invoca cada vez que el usuario presiona uno de los
checkboxes, cambiando su estado:

public void itemStateChanged(ItemEvent event) {

if(event.getSource()==options[0]) {
System.out.println("La opcion Lunes ha sido presionada");
else if (...)
...
}
}

El estado de cada checkbox se considera normalmente como FALSE. Se puede

cambiar a una estado particular con el metodo setState, y se puede averiguar
su estado con el metodo getState.

Seleccionando un Archivo
Regresando al programa original, notese que el codigo de la opcion Cargar
del menu invoca a un metodo loadFile, lo que permite al usuario seleccionar un
archivo que contiene una imagen para ser desplegada. En seguida, se presenta el
codigo de este metodo:

private void loadFile() {

FileDialog d = new FileDialog(this, "Cargar Archivo", FileDialog.LOAD);
d.setDirectory("...directorio donde comenzar la seleccion ...");
d.setVisible(true);
name = d.getFile();
directory = d.getDirectory();
canvas.repaint();
}

175
 En este metodo se crea una instancia de la clase FileDialog, lo que requiere
tres parametros:

El dueno del dialogo. Esta es una instancia de la clase Simple3, con la cual
este dialogo debe estar asociado, por lo que se utiliza la palabra clave this.
Una cadena de caracteres que aparece como ttulo de la ventana que surge
para el dialogo. Se ha escogido Cargar Archivo.
Una de dos constantes: FileDialog.LOAD, si se planea leer de un archivo
(que es lo que se intenta aqu) o FileDialog.SAVE, si se planea escribir un
archivo.

Ademas, se consideran un directorio de archivos inicial para que el usuario

seleccione un archivo de ah, y se invoca al metodo setVisible, lo que despliega
la ventana del dialogo. El usuario selecciona un archivo y presiona un boton para
indicar que el dialogo se ha completado.

En este punto, se extrae el nombre del archivo seleccionado con el metodo

getFile. Si ningun archivo ha sido seleccionado, se retorna un valor de tipo String
de longitud cero. Ya que el usuario puede cambiar de directorio en el dialogo, es
necesario extraer tambien esta informacion con el metodo getDirectory.

Desplegando una Imagen

Habiendo obtenido el nombre de un archivo en un directorio, se solicita al area
de dibujo redibujarse, intentando desplegar una imagen obtenida del archivo. En
seguida, se presenta el metodo paint de la clase Canvas3:

public void paint(Graphics g) {

Dimension d = getSize();
int cx = d.width/2,
cy = d.height/2;

//Se dibuja una linea alrededor del area de dibujo

g.setColor(Color.black);
g.drawRoundRect(2, 2, d.width - 5, d.height - 5, 20, 20);

if (parent.name != null) {
String filename = parent.directory + parent.name;
Image image = Toolkit.getDefaultToolkit().getImage(filename);
g.drawImage(image,
cx - (image.getWidth(this)/2),
cy = (image.getHeight(this)/2),
this);

176
 // Escribe el nombre del archivo bajo la imagen
Font f1 = new Font("TimesRoman", Font.PLAIN, 14);
FontMetrics fm1 = g.getFontMetrics(f1);
int w1 = fm1.stringWidth(parent.name);
g.setColor(Color.black);
g.setFont(f1);
int ctx = cx - (w1 / 2);
int cty = cy + (image.getHeight(this) / 2) + 30;
g.drawString(parent.name, ctx, cty);
}
else {
// Escribe el mensaje "No es archivo" en el centro del
// area de dibujo
Font f1 = new Font("TimesRoman", Font.PLAIN, 14);
...
}
}

En el codigo anterior se establece el nombre completo del archivo filename

a partir de la informacion recabada por el metodo loadFile. Entonces se lee el
archivo, y se construye una instancia de la clase Image con el enunciado:

Image image = Toolkit.getDefaultToolkit().getImage(filename);

Finalmente, la imagen se dibuja:

g.drawImage(image,
cx - (image.getWidth(this)/2),
cy = (image.getHeight(this)/2),
this);

El primer argumento de tipo Image se refiere a la imagen que se desea desplegar.

El segundo y tercer argumentos son la posicion en la cual debe desplegarse, a
partir de la esquina superior izquierda. Las operaciones aritmeticas hacen que la
imagen se centre en el area de dibujo. El cuarto argumento de tipo ImageObserver
permite llevar cuenta del progreso de crear y dibujar la imagen, verificando si se
hace exitosamente o no.

Siguiendo al Raton
Finalmente, se modifica el programa de tal modo que la imagen se posicione en
el punto donde se presione un boton del raton. Existen varios metodos que permiten

177
tomar acciones dependiendo de varias cosas que puede el usuario hace con el raton.
Aqu, se selecciona el metodo mouseClicked de la interfaz MouseListener, ya que
interesa solo si el raton ha sido presionado en el area de dibujo, por lo que se
especifica una clase Canvas5 que implementa tal interface:

class Canvas5 extends Canvas implements MouseListener {

...
}

Es necesario mencionar que esta clase es responsable de manejar el hecho de

presionar los botones del raton, por lo que se anade un enunciado al constructor de
la clase:

public Canvas5(Simple3 f) {
parent = f;
addMouseListener(this);
}

En seguida, se presenta el metodo mouseClicked que pertenece a la clase

Canvas5:

public void mouseClicked(MouseEvent event) {

mx = event.getX();
my = event.getY();
repaint();
}

El argumento event contiene las coordenadas en pantalla del punto donde se

presiona un boton del raton. Esta informacion se extrae con los metodos getX()
y getY(). Las coordenas se almacenan en dos variables de instancia mx y my,
pertenecientes a la clase Canvas5. En seguida se llama a redibujar el area de dibujo
con repaint. Para colocar la imagen en el punto dado, se posiciona la imagen en
el metodo paint en las coordenas (mx, my), en lugar de (cx, cy).

La interfaz MouseListener requiere de la implementacion de otros metodos,

los cuales para este ejemplo se proveen mediante codigos vacos:

public void mousePressed(MouseEvent event){ }

public void mouseReleased(MouseEvent event){ }
public void mouseEntered(MouseEvent event){ }
public void mouseExited(MouseEvent event){ }

178
Apendice A

Entrada por Teclado

Aun cuando se utilicen ventanas para la comunicacion de los programas con

el usuario, siempre es conveniente contar con un medio de comunicacion simple a
traves de salida por pantalla en texto, y entrada por el teclado. Java considera un
tipo de comunicacion basica con el usuario mediante cadenas de caracteres, que se
presentan en la pantalla utilizando el metodo System.out.println, que ha sido
utilizado extensivamente a traves de los programas anteriores. Por otro lado, en
el caso de la lectura de datos a partir del teclado, Java provee de la capacidad de
solicitar al usuario datos mediante un metodo apropiado de la clase BasicIo. Sin
embargo, el uso directo de los metodos de la clase BasicIo no resulta sencillo, pues
implica la manipulacion directa de variables del tipo InputStreamReader. Debido
a esto, se presenta a continuacion la clase KeyboardInput, la cual tiene por objetivo
apoyar la lectura de tipos primitivos provenientes del teclado en forma segura.

A.1. La clase KeyboardInput

KeyboardInput es una clase sencilla para leer valores de la lnea de comando.
Si un error ocurre durante la lectura, una excepcion es arrojada y atrapada, lo que
hace que un valor por omision sea retornado.

La declaracion de la clase KeyboardInput es como sigue:

import java.io.*;

public class KeyboardInput {

private final BufferedReader in =
new BufferedReader(new InputStreamReader (System.in)) ;

179
// Lectura de un valor int del teclado. El valor por omision es 0
public final synchronized int readInteger() {
String input = "" ;
int value = 0 ;
try {
input = in.readLine() ;
}
catch (IOException e) { }
if (input != null) {
try {
value = Integer.parseInt(input) ;
}
catch (NumberFormatException e) { }
}
return value ;
}

// Lectura de un valor long del teclado. El valor por omision es 0L

public final synchronized long readLong() {
String input = "" ;
long value = 0L ;
try {
input = in.readLine() ;
}
catch (IOException e) { }
if (input != null) {
try {
value = Long.parseLong(input) ;
}
catch (NumberFormatException e) { }
}
return value ;
}

// Lectura de un valor double del teclado. El valor por omision es 0.0

public final synchronized double readDouble() {
String input = "" ;
double value = 0.0D ;
try {
input = in.readLine() ;
}
catch (IOException e) { }
if (input != null) {
try {
value = Double.parseDouble(input) ;

180
 }
catch (NumberFormatException e) { }
}
return value ;
}

// Lectura de un valor float del teclado. El valor por omision es

// 0.0F
public final synchronized float readFloat() {
String input = "" ;
float value = 0.0F ;
try {
input = in.readLine() ;
}
catch (IOException e) { }
if (input != null) {
try {
value = Float.parseFloat(input) ;
}
catch (NumberFormatException e) { }
}
return value ;
}

// Lectura de un valor char del teclado. El valor por omision es

// (espacio)
public final synchronized char readCharacter() {
char c = ;
try {
c = (char)in.read() ;
}
catch (IOException e) {}
return c ;
}

// Lectura de un valor String del teclado. El valor por omision

// es "" (la cadena vacia)
public final synchronized String readString() {
String s = "";
try {
s = in.readLine() ;
}
catch (IOException e) {}
if (s == null) {
s = "" ;

181
 }
return s ;
}
}

182