Sie sind auf Seite 1von 483

Id

Java 2, incluyena
JAVA 2
MANUAL DE PROGRAMACIN
JAVA 2
MANUAL DE PROGRAMACIN
Luis Joyanes Aguilar
Matilde Fernandez Azuela
Departamento de Lenguajes y Sistemas Informticos e Ingeniera del Software
Facultad de I nformtica / Escuela Universitaria de informtica
Universidad Pontificia de Salamanca. Campus Madrid
Osborne
McGraw-Hill
MADRID BUENOS AIRES CARACAS GUATEMALA LISBOA MXICO
NUEVA YORK PANAMA SAN JUAN SANTAF DE BOGOT SANTIAGO SA0 PAUL0
SAN FRANCISCO * SIDNEY SINGAPUR ST. LOUIS TOKIO * TORONTO
AUCKLAND HAMBURG0 LONDRES * MILN MONTREAL NUEVA DELHI PARiS
CONTENIDO
.... <.<.... .. ..... < ..... ............... .... .... . ................ < ... .....
Captulo I . Introduccin a .Java ................
1 . I . La historia de J ava .......... ........,... <....,...<.<........<.
1.3. ;,Qu es .ll\l? .... <..._......<..<.<...._.....<.<......................................
I .7. I . J ava coi110 leiigua.jc de Internet
I.7.7. .lava con10 leng~ia.je
1.3. I . Sencillo ... ............. I . . . . . . . . . . . . . . . . . . . . .
I .3.3. Orientado
I .3.3. Distribuido ..................................................................
1 . 3. Caractersticas de J a ~a ......................
. <
......... <.............<.
1 .3.6. Seguro .......................................
1.3.7. ,4rqiiitectur
1 . 3. 8. Portable ....... ~ ...............................................
1 .3.9. Al to i-endiiniento .... .. <..........<............<.......
I .3.10. Mul ti hi l o ......................................................
I .3.1 I . r>inn1ico ....... ............ <........._ ....<...<<.<.......<
I .4. La programacin orientada a objetos como base de J ava
I .5. Especificacioiies del lengua-je J ava ......................................
1 .6, Aplicaciones y u p p / c t ~ .........................................
Seiiiejanzas y diterencias entre aplicaciones 4
Etapas para crear un programa ...................................
Componentes de ~i na aplicacin ........................................
.l. Herrainientas de desarrollo J ava ...... .<.............<
I .9, I , El entorno de desarrollo J DK .....................................
. I O. Una aplicacin prctica de J ava .. .... ..................... ..... ..
I .h. 1 ,
1 .7. I ,
1 .8.
xiii
1
2
3
3
4
5
5
6
7
7
8
8
9
9
I O
I o
11
1 1
12
13
13
15
15
18
21
71
27
V
vi Contenido
I, 11. Estructura de un programa aplicacin en J ava ................................................
1. 1 I . 1. Referencia a miembros de una clase .........................................................
I , 17. I Errores de compilaci ...............................................
I , 12.2. Errores de e-iecucin
I . 12.3. Errores Ibgicos .......................................................
25
27
I . 12. Errores de programacin ......................................................
....................................
Captulo 2. Caractersticas del lenguaje Java .......................................................... 31
2.1. Palabras resercadas .. ......................................................
2 2. Identi icadores ..... .................................................
7.3. Tipos de datos ....................................................
..................
2.6. constantes ................................................. ......................................
2.7. La biblioteca dc clases de J ava ....................................................
7.8. Coiiceptos bisicos sobre excep ...................................................
2.9.
7.10. Las clases Char act er y Bool ean ........................
La clase Nxmber y sus subclases ....................................
..........................
..................................
.....................................
2.13. La sentencia dc asignacin .......
2.14. Expresiones .................. ..................................................
.................................................
2.15. Cl aseMath ........... .........................................................
...............................
2.18. Operadores aritmticos ......................... .....................................
7.19. Operadores relacionales ................. .........................................
2.20. Operadores lb&' 'ICOS ............... ....................................................
.....................................................
...................................................
32
33
34
34
38
41
44
45
46
48
49
52
52
53
54
55
55
57
57
58
61
61
63
65
67
67
71
3. I . La sentencia i f ........... 72
3.3. La sentencia i f - el se 73
3.3. Las sentencias i f e I f - el se anidadas 74
3.4. La sentencia swi tch ..................................................... 78
80
3.5. La sentencia f or ....................
3.6. La sentencia br eak 83
3.7. La sentencia cont i nue ...... 85
Captulo 3. Decisiones y bucles ................. ............................................
...................................................
....................................................
............................
.....................................................
................................. ...................................
...............................................
Contenido vi
3.8. Diferencias entre cont i nue y br eak .........................................................
3.9. La sentencia whi l e ......................................................................................
3.10. La sentencia do- whi l e ................................................................................
Captulo 4 . Clases. objetos y mktodos .......................................................................
4.1.
4.2.
4.3.
4.4.
4.5.
4.6.
4.7.
4.8.
4.9.
4 . I O .
4.11.
Ob-jetos y clases ..
Declaracin y crea
Acceso a datos y n
Utilizacin de intodos
Paso de parnietros .........................................................................................
Paso de parrnetros por valor .
Paso de parmetro
Constructores ......
Modificadores dc
pr i vat e .................................
pr ot ect ed ....................................................................................................
4.12. publ i c ...........................................................................................................
4 . I 3 . Recursividad ...................................................................................................
. .
Captulo 5 . Herencia ...................................................................................................
5 .I .
5.3. El intodo cl one ............................................................................................
5.4. El mtodo equal s
5.5. El mtodo f i nal 1 ze .....................................................................................
5.6. El mtodo t ost r i ng
5.7. El mtodo get cl as s .....................................................................................
Descripcin de herencia ...................................................................................
5.2. La clase Obj ect . ...............................
5.8. Ventajas de la herencia ....................................................
5.9. Superclases y subclases ...................................................................................
5 . I 0 . Modificadores y herencia
5.1 I . Clases abstractas ...............................................................................................
5.12. Mtodos abstractos
5.13. Interfaces ... ............................................................................................
5.14. Definicin d
Captulo 6 . Encapsulamiento y polirnorfisrno ..........................................................
6.1.
6.2.
6.3.
6.4.
6.5.
6.6.
6.7.
6.8.
6.9.
Encapsulainiento .. ...............................
Modificadores de c
Modificadores de bariables ...............................
Modificadores de intodos ...............................................................................
Clases internas ..... ............ ..........
Paquetes ...........................................................................................................
Declaracin de un paquete .......
Paquetes incorporados .....................................................................................
Acceso a los elementos de un paquete
86
88
91
95
96
98
I o0
1 O0
102
I03
103
104
107
1 ox
109
1 1 1
1 1 1
117
118
I19
122
122
127
I73
123
124
124
I 25
127
129
134
I 35
141
142
142
143
144
144
149
150
151
152
vi Contenido
6. I 0. Importaciii de pacliietes ....... ............... .........
6. I I , Control de acceso a paquetes
6. 12. Polimortisino ....................................................... ............................
6.13. Ligadura .......................... _......... <.............<.<........_._..<...................
6.14, Ligadura diiiiiiiicn ...................................................... ...............
................................ <..
......................... <............_...................
...... <..<.........
7. I . Concepto de array .............................. ........................... <................
7.2. Proceso de arrays
7.2. I DeclaraciOn ................................ .............................................
7.2.2. CreaciUn ........ ............................................ <.....
7.3. Arrays de objetos .. ..... <.......................<......................
...................................
7.5. .4 rrays mu I t id i niens ioiia I es ._.... <.<.<._._._._......<..........._....<.<.........
7.6. Ordenacin de arrays ......... <..._._..................._..................
7.X. Burbuja ................ _.......... <..._._._....<.<.........._._..............
7.1 1 . Ordenacin ri pi da ........................................
7.12. Rsclueda ........................ ............_...... <..............._...........<....
7.7. Selection ................... <................. ........ _._.. <....<...................<.............
7.9. Insercin . . . . . . . . . . . . , . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.10. Shel l ,..._._............. _.... <...................<.<.........................
.........................................
..................................
......................
Captulo 8. Cadenas y fechas ....................................... ........................
8. I . Creacin de cadenas _............ <...............................<.......
8.2. Comparacin de cadenas .................... ........................................
8.3. Concatenacin ...... .......................................... <.......
X.4. Otros mtod ..... <...........................
8.5. Lacl ase St
8.6. La clase St r i ngBuf f er ................................ .........................
8.7. Mtodos de
8.8. La clase Dat e .........._........ <................_..........
8.9. Los formatos de Fechas ... ._.... <....<.......................................
8.10. La clase Cal endar .............................................. ...................
..............
Captulo 9. Interfaces grificas de usuario ..............................................
9. I . El AWT .......... ................................................
9.2. Realizacin d ..........................................
9.3. La clase Com
9.3. La clase Cont ai ner ............................. ........ <...........................<
9.5. Ventanas .............. ............ <.<.......................................
9.5, I . Clase Fr ame ...................................... ...................................
153
153
154
156
157
161
162
163
164
164
165
167
169
171
172
178
179
I x0
181
1x3
1x5
I X6
1 XX
193
194
197
20 1
202
20X
209
210
212
213
214
217
218
219
222
224
225
225
9.5.2. Clase Di al og ............................................................................................ 229
Contenido X
0.5.3. (lase Fi l eDi al og ..................................................................................
9.6. Clase Par?el ........................... .........................................
9.7. Clase Label ....................................................................................................
9.8. Clasc But t on ........................ ........................................
0. 0. Clase TextCornponent ................................................................ ~ ................
0.10. (lase canvas ........................
9.1 I . Clase Choi ce ..................................................................................................
9. 12. Clase Chec kbox ...................
............ <......<..................<.............
............................
............. <.............<.....................<......................,,,,.......................
......................
9.15. Meniis . .................................... <........<.........................,,.,.,......................
9.16. Adininistradores de diseno ...... ..........................................
9.16.1, Fl owLayout .....................................................................................
Capitulo 10. Gestin de eventos .......
10.2. Los componentes del AWT con
...................... <...............
1 0. 1 . Tipos de eventos .....................
1 0.3. Receptores de eventos ............
10.4. Procesamiento de eventos ................................................................................
10.5. Clases adaptadoras ......................................................................
10.6. Clases receptoras anniinas ..............................................................................
10.7. Problemas comunes en cl tratamiento de eventos
.........................................
....
Capitulo 1 1 . Applets ........................... ...... <..........
1 1 , 1 . Introduccin a HTML .............
I 1 2. Incorporacin de q 7 p / c ~ / . s a pginas Web .........................................................
I 1 2. I . Edicin de un documento HTML y ejecucin de applets .
1 1 .4. Transforinacin de aplicaciones en tipplefs ................................
1 1 .6. Incorporacin de imgenes .........................................................
11.3. Estructura de un tr/~plet
1 I .5. Incorporacin de sonido .......... ................................................
..........................................................................
Capitulo 12. Programacih concurrente: Hilos de ejecucin .................................
12.1, La prograi naci h niultihilo en J ava .................................................................
12.2. Estados de un hilo ............................................
12.3. Creacin de hilos ..........................................................................
12.4. Plani ticaci6n y pri
12.6. Grupos de hilos ..........................................................................
12.7. Sincronizaciii ........................ ............. <....<.........................<.<<
12.8. Animaciones ...............................................................................
. .
12.5. Hilos de tipo demonio ......................... ........................................... I ....
12.9, Doble hi!fj~/- ............................... ......... <.<..................................<.
232
234
234
236
238
242
244
246
249
252
254
256
256
257
258
262
263
264
265
266
269
272
274
276
285
286
289
29 1
294
29X
306
306
311
312
313
3 I 4
316
317
318
319
326
327
x Contenido
Captulo 13. Rlanejo de excepciones .........................................................................
13.1.
13.7.
I 3 . -3.
1.3.4.
13.5.
13.6.
13.7.
13.x.
C o i i c e p t os gen eral e s . . , . , . , . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mane.jo de excepciones .........
Captura y tiatanliento de exce ,. <..............<..<.... .......... <........
......... <....<...................
....................... <..._...........<.<........
. ,
Laiizar la cxcepcioii .,...._....,..
Declarar la excepcioii .... .... .. ............... .. ....... .... .. ... .........
El bloque f i nal i y ..........................
Creacicn de excepciones ................................................
Mi todos de la clase Thr owabl e ..........
.....................
. I
._... <..<....._................................
..........................................
Capitulo 14. Archivos .................................................................................................
14. I . La clase Fi l e ........... ..................................................
......................................... ........................... . ................ .....
14.3. Apertura de archivos .. ......................................... <...........
1 4. 4, Eii cade n aim i e n t o
14.5. Evcepciones en ar
......... <...............<.................
14.6. Mi todos de I np .......................................
14.7. hldodos de Out put s t r eam ........ <.<........<................................
14.8. [\;lbtodos de Reader ............................................... ........................
14.9. Xlitodos de Wr i t er ........................ .................................................
14.10. Mi todos de Dat aI nput St r eam....................................
14.1 I . Mi todos de Dat aOut put St r eam..
13.12. Vi todos de RandomAcces sF i l e ..................................
14, 13. Serializaciii de objetos .....................
........................ <......................
................................................
14.13. St r i ngTokeni z er y St r eamTokeni z er .............
14.1 5. Operaciones con
13.16. Archibos secuenciales ....
13.17. Archivos directo ..........................
14. I 8. Funciones de transformacin de clave y tratamiento de colisiones ..........
................... <......................
Captulo 15. Estructuras de datos definidas por el programador .........................
15.1. Lista ...................................... <........ .......................................
15.3. Lista ordenada ...............................................
15.4,
1.7.5. Listas doblemente enlazadas ......................................... ................
15.6. Pilas ............................................ ...........................................
15.7. Colas ......................... .............................................
15.8. Colas circulares ......................................... .......................................
15.7. Iiiiplementacin de una lista ,..............._.. <.........................
.............................
Listas genricas y LI SO de interfaces
339
340
343
343
345
347
348
353
358
361
362
368
370
373
375
378
379
379
3 79
380
38 1
38 1
382
3x3
383
3 84
395
396
41 1
412
415
417
422
434
435
43 8
442
A .
B .
C .
D .
E .
F .
G .
Contenido xi
APNDICES
Palabras reservadas J ava ...................................................................................... 445
Prioridad de operadores 44 7
Gua de sintaxis ..............................................................................
Paquetes de la plataforma J ava 2 . Versiones 1 . 3 y 1 . 4 Beta ...............................
Recursos: libros, revistas y WEB ........................................................................
ndice analtico ............................................................................................................ 529
PRLOGO
Cinco aos despus de su lanzamiento, J ava se ha convertido en
un estndar de la industria, en un lenguaje de programacin para
desarrollo de aplicaciones tanto de propsito general como de
Internet, y tambin en un lenguaje para comenzar la formacin en
programacin, al tener caractersticas excelentes para el aprendi-
zaje.
J ava, desarrollado por Sun Microsystems en 1995, es un mag-
nfico y completo lenguaje de programacin orientado a objetos
diseado para distribuir contenidos a travs de una red. Una de sus
principales caractersticas es que permite operar de forma inde7
pendiente de la plataforma y del sistema operativo que se est uti-
lizando. Esto quiere decir que permite crear una aplicacin que
podr descargarse de la red y funcionar posteriormente en cual-
quier tipo de plataforma de hardware o software. Generalmente, y
al contrario, todo programa o aplicacin queda atado a dos cosas:
al hardware y al sistema operativo. As, por ejemplo, una aplica-
cin Windows slo funcionar en plataforma Wintel (equipada
con procesadores Intel y sistema operativo Windows) igual que
una versin creada para Mac slo funciona sobre Power PC o
Imac y Mac OS o la misma aplicacin desarrollada para Unix, slo
lo hace sobre plataformas Unix y no hay forma de que funcione
sobre otra mquina.
La idea de J ava, por el contrario, es poner una capa sobre
cualquier plataforma de hardware y sobre cualquier sistema ope-
rativo que permite que cualquier aplicacin desarrollada en J ava
quede ligada nicamente a J ava, independizada por lo tanto de la
xi i i
xi v Prlogo
plataforma. Esta concepcin queda recogida en el concepto de mquina virtual
J VM (Java Virtual Machine), un software que interpreta instrucciones para cual-
quier mquina sobre la que est corriendo y que permite, una vez instalado, que una
misma aplicacin pueda funcionar en un PC o en un Mac sin tener que tocarla. Hoy
en da. cualquier sistema operativo moderno (Windows, Macintosh, Linux, Unix,
Solaris. etc.) cuenta con una J VM. As, lo que hace J ava en combinacin con esta
mquina es funcionar como hardware y como sistema operativo virtual, emulan-
do en software una CPU universal. Al instalar J ava, ste actuar como una capa de
abstraccin entre un programa y el sistema operativo. otorgando una total indepen-
dencia de lo que haya por debajo; es decir, cualquier aplicacin funcionar en cual-
quier mquina e incluso en cualquier dispositivo.
Otra gran ventaja es que los programadores no tendrn que desarrollar varias
versiones de la misma aplicacin, puesto que el modelo de desarrollo es el mismo
se trate del dispositivo ms pequeo o del ms grande de los servidores. Otra gran
ventaja es que permite que todas las mquinas. plataformas y aplicaciones se comu-
niquen entre s accediendo desde cualquier equipo, dondequiera que est situado, a
las aplicaciones que residan en una red, ya sea Internet o una intranet o extranet.
En definitiva, se puede decir que J ava es lo ms cercano que existe hoy da a un
lenguaje de computacin universal, lo que significa que puede correr en cualquier
plataforma siempre y cuando una mquina virtual haya sido escrita para ella.
LA GENEALOGA DE JAVA
J ava es un descendiente de C++ que a su vez es descendiente directo de C. Muchas
caractersticas de J ava se han heredado de estos dos lenguajes. De C, J ava ha here-
dado su sintaxis y de C++, las caractersticas fundamentales de programacin orien-
tada a objetos.
El diseo original de J ava fue concebido por J ames Gosling, Patrick Naughton,
Chris Warth, Ed Frank y Mike Sheridan, ingenieros y desarrolladores de Sun Mi-
crosystems en 1991, que tardaron 18 meses en terminar la primera versin de tra-
bajo. Este lenguaje se llam inicialmente Oak, y se le cambi el nombre por J ava
en la primavera de 1995.
Sorprendentemente, la inquietud original para la creacin de Oak no era
Internet. En realidad, se buscaba un lenguaje independiente de la plataforma (es
decir, de arquitectura neutra) que se pudiera utilizar para crear software que se
incrustara en dispositivos electrnicos diversos tales como controles remotos, auto-
mviles u hornos de microondas. Aunque el modelo de lenguaje elegido fue C++,
se encontraron con que, si bien se poda compilar un programa C++en cualquier tipo
de CPU (Unidad Central de Proceso), se requera, sin embargo, un compilador C++
completo que corriese en esa CPU. El problema, en consecuencia, se converta en
compiladores caros y en gran consumo de tiempo para crear los programas. Sobre
Prlogo XV
esas premisas, Gosling y sus colegas comenzaron a pensar en un lenguaje portable,
independiente de la plataforma que se pudiera utilizar para producir cdigo que se
ejecutara en una amplia variedad de CPU y bajo diferentes entornos. Entonces
coinenz6 a aparecer el nuevo proyecto y se decidi llamarle J ava.
Por qu Java es importante para Internet?
Internet ha ayudado considerablemente a catapultar a J ava al cenit del mundo de
la programacin de computadoras. y J ava. a su vez, ha tenido un profundo impacto
en Internet. La razn es muy simple: J ava extiende el universo de los objetos que se
mueven libremente en el ciberespacio que forma la red Internet. En una red existen
dos grandes categoras de ob-jetos que se transmiten entre las computadoras conec-
tadas (el servidor y la computadora personal): informacin pasiva y dinmica, pro-
gramas activos. Un ejemplo fcil de datos pasivos son los correos electrnicos que
usted recibe en su computadora o una pgina web que se baja de la red. Incluso si
descarga un programa, est recibiendo datos pasivos hasta tanto no ejecute dicho
programa. Sin embargo, existewotros tipos de objetos que se transmiten por la red:
programas dinmicos autoejecutables que son agentes activos en la computadora
cliente.
Estos programas dinmicos en red presentan serios problemas de seguridad y
portnhilidad. J ava ha resuelto gran cantidad de problemas con un nuevo modelo de
programa: el upplot.
J ava se puede utilizar para crear dos tipos de programas: aplicaciones y applets.
Una aplicucicn es un programa que se ejecuta en su computadora bajo el sistema
operativo de su computadora; en esencia, es un programa similar al creado utili-
zando C, C++ o Pascal. Cuando se utiliza para crear aplicaciones, J ava es un len-
guaje de propsito general similar a cualquier otro y con caractersticas que lo hacen
idneo para programacin orientada a objetos. Este libro dedica buena parte de su
contenido a ensear a disear, escribir y ejecutar aplicaciones,
Pero J ava tiene una caracterstica notable que no tienen otros lenguajes: la posi-
bilidad de crear applets. Un applet es una aplicacin diseada para ser transmitida
por Internet y ejecutada por un navegador Web compatible con J ava. Un applet es
realmente un pequeo programa J ava, descargado dinmicamente por la red, tal
como una imagen, un archivo de sonido, un archivo musical MP3 o divX, o una
secuencia de vdeo: pero con una notable propiedad, es un programa inteligente que
puede reaccionar dinmicamente a entradas y cambios del usuario.
J ava es un lenguaje idneo para resolver los problemas de seguridad y portabili-
dad inherentes a los sistemas que trabajan en red. La razn fundamental de este aser-
to reside en el hecho de que la salida de un compilador J ava no es un cdigo ejecutable,
sino cdigos de bytes (bytecode). Un hvtecode es un conjunto de instrucciones muy
optimizadas diseadas para ser ejecutadas por un sistema en tiempo de ejecucin
xvi Prlogo
J ava. denominado mquina virtual J ava (JUVLI Vi t +md Machine, J VM) que acta como
un interprete para los bytecodes. La traduccin de un programa en cdigo4 de bytes
facilita la ejecucin del programa en una amplia variedad de entorna y plataformas.
La razn es simple: slo es preciso implementar J VM en cada plataforma.
EVOLUCIN DE LAS VERSIONES DE JAVA
J ava comenz a desarrollarse en 1991 con el nombre de Proyecto Ouk (roble en
ingls) que era -segn cuentan sus inventores- el rbol que vean desde su despa-
cho. Tras muchas peripecias, J ava sali al mercado en 1995 y el cambio de nombre
parece que se deba a que era uno de los tipos de caf que servan en una cafetera
cercana al lugar en que traba.jaban los desarrolladores y sa es la razn de que el
logotipo de J ava sea una humeante taza de caf.
Una de las primeras aplicaciones que lo soportan con especificaciones comunes
para las que se comenz a disear J ava fue Internet; su objetivo era poder descar-
gar en cualquier tipo de mquina aplicaciones residentes en la Web y ejecutarlas
para trabajar con ellas contra la propia mquina del usuario. AI principio se trataba
de aplicaciones HTML -pginas de puro contenido esttico- y fue evolucionando y
adaptndose a Internet y a sus innovaciones tecnolgicas; eso significa que J ava
soporta XML de modo muy eficiente y las nuevas tecnologas inalmbricas, celula-
res o mviles. Dos grandes especificaciones existen actualmente en torno a J ava:
J 2EE (J ava 2 Enterprise Edition) y J 2ME (J ava 2 MicroEdition).
J2EE, est orientada al desarrollo de aplicaciones de propsito general y son
numerosos los grandes fabricantes (IBM. Nokia, Motorola, Hewlett-Packard ....) que
lo soportan con especificaciones comunes; J2EM, un nuevo estndar para disposi-
tivos inalmbricos (mviles, de bolsillo o de mano (handhrlds)) que requieren una
integracin en dispositivos con poco espacio fsico y memoria de trabajo. J 2EE es
ya un autntico estndar as reconocido por la industria y J 2EM va camino de con-
vertirse en otro gran estndar. que en este caso est contribuyendo a la revolucin
inaltnbrica que est haciendo que Internet llegue a dispositivos electrnicos de
todo tipo, como telfonos mviles (celulares), telfonos de sobremesa, electrodo-
msticos, decodificadores de TV digital, etc.
La versin original de J ava que comenz a comercializarse y expandirse con
rapidez fue la 1 .O, aunque pronto apareci la versin I . I , que si bien slo cambi el
segundo dgito del nmero, los cambios fueron ms profundos de lo que el nmero
suele indicar en la nomenclatura de los programas de software (modificaciones y
pequeas actualizaciones). De hecho, aadi numerosos elementos a la biblioteca.
redefini los sucesos (eventos) y reconfigur la citada biblioteca. Posteriormente la
versin 2, con sus diferentes kits de desarrollo, ha servido para asentar la eficiencia
y calidad J ava. Se puede considerar que Sun ha lanzado cinco versiones importan-
tes del lenguaje J ava:
Prlogo xvi i
Java 1.0. Una pequea versin centrada en la Web disponible uniformemente
para todos los navegadores Web populares y que se lanz en 1995.
J m u 1.1. Una versin lanzada en 1997 con mejoras de la interfaz de usuario,
manipulacin de sucesos (eventos) reescrita totalmente y una tecnologa de
com po ne n te s de no ni i nada J u vu Beuns.
J ui w 2 cot 7 SDK 1.2. Una versin ampliada significativamente y lanzada en
I Y98 con caractersticas de interfaces grficas de usuario, conectividad de
bases de datos y muchas otras mejoras.
J uw 2 COIZ SBK 1.3. Una versin lanzada en el 2000 que aade caractersticas
notables. como multimedia mejorada, ms accesibilidad y compilacin ms
rpida.
Juvrr 2 ~ 0 1 1 SDK 1.3 hetu. Una versin lanzada a primeros del mes de junio de
2001 que, entre otras me.joras. introduce la posibilidad de trabajar con XML. A
finales del 200 1 est prevista la salida de la versin definitiva.
Adems de los kits de desarrollo de J ava, existen numerosas herramientas
comerciales de desarrollo para los programadores de J ava. Las ms populares son:
Symantec Visual Caf.
Borland J builder.
IBM Visual Age for J ava.
Sun Forte for J ava.
Si usted trabaja con alguna herramienta distinta de SDK 1.3 y 1.4 para crear pro-
gramas J ava a medida que lea este libro, necesita asegurarse que sus herramientas
de desarrollo estn actualizadas para soportar J ava 2.
Los programas de este libro fueron escritos y probados con J ava SDK v. 1.3.1, la
versin ms actual existente durante el proceso de escritura del libro. Sin embargo,
durante la fase de pruebas de imprenta de la obra, Sun present oficialmente el 29
de mayo de 2001 la versin J ava SDK v. 1.4 beta con la cual fueron compilados y
probados todos los programas de nuevo, por lo que usted no deber tener ningn
problema. Bueno, realmente, s se le presentar un problema como a nosotros,
pero que por fortuna nos resolvieron los ingenieros de Sun Microsystems (Andrew
Bennett y Bill Shannon), cuya ayuda y apoyo tcnico destacamos de forma espe-
cial. El problema es que al tratar de ejecutar los applets bajo SDK v. 1.4 en el
navegador Web no le funcionarn completamente a menos que utilice unos progra-
mas pl ug-i n descargados del sitio de Sun.
Los navegadores existentes normalmente no soportan -como es lgico- la ltima
versin de J ava y slo cuando ellos realizan la nueva versin es cuando tienen en
cuenta esta ltima versin de J ava. Sun ha resuelto esta situacin proporcionando
un plug-in (aadido/actualizacin o parche). En realidad, cualquier clase aadida
a J ava I .2 y posteriores no se encuentra en la implementacin de J ava proporcionada
xvi i i Prlogo
por los navegadores. por lo que se originarn errores al usar las nuevas clases. pero
no debiera haber problemas cuando se est escribiendo cdigo que no usa estas nue-
vas caractersticas. No obstante, en J ava 1.4 esto no es as. pues se ha eliminado la
opcin de coinpilacin por defecto del compilador ( j r r i ~ r c . ) existente en J ava 1.3 que
iiutotiiticliiiieiite diriga el cdigo a la versin I . 1 de la mquina virtual. Para solu-
cionar este <<probleman se tienen dos posibilidades: Lisir siempre Jriiw Plug-in, lo
cual le permitir emplear las ltiinas rne.joras del producto. o dirigir especficamen-
te SLI cdigo a una mquina virtual determinada compatible con el navegador corres-
pondiente. mediante el empleo del modificador -tcrr,yet del cornpilador.
Las nuevas actualizaciones
Sun Microsystems es propietaria de J ava; sin embargo, numerosos fabricantes con-
tribuyen a la me-jora y desarrollo de las especificaciones del ectndar. Sun propor-
ciona las licencias de esta tecnologa pero e.jerce siempre un cierto control sobre las
implenientaciones que se hacen de la misma, con el ob.jetivo de mantener la inde-
pendencia de la plataforma. Ese objetivo se trata de conseguir con procesos contro-
lados por el programa JCP ( J mw Coinmimit~ Procrss). en los que se determina el
proceso formal de estandarizacin y continuar asegurndose de que las especifica-
ciones siguen siendo compatibles. Es decir. que J ava siga siendo J ava.
Las actualizaciones ms utilizadas actualmente son la versin J ava 2 (J 2SE)
y los kit de desarrollo J DK 1.2 y 1.3. Sin embargo, ya est disponible
( j ava . sun. corn/ j 2 se/ 1 . 4) la versin ms reciente. J 2SE 1.4 (kit de desarro-
Ilo J DK 1.4). para las plataformas Solaris. Linux y Windows.
Java J2SE 1.4 (incluida en el libro y en el CD)
Las aportaciones ms interesantes se encuentran en la integracin en el ncleo de la
plataforma de la posibilidad de trabajar con XML. estableciendo as los fundamen-
tos bsicos para la creacin y consumo de servicios Web. Existen mejoras en las
J FC (JCIVCI Foundation Cln.w.7) que afectan al rendimiento de las aplicaciones
cliente basadas en Si.~.ing y grficos J ava 2D. Tambin contempla el uso de arqui-
tecturas de 64 bits y se ha mejorado la seguridad con la integracin de una nueva
API compatible Kerberos.
Direcciones Web de inters profesional
Internet est plagada de direcciones de inters y excelentes relativas a J ava. No obs-
tante. adems de los recursos que incluimos en el Apndice G (que aconsejamos
Prlogo xi x
visite gradualmente) le daremos unas direcciones de gran inters sobre todo para
descargar software y documentacin actualizada.
ht t p: / / ~ava. s ur ~. . com/ j ~s e
http: / / l dva. sun. cnm/ ! Zse/ l . 3
http: / / ! ava. sun. _ om/ 72se/ 1. 4/
http: / / j ava. cun. corr/ j 2ce/ l . 3/ docs/ .
nttp: / / j ava. c~~n. co- / j ~se/ l . 4/ does/
kt t p: / / j ava. cn. - cm/ i : r ~- i * ~ts/ p~. ~gi n/ l . 3.
i r.dex, html
h t t p : / / ] a v a . s u n . c o m/ j ~s ~/ l . 4 / ~~~~/ ~~~~~/
pl ugi n/ i nci ex. h:il
- t t o: / / ] ava. sun. com/ j 2me
Platufornici Jnvtr 2, Srundurtl
Edition I: I . 4
P1rrtufi)rmci J ai w 2 Micro Ecli-
tion, J2ME (.ri.rtemci.r. inaldm -
17rico.r)
Como motor de bsqueda le recomendamos Google (www. g o o g l e . corn) ,
Al t avi st a (www. al t a v i s t a . corn) o Ask (www. ask. corn), aunque
si est acostumbrado a otros buscadores (tales como los incluidos en Terra, Ya.
StarMedia, Excite ...) es recomendable que haga pruebas prcticas para ver si real-
mente le puede ser ventajoso realizar el cambio.
EL LIBRO COMO HERRAMIENTA DIDCTICA
La obra J a ~ m 2. Mu t i i d de progrumacicn ha sido diseada y escrita pensando en
personas que desean iniciarse en el mundo de la programacin de J ava tanto para
desarrollo de aplicaciones como para desarrollo de upplets. Tiene como objetivo
primordial ensear a programar en J ava para entornos abiertos y entornos de
Internet en niveles de iniciacin y medios. Si bien es un libro pensado en el profe-
sional y en el estudiante autodidacto, la experiencia docente de los autores se ha
volcado en el libro tratando de conseguir una obra didctica que pueda servir no
slo para su uso en cursos profesionales, sino en cursos de enseanzas regladas
tales como los mdulos formativos de ciclo superior de la formacin profesional y
en los primeros semestres de estudios universitarios de ingeniera y ciencias. Se ha
buscado que el libro fuera autosuficiente, aunque el rendimiento mayor del libro se
xx Prlogo
conseguir cuando el lector tenga una formacin mnima de fundamentos de teora
de progranmacin. Conocimientos de otros lengua.jes de programacin. fundamen-
talmente estilo C/C++. ayudar considerablemente al aprendizaje gradual no slo
en el tiempo sino en el avance de contenidos.
Por todo ello. pensamos que el libro puede servir. adems de aprendimje auto-
didacto. para cursos de introduccin a la programacin/progranincin en J ava de un
semestre de duracin o cursos profesionales de unas 30-40 horas que ya posean
experiencia en otros lengua-jes de programacin.
CONTENIDO
Siempre que Sun lanza una nueva versin de J ava hace un ki t de desarrollo gratis
que pone disponible en su Web para soportar a dicha versin. Este libro se ha
creado utilizando el kit que se denomina Java 2 Software Development Kit,
Standard Edition, Versin 1.3 (JDK 1.3). Tras lanzar Sun la versin 1.4 beta, se
han probado todas las aplicaciones y applefs con esta nueva versin (JDK 1.4).
As mismo, se han actualizado los paquetes de la plataforma J ava 2 para incluir
ambas versiones y el contenido del CD ad.junto al libro que incluye dichas versio-
nes para los entornos Windows y Linux. El libro consta de quince captiilos y siete
apndices (A-G). Un breve contenido de los captulos y apndices se resea a con-
tinuacin:
Captulo 1. Introduccin CI JLiva. En este captulo se realiza una descripcin de
la historia de J ava junto a una breve descripcin de las caractersticas ms notables.
Se describe el concepto de aplicacin y de uppler y los mtodos para crear un
programa J ava. Sun tiene disponible en su pgina Web (www.sun.com) el Kit de
Desarrollo necesario para la compilacin y ejecucin de programas denominado
J DK (Juiu Development Ki f ) y en este captulo se explica este entorno de desarro-
llo, as como los errores tpicos que se producen en la fase depuracin y puesta a
punto de programas por parte del usuario.
Captulo 2. Caructeri~ricus del lenguaje Javu. Todo lenguaje de programacin.
y J ava no es una excepcin, dispone de un conjunto de elementos bsicos que cons-
tituyen su ncleo fundamental para la escritura de programas. En el captulo se des-
criben: palabras reservadas. identificadores, tipos de datos. variables, constantes y
operadores. as como una breve introduccin a las clases y bibliotecas de clases de
J ava.
Captulo 3. Decisiorzes y bucles. Los programas requieren siempre de sentencias
y estructuras de control para seguir la secuencia de e.jecucin de sus instrucciones.
La ejecucin secuencia1 de un programa requiere de modo continuo una toma de
decisiones e iteraciones o repeticiones: para ello, se utilizan sentencias de decisin
y de iteracin para realizar los bucles o repeticiones de acciones. Se describen
Prlogo xxi
las sentencias bsicas: i f , ef - el se, f or, whi l e, do- whi l e, br eak y
cont i nue.
Captulo 4. C1usr.s. ohj r r o. s y inPtodos. El concepto de clase y de objeto como
instancia o e.jemplar de una clase se analizan con el apoyo de la sintaxis utilizada
para SLI escritura.
Captulo 5. Herencicr. Una de las propiedades fundamentales del concepto de
orientacin a objetos es la herencia. Se explica el concepto, as como el mtodo de
implementar en J ava dicha propiedad y sus ventajas e inconvenientes.
Captulo 6. Eiic~rrp,sirlcin~ieiito y polinzorflsmo. Otras dos propiedades fundamen-
tales de la orientacin a objetos son el encapsulamiento de la informacin y el con-
cepto de polimorfismo. Ambas propiedades. los mtodos y sintaxis se describen en
este captulo.
Captulo 7. Arruys. La informacin bsica manejada por los programas se or-
ganiza en estructuras de datos. Se describe el array como representante genuino de
listas. tablas o vectores. as como mtodos para ordenar estas estructuras de infor-
macin y realizar bsqueda de informacin en las mismas.
Captulo 8. Cadenus y,fechus. El concepto de cadena como secuencia o lista de
caracteres y las clases especficas necesarias para su manipulacin se analizan en este
captulo. Tambin se considera el concepto casi siempre necesario en un programa
del tratamiento de las fechas como elementos bsicos de medicin del tiempo.
Captulo 9. iizterfilces ,qrcficn.s de usuario. Una de las grandes virtudes de los
lenguajes de programacin actuales, y J ava en particular, es la facilidad que ofrece
al usuario para construir interfaces grficas sencillas y adaptadas al entorno de tra-
bajo.
Captulo 10. Gestin c c eventos. La programacin mediante eventos o sucesos
es otra de las caractersticas sobresalientes que aporta J ava al mundo de la progra-
macin. El concepto y los tipos de eventos as como mtodos para su gestin y
manipulacin se describen en este captulo.
Captulo 11. Applers. Los programas conocidos como applets son, sin gnero de
dudas. el puente ideal para la conexin con el mundo Internet y una de las propie-
dades de J ava que lo han hecho tan popular. Una breve introduccin al lenguaje
HTML y el modo de realizar applrts son la base del captulo.
Captulo 12. Programucion concurrente: Hilos de ejecucin. Otra propiedad
fundamental de J ava como lenguaje de tiempo real es la posibilidad de manejar pro-
cesos en paralelo. El concepto de hilo (thread), su manipulacin e implementacin
se analizan en este captulo.
Captulo 13. Manqjo dr excepciones. El concepto de excepciones es vital en la
programacin moderna. Lenguajes como Ada y C++ lo incorporaron a su sintaxis,
y J ava, siguiendo los pasos de estos dos potentes lenguajes, ha incluido el trata-
miento de excepciones en sus compiladores.
Captulo 14. Archivos. Las estructuras de datos organizados en torno a archivos
o ficheros son pieza fundamental en el proceso de informacin de cualquier orga-
xxi i Contenido
nizacin. Su organizacin. diseo y construccin constituyen el contenido funda-
mental de este captulo.
Captulo 15. E.struc~tirrn.s de cirrtos defliiicti.s por 01 progrtrniudor: Una vez que el
programador sabe mane.jar estructuras de datos bsicas como arrays y archivos, sen-
tir la necesidad con relativa frecuencia de utilizar estructuras de datos dinmicas
tales como listas, pilas y colas. Su concepto y mtodos de iinplementacin se expli-
can en este ltimo captulo.
En los apndices. se incluyen herramientas de trabajo complementarias para el
programador tales como: Lisrndo de pa1cihrci.s r-eservad(is Juvci ( A) ; fiihla de prio-
riud de operadores ( B) ; Gua de sintaxis de JLI LYI 2, que facilita la consulta al lec-
tor en la fase de escritura y depuracin de prograinas ( C) ; Paquetes de la platuforma
J ai n 3 ms utilizados e incluidos en las versiones de 1.3.1 y 1.4 de los kit de desa-
rrollo J DK (0); Una conzpuracicn eritw l o s 1rnguuje.s de progr-armickjn orientados
ci ohjetos mr s p o p l ~ i r e s en la uctucilidd: C++y J ava ( E) ; Coriteriido del CD como
elemento de ayuda en el aprendizaje y formacin en J ava para el lector y herra-
mienta de software complementaria para cursos y seminarios en laboratorios de
programacin ( F) ; Recursos de J u i u : libros, revistas y sitios Web de inters.
CD QUE ACOMPAA AL LIBRO
El disco compacto que se adjunta en las tapas de este libro contiene la versin
Java 2 y el kit de desarrollo JDK de Sun versiones 1.3.1 y 1.4 para entornos
Windows y Linux. As mismo, se han incluido todas las aplicaciones y applets
sobresalientes incluidos en el libro con el ob-jetivo fundamental de ayudarle en el
proceso de compilacin y ejecucin.
AGRADECIMIENTOS
Como ya hemos indicado anteriormente, no podemos terminar este prlogo sin
expresar nuestra gratitud a todo el equipo de Sun Microsystems en Palo Alto (Ca-
lifornia), su disponibilidad y efectividad a la hora de resolver cualquier consulta ha
resultado una inestimable ayuda en el desarrollo de esta obra. Evidentemente com-
portamientos profesionales como &tos son algunos de los millones de razones para
usar J ava. As pues, reiteramos nuestro agradecimiento a Sun Microsystems y en
particular a los ingenieros:
Andrew Bennett
Engineering Manager. Sun Microsystems. Inc.
CONTENIDO
1 . I . La historia de J ava.
1.2. Qu es J ava?
1.3. Caractersticas de J ava.
1.4.
1.5. Especificaciones del lenguaje J ava.
1.6. Aplicaciones y applets.
1.7. Creacin de programas.
1.8. Componentes de una aplicacin.
1.9. Herramientas de desarrollo J ava.
1 .I O. Una aplicacin prctica de J ava.
1 . I I . Estructura de un programa aplicacin en J ava.
1 .I 2. Errores de programacin.
La programacin orientada a objetos como base
de J ava.
m 1
2
Java 2. Manual de programacin
Este captulo introduce al lector en el mundo de J ava, su fortaleza
y sus debilidades. Describe la programacin en J ava y por qu es
diferente de la programacin en cualquier otro lenguaje, as como
las ventajas que estas diferencias pueden representar en la crea-
cin de aplicaciones nuevas y eficientes.
El futuro de la computacin est influenciado por Internet y
J ava es una parte importante de ese futuro. Java es el lenguaje de
programacin de lnternet y es una plataforma cruzada, orientada
a objetos, usada en la Red y preparada para multimedia. Desde su
nacimiento real en 1995, J ava se ha convertido en un .lenguaje
maduro para el desarrollo de aplicaciones crticas y eficientes.
Este captulo comienza con una breve historia de J ava y sus carac-
tersticas ms sobresalientes, as como ejemplos sencillos de apli-
caciones y el concepto de applefs J ava.
1.1. LA HISTORIA DE JAVA
J ava no fue creado originalmente para la red internet. Sun Microsystems comenz a
desarrollarlo con el objetivo de crear un lenguaje, independiente de la plataforma y
del sistema operativo, para el desarrollo de electrnica de consumo (dispositivos
electrnicos inteligentes, como televisores, vdeos, equipos de msica, etc.).
El proyecto original, denominado Green comenz apoyndose en C++, pero a
medida que se progresaba en su desarrollo el equipo creador de <<Green comenz
a encontrarse con dificultades, especialmente de portahilidad. Para evitar estas difi-
cultades, decidieron desarrollar su propio lenguaje y en agosto de 1991 naci un
nuevo lenguaje orientado a objetos. Este lenguaje fue bautizado con el nombre de
Oak. En 1993, el proyecto Green se volvi a renombrar y pas a llamarse First
Penon Juc. Sun invirti un gran presupuesto y esfuerzo humano para intentar ven-
der esta tecnologa, hardware y software, sin gran xito.
A mitad de 1993, se lanz Mosaic, el primer navegador para la Web y comenz a
crecer el inters por Internet (y en particular por la World Wide Web). Entonces, se
redise el lenguaje para desarrollar aplicaciones para internet y, en enero de 1995,
Oak se convirti en Java. Sun lanz el entorno J DK 1 .O en 1996, primera versin del
kit de desarrollo de dominio pblico, que se convirti en la primera especificacin for-
mal de la plataforma J ava. Desde entonces se han lanzado diferentes versiones, aun-
que la primera comercial se denomin J DK 1.1 y se lanz a principios de 1997.
Introduccin a Java 3
En diciembre de 1998 Sun lanz la plataforma J ava 2 (que se conoci como J DK
1.2 durante su fase de pruebas beta). Esta versin de J ava ya represent la madurez
de la plataforma J ava. Sun renombr J ava 1.2 como J ava 2.
El paquete de J ava que se utiliza en esta obra, incluye el compilador J ava y otras
utilidades, se denomina oficialmente J ava 2 J DK, versin 1.3.
Los programas J ava se pueden incluir (((embeber)) o ((empotrar))) en pginas
HTML y descargarse por navegadores Web para llevar animaciones e interacciones
a los clientes Web. Sin embargo, la potencia de J ava no se limita a aplicaciones
Web, J ava es un lenguaje de programacin de propsito general que posee carac-
tersticas completas para programacin de aplicaciones independientes o autno-
mas. J ava, como lenguaje, es fundamentalmente orientado a objetos. Se dise
desde sus orgenes como verdadero lenguaje orientado a objetos, al contrario que
otros lenguajes, como C++y Ada, que tienen propiedades de lenguajes procedi-
mentales. La programacin orientada a objetos (POO) es tambin, actualmente, un
enfoque de programacin muy popular que est reemplazando poco a poco a las tc-
nicas tradicionales de programacin procedimental o estructurada.
La ltima versin lanzada por Sun es J ava 2 J DK 1.4 Beta. En la direccin
www . sun. corn se pueden encontrar todas las versiones para Windows9x,
Windows 2000/NT, UNIX, Unix (Solaris), Macintosh, ...
1.2. QU ES JAVA?
El significado de J ava tal y como se le conoce en la actualidad es el de un len-
guaje de programacin y un entorno para ejecucin de programas escritos en el
lenguaje J ava. AI contrario que los compiladores tradicionales, que convierten el cdi-
go fuente en instrucciones a nivel de mquina, el compilador J ava traduce el
cdigo fuente J ava en instrucciones que son interpretadas por la Mquina Virtual
J ava (J VM, Java Virtual Machine). A diferencia de los lenguajes C y C++en los
que est inspirado, J ava es un lenguaje interpretado.
Aunque hoy en da J ava es por excelencia el lenguaje de programacin para
Internet y la World Wide Web en particular, J ava no comenz como proyecto
Internet y por esta circunstancia es idneo para tareas de programacin de pro-
psito general y, de hecho, muchas de las herramientas J ava estn escritas en
J ava.
1.2.1. Java como lenguaje de Internet
J ava es un lenguaje para programar en Internet que trata de resolver dos problemas
claves con el contenido de Internet:
4 Java 2. Manual de programacin
Computadora local
Sistema operativo
Navegador J ava
Mquina virtual
J ava
En la actualidad, el contenido de la WWW es pasivo y esttico.
La entrega (Deliverry) del contenido WWW es dependiente de la configura-
cin de cada navegador Web de usuario.
Computadora servidor
(host)
Cdigo
fuente J ava
. Cdigo fuente
En el mundo de la Web, J ava es una tecnologa facilitadora que permite a los
desarrolladores crear pginas Web que se entregarn de modo consistente a todos
los usuarios con un navegador habilitado para J ava y con independencia de la pla-
taforma hardware y el sistema operativo que se est utilizando'. Dado que el cdi-
go fuente se interpreta, si existe un intrprete J ava para una plataforma especfica
hardware o sistema operativo, se pueden escribir programas con el conocimiento de
que sern tiles en esa plataforma.
La Figura 1.1 muestra cmo el cdigo fuente J ava se transfiere en Internet. En
la computadora servidor (host) se almacena el cdigo fuente. Cuando un usuario de
una computadora local se conecta con el servidor a travs de Internet mediante un
navegador habilitado para J ava, el cdigo fuente se transfiere de la computadora
servidor a la computadora local.
1.2.2. Java como lenguaje de propsito general
A medida que J ava se populariza en desarrollos de Internet, gana tambin como len-
guaje de propsito general. J ava es totalmente portable a gran variedad de platafor-
mas hardware y sistemas operativos.
J ava tiene muchos conceptos de sintaxis de C y C++, especialmente de C++, del
que es un lenguaje derivado. Aade a C++propiedades de gestin automtica de
memoria y soporte a nivel de lenguaje para aplicaciones multihilo. Por otra parte,
J ava, en principio a nivel medio, es ms fcil de aprender y ms fcil de utilizar que
C++ ya que las caractersticas ms complejas de C++ han sido eliminadas de J ava:
herencia mltiple, punteros (apuntadores) y sentencia got o entre otras.
' En Cohn et al., Java. DeveloperS Reference, Indianapolis: Sams Net. 1996. se describen las caracte-
rsticas fundamentales del lenguaje J ava original.
Introduccin a Java 5
Las iinpleinentaciones de la Mquina Virtual J ava pueden ser muy eficaces y eso
hace posible que los programas J ava se ejecuten tan rpidamente como los programas
C++. Esta caracterstica clave de J ava, unida a sus fortalezas como lenguaje de Internet,
lo hacen muy adecuado para desarrollos en sistemas clienteiservidor, soporte masivo
de los sistemas informticos de la mayora de las empresas y organizaciones.
Las propiedades que se vern ms adelante hacen a J ava doblemente idneo para
desarrollos cliente/servidor y para desarrollos de Internet.
1.3. CARACTERISTICAS DE JAVA
J ava ha conseguido una enorme popularidad. Su rpida difusin e implantacin en el
mundo de la programacin en Internet y fuera de lnea (offline) ha sido posible gra-
cias a sus importantes caractersticas. Los creadores de J ava escribieron un artculo,
ya clsico, en el que definan al lenguaje como sencillo, orientado a objetos, distri-
buido, interpretado, robusto, seguro, arquitectura neutra, alto rendimiento, multihilo
y dinmico. Analicemos ms detenidamente cada caracterstica.
1.3.1. Sencillo
Los lenguajes de programacin orientados a objetos no son sencillos ni fciles de
utilizar, pero J ava es un poco ms fcil que el popular C++*, lenguaje de desarrollo
de software ms popular hasta la implantacin de J ava.
J ava ha simplificado la programacin en C++, aadiendo caractersticas funda-
mentales de C++ y eliminando alguna de las caractersticas que hacen a C++un len-
guaje difcil y complicado.
J ava es simple porque consta slo de tres tipos de datos primitivos: nmeros,
boolean y arrays. Todo en J ava es una clase. Por ejemplo, las cadenas son objetos
verdaderos y no arrays de caracteres. Otros conceptos que hacen la programacin
en C++ ms complicada son los punteros y la herencia mltiple. J ava elimina los
punteros y reemplaza la herencia mltiple de C++con una estructura nica deno-
minada interfaz ( i n te r face).
J ava utiliza asignacin y recoleccin automtica de basura (garbage collection),
aunque C++ requiere al programador la asignacin de memoria y recoleccin de
basura.
Otra caracterstica importante es que la elegante sintaxis de J ava hace ms fcil
la escritura de programas.
En C++. Inicicicin y Refereiicia (McCraw-Hill, 1999). de Luis J oyanes y Hctor Castn, podr encon-
trar una gua de iniciacin con enfoque similar a esta obra. si usted necesita iniciarse en C++.
6 Java 2. Manual de programacin
1.3.2. Ori entado a obj etos
La programacin orientada a objetos modela el inundo real, cualquier cosa del
inundo puede ser inodelada cot no un ob-jeto. As una circunferencia es un objeto, un
autoiiih i I es un &jeto, una ventana es un objeto, un libro cs un ob.jeto e incluso un
prstamo o una tarjeta de crdito son objetos. Un prograina J ava se denomina oricii-
t t rt i o LI oi ?j c' / o. s debido a que la programacin en J ava se centra en la creacin, mani-
pulacin y coiistruccih de objetos.
Un objeto tiene p i ~ ) p i ~ & ~ i c ~ , s (un estado) y un coniportainieiito. Las propiedades
o el estado se detinen iitilinndo datos y el coinportainiento se define utilizando
mtodos. Los ob-jetos sc detitien utilizando clases en J ava. Una clase es similar a
una plantilla para construir objetos. Con la excepcicn de los tipos de datos primiti-
\os. todo en J a\.a es uti ob.jeto. En J ava, al contrario de lo que sucede en C++, no
hay fuiicioiies globales: todas las iiinciones se in\,ocan a tra\,Cs de tin objeto.
Por e-jeinplo, se puede definir un objeto cuadrado mediante una clase
cuadrado (Fig. l .2), con un l ado (propiedad) y cal i ul ar Super f i ci e
como el mt.todo qiie encuentre o calcule la superficie del cuadrado.
Clase
Instanoar I I ddT 1 lnstanciar
cuadrado
de lado 1 O
cuadrado
de lado 25
Figura 1.2. Dos objetos , ~d l rCri c de lados 10 y 25
Se crean a partir de la clase r, i a j r ~i
Un objeto es una realizacin concreta de una descripcin de una clase. El pro-
ceso de creacicn de objetos se denomina i i ~7~f ~1~1~. i ~r c, i i ? (crear instancias) de una
clase.
AI i i u f c r wi t n . una clase. se crean objetos. As. es posible crear un objeto cua-
dr ad~ instaiiciando la clase con un lado determinado. por ejemplo se puede crear
un cuadrado de lado I O y otro cuadrado de lado 25. Se puede encontrar cl rea de
los respecti\ os cuadrados usando el inktodo cal cul ar Super f Lcie.
Uti programa consta de una o ms clases que se disponen en una jerarqua en
modo rbol, de modo qiie una clase hija puede heredar propiedades y comporta-
mientos de su clase padrc (ascendente). J ava con un conjunto de clases pre-
dctinidas, agrupadas en paquetes que se pueden utilizar en los programas,
Introduccin a Java 7
La programacin orientada a objetos proporciona mayor flexibilidad, modulari-
dad y reusabilidad. En la actualidad est ya muy implantado este tipo de programa-
cin y J ava se convertir en breve plazo en uno de los lenguajes ms usados de
propsito general.
1.3.3. Distribuido
La computacin distribuida implica que varias computadoras trabajan juntas en la
red. J ava ha sido diseado para facilitar la construccin de aplicaciones distribuidas
mediante una coleccin de clases para uso en aplicaciones en red. La capacidad de
red est incorporada a J ava. La escritura de programas en red es similar a enviar y
recibir datos a y desde un archivo. La utilizacin de una URL (Uniform Resource
Locator) de J ava puede hacer que una aplicacin acceda fcilmente a un servidor
remoto.
1.3.4. Interpretado
J ava es interpretado y se necesita un intrprete para ejecutar programas J ava. Los
programas se compilan en una Mquina Virtual J ava generndose un cdigo inter-
medio denominado bytecode. El bytecode es independiente de la mquina y se
puede ejecutar en cualquier mquina que tenga un intrprete J ava.
Normalmente, un cornpilador traduce un programa en un lenguaje de alto nivel
a cdigo mquina. El cdigo slo se puede ejecutar en la mquina nativa. Si se eje-
cuta el programa en otras mquinas, ste ha de ser recompilado. As por ejemplo,
cuando un programa escrito en C++ se compila en Windows, el cdigo ejecutable
generado por el compilador slo se puede ejecutar en una plataforma Windows. En
el caso de J ava, se compila el cdigo fuente una sola vez y el bytecode generado por
el compilador J ava se puede ejecutar en cualquier plataforma.
Nota: Los programas J ava no necesitan ser recompilados en una mquina des-
tino. Se compilan en un lenguaje ensamblador para una mquina imaginaria,
denominada mquina virtual.
Sin embargo, los intrpretes J ava tienen una seria desventaja sobre los sistemas
convencionales. Son, normalmente, mucho ms lentos en ejecucin. Innovaciones
recientes en el mundo J ava han avanzado sobre las ideas de los intrpretes y han
aparecido compiladores J IT (just-in-time) que leen la representacin en bytecode
independiente de la mquina de un programa J ava, e inmediatamente antes de que
8
Java 2. Manual de programacin
la ejecucin traduzca la representacin en b-ytecode en instrucciones de la mquina
real del sistema en el que el programa J ava se est ejecutando. Dado que los progra-
mas J ava se ejecutan a continuacin como instrucciones mquina, pueden ser casi
tan rpidos como programas compilados en lenguajes ms convencionales para pla-
taformas de hardware especficas y mantener la portabilidad de la mquina virtual.
1.3.5. Robusto
Robusto significa fiable. Ningn lenguaje puede asegurar fiabilidad completa. J ava se
ha escrito pensando en la verificacin de posibles errores y por ello como un lenguaje
fuertemente tipificado (con tipos). J ava ha eliminado ciertos tipos de construcciones de
programacin presentes en otros lenguajes que son propensas a errores. No soporta,
por ejemplo, punteros (apuntadores) y tiene una caracterstica de manejo de excepcio-
nes en tiempo de ejecucin para proporcionar robustez en la programacin.
Regla: J ava utiliza recoleccin de basura en tiempo de ejecucin en vez de
liberacin explcita de memoria. En lenguajes como C++es necesario borrar
o liberar memoria una vez que el programa ha terminado.
1.3.6. Seguro
J ava, como lenguaje de programacin para Internet, se utiliza en un entorno distri-
buido y en red. Se puede descargar un applet J ava y ejecutarlo en su computadora
sin que se produzcan daos en su sistema, ya que J ava implementa diversos meca-
nismos de seguridad para proteger su sistema de daos provocados por un progra-
ma stray. La seguridad se basa en la premisa de que nada debe ser trusted.
Naturalmente la seguridad absoluta no existe, pero, aunque se encuentran pro-
blemas de seguridad en J ava, stos no son lo suficientemente notables como para
producir trastornos apreciables.
Nota: Existen numerosos sitios en la Red para informacin sobre seguridad de
computadoras. Este sitio
de la universidad de Princeton (all imparti clase el fsico universal Einstein)
es excelente para estudiar problemas de seguridad informtica, especialmente
para J ava, ActiveX y J avaScript.
www. cs. pr i ncet on. edu/ si p/ .
Introduccin a Java 9
1.3.7. Arquitectura neutral
Una de las caractersticas ms notables de J ava es que es de arquitectura neutral,
lo que tambin se define como independiente de la plataforma. Se puede escribir
un programa que se ejecute en cualquier plataforma con una Mquina Virtual
J ava.
Se pueden ejecutar applets de J ava en un navegador Web; pero J ava es algo ms
que escribir upplets de J ava, ya que se pueden tambin ejecutar aplicaciones J ava
autnomas (stand-alone) directamente en sistemas operativos que utilicen un intr-
prete J ava.
I I
Importante: Utilizando J ava, los desarrolladores necesitan escribir una nica
versin para ejecutarse en todas las plataformas, dado que los bytecodes no se
corresponden a ninguna mquina especfica y trabajan en todas las mquinas.
Comentario: Un programa J ava es el mismo si se ejecuta en un PC, un
Macintosh, o un sistema Unix. Es distinto de los lenguajes convencionales
tales como C/C++
1.3.8. Portable
Java es un lenguaje de alto nivel que permite escribir tanto programas convencio-
nales como aplicaciones para Internet (applets). Dado que Internet es una red for-
mada por equipos muy diferentes interconectados por todo el mundo, resulta
fundamental para los programas que rueden en ella su independencia de la plata-
forma en la que van a ser ejecutados. Dicha independencia se obtiene en J ava gra-
cias a que el compilador J ava genera un cdigo intermedio, bytecode (cdigo byte),
no ejecutable por s mismo en ninguna plataforma, pero que puede ser ejecutado a
gran velocidad mediante un intrprete incorporado en la mquina virtual J ava. En
las diferentes plataformas existirn mquinas virtuales especficas, y cuando el
cdigo byte llegue a esas mquinas virtuales ser interpretado pasndolo al cdigo
adecuado para la computadora receptor de la aplicacin. Las mquinas virtuales J ava
son programas capaces, entre otras cosas, de interpretar el cdigo byte, que pueden
venir incluidos en los navegadores, proporcionados con el sistema operativo, con el
entorno J ava o bien obtenerse a travs de Internet (mediante descarga del corres-
pondiente programa). Por tanto, los programas J ava pueden ejecutarse en cualquier
plataforma sin necesidad de ser recompilados; es decir, son muy portables.
10 Java 2. Manual de programacin
Pero la portabilidad de J ava an va ms all; J ava fue diseado de modo que
pueda ser transferido a nuekas arquitecturas.
En J ava todos los tipos de datos primitivos son de tamaos definidos con inde-
pendencia de la mquina o sistema operativo en el que se ejecute el programa. Esta
caracterstica es distinta de C o C++, en los que el tamao de los tipos depender
del coinpilador y del sistema operativo.
Nota: El tamao fijo de los nmeros hace el programa portable.
I I
Regla: El entorno J ava es portable a nuevos sistemas operativos y hardware.
El compilador J ava est escrito en J ava.
1 I
1.3.9. Al to rendimiento
Los coinpiladores de J ava han ido mejorando sus prestaciones en las sucesivas
\!ersiones. Los nuevos compiladores conocidos como J lT @st-in-tirvze) permiten
que prograinas J ava independientes de la plataforma se ejecuten con casi el
mismo rendimiento en tiempo de ejecucin que los lenguajes convencionales
coin pi 1 ados .
1.3.10. Multhilo
J ava es uno de los primeros lenguajes que se han diseado explcitamente para tener
la posibilidad de mltiples hilos de ejecucin; es decir, J ava es multihilo (multith-
reudit7g). Multihilo es la capacidad de un programa de ejecutar varias tareas simul-
tneamente. Por ejemplo, la descarga de un archivo de vdeo mientras se graba el
vdeo. La Programacin multihilo est integrada en J ava. En otros lenguajes se tiene
que llamar a procedimientos especficos de sistemas operativos para permitir mul-
tihilo.
Los hilos sincronizados son muy tiles en la creacin de aplicaciones distribui-
das y en red. Por ejemplo, una aplicacin puede comunicarse con un servidor remo-
to en un hilo, mientras que interacta con un usuario en otro hilo diferente. Esta
propiedad es muy til en programacin de redes y de interfaces grficas de usuario.
Un usuario de Internet puede or una emisora de msica mientras navega por una
pgina Web y un servidor puede servir a mltiples clientes al mismo tiempo.
introduccin a Java 11
1.3.1 1. Dinmico
Como Java es interpretado, es un lenguaje muy dinmico. En tiempo de ejecucin, el
entorno J ava puede extenderse (ampliarse) mediante enlace en clases que pueden
estar localizadas en servidores remotos o en una red (por ejemplo, Intranet/Intemet).
Es una gran ventaja sobre lenguajes tradicionales como C++ que enlaza clases antes
del momento de la ejecucin.
Se pueden aadir libremente nuevos mtodos y propiedades a una clase sin afec-
tar a sus clientes. Por ejemplo, en la clase Cuadr ado se pueden aadir nuevos
datos que indiquen el color del polgono y un nuevo mtodo que calcule el perme-
tro del cuadrado. El programa cliente original que utiliza la clase Cuadr ado per-
manece igual. En tiempo de ejecucin, J ava carga clases a medida que se necesitan.
1.4. LA PROGRAMACIN ORIENTADA A OBJETOS
COMO BASE DE JAVA
La programacin orientada a objetos (POO) es la base de J ava y constituye una nueva
forma de organizacin del conocimiento en la que las entidades centrales son los objetos.
En un objeto se unen una serie de datos con una relacin lgica entre ellos, a los que se
denomina variables de instancia, con las rutinas necesarias para manipularlos, a las que
se denomina mtodos. Los objetos se comunican unos con otros mediante interfaces bien
definidas a travs de puso de mensajes; en PO0 los mensajes estn asociados con mto-
dos, de forma que cuando un objeto recibe un mensaje, ejecuta el mtodo asociado.
Cuando se escribe un programa utilizando programacin orientada a objetos, no se
definen verdaderos objetos, sino clases; una clase es como una plantilla para construir
varios objetos con caractersticas similares. Los objetos se crean cuando se define una
variable de su clase. En las clases pueden existir unos mtodos especiales denominados
constructores que se llaman siempre que se crea un objeto de esa clase y cuya misin
es iniciar el objeto. Los destructores son otros mtodos especiales que pueden existir en
las clases y cuya misin es realizar cualquier tarea final que corresponda realizar en el
momento de destruir el objeto. Las propiedades fundamentales de los objetos son:
El encapsulamiento, que consiste en la combinacin de los datos y las opera-
ciones que se pueden ejecutar sobre esos datos en un objeto, impidiendo usos
indebidos al forzar que el acceso a los datos se efecte siempre a travs de los
mtodos del objeto. En J ava, la base del encapsulamiento es la clase, donde se
define la estructura y el comportamiento que sern compartidos por el grupo
de objetos pertenecientes a la misma. Para hacer referencia a los componentes
accesibles de un objeto ser necesario especificar su sintaxis:
nombreobjeto. nombreComponente.
12 Java 2. Manual de programacin
La herencia es la capacidad para crear nuevas clases (descendientes) que se
construyen sobre otras existentes, permitiendo que stas les transmitan sus pro-
piedades. En programacin orientada a objetos, la reutilizacin de cdigo se
efecta creando una subclase que constituye una restriccin o extensin de la
clase base, de la cual hereda sus propiedades.
El polimorjismo consigue que un mismo mensaje pueda actuar sobre diferen-
tes tipos de objetos y comportarse de modo distinto. El polimorfismo adquiere
su mxima expresin en la derivacin o extensin de clases; es decir, cuando
se obtienen nuevas clases a partir de una ya existente mediante la propiedad de
derivacin de clases o herencia.
1.5. ESPECIFICACIONES DEL LENGUAJE JAVA
Los lenguajes de computadoras tienen reglas estrictas de uso que deben seguirse cuan-
do se escriben programas con el objeto de ser comprendidos por la computadora. La
referencia completa del estndar J ava se encuentra en el libro Java Languaje
Specification, de J ames Gosling, Prill J org y Grey Steele (Addison Wesley, 1996).
La especificacin es una definicin tcnica del lenguaje que incluye sintaxis,
estructura y la interfaz de programacin de aplicaciones (API, application pro-
gramming interfuce) que contiene clases predefinidas. El lenguaje evoluciona rpi-
damente y el mejor lugar para consultar las ltimas versiones y actualizaciones del
mismo se encuentra en el sitio Web de internet de Sun
Las versiones de J ava de Sun se incluyen en J DK (Java Deivlupment Kit), que
es un conjunto de tierramientas que incluyen un cornpilador, un intrprete, el entor-
no de ejecucin J ava, el lenguaje estndar J ava y otras utilidades.
En la actualidad existen cuatro versiones J DK. Este libro es compatible con J DK
1.4 Beta, que es una mejora sustancial de las versiones anteriores J DK 1 .O y J DK 1.1.
La nueva versin J DK 1.3 incluye un compilador J IT (jusf-in-time) para ejecutar el
cdigo J ava. El entorno J DK est disponible para Windows9Y98, Windows NT/2000
y Solaris, pero existen muchos entornos de desarrollo para J ava: J Builder de Borland,
Visual Age Windows de IBM, Visual J ++de Microsoft, Visual Caf de Symantec, etc.
Nota: Todos los programas de este libro se pueden compilar y ejecutar en los
entornos J DK 1.2, J DK 1.3 y J DK 1.4 y deben poder trabajar con cualquier
herramienta de desarrollo que soporte las citadas versiones.
Introduccin a Java 13
J DK consta de un conjunto de programas independientes cada uno de los cuales
se invoca desde una lnea de rdenes. Las herramientas de desarrollo ms impor-
tantes se pueden encontrar en los siguientes sitios de Internet:
Caf de Symantec www. symant ec. com
Sun J ava Workshop www. j avasof . com
Visual Age for J ava by IBM
J Factory de Roge Wave www. r ogewave. com
J Builder de lmprise www. i mpr i se. com
Visual J ++de Microsoft www. mi cr osof t . com
Forte de Sun www. sun. com
www. i bm. com
Estas herramientas proporcionan un ED (Entorno Integrado de Desarrollo) que
permite el rpido desarrollo de programas. Le recomendamos utilice herramientas
EID para desarrollo de programas y ejecute las tareas integradas en la interfaz gr-
fica de usuario, tales como: edicin, compilacin, construccin, depuracin y
ayuda en linea.
1.6. APLICACIONES Y APPLETS
Los programas en J ava se dividen en dos grandes categoras: aplicaciones y applets.
Las aplicaciones son programas autnomos independientes (standalone), tal como
cualquier programa escrito utilizando lenguajes de alto nivel, como C++, C, Ada,
etc.; las aplicaciones se pueden ejecutar en cualquier computadora con un intrpre-
te de J ava y son ideales para desarrollo de software. Los applets son un tipo espe-
cial de programas J ava que se pueden ejecutar directamente en un navegador Web
compatible J ava; los applets son adecuados para desarrollar proyectos Web.
Los applets son programas que estn incrustados, ((empotrados)) (embedded) en
otro lenguaje; as cuando se utiliza J ava en una pgina Web, el cdigo J ava se empo-
tra dentro del cdigo HTML. Por el contrario, una aplicacin es un programa J ava
que no est incrustado en HTML ni en ningn otro lenguaje y puede ser ejecutado
de modo autnomo.
Naturalmente, a primera vista parece deducirse que las aplicaciones son ms
grandes (y en principio ms complejas) que los applets. Sin embargo, esto no es
necesariamente verdad.
1.6.1 Semejanzas y diferencias entre aplicaciones y applets
Una de las primeras preguntas que suele hacerse el programador principiante en
J ava es: ;Cundo debo utilizar una aplicacin y cundo un applet? La respuesta no
14 Java 2. Manual de programacin
siempre es fcil, pero ineludiblemente pasa por conocer las semejanzas y diferen-
cias que tienen ambos tipos de programas. Gran parte del cdigo de las aplicacio-
nes y los upplets es el mismo, presentndose las diferencias al considerar los
entornos de ejecucin de los programas.
Regla:
Las aplicaciones se ejecutan como programas independientes o autnomos,
Los upplets deben ejecutarse en un navegador Web.
de modo similar a cualquier otro lenguaje de alto nivel.
El desarrollo de las aplicaciones J ava suele ser algo ms rpido de desarrollar
que los upplets, debido a que no necesita crear un archivo HTML y cargarlo en un
navegador Web para visualizar los resultados.
Sugerencia: Si su programa no necesita ejecutarse en un navegador Web, elija
crear aplicaciones.
Un aspecto muy importante en el desarrollo de programas es la seguridad. Los
upplets necesitan unas condiciones de seguridad para evitar daos en el sistema en
el que est funcionando el navegador, por tanto, tienen ciertas limitaciones. Algunas
limitaciones a considerar son:
Los applets no pueden leer o escribir en el sistema de archivos de la computa-
dora, pues en caso contrario podran producir daos en archivos y propagar
virus.
Los upplets no pueden establecer conexiones entre la computadora de un usua-
rio y otra computadora, excepto que sea el servidor donde estn almacenados
los applets'.
Los applets no pueden ejecutar programas de la computadora donde reside el
navegador, dado que podran originar daos al sistema.
Por el contrario, las aplicaciones pueden interactuar directamente con la compu-
tadora sobre la que se ejecutan, sin las limitaciones anteriormente mencionadas.
Esta actividad comienza ya a desarrollarse con las tecnologas Napster creadas por Fanning, un estu-
diante norteamericano a primeros del ao 2000. Otras tecnologas similares con Gnutella, Scour, etc., y se
las conoce de modo genrico como tecnologas P2P (peer-ro-peer).
Introduccin a Java 15
Notas:
En general, se puede convertir un applet J ava para ejecutarse como una apli-
Una aplicacin no siempre se puede convertir para ejecutarse como un
cacin sin prdida de funcionalidad.
upplet, debido a las limitaciones de seguridad de los applets.
En este libro aprender fundamentalmente a escribir aplicaciones J ava, aunque
tambin dedicaremos atencin especial a desarrollar applets.
1.7. CREACIN DE PROGRAMAS
Antes de que una computadora pueda procesar un programa en un lenguaje de alto
nivel, el programador debe introducir el programa fuente en la computadora y la
computadora a su vez debe almacenarlo en un formato ejecutable en memoria. Las
etapas clsicas en un lenguaje tradicional son: edicin, compilacin, enlace, ejecu-
cin y depuracin de un programa.
Las herramientas fundamentales empleadas en el proceso de creacin de programas
son, por tanto: editor, compilador, depurador y, naturalmente, el sistema operativo.
El editor es un programa utilizado para crear, guardar (salvar o almacenar) y
corregir archivos fuente (escritos en lenguaje J ava). El compilador es un programa
que traduce un programa escrito en un lenguaje de alto nivel a un lenguaje mqui-
na. El depurador es un programa que ayuda a localizar errores en otros programas.
El sistema operativo es el programa con el que interacta el usuario con el objeto
de especificar qu programas de aplicacin y/u operaciones del sistema debe ejecu-
tar la computadora (los sistemas operativos ms utilizados son: Windows
9x/NT/2000, Linux, Unix, Solaris y Mac)'.
1.7.1 Etapas para crear un programa
La creacin de un programa debe comenzar con la escritura del cdigo fuente
correspondiente a la aplicacin. Cada programa J ava debe tener al menos una clase.
Un ejemplo de una aplicacin J ava sencilla que sirva de modelo es el popular
((Hol a mundo)) de Stroustrup (el autor de C++), modificado para que visualice un
mensaje de bienvenida con el nombre de un pequeo pueblo andaluz.
' Microsoft ha anunciado el lanzamiento de la arquitectura .NET y el sistema operativo Windows XP para
el segundo trimestre de 200 I .
16
Java 2. Manual de programacin
/ / Est a apl i caci n vi sual i za: Hol a Car chel ej o. Bi enveni do a J ava
publ i c class Bi enveni do
I
publ i c stati c void mai n ( St r i ng[ ] ar gc)
t
Cyct em. out . pr i nt l n( " Hol a Car chel ej o. Bi enveni do a J ava" ) ;
Las etapas que preparan un programa para su ejecucin son:
1. Crear una carpeta de proyecto en la que se recojan todos los archivos signi-
ficativos, incluyendo clases que se desean incluir.
2. Utilizar un programa editor que introduzca cada lnea del programa
fuente en memoria y lo guarde en la carpeta proyecto como un archivo
fuente.
3. Utilizar el programa compilador para traducir el programa fuente en byteco-
de (cdigo en bytes). Si existen errores de sintaxis (un error gramatical de una
lnea en un programa J ava), el compilador visualiza esos errores en una ven-
tana.
4. Utilizar el programa editor para corregir esos errores, modificando y vol-
viendo a guardar el programa fuente. Cuando el programa fuente est
libre de errores, el compilador guarda su traduccin en bytecode como un
archivo.
5 . El intrprete J ava (J VM) traduce y ejecuta cada instruccin en bytecode.
6. Si el cdigo no funciona correctamente se puede utilizar el depurador para
ejecutar el programa paso a paso y examinar el efecto de las instrucciones
individuales.
Edicin
Editar el programa Bi enveni do con un editor" escribiendo el texto correspon-
diente al programa fuente. Debe darle un nombre al archivo fuente que constituye
el programa ( Bi enveni do. j ava). Por convenio, el archivo del programa fuen-
te debe terminar con la extensin j ava. Almacene el programa en la carpeta
C: \ j dkl . 3 . O - 02\ bi n.
Los editores que se han utilizado en la preparacin de este libro son Edit.com y Notepad.exe (se tra-
baj bajo Windows 98).
Introduccin a Java 17
Error tpico: Palabras mal escritas: J ava es sensible a las letras maysculas y
minsculas y el siguiente programa dara error:
I
public cl ass Bi enveni do
I
public s t at i c void Mai n ( St r i ng[ ] ar gs)
t
Syst em. out . pr i nt l n ( " Hol a Car chel ej o. Bi enveni do a J ava") ;
pues mai n debe escribirse slo en minsculas.
y Los nombres de mtodos y variables con una letra minscula.
Los nombres de las clases comienzan normalmente con una letra mayscula
Compilacin
La orden siguiente compila Bi enveni do. j ava:
j avac Bi enveni do. ] ava
Si no existen errores de sintaxis, el compilador genera un archivo denominado
Bi enveni do. cl ass. El archivo no es un archivo objeto tal como se genera en
otros compiladores de lenguajes de alto nivel. Este archivo se llama bytecode. El
bytecode es similar a las instrucciones mquina, pero su arquitectura es neutral y se
puede ejecutar en cualquier plataforma que tenga el entorno en tiempo de ejecucin
y el intrprete J ava.
Nota: Una gran ventaja de J ava es que el cdigo bykcode puede ejecutarse en
diferentes plataformas hardware y sistemas operativos.
El cornpilador enlazar el archivo del cdigo fuente en J ava y objetos impor-
tados.
18
Java 2. Manual de programacin
Archivo
fuente
Objetos
importados
1 Compilador 1
Figura 1.3. El cdigo fuente de un programa se compila en bytecode.
Ejecucin
Para ejecutar un programa J ava, se debe ejecutar el bytecode del programa en cual-
quier plataforma que soporte un interprete J ava. La siguiente orden ejecuta el cdi-
go bytecode del programa aplicacin Bi enveni do. j ava:
j ava Bi enveni do
La salida de este programa se muestra en la Figura 1.4.
Fi gura 1.4. La salida del programa Bi enveni do.
1.8. COMPONENTES DE UNA APLICACIN
En un programa aplicacin, destacan los siguientes elementos: Comentarios, 4
Palabras reservadas, Sentencias, Bloques, Clases, Mtodos, el mtodo ma in.
Comentarios
La primera lnea del programa Bi enveni do es un Comentario. Los
Comentarios sirven para documentar los programas y en ellos se escriben anota-
Introduccin a Java 19
ciones sobre cmo funciona el programa o sobre cmo se ha construido. Los
comentarios ayudan a los programadores actuales y futuros o a los usuarios de los
mismos a comprender el programa. En J ava, como en todos los lenguajes de pro-
gramacin, los comentarios no son sentencias de programacin y son, por consi-
guiente, ignorados por el cornpilador. En J ava, los comentarios que constan de
una nica lnea estn precedidos por dos barras inclinadas (/ /), si se extienden
sobre varias lneas estn encerrados entre / * y */ . Cuando el compilador
encuentra un comentario del tipo / / ignora todo el texto que viene a continua-
cin hasta el final de lnea, y cuando el compilador se encuentra con un comen-
tario de la forma / * y * / ignora todo el texto entre ambos juegos de caracteres.
Ejemplos de comentarios:
/ / Est o es un coment ar i o r el at i vo
/ * a l a Si erra de Cazorl a, escr i t o
por Mackoy */
Existen tambin otra clase de comentarios, denominados comentarios de docu-
rnentacion, que pueden ser extrados a archivos HTML utilizandojavadoc. Es nece-
sario introducirlos entre los smbolos / * * . . . * /.
Palabras reservadas
Las palabras reservadas o palabras clave (Keywords) son palabras que tienen un
determinado significado para el compilador y no pueden ser utilizadas para otros
fines. Por ejemplo, la palabra whi l e significa que se habr de evaluar la expre-
sin que viene a continuacin y, en funcin del valor de la misma, se ejecutarn
o no se ejecutarn las sentencias siguientes. Otras palabras reservadas son
publ i c, stati c, pri vate, que representan modificadores. Otro ejemplo es
cl ass, una palabra reservada muy utilizada, que significa que la palabra que
viene a continuacin es el nombre de la estructura clase. Las palabras reservadas
se resaltarn en los cdigos fuente que aparecen en el libro escribindolas en
negrita.
Precaucin: J ava es sensible a las maysculas, por consiguiente, whi l e es
una palabra reservada y Whi l e no es palabra reservada,
Sentencias
Una sentencia representa una accin o una secuencia de acciones. Cada sentencia
termina con un punto y coma (; ). Ejemplos de sentencias son:
20
Java 2. Manual de programacin
z = 15;
z = z+10u;
/ / est a sent enci a asi gna 15 l a
/ / a var i abl e z
/ / est a sent enci a aade 130
/ / ai val or de z
pr i nt l r . ( " Bi enveni do Sr . Mackoy" ) ; / / sent enci a de vi sual i zaci n
Bloques
Un bloque es una estructura que agrupa sentencias. Los bloques comienzan con una
llave de apertura ( {) y terminan con una llave se cierre ( }). Un bloque puede estar
dentro de otro bloque y se dice que el bloque interior est anidado dentro del exte-
rior o que ambos bloques estn anidados:
z = 15;
z = 2+100;
if ( z > 225)
!
z = 2- 5;
Clases
La clase es la construccin fundamental de J ava y, como ya se ha comentado,
constituye una plantilla o modelo para fabricar objetos. Un programa consta de
una o ms clases y cada una de ellas puede contener declaraciones de datos y
mtodos.
Mtodos
Un mtodo es una coleccin de sentencias que realizan una serie de operaciones
determinadas. Por ejemplo:
Syst em. out . pr i nt l n ( " Bi enveni do a Car chel ej o" ) ;
es un mtodo que visualiza un mensaje en el monitor o consola.
Mtodo ma i n ( I
Cada aplicacin J ava debe tener un mtodo mai n declarado por el programador
que define dnde comienza el flujo del programa. El mtodo mai n tendr siempre
una sintaxis similar a sta:
Introduccin a Java 21
public static void ma; ? ( St r - nq; : ar as)
1.9. HERRAMIENTAS DE DESARROLLO JAVA
El J DK viene con un conjunto de herramientas tal como se coment anteriormente:
un compilador J ava javac), una Mquina Virtual J ava java), una herramienta para
visualizar applets (applet Viewer), un depurador elemental jdb) y una herramienta
de documentacin javadoc). Estas herramientas se utilizan para crear, depurar,
documentar y usar programas J ava. Dependiendo de su entorno y su plataforma, los
detalles reales de cmo instalar J DK o cualquier conjunto de herramientas J ava,
difieren de unos fabricantes a otros y lo ms recomendable ser seguir las instnic-
ciones que nos ofrezcan ellos.
Las herramientas de desarrollo ms importantes se pueden encontrar en los sitios
de Internet declarados en el apartado ((Especificaciones del lenguaje J ava)). Estas
herramientas proporcionan un entorno integrado de desarrollo, EID (IDE,
Integrated Development Environment) y sirven para proporcionar un desarrollo
rpido de programas de modo eficiente y productivo.
1.9.1. El entorno de desarrollo JDK
La creacin de un programa en J ava, ya sean applets o aplicaciones convenciona-
les, necesita la instalacin de las herramientas de desarrollo de J ava. El Kit de
Desarrollo de J ava (J DK) es una donacin de Sun Mycrosystem a la que podemos
acceder visitando el sitio que posee Sun en la Red. Como J DK es gratuito y las ver-
siones que se pueden bajar de la Red estn actualizadas, es muy frecuente su uso
por los programadores, no obstante la existencia de los entornos de desarrollo inte-
grados que pretenden facilitar las tareas de edicin, compilacin, ejecucin y depu-
racin, haciendo todas ellas directamente accesibles desde los mismos.
Para trabajar con J DK en Windows 95/98/NT, resulta cmodo y eficaz abrir
varias ventanas, y usarlas de la forma siguiente:
En una ventana abrir un editor, como Edit o Notepad, donde se ir escribien-
do el cdigo.
Otra ventana le ser necesaria para tener acceso al indicador (prompt) del siste-
ma y poder invocar desde all al compilador y a las dems herramientas del J DK.
En una tercera puede tener abierto un archivo con documentacin sobre el API
de J ava.
22 Java 2. Manual de programacin
Puede usar una cuarta ventana para abrir un navegador con soporte J ava, por
ejemplo 2ilicrosoft Explorer en versin 4.0 o superior, o el appletviewer para la
verificacin del correcto funcionamiento de los applets.
1 .lo. UNA APLICACIN PRCTICA DE JAVA
Inicialmente se expondr la creacin de programas convencionales, y para ver su
estructura bsica as como las fases a las que antes aludamos, necesarias para su
ejecucin, seguiremos el siguiente ejemplo: Considere que trabaja con el J DK ins-
talado en un PC bajo Windows 9x y cree la carpeta libro en el directorio raz de su
disco de arranque. Despus, situndose dentro de libro, cree otra denominada
T2ri7aOl.
Abra una ventana DOS, trasldese a la carpeta Terna01 y llame al editor (Edit):
' L. -. \ I di ~. dc ws> c0 C: \ ; i br o\ t emaOl
i : \ l i br o\ Tema31> edi t
Una vez dentro de Edit copie el texto incluido en la Figura 1.5 fijndose atenta-
mente para no omitir en su copia ninguno de los caracteres ni signos de puntuacin
que aparecen en l. AI terminar, gurdelo con el nombre E] empl ol . j ava y salga
del editor.
ipor t j atJ 3. i i3 . f< ;
' L ui s J oyaner &giJ i 1 ar
J l
1a;s E j ernpl ci f
nuti l i t s tati c w i d main (stri ng[] arg] {
) a programar en J AVA" ) ;
Fi gura 1.5.
El archivo creado es el archivo fuente, al que en J ava tambin se le llama unidad
de cornpiltrcicn. Dicho archivo debe ser almacenado con el nombre E] empl ol , ya
que en J ava el cdigo siempre ha de estar dentro de una clase y el nombre del archi-
vo debe coincidir con el de la clase que tiene el mtodo mai n ( ) . En el caso del
ejemplo no sera necesario considerar esta situacin, ya que slo hay una clase. El
archivo fuente debe escribirse dividido en secciones bien definidas, separadas por
Introduccin a Java 23
lneas en blanco y precedidas por un comentario identificativo de las misinas. Es
importante guardar dicho archivo con la extensinjava. Con estos pasos habr ter-
minado la fase de edicin del programa.
A continuacin, el programa debe ser compilado, es decir, traducido a bytecode
(cdigo byte), que es el lenguaje que entiende el intrprete de J ava. Para compilar
un programa con el J DK hay que invocar aj avac y especificar el nombre del pro-
grama a compilar sin olvidar reflejar su extensin java). Ahora debe tener en cuen-
ta que para efectuar la compilacin y ejecucin de sus programas tal y como se
indica a continuacin debe modificar la variable de entorno path, aadiendo al
path anterior el subdirectorio o carpeta donde se encuentran los programas para
compilar, ejecutar depurar y documentar las aplicaciones (javac, ,java, ,jdh y ,jaw-
doc respectivamente). Esta modificacin deben introducirse en el archivo
C: \a u t oexec. ba t, para que los nuevos valores se establezcan cada vez que se
arranque la computadora.
SET PATH=%PATHL&; C: \ j dkl . 3. 1\ bi n
o bien
SET PATH=OEATHcc; C: \ ~dkl . 4\ bi n (para trabajar Con la 1.4 Beta)
As mismo, es conveniente adaptar el contenido de cl asspath para que .lava
pueda localizar siempre lais claseis creadais.
SET CLASSEATH=. ; C: \
El valor asignado a CLASSPATH hace que J ava busque las clases en la carpeta
actual y el directorio raz. Suponiendo establecidos los anteriores valores para com-
pilar E j empl ol . j ava bastara la siguiente orden:
C: \ l i br o\ TemaOl > j avac Ej er npl ol . j ava
Por ltimo, ser necesario llamar al intrprete de J ava para que el programa con
extensin cl ass surgido en la operacin de compilacin y que contiene el cdigo
byte pueda ser ejecutado. Para ello, cuando se dispone del J DK, en la lnea de rde-
nes o ventana de mandatos del sistema se escribir la palabra j ava seguida por el
nombre del programa a ejecutar, sin especificar la extensin del mismo y teniendo
en cuenta que, si la clase pertenece a un paquete, el nombre de la misma debe ir pre-
cedido por el del paquete de la forma siguiente:
C: \ l i br o\ TemaOl > j ava l i br =. TemaOl . i j emFl ol
o bien.
C: \ WI NDOWS> j ava l i br o. TemaOl . Ej empl o1
24 Java 2. Manual de programacin
dado el valor establecido para la variable CLASSPATH, que hace que el intr-
prete de J ava busque en el directorio raz y a partir de ah en aquellos cuyo nom-
bre coincida con los elementos del paquete C : \ l i br o\ TemaO 1. Es decir, se
pasa como parinetro aj ava el nombre de la clase especificando el paquete al que
pertenece, sin incluir la extensin y distinguiendo entre maysculas y minscu-
las. La salida obtenida con la ejecucin del programa es la impresin en pantalla
de la lnea
Ccrni enzo a pr ogr amar en J AVA
Una breve explicacin del cdigo fuente escrito es la siguiente:
La primera instruccin sirve para indicar el paquete al que pertenecer la clase
que est siendo definida. Los paquetes son un mecanismo para organizar las
clases. y cuando se declara que una clase pertenece a un paquete, dicha clase
deber ser almacenada en un subdirectorio o carpeta cuyo nombre coincida con
lo especificado como nombre del paquete. En nuestro caso, como el paquete se
denomina 1 i b r o . Tema O 1, la clase E j emp 1 o 1 deber ser almacenada en la
carpeta 1 i br o\ TemaO 1.
La sentencia i mpor t va seguida por el nombre de un paquete y se utiliza para
poder referirse ms adelante a clases pertenecientes a dicho paquete sin nece-
sidad de cualificarlas con un nombre de jerarqua de paquetes. En el ejemplo,
no existe aplicacin posterior.
La tercera lnea es un comentario (comentario de una lnea)
La palabra reservada cl ass permite especificar que se va a definir una
clase, una palabra clave o reservada es una palabra especial con un signifi-
cado preestablecido en el lenguaje J ava. Para delimitar la clase, se emplean
llaves, { }.
Para ejecutar el programa, el intrprete de J ava comienza llamando al mto-
do mai n ( ) ; como este mtodo se llama antes de la creacin de un objeto,
ha de declararse como st at i c y as se le podr llamar sin tener que refe-
rirse a una instancia particular de la clase; como adems se llama por cdigo
fuera de su clase tambin tiene que ser declarado como publ i c, que es la
forma de permitir que un miembro de una clase pueda ser utilizado por cdi-
go que est fuera de la misma. La palabra reservada voi d indica que mai n
no devuelve nada. St r i ng [ ] ar gs es la declaracin de un array de cade-
nas, mediante el que la clase podra tomar un nmero variable de parmetros
en la lnea de comandos, aunque no se use es necesario incluir este parme-
tro cuando se define el mtodo mai n ( ). Se emplean llaves, { }, para delimi-
tar cI nietodo.
* 0 !I .!>I \ ;I. la pantalla de la coinputadora es un objeto predefinido cuya referen-
1 . t. La clase Syst empertenece al paquete j ava. l ang que " %, : , .
--
se importa automticamente y, por tanto, no necesita cualificacin. El mtodo
pr i nt I n ( ) toma la cadena que se le pasa como argumento y la escribe en la
salida estndar. Todas las sentencias en J ava deben terminar en ; . Tenga en cuen-
ta que J ava es sensible a las maysculas, por lo que considera distintos los identi-
ficadores si se cambian maysculas por minsculas o viceversa, es decir, sys t em
y System son identificadores diferentes.
. Cir,5*
I .I I . ESTRUCTURA DE UN PROGRAMA APL I CACI ~N
EN JAVA
Para crear programas en J ava hay que tener en cuenta que toda implementacin
que se realice se efectuar encapsulada en una clase. Un programa aplicacin fuen-
te en J ava se podra considerar formado por las siguientes partes:
Una sentencia de paquete (package) que tambin puede ser omitida.
Una, ninguna o varias sentencias de importacin (i mport).
Una serie de comentarios opcionales colocados en diversos lugares del pro-
Declaraciones de las clases privadas deseadas; puede no haber ninguna.
Una declaracin de clase pblica.
grama.
A su vez una declaracin de clase comenzar con la sentencia cl ass y podr
contener:
Declaraciones de variables de la clase (estticas).
Declaraciones de variables de instancia.
Definiciones de constructores.
Definiciones de mtodos.
Dado que una clase es un modelo y las instancias son los objetos de esa clase, a
las variables de instancia se las denomina as porque cada objeto contendr una
copia propia de dichas variables, de forma que los datos de un objeto se encontra-
rn separados de los de otro objeto, utilizndose los mtodos para la modificacin
de los valores de las variables de instancia. En consecuencia, un programa muy sen-
cillo que se puede crear en J ava es:
public class E J ernplo2
public static void mai n ( Szr i ng[ l ar gs)
26
Java 2. Manual de programacin
formado exclusivamente por una declaracin de clase pblica
Compilacin; j avac Ej empl o2. j ava
Ejecucin: j ava Ej empl o2
Las clases de un programa contienen mtodos, interactan entre s y no necesi-
tan contener un mtodo mai n ( ) , pero ste s ser necesario en la clase que consti-
tuya el punto de partida del programa. Tenga tambin en cuenta que las applets no
utilizan el mtodo mai n ( ) .
La declaracin de mtodos en una clase se puede efectuar en cualquier orden y
cada una de ellas se compone por una cabecera y un cuerpo. La cabecera del mto-
do debe contener su nombre, una lista de parmetros y el tipo de resultado. Se espe-
cificar voi d cuando el mtodo no devuelva resultados. En la implementacin del
mtodo, cuando ste no haya sido declarado voi d, se utilizar la instruccin
r et ur n para devolver un valor al punto de llamada del mtodo. La lista de par-
metros consistir en cero o ms parmetros formales cada uno de ellos precedido
por su tipo y separados por comas. Cuando se llama a un mtodo los parmetros
actuales se asignan a los parmetros formales correspondientes. Entre los parme-
tros actuales (los de la llamada) y formales (los de la declaracin) debe existir con-
cordancia en cuanto a nmero, tipo y orden. Formatos de mtodos pueden ser los
siguientes:
Ejemplo
tipol nombre-funcion (lista de parmetros)
/ / decl ar aci n de var i abl es
/ / sent enci as ej ecut abl es
/ / sent enci a r et ur n con el val or a devol ver
I
Ejemplo
void nombre-procedimien to (tipo4 nombre-par3, ti po5 nombre-par4)
i
/ / decl ar aci n de var i abl es
/ / sent enci as ej ecut abl ec
I
En el primer ejemplo, ti po 1 representa el tipo de dato devuelto por 'el mto-
do; cuando el mtodo no devuelve ningn valor se especificar voi d como tipo
Introduccin a Java 27
devuelto. La lista de parmetros es una secuencia de parejas tipo-identificador sepa-
radas por comas. Observe el formato expuesto en el segundo ejemplo.
En J ava es posible agrupar sentencias simples, encerrndolas entre una pareja de
llaves para formar un bloque o sentencia compuesta; las variables declaradas den-
tro de un bloque slo son vlidas en dicho bloque y, si ste tuviera otros anidados,
en los interiores a l. En un programa J ava se podrn declarar variables tanto den-
tro como fuera de los mtodos. Las variables declaradas dentro del cuerpo de un
mtodo se crean cuando se ejecuta el cuerpo del mtodo y desaparecen despus. Las
variables que se declaran fuera del cuerpo de un mtodo son globales a la clase. Las
que se declaran como f i nal y st at i c son, en realidad, constantes.
1.1 1 .I. Referencia a miembros de una cl ase
En los programas escritos en J ava se har referencia a los miembros de una clase,
mtodos y variables de instancia, desde otras distintas de aquellas en las que fueron
definidos, para lo que generalmente ser necesario declarar un objeto de la clase
adecuada y a continuacin escribir nombr eObj eto . nombr eComponent e. No
obstante, hay ocasiones en las que se utilizan mtodos y variables de instancia sin
necesidad de efectuar la declaracin de ningn tipo de objeto, especificando para su
llamada nombr ecl ase. nombr eComponent e. Para que esto pueda ocurrir y a
un miembro de una clase sea posible llamarlo con el nombre de la clase en la que
ha sido declarado, sin tener que referirse a una instancia particular de la misma,
dicho miembro debe haber sido declarado st at i c (esttico).
1 .I 2. ERRORES DE PROGRAMACIN
Los errores de programacin son inevitables, incluso para programadores experi-
mentados. El proceso de corregir un error (bug en ingls) se denomina depuracin
(debugging) del programa. Cuando se detecta un error en J ava, se visualiza un men-
saje de error que devuelve la posible causa del error. Desgraciadamente los errores
a veces no se detectan y los mensajes de error no son siempre fciles de interpretar.
Existen tres tipos de errores: errores de compilacin (sintaxis), errores de ejecucin
y errores lgicos.
1 .I 2.1. Errores de compi l aci n (si ntaxi s)
Los errores de sintaxis ocurren cuando el cdigo viola una o ms reglas gra-
maticales de J ava. Los errores de sintaxis se detectan y visualizan por el com-
pilador cuando se intenta traducir el programa, por esta razn se denominan
28
Java 2. Manual de programacin
tambin errores de compilacin. Los errores de compilacin provienen de erro-
res en la construccin del cdigo tales como escribir mal una palabra reserva-
da, omitir algn signo de puntuacin o bien utilizar, por ejemplo, una llave de
apertura sin su correspondiente llave de cierre. Estos errores suelen ser fciles
de detectar ya que el compilador suele indicar dnde se producen las posibles
causas.
Ejemplo
La compilacin del siguiente programa produce errores de sintaxis:
/ / est e prograrra cont i ene er r or es de si nt axi s
public class Demo
public static void mai n ( St r i ng[ ] ar gs)
z=50;
Cyst en. out . pr i nt l n( z+l O) ;
La ejecucin de este programa produce un error detectado por el compilador del
entorno J DK.
Figura 1.6. El compilador del J DK detecta un error de sintaxis.
El error de sintaxis es la no declaracin previa de la variable z, que se utiliza en
dos sentencias.
Introduccin a Java 29
Nota: Error de sintaxis: Es una violacin de las reglas de gramtica de J ava,
detectada durante la traduccin del programa.
1 . I 2.2. Errores de ej ecuci n
Los errores de ejecucin son errores que producen una terminacin anormal y que
se detectan y visualizan durante la ejecucin del programa. Un error de ejecucin
se produce cuando el usuario instruye a la computadora para que ejecute una ope-
racin no vlida, tal como dividir un nmero por cero o manipular datos indefini-
dos o no vlidos en la entrada.
Un error de entrcrdu ocurre cuando el usuario introduce un valor de entrada
imprevisto que el programa no puede manejar. Por ejemplo, si el programa espera
leer un nmero, pero el usuario introduce una cadena de caracteres. En J ava, los
errores de entrada hay que declararlos en una clusula t hr ows o bien capturarlos
y tratarlos directamente dentro del mtodo en el que se pueden producir (vase el
Captulo 13, ((Manejo de excepciones))).
Ejemplo
public class ErrorDeE~ecucion
i
private static int z;
static void prueba0 ,
i
1
public static void rnai n(Ctri ng[] args)
i
z=l O/ z;
prueba ( ) ;
Figura 1.7. Error de ejecucin.
30 Java 2. Manual de programacin
AI invocar al mtodo pr ueba ( ) , se produce un error en tiempo de ejecucin:
j ava. 1ang. Ar i t hmet i cExcept i on: / by zer o
que indica un intento de dividir por cero (valor de z), operacin no vlida.
r I
Nota: Error de ejecucin: Se intent ejecutar una operacin no vlida que fue
detectada durante la ejecucin del programa.
1.1 2.3. Errores l gi cos
Los errores lgicos ocurren cuando un programa realiza un algoritmo incorrecto
y no ejecuta la operacin que estaba prevista. Existen muchos tipos de razones
para que se produzcan errores lgicos. Normalmente los errores lgicos son dif-
ciles de detectar, ya que no producen errores en tiempo de ejecucin y no visua-
lizan mensajes de error. El nico sntoma de que se ha producido un error lgico
puede ser la salida incorrecta del programa. Se pueden detectar errores lgicos
comprobando el programa en su totalidad y comparando su salida con los resul-
tados calculados. La prevencin de errores lgicos se puede realizar verificando
el algoritmo y el programa correspondiente antes de comenzar el proceso de eje-
cucin.
Nota: Error lgico: Es un error producido por un algoritmo incorrecto.
Por ejemplo, la instruccin
Syst em. out . pr i nt l n ( " Si e de Cazor l a" ) ;
no muestra la frase que se deseaba, pues no se ha escrito bien:
Syst em. out . pr i nt l n ( " Si er r a de Cazor l a" ) ;
pero el compilador no puede encontrar el error ya que la primera sentencia es sin-
tcticamente correcta.
CAPI TU
Caractersticas del
lenguaje J ava
CONTENIDO
2.1. Palabras reservadas.
2.2. Identificadores.
2.3. Tipos de datos.
2.4. Tipos simples (primitivos).
2.5. Variables.
2.6. Constantes.
2.7. La biblioteca de clases de J ava.
2.8. Conceptos bsicos sobre excepciones.
2.9. La clase Number y sus subclases.
2.10. Las Clases Char act er y Bool ean.
2.1 I . Entrada y salida bsicas.
2.1 2. Operadores.
2.13. La sentencia de asignacin.
2.1 4. Expresiones.
2.15. Class Mat h.
2.16. Paquete j ava. mat h.
2.1 7. Conversiones de tipos. Operadores molde.
2.1 8. Operadores aritmticos.
2.1 9. Operadores relacionales.
2.20. Operadores lgicos.
2.21. Operadores de manipulacin de bits.
2.22. Operadores de asignacin adicionales.
2.23. Operador condicional.
2.24. Prioridad de los operadores
31
32 Java 2. Manual de programacin
Este captulo expone los tipos de datos simples que ofrece J ava,
explica los conceptos de constantes y variables, y ensea como
efectuar su declaracin. Se tratan tambin en el captulo las ope-
raciones bsicas de entradakalida y los distintos tipos de opera-
dores y expresiones, comentndose adems algunas clases de
gran utilidad.
2.1. PALABRAS RESERVADAS
Las palabras reservadas son palabras con un significado especial dentro del lengua-
je. En J ava 2 las palabras reservadas se listan en la Tabla 2.1 :
Tabla 2.1. Palabras reservadas J ava 2
abst r act
bool ean
br eak
byt e
byva 1 ue
case
cast
cat ch
char
cl ass
const '
cont i nue
def aul t
do
doubl e
el se
ext ends
f al se
f i nal
f i nal l y
f l oat
f or
f ut ur e'
gener i c'
got 0
i f
i mpl ement s
i mpor t
i nner
i nst anceof
i nt
i nt er f ace
l ong
nat i ve
new
nul l
oper at or '
out er '
package
pr i vat e
pr ot ect ed
publ i c
r est '
r et ur n
shor t
st at i c
super
swi t ch
synchr oni zed
t hi s
t hr eadsaf e
t hr ow
t hr ows
t r ansi ent
t r ue'
t r y
var '
voi d
vol at i l l e
whi l e
No son autnticas palabras reservadas,
No se utilizan en las ltimas versiones de J ava.
'Los mtodos nativos estn implementados en otros Icnguajes corno C o C++.
En J ava se declara un mtodo nativo con la palabra reservada nat i ve y el
cuerpo de mtodo vaco.
Caractersticas del lenguaje Java 33
2.2. IDENTIFICADORES
Al igual que sucede con cualquier entidad o elemento del mundo real que se iden-
tifica con un nombre, los elementos de un lenguaje de programacin utilizan sm-
bolos especiales, denominados ident$caores. Son identificadores, por tanto, los
nombres que reciben las clases, interfaces, paquetes, mtodos, variables o instancias
en un programa. Un identificador en J ava debe cumplir las siguientes reglas:
Puede tener cualquier longitud (uno o ms caracteres).
No puede contener operadores tales como +, -, . . .
No puede coincidir con una palabra reservada, por tanto no puede ser t r ue,
f al se o nul l .
El primer carcter slo puede ser una letra, el carcter $ o el carcter de subra-
yado.
Despus del primer carcter pueden aparecer cualquier combinacin de letras,
dgitos, $ y - .
Las letras podrn ser maysculas y minsculas incluyendo, en ambos casos, las
acentuadas y la .
Debe ser referenciado siempre de la misma manera, sin cambiar maysculas
por minsculas ni viceversa. AI cambiar maysculas por minsculas o al con-
trario, J ava lo interpreta como un identificador diferente.
Ejemplo
Identijicadores validos Ientificudores no validos
$5
5B
Nombr e Z - t l
Char char
a t r ue
f al se
nul l Ape1 1 i dos
Super f i ci e - si gno
P
El compilador J ava detecta los identificadores vlidos e informa de los errores
de sintaxis que existan en el programa fuente.
Nota: J ava emplea la especificacin Unicode para utilizar caracteres. As se
pueden emplear letras del alfabeto ingls y de otros idiomas internacionales
recogidos en Unicode. sta es la razn por la que a, b, g , . . . , son
caracteres legales.
34 Java 2. Manual de programacin
2.3. TIPOS DE DATOS
J ava es un lenguaje fuertemente tipeado; esto implica que constantes, variables y
expresiones tienen un tipo asociado y toda variable que interviene en un programa
debe ser declarada antes de poder ser utilizada. Adems, J ava comprueba las ope-
raciones de asignacin, el paso de parmetros y las expresiones para asegurarse
sobre la compatibilidad entre los tipos de datos que intervienen en ellas.
Una primera clasificacin de los tipos de datos en J ava nos obligara a distinguir
entre tipos simples y definidos por el usuario, debido a que tienen caractersticas
muy diferentes, constituyendo los tipos simples la base sobre la que se crearn los
tipos definidos por el usuario.
2.4. TIPOS SIMPLES (PRIMITIVOS)
Los tipos simples @/*irnitivos) no estn orientados a objetos y pueden subdividirse
en enteros, reales, datos de tipo carcter y lgicos o booleanos, caracterizndose
cada uno de estos grupos por el conjunto de valores que pueden tomar y las opera-
ciones que se pueden realizar sobre ellos. Cada tipo de dato tiene un dominio
(rango) de valores. El compilador asigna espacio de memoria para almacenar cada
variable o constante con arreglo a su tipo.
Enteros
J ava ofrece cuatro tipos de enteros: byt e, shor t , i nt y l ong. Todos ellos ad-
miten valores tanto positivos como negativos, y cada uno permite almacenar valo-
res en un determinado rango, definindose como valores con signo de 8, 16, 32 y
64 bits.
Tabla 2.2. Tipos primitivos enteros
Nombre. Tamao Rango de valores
en bits
Declaracin
byt e 8 - 128 a 127 byte var l ;
shor t 16 - 32768 a 32767 short var 2 ;
i nt 32 - 2141483648 a 2147483647 i nt var 3;
l ong 64 - 9223372036854715808 a l ong var 4;
9223372036a54175801
Es posible escribir constantes enteros en otras bases distintas a la decimal:
octal, hexadecimal. Una constante octal es cualquier nmero que comienza con
Caracteristicas del lenguaje Java 35
un O y contiene dgitos en el rango 1 a 7 ( O 12 3 4 ) . Una constante hexadeci-
mal comienza con Ox y va seguida de los dgitos O a 9 o las letras A a F
( OxF10) .
Reales
Los tipos de datos de coma flotante permiten almacenar nmeros muy grandes, muy
pequeos o que contienen coma decimal. J ava soporta dos formatos de coma flo-
tante f l oat y doubl e. El tipo f l oat utiliza 32 bits para el almacenamiento y
guarda los valores con precisin simple (6 7 dgitos). El tipo doubl e utiliza 64
bits para el almacenamiento y guarda los valores con mucha mayor precisin (14 15
dgitos); suele ser el tipo devuelto por muchas funciones matemticas y suele ser el
ms empleado.
Tabla 2.3. Tipos primitivos de coma flotante
~ ~~
Nombre Tamao
en bits
~~ ~~ ~~ -
Rango de valores Declaracin
e inicializacin
f l oat 32 (precisin simple) 3, 4E- 38 a 3, 4E38 f l oat numl =2. 7182f ;
doubl e 64 (precisin doble) 1, 7E- 308 a 1, 7E308 double num2=2. 7182d;
Carcter
El tipo de datos char de J ava se utiliza para representar un carcter, ste tipo
emplea 16 bits para el almacenamiento de un carcter y lo efecta en formato
Unicode. Unicode presenta dos ventajas: (1) permite a J ava trabajar con los carac-
teres de todos los idiomas; (2) sus primeros 127 caracteres coinciden con los del
cdigo ASCII.
Tabla 2.4. Tipo primitivo para representar un carcter
Nombre Tamao Rango de valores Declaracin
en bits e inicializacin
char 16 caracteres alfanumricos char l etra= a ;
Un literal carcter representa un carcter o una secuencia de escape encerrada
entre comillas simples. Por ejemplo, c , D . Una cadena de caracteres (string),
es un conjunto de cero o ms caracteres (incluyendo las secuencias de escape) ence-
rrados entre dobles comillas.
36
Java 2. Manual de programacin
Ejemplo
Ejemplos de cadenas
"Cr,a caaena"
"Ci erra Ue Ar acena"
"C; er r a de Cazorl a"
" Pr i mer a l i nea \ r \ n Segunda l i nea"
"Pri r?era pgi na \ f Segunda pgi na"
,, P
,ol>;mna ; \ t Col umna 2"
,, 1 ,
Regla: En J ava, el tipo char representa un carcter.
En J ava, para representar una cadena de caracteres se utiliza una estructura de
datos denominada Stri ng. El concepto de string se explica con detenimiento en
el Captulo 8, ((Cadenas y fechas)).
Regla: Una cadena se debe encerrar entre dobles comillas. Un tipo carcter es
un nico carcter encerrado entre simples comillas.
Los caracteres J ava utilizan Unicode, que es un esquema universal para codifca-
cin de caracteres en 16 bits establecido por el consorcio Unicode para soportar el
intercambio, proceso y presentacin de los textos escritos en los diferentes idiomas
del mundo (vase el sitio Web de Unicode en www . Uni code. org). Unicode toma
dos bytes, expresados en cuatro nmeros hexadecimales que corren de ' \ u O O O O ' a
' \ uFFFF' . La mayora de las computadoras utilizan el cdigo ASCII (Unicode
incluye los cdigosASCI1 de ' \ uOOOO' a ' \ uOOFF' ) . En J ava se utiliza el cdi-
go ASCII, as como Unicode y las secuencias de escape como caracteres especiales.
Tabla 2.5. Secuencias de escape
~ ~ ~ ~ ~~~~~
Secuencia Significado
\ b
\ t
\ n
\ f
\ r
\ "
\ '
\ \
\ uxxxx
Retroceso
Tabul aci h
Nueva lnea
Avance de pgina
Retorno de carro sin avance de lnea
Dobles comillas
Comillas simples
Barra inclinada inversa
Carcter Uni code
Caractersticas del lenguaje Java 37
Ejemplo
Ejemplos de secuencias de escape:
'\k'
' \ n'
' \ t '
' \ u015Ef
Tabla 2.6. Ejemplos de caracteres especiales
Carcter ASCII Unicode
Retroceso de espacio
Tabulacin
Avance de lnea
Retorno de carro
\ b
\ t
\ n
\ r
\ u008
\ u009
\ uOOA
\uOOD
Precaucin: \
Una cadena debe encerrarse entre dobles comillas.
Un carcter es un nico carcter encerrado entre simples comillas.
Un carcter Unicode se debe representar mediante el cdigo ' \ uXXXX ' .
Para almacenar un carcter, se almacena el cdigo numrico que lo representa;
por tanto, internamente los caracteres son nmeros y esto capacita a J ava para rea-
lizar algunas operaciones numricas con datos de tipo char.
Ejemplo
class CocMayuccu; ac
i
public static void mai n ( St r i ng ar gci ] )
char c;
c=' a' - 32;
Cyst em. out . pr i nt ( " El car ct er es " ) ;
Cyst ex. out . pr i nt l n ( c) ;
c t t ;
Syst em. cut . pr i nt ( " Si gui ent e car ct er " ) ;
Syct en. out . pr i nt l n ( c) ;
38 Java 2. Manual de programacin
Lgico (boolean)
Un dato de tipo lgico puede tomar exclusivamente uno entre los dos siguientes
posibles valores: true, f al se (verdadero falso).
Tabla 2.7. Tipo primitivo para representar datos lgicos
Nombre Rango de valores Declaracin e inicializacin
boolean true, f al se boolean bandera = f al se;
Las variables booleanas almacenan el resultado de una expresin lgica, tenien-
do en cuenta que sta puede estar formada por una nica constante o variable de tipo
lgico. Su contenido puede ser directamente mostrado por pantalla mediante el
mtodo pr i nt l n ( ) .
Ejemplo
package l i br o. Tema02;
cl ass Ej empl o2
t
public st at i c void mai n ( St r i ng[ ] ar g)
{ byte di a;
boolean cor r ect o;
di a = - 3;
cor r ect o = di a > O;
S ys tern. out . pr i nt ( " Di a " ) ;
Syst em. out . pr i nt ( di a) ;
Syst em. out . pr i nt ( " cor r ect o = " ) ;
Cyst em. out . pr i nt l n( cor r ect o) ;
2.5. VARIABLES
Las variables almacenan datos cuyo valor puede verse modificado durante la eje-
cucin de un programa. Las variables se utilizan para representar tipos de datos muy
diferentes. En J ava hay que distinguir entre variables por valor y objetos o variables
por referencia; las variables de tipo simple son variables por valor.
Declaracin de variables. Para utilizar una variable se necesita declararla e
indicar al compilador el nombres de la variable, as como el tipo de dato que repre-
Caractersticas del lenguaje Java 39
senta. Esta operacin se denomina declaracin de variables. Toda variable debe ser
declarada antes de poder ser utilizada. Para declarar variables de tipo simple se
especifica su nombre y su tipo, que define tanto los datos que la variable va a poder
almacenar como las operaciones que tendr permitidas. La sintaxis es, por tanto:
t i pol l at o nombr evar i abl e;
Ejemplo
Declaracin
int z; / / decl ar a z como una var i abl e ent er a
double base; / / decl ar a base como var i abl e doubl e
char b; / / decl ar a b como var i abl e char
Nota: Las variables permiten almacenar datos, de entrada, salida o datos inter-
medios.
Consejo: Los identificadores se utilizan para nombrar variables, constantes,
mtodos, clases y paquetes. Los identificadores descriptivos son los ms utili-
zados, ya que hacen los programas ms fciles de leer. J ava es sensible a las
maysculas, por consiguiente Z y z son identificadores diferentes.
Sentencias de asignacin. Despus que una variable se declara, se puede asignar
un valor a esa variable utilizando una sentencia de asignacin. La sintaxis de la
asignacin tiene el siguiente formato:
var i abl e = expr esi n;
Es preciso tener en cuenta que una expresin es un conjunto de operadores y
operandos, pero una nica constante o variable tambin constituye una expresin.
Ejemplo
2 = 5; / / asi gna 5 a z
l ongi t ud = 1.0 / / asi gna 7. 0 a l ongi t ud
b = \ B f ; / / asi gna ' B' a b
Regla: El nombre de la variable debe estar a la izquierda 5 = z; es ilegal.
40 Java 2. Manual de programacin
Como ya se indic anteriormente, una expresin representa un clculo que
implica valores, variables y operadores.
super f i ci e = 3. 141592 * r adi o * r adi o;
z = z t i ; / / el val or de z t 1 se dsi ynd a. l a var i abl e z
Precaucin: La sentencia de asignacin utiliza el signo igual (=). Tenga cui-
dado, no utilizar : =que se utiliza con frecuencia en otros lenguajes de pro-
gramacin.
t i poDat o nombr evar i abl e = val or - i ni ci al ;
Declaracin e inicializuciri de variables en un solo puso. Se puede declarar e
inicializar una variable en un solo paso en lugar de en dos pasos como se ha mos-
trado en las operaciones.
Ejemplo
Declaracin con asignacin del valor inicial Declaracin y asignacin de un valor
char r espuest a = S
i nt cont ador = 1;
f l oat peso = 156. 45f ;
char r espuest a;
r espuest a= C ;
i nt cont ador ;
cont ador =l ;
f l oat peco ;
peso=156. 45f ;
Precaucin: Una variable se debe declarar antes de que se le pueda asignar un
valor. A una variable se le debe asignar un valor antes de que se pueda leer en
un mtodo.
Consejo: Siempre que sea posible, es conveniente declarar una variable y
asignarle su valor inicial en un solo paso, ya que esta accin facilita la inter-
pretacin del programa.
Caractersticas de/ lenguaje Java 41
mbito. Es importante el lugar donde se efecta la declaracin de las variables,
pues ste determina su mbito. En J ava es posible agrupar sentencias simples, ence-
rrndolas entre una pareja de llaves para formar bloques o sentencias compuestas y
efectuar declaraciones de variables dentro de dichos bloques, al principio de los
mtodos o fuera de ellos. Una sentencia compuesta nula es aquella que no contiene
ninguna sentencia entre las llaves { }.
Ejemplo
i nt i =25;
double j =Mat h. sqr t ( 20) ;
i++;
j += 5;
Syst em. out . pr i nt l n( i +" " t j ) ;
{i nt aux = i;
i =( i nt) ( j ) ;
j = aux;
/ / A cont i nuaci n comi enza un bl oque
1 / / Fi n del bl oque
Syst em. out . pr i nt l n (i+" " t j ) ; / / aux aqu no est def i ni da
Es decir, en J ava es posible declarar variables en el punto de utilizacin de las
mismas dentro del programa, pero habr de tener en cuenta que su mbito ser el
bloque en el que han sido declaradas. Como ya se ha indicado, un bloque de sen-
tencias se delimita entre dos llaves y las variables declaradas dentro de un bloque
slo son vlidas en dicho bloque. Si un bloque tuviera otros anidados, en los inte-
riores a l. No se pueden declarar variables en bloques interiores con el nombre de
otras de mbito exterior.
Las variables declaradas dentro del cuerpo de un mtodo son variables locales,
y slo existirn y se podr hacer referencia a ellas dentro del cuerpo del mtodo. Las
variables que se declaran fuera del cuerpo de un mtodo son variables de instancia
y cada instancia de la clase tendr una copia de dichas variables. Las variables
declaradas fuera del cuerpo de los mtodos y en cuya declaracin se especifique la
palabra st at i c son variables de clase, esto quiere decir que no se har una copia
de ellas para cada uno de los objetos de la clase y, por tanto, su valor ser compar-
tido por todas las instancias de la misma.
2.6. CONSTANTES
Las constantes son datos cuyo valor no puede variar durante la ejecucin de un pro-
grama. En un programa pueden aparecer constantes de dos tipos: literales y simb-
licas. Las constantes simblicas o con nombre representan datos permanentes que
42 Java 2. Manual de programacin
nunca cambian y se declaran como las variables, pero inicializndose en el momento
de la declaracin y comenzando dicha declaracin con la palabra reservada f i nal ,
que sirve para que el valor asignado no pueda ser modificado. Las constantes de clase
se declaran en el cuerpo de la clase y fuera de todos los mtodos, siendo necesario
comenzar su declaracin con las palabras reservadas f i na 1 y c t a t i c. La palabra
clave f i nal es obligatoria en la declaracin de constantes, mientras que st at i c
consigue que slo exista una copia de la constante para todos los objetos que se decla-
ren de esa clase. La sintaxis para declarar una constante de clase es:
s t at i c f i nal t i poDat o NOMBRECONSTANTE = val or ;
Ejemplo
1. s t at i c f i nal double PI = 3. 141592;
super f i ci e = r adi o * r adi o * PI ;
2. cl as s Pr ueba
i
s t at i c f i nal i nt MAX = 700;
void Mt odo ( )
/ / . . .
I
/ / .
1
Precaucin: El nombre de las constantes se suele escribir en maysculas.
Antes de utilizar una constante debe ser declarada. Una vez que se ha declara-
do una constante no se puede modificar su valor.
Las constantes literales son valores de un determinado tipo escritos directamen-
te en un programa. Dichas constantes podrn ser enteras, reales, lgicas, carcter,
cadena de caracteres, o el valor nul l .
Constantes enteras
Las constantes enteras representan nmeros enteros y siempre tienen signo. La
escritura de constantes enteras en un programa debe seguir unas determinadas
reglas:
No utilizar comas ni signos de puntuacin en nmeros enteros.
123456 en lugar de 123.456.
Caractersticas del lenguaje Java 43
Puede aadirse una L o 1 a1,final del nmero para especificar que se trata de
Si se trata de un nmero en base decimal no podr comenzar por cero.
un l ong 123456L.
0123 es una const ant e ent er a en base oct al
0x123 es una const ant e ent er a en hexadeci mal
cimal mediante la colocacin de Ox o bien OX delante del nmero.
La notacin octal se indica poniendo un cero delante del nmero y la hexade-
Constantes reales
Una constante flotante representa un nmero real, siempre tiene signo y repre-
senta aproximaciones en lugar de valores exactos. Las constantes reales tienen el
tipo doubl e por defecto, aunque tambin pueden ir seguidas por una d o D que
especifique su pertenencia a dicho tipo. Cuando se les aade una f o F se obli-
ga a que sean de tipo f l oat . Para escribir una constante real se puede especifi-
car su parte entera seguida por un punto y su parte fraccionaria, o bien utilizar la
notacin cientfica, en cuyo caso se aade la letra e o E seguida por un expo-
nente.
82. 341 equivale a 82. 347d 2. 5e4 equivale a 2 5 O O Od
4E- 3F equivalea O. 004f 5. 435E- 3 equivalea O. 005435d
Constantes gicas
Las constantes literales de tipo lgico disponibles en J ava son t r ue y f al se, que
significan ver dader o y f al so respectivamente.
Constantes de tipo carcter
Una constante de tipo carcter es un carcter vlido encerrado entre comillas sim-
ples. Los caracteres que pueden considerarse vlidos son:
Las letras maysculas y minsculas, incluyendo en ambos casos las acentuadas y la .
Los dgitos.
Los caracteres $, - y todos los caracteres Unicode por encima del OOCO .
Existen, adems, ciertas secuencias especiales, denominadas secuencias de esca-
pe, que se usan para representar constantes de tipo carcter.
44 Java 2. Manual de programacin
Tabla 2.8. Ejemplos de constantes de tipo carcter representadas
mediante secuencias de escape
~ ~ ~ ~~ ~~ ~~
Secuencia Significado Secuencia Significado
\n' Nueva lnea
I \ I I \
I \ t ' Tabulacin
I \ I l l I,
' \ b' Retroceso I \ u0007' Pitido
' \ r ' Retorno de carro sin avance de lnea ' \ uOOI B1 Esc
I \ \ ' \
Constantes de tipo cadena
Una constante literal de tipo cadena en J ava est constituida por una serie de carac-
teres, entre los que pueden aparecer secuencias de escape, encerrados entre comi-
llas dobles. Para cada constante literal de tipo carcter usada en un programa J ava
crea automticamente un objeto de tipo St r i ng con dicho valor.
Ejemplo
/ / Secuenci as de escape
class Tr esNumer os
11La salida de este
i
publ i c stati c voi d mai n ( St r i ng ar gs[ ] )
i
1
Syst em. out . pr i nt ( " \ t 1 \ n \ t 2 \ n \ t 3 " ) ;
2.7. LA BIBLIOTECA DE CLASES DE JAVA
La potencia del lenguaje J ava radica en su biblioteca de clases. J ava posee una
biblioteca de clases organizada en paquetes, que son un conjunto de clases lgi-
camente relacionado, y, por tanto, para referenciar una de estas clases en un pro-
grama es necesario escribir su nombre completo, es decir, incluir en el mismo el
paquete al que pertenece, o bien importar el paquete. Una excepcin la constitu-
yen las clases pertenecientes al paquete j ava . l ang, que se importa automti-
camente.
Entre los paquetes de J ava que ms destacan se podran mencionar los
siguientes:
Caractersticas del lenguaje Java 45
1ar. g Funciones del lenguaje net Para redes
ut i 1 Utilidades adicionales ' awt Grficos 2 interfaz grfica de usuario
i o Entrada/Salida
t ext Formateo especializado appl et Para crear programas que se ejecuten en la Web
awt . ever.t Sucesos desde el teclado. ratn. etc.
La sentencia i mpor t slo indica a J ava dnde buscar las clases utilizadas en un
programa.
2.8. C ~ N C E P T ~ S BSICOS SOBRE EXCEPCIONES
Cuando en la ejecucin de un programa se produce un error, J ava lanza una
excepcin', que ser necesario capturar para que el programa no se detenga. La
clase Except i on, con sus subclases I OExcept i on y Runt i meExcept i on
contiene las excepciones que una aplicacin necesita manejar habitualmente.
En el paquete j ava . i o se define la excepcin denominada I OExcept i on
para excepciones originadas por errores de entradaisalida. Estas excepciones se
han de manejar de forma que el mtodo donde se puedan producir debe capturar-
las o bien declarar que se lanzan mediante una clasula t hr ows, en cuyo caso el
mtodo invocador est obligado a capturarlas. Para capturar una excepcin en ope-
raciones de entrada/salida el programa deber incluir la sentencia i mpor t
j ava . i o y adems habr que poner a prueba el cdigo capaz de lanzar la excep-
cin en un bloque t r y y manejar la excepcin en un bloque cat ch, el manejo la
excepcin se puede reducir a la presentacin de un mensaje de error.
/ / capt ur a de excepci ones de ent r ada y cal i i a
t=Y
/ / oper aci ones de ent r ada y sal i da
I
catch ( I OExcept i on e)
!
Cyst em. out . pr i nt l n ( " Er r or " ) ;
Las operaciones aritmticas tambin pueden dar origen a excepciones; por ejemplo,
la divisin por cero. Estas excepciones pertenecen la clase Runt i meExcept i on del
paquete j ava . l ang y son lanzadas automticamente por J ava y el compilador no
obliga a su manejo.
' Una excepcin es un tipo especial de error (objeto error) que se crea cuando sucede algo impre\ isto en un prtr
grama. Enel Captulo 13 se estudia con ms detalle el concepto y manipulacin de excepciones.
46 Java 2. Manual de programacin
/ ka- tura gener i ca de excepci ones de l a cl ase Except i on
try
/ / oper aci ones de ent r ada y sal i da
catch ( Except i on e)
i
C ys tern. out . pr i nt I n ( " Er r or " t e j ;
2.9. LA CLASE Number Y SUS SUBCLASES
J ava utiliza los tipos simples byt e, i nt , l ong, f l oat y doubl e, que no estn
orientados a objetos, por razones de rendimiento. Si lo que se necesita es un objeto
de alguno de estos tipos, ser necesario recurrir a las clases Byt e, I nt eger ,
Long, Fl oat y Doubl e, que son subclases de Number . Number pertenece al
paquete j ava . l ang y proporciona mtodos que devuelven el valor del objeto
como el correspondiente tipo simple. Mtodos de Number con dicha finalidad son:
publ i c
publ i c
publ i c
publ i c
publ i c
byte byt eval ue ( )
abstract double doubl eval ue ( )
abstract f l oat f l oat val ue ( )
abstract i nt i nt Val ue( j
abstract long l ongval ue ( j
Number es una clase abstracta, concepto que se explicara con detalle ms ade-
lante, y sus mtodos abstractos han de ser definidos en cada una de las subclases
comentadas. Por otra parte, las clases Byt e, I nt eger , Long, Fl oat y
Doubl e permiten construir objetos de la clase correspondiente mediante los
mtodos:
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
Byt e (byte pl)
Byze( j ava. l ang. Ct r i ng pl)
I nt eger ( i nt p1)
I r , t eger ( j ava. l ang. St r i ng pl)
Long (long pl )
Lor Lg( j ava. l ang. St r i ng pl)
Fl oat (double pl)
Fl oat (f l oat pl)
Fl oat ( j ava. l ang . St r i ng pl)
Doubl e (double pl )
Doubl e ( j ava. l ang. St r i ng pl)
Caractersticas del lenguaje J ava 47
Es decir, se pueden construir objetos de estos tipos a partir de los valores num-
ricos adecuados o a partir de cadenas con valores vlidos para el tipo. La construc-
cin ha de efectuarse con la ayuda del operador new, que tambin aparece
comentado con posterioridad.
Doubl e d = new Doubl e( " 2. 71828" ) ;
double r eal = d. doubl eVal ue ( ) ;
I nt eger ent = new I nt eger ( 34) ;
int 1 = ent . i nt Val ue ( ) ;
Las clases I nt eger y Long proporcionan dos mtodos muy utilizados para
convertir una cadena en un nmero, par seI nt y par sel ong. Estos mtodos
lanzan una Number For mat Except i on, que es una Runt i meExcept i on,
cuando surge algn problema.
public static int par seI nt ( j ava. l ang. St r i ng pi)
/ / el segundo par met r o per mt e especi f i car l a base
public static int par seI nt ( l ava. l ang. St r i ng p:, int 02)
public static long par seLong ( l ava. l ang. St r i ng pi)
/ / el segundo par met r o per mi t e especi f i car l a base
public static long parseL ong(j ava.1ang.Ctri ng pi, int 0 2 )
Ejemplo
int 1 = 1nt eger . par seI nt ( " 20C1" ) ;
int j = 1nt eger . par seI nt ( " 101" , 2) ;
Syst em. out . pr i nt l n( " i = " + 1 + " j = " + 1) ;
La salida sera
1 = 2001 j = 5
Otros mtodos interesantes de las clases I nt eger y Long son:
class I nt eqer
public static j ava. l ang. St r i ng toString(int p)
public static l ava. l ang. St r i ng toBi naryS: r: -, g (int p )
public static j ava. l ang. St r i ng toHexString(int p)
public static j ava. l ang. St r i ng t o0ct al St r i pg( i nt p )
48 Java 2. Manual de programacin
cl as s Long
publ i c st at i c j ava. l ang. St r i ng t oSt r i ng( 1ong p)
publ i c st at i c j ava. l ang. St r i ng t oBi nar ySt r i ng( 1ong p)
publ i c st at i c j ava. l ang. St r i ng t oHexSt r i ng( 1ong p)
publ i c st at i c j ava. l ang. St r i ng t oOct al St r i ng( 1ong p)
Estos mtodos permiten respectivamente convertir nmeros ( i nt o l ong) en
una cadena decimal, binaria, octal o hexadecimal.
2.10. LAS CLASES Character Y Boolean
La clase Char act er se utiliza para crear objetos a partir de un parametro char .
El constructor es:
publ i c Character ( char p)
y posee el mtodo public char char val ue ( ) que devuelve el valor char
Correspondiente.
Otros mtodos interesantes de esta clase son:
publ i c st at i c char t oupper case ( char p)
publ i c st at i c char t oLower Case ( char p )
que devuelven el carcter que reciben como argumento transformado a maysculas
en el caso del primer mtodo y a minsculas en el caso del segundo.
La clase Bool ean permite crear objetos a partir de un dato de tipo bool ean.
Sus constructores son:
publ i c Bocl ean ( bool ean p)
publ i c Bool ean( j ava. l ang. St r i ng p)
y para obtener el correspondiente valor bool ean se usa
publ i c bool ean bool eanval ue0
Ejemplo
bool ean rnayor = 3 + 1 > 5;
Sool ean ob = new Bool ean( mayor ) ;
bool ean b = ob, bool eai Val ue ( ) ;
Caractersticas del lenguaje Java 49
2.1 1. ENTRADA Y SALIDA BSICAS
En J ava la entrada y salida de informacin se realiza mediante fl uj os; es decir,
secuencias de datos que provienen de una fuente. Estos flujos son objetos que
actan de intermediarios entre el programa y el origen o destino de la informacin,
de forma que ste lee o escribe en el flujo y puede hacer abstraccin sobre la natu-
raleza de la fuente. Como las clases relacionadas con flujos pertenecen a un paque-
te denominado j ava . i o, los programas que utilizan flujos necesitan la inclusin
en los mismos de la instruccin
import j ava. i o. *;
En J ava existen unos flujos estndar, manipulados por la clase Syst emdel
paquete j ava . l ang, que permiten realizar operaciones de entradaisalida:
' syst em. i n. representa la entrada estndar y es del tipo j ava. i o. I npLt Szr eam
*Syst em. out , del tipo j ava. i o. Pr i nt St r eam, referencia ia pantalla
*syst em. er r , de tipo j ava. 10. Pr i nt st r eam, referencia la salida de errores
publ i c stati c f i nal j ava. i o. I nput Ct r eam ;I:
publ i c stati c f i nal l ava. i o. Pr i nt st r eam out
publ i c stati c f i nal j ava. i o. Pr i nt St r eam er r
La salida bsica por pantalla se lleva a cabo mediante los mtodos pr i nt y
pr i nt l n, pertenecientes a la clase Pr i nt st r eam. A estos mtodos se les puede
llamar mediante Syst em. out , que hace referencia a la salida estndar. El mecanis-
mo bsico para salida con formato utiliza el tipo St r i ng. En la salida, el signo + com-
bina dos valores de tipo St r i ng y si el segundo argumento no es un valor de tipo
St r i ng, pero es un tipo primitivo, se crea un valor temporal para l de tipo St r i ng.
Estas conversiones al tipo St r i ng se pueden definir tambin para objetos.
Ejemplo
/ *
Ej empl o 1" sobr e oper aci ones bsi cas de ent r ada y sal i da.
Ej ecut e el si gui ent e pr ogr ama y anal i ce l os r esul t ados
* /
import j ava. i o. *;
publ i c cl ass Er. t r adaCa 1 i aa 1
t
publ i c stati c void mai n ( St r i ng[ ] ar gs)
i nt 1;
char c;
50
Java 2. Manual de programacin
Sys; err. out . pr i nt l n ( " Escr i ba un nmer o nat ur al con" +
; =Cyst er r . i n. r ead ( ) ;
Syst em. i n. ski p ( 2) ;
/ *
" un ni co d gi t o y pul se RETURN" ) ;
sai t a dos car act er es en el f l uj o de ent r ada:
\ r \ n
Car act er es or i gi nados al pul sar l a t ecl a RETURN
*/
Cyst er , . out . pr i nt l n( i ) ;
Syst em. out . pr i nt l n ( " Escr i ba un nmer o nat ur al con" +
" un ni co d gi t o y pul se RETURN" ) ;
c=(char) Syst er n. i n. r ead( ) ;
Cyst er n. out . pr i nt l n ( c) ;
catch ( I OExcept i on e)
Cyst em. out . pr i nt l n ( " Er r or " ) ;
La entrada de datos por consola se efecta en J ava leyendo bytes de un flujo de
entrada y almacenndolos en objetos de distinto tipo, como se hizo mediante
Syst em. i n. r ead ( ) en el ejemplo anterior. La instruccin Syst em. i n.
sk i p ( 2) ; que tambin aparece en dicho ejemplo puede sustituirse por esta
otra Syst em. i n. ski p( Syst em. i n. avai l abl e( ) ) ; paraqueel pro-
grama determine automticamente el nmero de caracteres que quedan en el
flujo de entrada y se desean saltar.
No obstante, la entrada bsica en J ava suele realizarse mediante el mtodo
r eadLi ne ( ) de la clase Buf f er edReader , que lee una secuencia de caracte-
res de un flujo de entrada y devuelve una cadena y, adems, mejora el rendimiento
mediante la utilizacin de un bfer. Para efectuar este tipo de entrada debe cons-
truirse un objeto de la clase Buf f er edReader sobre otro de la clase
I nput St r eamReader asociado a Syst em. i n, que se encarga de convertir en
caracteres los bytes ledos desde teclado. Segn este planteamiento, la lectura de
valores numricos conllevara dos fases: lectura de una cadena y conversin de la
cadena en nzmero. Cuando si trata de valores de tipo i nt o l ong los mtodos
I nt eger . par sei nt e I nt eger . par seLong proporcionan un mecanismo
de conversin adecuado, mientras que para valores de tipo real se recurre a efec-
tuar la construccin de objetos de tipo Fl oat o Doubl e a partir de la representa-
cin en forma de cadena del nmero en coma flotante, para despus, mediante
f l oat val ue o doubl eVal ue, obtener el valor f l oat o doubl e que encap-
sula dicho objeto. Como ya se ha visto, I nt eger , Long, Fl oat y Dobl e son
Caractersticas de/ lenguaje Java 51
clases pertenecientes al paquete j ava . l ang que representan como objetos los
tipos simples de su mismo nombre.
Ejemplo
/ *
El empl o 2" sobr e oper aci ones de ent r ada y sal i da.
Ej ecut e el si gui ent e pr ogr ama y anal i ce l os r esul t accs
*/
import j ava . i o. * ;
public class Ent r adasal i da2
i
public static voi d mai n ( St r i ng[ ] ar gs)
I nput Ct r eamReader i sr = new I nput Ct r eamReader ( Syst em. i n) ;
Buf f er edReader br = new Buf f er edReader ( ; sr ) ;
St r i ng cadena;
try
Cyst em. out . pr i nt l n ( " Escr i ba su nombr e y pul se RETU; I N") ;
cadena=br . r eadLi ne( ) ;
Syst em. out . pr i nt l n ( "Hol a" +cadena+
", escr i be un nmer o ent er o y pul sa RETCW") ;
int ent er o=I nt eger . par seI nt ( br . r eadLi ne( ) 1 ;
Cyst em. out . pr i nt l n ( "El nmer o i nt r oduci do f ue el "+er . t er c) ;
Cyst em. out . pr i nt l n ( "Ami go/ a" +cadena+
", i nt r oduzca ahor a un r eal y pi l se XFTLJ S>J ") ;
Syst em. out . pr i nt l n ( " ( ut i l i ce el punt o corno separ ador " +
cadena=br . r eadl i ne( ) ;
Doubl e d=new Doubl e ( cadena) ;
double r eal = d. doubl eval ue ( ) ;
Syst em. out . pr i nt l n ( " El r eal es " +r eal ) ;
" ej 3. 45) " ) ;
1
i
1
catch ( TOExcept i on e)
Syst em. out . pr i nt l n ( " Er r or " ) ;
1
AI realizar este tipo de operaciones de entrada/salida hay que tener en cuenta la
posible generacin de excepciones; por ejemplo, aquellas que son lanzadas por
r eadLi ne ante un error de lectura, y estas excepciones deben ser recogidas o
bien listadas en una clusula throws que las devuelva al mtodo llamador.
52
Java 2. Manual de programacin
2.12. OPERADORES
Los operadores de un lenguaje se pueden utilizar para combinar o modificar los
valores de un programa. J ava posee un gran conjunto de operadores. La lista com-
pleta de los operadores J ava se muestra en la Tabla 2.9.
Tabla 2.9. Lista completa de operadores J ava
> < !
-_ _ _ <= >= I =
~
- ~
? :
& &
-
+=
_ -
++
/ &
*= /=
<< >>
t
>>>
&=
>>>= ( t i po) new i nst anceof o
r .
1 1
2.12.1. Operadores sobre enteros
Los operadores que trabajan sobre enteros pueden ser binurios o unarios (unita-
rios). Los operadores binarios son aquellos que requieren dos operandos (Tabla
2.1 1). Los operadores unarios son aquellos que requieren un nico operando
(Tabla 2.10). En ambas tablas se proporciona un ejemplo de la utilizacin de cada
operador.
La Tabla 2.12 muestra un tipo especial de operadores de asignacin que se basan
en los otros operadores. Estos operadores actan sobre un operando y almacenan el
valor resultante de nuevo en el mismo operando.
Ejemplo
z += 5; equivale a z = z + 5 ;
Tabla 2.1 O. Operadores unitarios sobre enteros
Operador Operacin Ejemplo
-
Negacin unitaria -a
++ Incremento ++a o bien a ++
_ _ Decremento - - a o bien a- -
- Negacin lgica bit a bit - a
Caractersticas del lenguaje Java 53
Tabla 2.11. Operadores binarios sobre enteros
~
Operador Operacin Ejemplo
- - Asignacin
_ _ _ _ Igualdad
I = Desigualdad
< Menor que
a = b
a != b
a < b
a == b
<= Menor o igual que a <= b
>= Mayor o igual que a >= b
> Mayor que a > b
+ Suma a + b
- Diferencia a - b
Producto a * b
/ Divisin a / b
, Mdulo a % b
<< Desplazamiento a izquierdas
a << b
>> Desplazamiento a derechas
a >> b
>>> Desplazamiento a derechas con rellenado de ceros a >>> b
& AND bit a bit a & b
I OR bit a bit a l b
XOR bit a bit a ^ b
*
Tabla 2.1 2. Operadores de asignacin enteros
t=
/=
-
-
>>=
-
--
&=
9-
>>>=
0 -
*=
I =
<<=
2.12.2. Operadores sobre valores de coma fl otante
Los operadores sobre valores de coma flotante son un subconjunto de los disponi-
bles para tipos enteros. La Tabla 2.13 muestra los operadores que pueden operar
sobre operandos de tipo f l oat y doubl e.
54
Java 2. Manual de programacin
Tabla 2.13. Operadores sobre valores de coma flotante
Operador OperJ\cin Ejemplo
_ _
_ _ _ _
I =
<
<=
>=
>
+
/
,
++
_ _
Asignacin
Igualdad
Desigualdad
Menor que
Menor o igual que
Mayor o igual que
Mayor que
Suma
Resta
Multiplicacin
Divisin
Mdulo
Negacin unitaria
lncrernento
Decremento
a = b
b
a != b
a < b
a <= b
a >= b
a > b
a + b
a - b
a * b
a / b
- a
++a o bien a++
--a o bien a- -
a ==
a % b
2.13. LA SENTENCIA DE ASIGNACIN
La sentencia de asignacin se usa para dar valor a una variable o a un objeto en el
interior de un programa, aunque hay que tener en cuenta que las variables de tipo
objeto se comportan de forma diferente a como lo hacen las de tipo simple cuando
se realiza una asignacin. El operador de asignacin es el signo de igualdad y en
este tipo de sentencias la variable se colocar siempre a la izquierda y la expresin
a la derecha del operador.
Los objetos de una determinada clase se crean utilizando el operador new que
devuelve una referencia al objeto, la cual se almacenar en una variable del tipo
objeto mediante una sentencia de asignacin. Las sentencias de asignacin tam-
bin se podrn aplicar entre dos variables de tipo objeto. A las variables de tipo
objeto se las denomina variables por referencia, debido a que cuando se asigna
una variable de tipo objeto a otra (a diferencia de lo que ocurre con las variables
de tipo simple) no se efecta una copia del objeto, sino que slo se hace una
copia de la referencia, es decir, de la direccin de memoria donde se encuentra
el objeto.
Doubl e d, d2;
d = new Doubl e( " 3" ) ;
d2 = d;
Caractersticas del lenguaje Java 55
En cuanto a las variables de tipo simple, tras efectuar su declaracin, podr usar-
se el operador de asignacin, para adjudicarles el valor de una expresin.
int x, y;
x=5 ;
y=x ;
Este operador es asociativo por la derecha, lo que permite realizar asignaciones
mltiples. As,
adjudica a las tres variables el valor 5.
2.14. EXPRESIONES
En general, las expresiones se definen como un conjunto de operadores y operan-
dos, pero hay que tener en cuenta que dicho conjunto puede estar formado exclusi-
vamente por un operando. Es decir, que las expresiones pueden ser una constante,
una variable o una combinacin de constantes, variables y/o funciones con opera-
dores, tanto binarios como unitarios.
Como ya se coment, en J ava las variables declaradas st at i c y f i na 1 son
en realidad constantes y los mtodos cuyo tipo de resultado no es voi d y que
se declaran como publ i c y st at i c pueden ser considerados funciones glo-
bales.
2.15. CLASE Math
La clase j ava . l ang . Mat h proporciona una serie de constantes y funciones de
uso muy comn en expresiones aritmticas.
Mat h es una clase en el paquete fundamental j ava . l ang. Los mtodos est-
ticos de la clase Mat h realizan clculos matemticos bsicos tales como mximo,
mnimo, valor absoluto y operaciones numricas que incluyen funciones exponen-
ciales, logartmicas, raz cuadrada y trigonomtricas. Los clculos en coma flotan-
te se realizan utilizando doubl e y algoritmos estndar.
56 Java 2. Manual de programacin
Mtodos sobre tipos numricos
Invocacin Significado Estructura de la cabecera de la declaracin del miembro
Mat h. abs ( exp) valor absoluto public stati c double abs (double pl)
de e.rp public stati c f l oat abs (f l oat pi)
public stati c i nt abs ( i nt pl)
public stati c long abs (long pl)
Mat h. max( expl , expZ) mayorentre public static double max (double pl , double p2)
expl yexp2 public stati c float max (float pi, float p2)
public stati c i nt rnax ( i nt p i , i nt p2)
public stati c long rnax (long p l , long p2)
Mat h. mi n( expl , expZ) menorentre public static double rni n (double pi, double p2)
expl . vexp2 public stati c float mi n (fl oat pi , fl oat p2)
public stati c i nt mi n ( i nt pi, i nt p2)
public stati c long rni n (long pl, long p2)
Como se puede apreciar a travs de las cabeceras de los mtodos, stos estn
redefnidos para que puedan trabajar con diferentes tipos de datos.
Mtodos de coma flotante
~ ~
Invocacin Significado Estructura de la cabecera de la declaracin del miembro
Mat h. pow( a, b) ah pal i cstati c&aep <*pi,chhlep?)
Mat h. exp( a) ea public stati c double exp (double pi)
Mat h. cei 1 ( a) r. 1 public stati c double cei l (double pi)
Mat h. f l oor ( a) Lul public stati c double fl oor (-le pi )
Mat h. l og( a) ' n (4 public stati c double l ong (double pl)
Mat h. sqr t ( x) 6 public static double sqr t (double pi )
Mat h. r ound ( n) redondeo al entero public stati c long r ound (double pi)
( l ong o i nt ) public stati c i nt r ound (f l oat pi)
ms cercano
log natural
Mat h. r andom( ) nmero aleatorio' public stati c synchronized double r andom( )
Constantes de coma flotante
Invocacin Significado
Mat h . E base del logaritmo natural public stati c f i nal double E
Mat h. PI p public stati c f i nal double P I
Estructura de la cabecera de la declaracin del miembro
' Laclase Random perteneciente al paquete j ava . ut i 1 ofrece un mayor nmero de posibilidades para la gene-
racin de nmeros aleatonos. Puede generar nmero aleatonos incluso siguiendo diferentes tipos de distribucin.
j
Caractersticas del lenguaje Java 57
Funciones trigonomtricas
Invocacin Significado Estructura de la cabecera de la declaracin del miembro
~
Mat h. si n (19) sen (19) public static double si n (double pi)
Mat h. cos (8) CUJ (8) public static double cos (double pi)
Mat h. t an (8) tg (8) public static double t an (double pl)
Mat h. asi n( x) -u <arcsen(x)<u public static double asi n (double pi)
Mat h. acos( x) O < urcm(x)<8 public static double acoc (double pi)
Mat h. at an ( x) -yhrcfg(x)<D public static double at an (double pi)
2
Mat h. at an2 ( a, b) -IIhrcrg(a)<Fl
2 - 2
public static double at an2 (double pl, double p2)
b
Ejemplo
. . .
/ / Cal cul o del r ea de un c r cul o de r adi o 10
int r = 10;
double c = Mat h. pow( r , 2) *Mat h. PI ;
Syst em. out . pr i nt l n ( c) ;
...
2.16. PAQUETE java.math
El paquete j ava. mat h tiene las clases Bi gDeci mal y Bi gI nt eger y sopor-
ta operaciones de coma flotante y enteros de precisin ampliada.
2.17. CONVERSIONES DE TIPOS. OPERADORES MOLDE
Con frecuencia se necesita convertir un dato de un tipo a otro sin cambiar el valor
que representa. Las conversiones de tipo pueden ser automticas o explcitas, es
decir, solicitadas especficamente por el programador.
Conversiones automticas
En las expresiones pueden intervenir operandos de diferentes tipos y, cuando esto
ocurre, para efectuar las operaciones J ava intenta realizar conversiones automticas
de tipo. Las conversiones automticas que podr efectuar son:
58
Java 2. Manual de programacin
char
in long float double
byte short
Fi gura 2.1. Conversiones automticas.
En la operacin de asignacin convierte el valor a la derecha del signo igual al
tipo de la variable, siempre que los tipos sean compatibles y esta operacin no oca-
sione una prdida de informacin, es decir, cuando se trate de conversiones como
las mostradas en la Figura 2.1.
Conversiones explcitas
Este tipo de conversiones utiliza los denominados operadores de conversin, molde
o cast, y puede ser necesario cuando se precisa un estrechamiento de tipo, conver-
sin en el sentido tipo ms alto a tipo ms bajo, o en casos como el siguiente para
generar una entidad temporal de un nuevo tipo.
. . .
i nt a = 5;
byt e b = 5;
b = ( byt e) ( b * 2) ;
/ *si no se pone el mol de da er r or ya que el
2 es ent er o y avi sa que no se puede
conver t i r aut omt i cament e i nt a byt e */
f l oat c = a / b;
/ *di vi si n ent er a. El oper ador di vi si n
f unci ona a dos ni vel es: ent er o y r eal */
. . .
i nt a = 5;
byt e b = 5;
b ( byt e) ( b * 2) ;
f l oat c = ( f l oat l a / b;
/ / di vi si n r eal
S a l i d a :
@. O 5 10
Sal i da :
0. 5 5 10
El operador molde tiene la misma prioridad que los operadores unarios.
Mediante los operadores molde cualquier valor de un tipo entero o real puede ser
convertido a o desde cualquier tipo numrico, pero no se pueden efectuar conver-
siones entre los tipos enteros o reales y el tipo bool ean.
2.18. OPERADORES ARITMTICOS
Los operadores aritmticos permiten realizar operaciones aritmticas bsicas,
actan sobre operandos numricos y devuelven un resultado de tipo numrico. Los
Caractersticas de/ lenguaje Java 59
operadores aritmticos en J ava pueden tambin actuar sobre operandos de tipo
char, ya que J ava considera este tipo prcticamente como un subconjunto de los
i nt . Los operadores aritmticos de J ava se muestran en la Tabla 2.14.
Tabla 2.14. Operadores aritmticos
- -~
Operador Significado Operador Significado
+ Operador unario + /
o Suma
Divisin entera si los operandos son de
tipo entero
- Operador unario - / Divisin real con operandos de tipo real
o Resta
* Mu1 tip1 icacin % Mdlo, es decir, resto de la divisin
entera. No es necesario que los
operandos sean enteros
Ejercicio
Convertir un nmero de metros ledos desde teclado en un complejo de pies y pulgadas
sabiendoque 1 metro = 39. 27 p u l g a d a s y 1 pie = 12 p u l g a d a s .
package l i br o. Tema02;
import j ava. i o. *;
public class Conver si on
i
public static void mai n ( St r i ng[ ] ar gs)
I
I nput St r eamReader i sr =new I nput St r eamReader ( Syst em. i n) ;
Buf f er edReader br = new Buf f er edReader ( i sr ) ;
St r i ng cadena;
try
I
Syst em. out . pr i nt l n ( " I ndi que el nmer o de met r os y" +
cadena = br . r eadLi ne( ) ;
Doubl e d = new Doubl e( cadena) ;
double met r os = d. doubl eVal ue ( ) ;
double pul gadas = met r os * 39. 27;
double pi es = pul gadas / 12;
pul gadas = pul gadas % 12; / / es posi bl e apl i car % a r eal es
pi es = pi es - pul gadas / 12;
Syst em. out . pr i nt l n ( " Conver si n de met r os en un compl ej o" +
Syst em. out . pr i nt l n( met r os + " met r os son " + pi es +
" pul se RETURN" ) ;
" de pi es y pul gadas" ) ;
" pi es y " + pul gadas + " pul gadas" ) ;
i
Caractersticas de/ lenguaje Java 61
2.19. OPERADORES RELACIONALES
Los operadores relacionales o de comparacin permiten comparar valores para
determinar su igualdad u ordenacin y el resultado de las expresiones en las que
intervienen es de tipo lgico. En cuanto a los operandos hay que tener en cuenta que
slo los tipos numricos se pueden comparar utilizando operadores de ordenacin,
mientras que los de igualdad y desigualdad pueden actuar sobre cualquier tipo de
dato. La Tabla 2.15 lista los operadores relacionales.
Tabla 2.15. Operadores relacionales
Operador Nombre Ejempio Respuesta
_ _ _ _ Igual (operador formado por dos signos =consecutivos) 1 == 2 f al se
I = Distinto 1 != 2 true
> Mayor que 1 > 2 f al se
< Menor que 1 < 2 true
>= Mayor o igual 1 >= 2 f al se
<= Menor o igual 1 <= 2 true
2.20. OPERADORES LGICOS
Los operadores lgicos o booleanos actan sobre operandos de tipo lgico para
devolver un resultado tambin de tipo lgico. La Tabla 2.16 contiene la lista de los
operadores lgicos existentes en J ava.
Tabla 2.16. Operadores lgicos
Operador Significado Operador Significado
& AND lgico 1 1 OR en cortocircuito
I OR lgico XOR
&& AND en cortocircuito I NOT unario lgico
h
Las reglas de funcionamiento son las siguientes:
El operador & da como resultado true si al evaluar cada uno de los operandos
el resultado es true. Si alguno de ellos es f al se, el resultado es f al se.
&& es anlogo a &, pero si el primer operando es f al se, el segundo no es eva-
luado. Esta propiedad se denomina evaluacin en cortocircuito. Por ejemplo,
la siguiente expresin evitara calcular la raz cuadrada de nmeros negativos:
( X >= O) && ( Mat h. sqr t ( x) >= 2)
62
Java 2. Manual de programacin
Tabla 2.17. Tabla de verdad del operador &&
~~~~
Operandol Operando2 Operandol 6 h Operando2
f al se f al se f al se
f al se true f al se
true f al se f al se
true true true
El operador 1 da como resultado f al se si al evaluar cada uno de los operan-
dos el resultado es f al se. Si uno de ellos es true, el resultado es true.
1 I es anlogo a I , pero, cuando se usa, si el primer operando es true, el
segundo no se evala.
Por ejemplo, en la siguiente expresin:
( 10 > 4) 1 1 (num == O)
la sentencia num == O nunca se ejecutar.
Tabla 2.18. Tabla de verdad del operador I I
Operando 1 Operando 2 Operando 1 I I Operando 2
f al se f al se f al se
f al se true true
true f al se true
true true true
El operador ! da como resultado f al se si al evaluar su nico operando el re-
sultado es true, y devuelve t r ue en caso contrario.
Tabla 2.19. Tabla de verdad del operador !
Operando !Operando
f al se
true
true
f al se
El operador
, ,
da como resultado t r ue si al evaluar sus operandos uno de
ellos es true y el otro f al se, y devuelve f al se cuando ambos son t r ue y
tambin cuando ambos son f al se.
Caractersticas del lenguaje Java 63
Tabla 2.20. Tabla de verdad del operador A
Operando 1 Operando 2 Operando 1 Operando 2
f al se f al se f al se
f al se true true
true f al se true
true true f al se
2.21. OPERADORES DE MANIPULACIN DE BITS
Actan sobre operandos de tipo entero modificando los bits de sus operandos
Tabl a 2.21. Operadores de manipulacin de bits
Operador Nombre
&
I
-
<< Desplazamiento a la izquierda
>>>
>> Desplazamiento a la derecha
AND a nivel de bit
OR a nivel de bit
NOT unario a nivel de bit
XOR
Desplazamiento a la derecha rellenando con ceros
A
Para trabajar con estos operadores es necesario tener presente que:
J ava:
- Almacena los enteros como nmeros binarios.
- Todos sus enteros, excepto los char, son enteros con signo, es decir,
- Los nmeros negativos se almacenan en complemento a dos, es decir,
pueden ser positivos o negativos.
cambiando por ceros los unos del nmero y viceversa y sumando un
uno al resultado.
La Tabla 2.22, que describe las acciones que realizan los operadores &
I
A
y - sobre los diversos patrones de bits de un dato de tipo entero.
64 Java 2. Manual de programacin
& sobre bits
A B A & B
O 0 O
o 1 O
1 0 O
1 1 1
I sobre bits * sobre bits - sobre bits
A B A I B A B A A B A - A
O 0 O O 0 O 1 O
o 1 1 o 1 1 O 1
1 0 1 1 0 1
1 1 1 1 1 O
El desplazamiento a la izquierda tiene el siguiente formato val or << n y
mueve a la izquierda n posiciones los bits del operando, rellenando con ceros
los bits de la derecha.
O O O 1 1 1 O 1 val or es29
tras val or = val or << 3, el val or es 232
o -24 si el primer 1 por la izquierda es el signo (complemento a dos)
1 1 1 0 1 0 O 0
. . .
byte c = 29;
int d = c << 3;
Syst em. out . pr i nt 1n ( d) ;
byte e = ( byt e) ( c << 3) ;
Syst er n. out . pr i nt 1n ( e) ;
S a l i d a :
232
-24
El desplazamiento a la derecha, val or >> n, mueve a la derecha n posi-
ciones los bits del operando, perdindose los bits de la derecha y rellenndose
los de la izquierda con el contenido del bit superior inicial, lo que permite con-
servar el signo.
I
byte b = -2;
int c = b >> 1;
/ / equi val e a di vi di r por 2
int c = -2;
c = c >> 1;
/ / equi val e a di vi di r por 2
Syst er n. out . pr i nt l n ( c) ; I syst er n. out . pr i nt l n( c) ;
I
S a l i d a -1 S a l i d a -1
Para efectuar desplazamientos a la derecha en datos de tipo i nt sin conservar el
signo el operador adecuado es >>>, que rellena con un cero el bit superior.
Caractersticas del lenguaje Java 65
Syst em. out . pr i nt 111 ( b) ;
...
byte b = - 2;
b = (byte) ( b >>> 1);
Syst em. out . pr i nt l n( c) ;
I . . .
bi te b = - 2;
i nt c = b >>> 1;
i nt c = - 2;
c = c >>> 1;
Syst em. out . pr i nt l n( c) ;
Sa 1 i d a 2 147483647
2.22. OPERADORES DE ASI GNACI ~N ADICIONALES
Adems del operador de asignacin ya comentado, J ava proporciona operadores de
asignacin adicionales (Tabla 2.23). Estos operadores actan sobre variables de
tipos simples como una notacin abreviada para expresiones utilizadas con fre-
cuencia. Por ejemplo, el operador ++ permite la sustitucin de la expresin a=a+l
por a+t. Los operadores ++ y -- necesitan una explicacin adicional. Dichos
operadores se denominan de autoincremento y autodecremento respectivamente y
admiten su aplicacin en dos formas, preJja y posGja, que adquieren importancia
cuando los mismos se usan dentro de una expresin mayor.
Prefija ++a
Postfja a++
Ejemplo
. . .
i nt a, b, c;
a = b = 5 ;
c = a++ + ++b;
/ * c es el r esul t ado de l a suma del val or or i gi nal de a
Syst em. out . pr i nt l n ( c+" " +a+" " +b) ;
con el nuevo val or de b */
. . .
La s a l i d a es
11 6 6
Los operadores &=, 1 = y A=, cuando actan sobre valores lgicos, son ope-
radores lgicos; si los operandos son enteros, son operadores de manipulacin de bits.
66
Java 2. Manual de programacin
Ejemplo
package l i br o. Tema02;
publ i c cl ass Oper ador es
I
Publ i c st at i c voi d mai n ( St r i ng[ ] ar gs)
bool ean a=t r ue;
a &=t r ue ;
Syst em. out . pr i nt l n( " t r ue & t r ue = " +a) ;
a &=f al se;
Syst em. out . pr i nt l n
a&=f al se ;
Syst em. out . pr i nt l n
a &=t r ue;
Syst em. out . pr i nt l n
Tabla 2.23.
" t r ue & f al se = " +a) ;
" f al se & f al se = " +a) ;
" f al se & t r ue = " +a) ;
Operadores de asignacin
Operador Nombre Ejemplo
-
- Asignacin simple i nt a = 5;
/ / a t oma el val or 5
++ Incremento y asignacin a++
/ / a val e 6
-- Decremento y asignacin a- - ; / / equi va; e a a=a- 1
/ / a val e 5
*= Multiplicacin y asignacin a*=4; / / a = a" 4
/ / a t oma el val or 20
/= Divisin y asignacin a/ =2; / / a = a/ 2
/ / a torna el val or de 10
*= Mdulo y asignacin a"- - 0- 6; / / a = a%6
/ / a val e 4
T= Suma y asignacin a+=8; / / a = a+8
/ / a val e 12
/ / a val e - 11
<<= Desplazamiento a la, a<<=2; / / a = a<<2
izquierda y asignacion / / a val e - 44
>>= Desplazamiento a la a>>=6; / / a = a>>6
derecha y asignacin / / a val e -1
>>>= Desplazamiento a la derecha a>>>=24; / / a = a>>>24
y asignacin rellenando con ceros / / a val e 2 55
- _ - Resta y asignacin a- =23; / / a = a- 23
&=
I =
a=3;
Asignacin AND o a&=6; / / equi val en a a=3&6
AND sobre bits y asignacin / / a val e 2
a=3;
Asignacin OR o a 1 =6; / / equi val en a a=3l 6
OR sobre bits y asigancin / / a val e I
a=3;
-
- Asignacin XOR o a^=6; / / equi val en a a= 3 - 6
XOR sobre bits y asigancin / / a val e 5
Caractersticas de/ lenguaje Java 67
2.23. OPERADOR CONDICIONAL
El operador condicional, ? : , es un operador ternario, es decir, requiere tres ope-
randos, y se utiliza en expresiones condicionales, devolviendo un resultado cuyo
valor depende de si la condicin ha sido o no aprobada. El formato del operador
condicional es:
condi ci on ? oper andol : oper ando2;
y conlleva la ejecucin de las siguientes operaciones: se evala la condicin; si
la condicin es true, el resultado es operandol , y si es f al se, es operando2.
Por ejemplo:
double comi si n = (ventas > 150000) ? 0. 10 : 0. 05;
si las ventas son superiores a 15 O O O O, se adjudica el valor O . 1 O a comisin; en
caso contrario, se le adjudica O . 05.
2.24. PRIORIDAD DE LOS OPERADORES
Las expresiones se evalan siguiendo el orden de prioridad de los distintos opera-
dores que intervienen en ellas, atendiendo primero a los de mayor prioridad. A
igualdad de prioridad se evalan de izquierda a derecha. Los parntesis se pueden
utilizar con la finalidad de cambiar el orden preestablecido, ya que las operaciones
encerradas entre parntesis siempre se evalan primero. Cuando hay varios parn-
tesis anidados se calcula primero el resultado de las operaciones encerradas en los
ms internos.
La prioridad, de mayor a menor, de los distintos operadores en J ava aparece
reflejada en la Tabla 2.24, los operadores situados en la misma lnea tienen igual
prioridad. En J ava todos los operadores binarios, excepto los de asignacin, se eva-
lan de izquierda a derecha (asociatividad).
Consejo: Se pueden utilizar parntesis para forzar un orden de evaluacin, as
como facilitar la lectura de un programa.
68 Java 2. Manual de programacin
Ejemplo
;Cul es el valor de la siguiente expresin, teniendo en cuenta que i vale l ?
5 + 4 * 4 > 5 * ( 5 +4 ) - i t t
Recul t ad0
f al se
Ejercicio
Determinar si un ario ledo desde teclado es o no bisiesto, teniendo en cuenta que
un ao es bisiesto cuando es mltiplo de 4 y no lo es de 100 o si es mltiplo de
400.
i mpor t j ava. i o. *;
publ i c cl ass Pr i or i dad
publ i c st at i c voi d mai n ( St r i ng[ ] ar gs)
I
I nput St r eamReader i sr =new I nput Ct r ear nReader ( Syst er n. i n) ;
Buf f er edReader br = new Buf f er edReader -..) ;
St r i ng cadena;
try
i
Syst em. out . pr i nt ( " Escr i ba el ao co' , 4 d gi t os " ) ;
cadena = br . r eadLi ne ( ) ;
i nt ao = I nt eger . par seI nt ( cadena) ;
bool ean bi si est o = ao % 400 == O 1 1
Syst em. out . pr i nt l n( bi si est o) ;
I
cat ch( Except i on e)
i
ao % 100 != O && ao % 4 == O;
Cyst er n. out . pr i nt l n ( " Cual qui er t i po de er r or " ) ;
Caractersticas de/ lenguaje Java 69
Tabla 2.24. Prioridad de los operadores
Operador Asociatividad
0 [ I I - D
++ -- D- I
new ( ti po) D- I
/ % I - D
+ I - D
>> >>> << I - D
> >= < <= i nstance of I - D
_ _ != I - D
& I - D
I - D
I I - D
&& I - D
I 1 I - D
? : D- I
/= %= += -= >>= >>>= <<= &= ^= / = D- I
- I
*
-
_ _
-
- *=
3
Decisiones y bucles
CONTENIDO
3.1. La sentencia i f .
3.2. La sentencia i f - el se.
3.3.
3.4. La sentencia swi t ch.
3.5. La sentencia f or .
3.6. La sentencia br eak.
3.7. La sentencia cont i nue.
3.8.
3.9. La sentencia whi l e.
Las sentencias i f e i f - el se anidadas
Diferencias entre cont i nue y br eak.
3.10. La Sentencia do- whi l e.
71
72 Java 2. Manual de programacin
En todos los lenguajes de programacin existen construcciones
que permiten tomar decisiones basadas en una condicin. Para
efectuar esta tarea J ava dispone de las sentencias i f , i f - el se y
swi t ch. Un bucle es una seccin de cdigo que se ejecuta
muchas veces hasta que se cumple una condicin de terminacin.
Las sentencias disponibles en J ava para la creacin de bucles son
f or , whi l e y do- whi l e. Este captulo pretende introducirle en el
manejo de ambos tipos de sentencias.
Las sentencias selectivas controlan el flujo de ejecucin en los
programas basndose en el valor de una expresin slo conocida
en tiempo de ejecucin. En J ava existen slo dos tipos de senten-
cias selectivas, i f y swi t ch, en las que la primera se puede con-
siderar a su vez dividida en dos clases, i f e i f - el se.
Las sentencias repetitivas permiten repetir una accin o grupo
de acciones mientras o hasta que se cumple una determinada
condicin. J ava dispone de tres sentencias de este tipo: f or ,
whi l eydo- whi l e.
3.1. LA SENTENCIA if
La sentencia i f permite en un programa tomar la decisin sobre la ejecucidno ejecu-
cin de una accin o de un grupo de acciones, mediante la evaluacin de una expresin
lgica o booleana. La accin o grupo de acciones se ejecutan cuando la condicin es cier-
tay en caso contrario no se ejecutan y se saltan. Los formatos para una sentencia i f son:
i f ( condi ci n)
sent enci a ;
if ( condi ci n)
i
/ / secuenci a de sent enci as
Ejemplo
. . .
double por cent aj e = 0;
/ * Si l as vent as son i gual es o super i or es a 300000 pt s.
per ci be un 12% de comi si n, en caso cont r ar i o
no cobr a comi si n */
por cent aj e = 0. 12;
i f ( vent as >= 300000)
i nt pr i ma = ( i nt) ( vent as * por cent aj e) ;
Decisiones y bucles 73
Nota: La colocacin de un signo de punto y coma despus de la condicin de
una estructura i f constituye un error en la lgica del programa:
if ( condi ci n) ;
// si se cumpl e l a condi ci n no se ej ecut a ni nguna acci n
sen t en c i a;
3.2. LA SENTENCIA if -else
Esta clase de sentencia i f ofrece dos alternativas a seguir, basadas en la conipro-
bacin de la condicin. La palabra reservada el se separa las sentencias utili/adas
para ejecutar cada alternativa. La sintaxis de la sentencia i f - el se es:
i f ( c o n d i c i o n )
el se
sen t e n c i a 1 ;
sen t enci a2;
i f (condi ci cn)
Si la evaluacin de la condicin es verdadera, se ejecuta la scnteilc.ic// o la
secuencia de sentenciasl, mientras que si la evaluacin es falsa se ejecuta la sew-
tencia2 o la secuencia de sentencias2. Es decir, que las sentencias a realbar tanto
cuando se cumple como cuando no se cumple la condicin podrn ser simples o
compuestas. Posibles errores de sintaxis seran:
i f ( condi ci on) ;
s e nt enci a 1 ;
else
s en t e nc i a2;
Nota: Es necesario recordar que J ava proporciona un operador, el condicional,
capaz de reemplazar instrucciones i f - e 1 s e.
Ejercicio
Adivinar un nmero pensado por la computadora.
74 Java 2. Manual de programacin
i f ms cer cana, es ci er i r
zor zepor . de a1 seg.i ndo */
import 4a ~a . i o . ~;
publ i c cl ass J uego
/ * a pesar de l a sangr a, est e
el se cor r esponde al
pr i mer i f */
publ i c stati c void mai n ( St r i ng ar gs[ ] )
{ I npdt St r ear r Reader i sr = new I nput St r ear nReader ( Cyst em. 1n) ;
Bcf f er edReader br = new Buf f er edReader ( i sr ) ;
Czr-ng cadena;
try .
Syst e- ; . o~t . pr; n: ( "I r. t roduzca un nmer o ent er o ent r e 1 y 3 " ) ;
cader,a = i r . r eaci l i ne ( ) ;
i nt n = ( i nt) ( Mat h. r andom( ) * 3) +1;
// Moz?. . r andr mO devuel ve un cioubie al eat or i o ent r e O. C y 1. 0
i nt I = I nt eger . par seI nt ( cadeca) ;
i f ( i == n)
else
Cystem.oi t . pr i nt l n ( " Acer t " ) ;
Cyst em. out . pr i ct l n ( " No acer t , el nmer o er a " +n) ;
catch(Exceptivn e)
Cys:ei .ozt . pr i nt ; n ( " C. ~dl qui er t i po de er r or " ) ;
\
La estructura i f -e 1 se anterior podra haber sido sustituida por:
Cys:e?.c'~t . pr - ~ni l n ( i == n ? " Acer t " : " No acer t , er a " +n) ;
3.3. LAS SENTENCIAS if E i f - el se ANIDADAS
Es posible que alguna de las sentencias a ejecutar especificadas en una instruccin
i f sea a su vez otra sentencia i f .
i f ( co~di zi cl )
i f (condl ci 6n2)
el se
c e.? t e;: cl a : ;
sei t eEci a2;
i f ( c o n d i c i n l )
t
i f ( condi ci n2)
s ent e nc i a 1 ;
else
/ * l a cal abra r eser vada el se se
cor r esponde cor l a sent enci a
sen t e n c i a 2 ;
Decisiones y bucles 75
if ( c ondi c i nl j
if
else
( condi ci 6n2 j
sentencial;
c en t e n c i a 2 ;
if ( Co n d i i l c n 3 )
sent en ci a 3;
else
s e nt e nc i ad;
else
/ / puede exi sti r ani i aci n
/ / en ambas ramas
if ( condi ci ni )
sen t e n c i a l ;
else
if ( condi ci n2 j
sen t e nc i a2;
/ / l a ani daci n en l a rama el se
/ / puede ser u;: i f
if (rondi ci cl j
seri t e n cia; ;
else
/ x E l 15 r, :?-el se ari:3adz
pUede ser i na mks de i a
secuenci a de sezterei as
que se pueder. C G ~ O Z ~ ~ en
cualq,iera de l ac ZaTas */
if ( c o n d i ci 5,: )
sen t e:: i i a 1 ;
else
if ( cocdi ~i ~~2)
else
ser t en ci a 2 ;
s ec r e,? ci 5; 3 ;
/ * l a an:iac:n en l a r a x ~
el se puede ser czr z
i f-eLse */
La construccin i f -el se-i f mltiple, tambin denominada de a/ t ernat i i u~
mltiples i f -el se, es muy habitual en programacin y se suele escribir de la
forma siguiente:
if ( c ondi c i nl j
s e n t e n c i a l ;
else if ( c ondi c i on2)
sen t e nc i a2;
else if (condi ci n3j
sen t e nc i a3;
. . .
else if (condi ci nN)
else
sen tenci a N ;
sentenci ax; //opci onal
La sentencia anterior realiza una serie de test en cascada hasta que se produce
una de las siguientes condiciones:
Una de las clusulas especificadas en las sentencias i f se cumple; en ese caso
la sentencia asociada se ejecuta y no se tiene en cuenta el resto.
76
Java 2. Manual de programacin
Yinguna de las clusulas especificadas se cumple y entonces, si existe, se eje-
cuta la ltiiiia sentencia el se.
Ejercicio
Programa que ordena de mayor a menor tres nmeros ledos desde teclado.
import a: 2 . - 3 . * ;
publ i c cl ass Oruiena3
publ i c stati c void rnair, ( St r i ng( : ar yc)
l .,p~~tstrcJ m"eader i cr = new I nputst rearnxeader (S!ystem. i n) ;
I -,i fi eredReader hi = new BufferedReader ( i cr ) ;
sr1-i ng zzciena;
double a, 12, c;
t=Y
?ycteT. ci t. pri rat ("2F.tr-oduzi a ' ~ 3 nmer o " ) ;
.-acier,^ = br . reaciLine ( ) ;
i bl e ci l = new Cioibie ( cadena) ;
~m. oi i t. pri nt ( " I nt oduzca ot r o i ni erc " ) ;
cdci enz = lar. reaaL i ne ( 1 ;
I ?c~bl e 62 = new X & l e (caaer,a) ;
Sycterri .out . pri nr ( " I n~r oaut c a e; t er cer n?,ero " ) ;
iaciena = hr . readLi i .e ( ) ;
Prxble ci3 = new 3cbl e (caCena) ;
b = d2. dsubl eVal ue ( ) ;
~ - d3. dsubl eVal ue ( 1 ;
i f ( a > b)
. -
i f (o > c )
else
Systeri .out, .prl r?ti r, (af" " t bT" " Cc) ;
i f ( c > a )
else
Syct e?. cct . pr i nt l n ( c ~" "tat" " A - - ) ;
Syct em. ~u; . ~r i ct l n ( a+" " Act " " +b) ;
else
i f (a -, c )
else
3- - i em. ou~. or i r , t l n ( b t " "*;;,t" " +c) ;
i f ( c > I =)
else
syctei . oct. pri nti r. (i t" " +b+" " +a) ;
Systerr,.out . pri rl tl n (b+" " ~c t " " r a) ;
1
catch(2xcecr:on e )
' I
Decisiones y bucles 77
Ejercicio
Obtener las soluciones, reales e imaginarias, de una ecuacin de segundo grado.
import j ava. i o. *;
public Class Ecuaci on
i
public static void mai n ( St r i ng[ ] ar gs)
{
I nput St r eamReader i sr = n e w I nput St r eamReader ( Syst er n. i n) ;
Buf f er edReader br = n e w Buf f er edReader ( i sr ) ;
St r i ng cadena;
double a, b, c, xl , x2;
Syst em. out . pr i nt l n ( " I nt r oduzca l os coef i ci ent es" ) ;
Cyst em. out . pr i nt ( " a ? " ) ;
cadena = br . r eadLi ne ( ) ;
Doubl e dl = n e w Doubl e ( cadena) ;
Syst em. out . pr i nt ( "b ? " ) ;
cadena = br . r eadLi ne( ) ;
Doubl e d2 = n e w Doubl e( cadena) ;
Syst em. out . pr i nt ( " c ? " ) ;
cadena = br . r eadLi ne ( ) ;
Doubl e d3 = n e w Doubl e ( cadena) ;
a = dl . doubl eval ue ( ) ;
b = d2 . doubl eval ue ( ) ;
c = d3. doubl eval ue ( ) ;
if ( a==O)
Syst em. out . pr i nt l n ( " No es ecuaci n de segundo gr ado" ) ;
else
i
double d =( b*b- 4*a*c) ;
if ( d>O)
i
xl = ( - bt Mat h. sqr t ( d) ) / ( 2*a) ;
x2 = ( - b- Mat h. sqr t ( d) ) / ( 2*a) ;
Syst em. out . pr i nt 1n ( " xl = " t xl ) ;
Syst er n. out . pr i nt l n( " x2 = " t x2) ;
1
else if ( d==O)
(
x1=x2= ( - b) / ( 2*a) ;
\
else
i
'
Cyst er n. out . pr i nt l n( " x1 = x2 = " t xl ) ;
d=Mat h. abs ( d) ;
Syst em. out . pr i nt l n( " x1 = " +- b/ ( 2*a) t " +" +
Mat h. sqr t ( d) / ( 2*a) t " i " ) ;
78
Java 2. Manual de programacin
Syst em. out . pr i nt l n( " x2 = " t - b/ ( 2*a) +" - "f
Mat h. sqr t ( d) / ( 2*a) t " i " ) ;
I
i
cat ch( Except i on e)
i
Syst em. out . pr i nt l n ( " Excepci n " t e) ;
/ / Except i on es super cl ase
l
I
I
3.4. LA SENTENCIA s wi t c h
Cuando se tienen muchas alternativas posibles a elegir, el uso de sentencias i f -
el se- i f puede resultar bastante complicado, siendo en general ms adecuado en
estos casos el empleo de la sentencia swi t ch. La sintaxis de una sentencia
swi t ch es la siguiente:
swi t ch ( e x pr e s i on)
I
case c o n s t a n t e l :
sen t e n ci a s 1 ;
/ / si se t r at a de ml t i pl es acci ones no es necesar i o
/ / encer r ar l as ent r e l l aves
br eak;
case cons t ant e2:
s e nt en ci a s2;
br eak;
. . .
case const ant eN:
' s e n t en ci a sN;
br eak;
sen t e n c i a sX;
def aul t
i
Importante: En la sentencia swi tch la expresin ha de devolver un resulta-
do de tipo entero o carcter. La sentencia break se utiliza con la sentencia
swi tch para abandonar dicha sentencia tras la ejecucin de las sentencias
asociadas a una determinada clusula case,
El funcionamiento de la sentencia swi t ch es el siguiente:
Decisiones y bucles 79
Cuando el valor de la expresin coincide con una constante de case, se
ejecutan el grupo de sentencias asociadas y si la ltima sentencia de un grupo
es break, tras llegar a ella, el programa sale de la estructura swi tch. Si la
sentencia break se omite, la ejecucin sigue en el siguiente grupo de senten-
cias, con independencia del valor de la constante case. Generalmente la pala-
bra reservada break se omite cuando se desea ejecutar la misma accin para
dos o ms constantes de case.
La clusula def aul t es un caso especial de case. Las sentencias que vie-
nen a continuacin de ella se ejecutan si ninguna de las constantes que siguen
a las diferentes sentencias case coincide con el valor de la expresin de
swi tch.
Para comprender mejor cmo utilizar la sentencia swi tch consideremos un
programa que muestra un men de opciones (una de sus aplicaciones ms tpicas).
Ejemplo
Men de opciones:
i mpor t j ava. i o. *;
publ i c cl ass Cel ect Mul t
i
publ i c st at i c voi d mai n ( St r i ng[ ] ar gs)
t
t ry
( Syst em. out . pr i nt l n ( i i ~ ~ ~ i i ) ;
Syst em. out . pr i nt l n ( " C. Car gar ar chi vo" ) ;
Syst em. out . pr i nt l n ( " G. Gr abar ar chi vo" ) ;
Syst em. out . pr i nt l n ( " I . I mpr i mi r ar chi vo" ) ;
Syst em. out . pr i nt l n ( " S. Sal i r del pr ogr ama" ) ;
Syst em. out . pr i nt ( " El i j a opci n ( C, G, I , S) " ) ;
char opci on =( char ) Cyst em. i n. r ead( ) ;
Syst em. i n. ski p( Syst em. i n. avai l abl e( ) ) ;
swi t ch ( opci on)
t
case ' C' . . case ' c' :
Cyst em. out . pr i nt l n( " Ha sel ecci onado Car gar ar chi vo" ) ;
br eak;
case ' G' : case ' g' :
Syst em. out . pr i nt l n( " Ha sel ecci onado Gr abar ar chi vo" ) ;
br eak;
case ' 1' . . case ' i ' :
Syst em. out . pr i nt l n( " Ha sel ecci onado I mpr i mi r ar chi vo" ) ;
br eak;
Syst em. out . pr i nt l n ( "Ha sel ecci onado Sal i r de pr ogr ama") ;
br eak;
case ' S I : case ' s' :
80
Java 2. Manual de programacin
defaul t:
Syst em. out . pr i nt l n ( " Opci n no vl i da" ) ;
1
1
catch ( Except i on e)
i )
En el programa anterior, cuando se pulsa la tecla s, se visualiza el mensaje Ha
sel ecci onado Sal i r de pr ogr ama, y si pulsa la tecla Z, aparece el de
Opci n no vl i da. Observe que se utilizan dos clusulas case para permitir
al usuario introducir letras maysculas o minsculas. Es decir, los mltiples case
se utilizan para permitir que una serie de condiciones proporcionen la misma res-
puesta.
Nota: En una sentencia swi t ch no pueden aparecer constantes case iguales,
pero las sentencias a ejecutar en una sentencia swi t ch pueden ser a su vez
sentencias swi t ch y las sentencias swi t ch anidadas s pueden tener cons-
tantes case iguales.
3.5. LA SENTENCIA for
El bucle f or est diseado para ejecutar una secuencia de sentencias un nmero
fijo de veces. La sintaxis de la sentencia f or es:
for ( i ni c i al i z ac i n; condi ci n de t ermi naci n; i ncrement o)
sent enci as; / / desde O a un bl oque del i mi t ado por { I
Las s e nt e nc i as podrn ser cero, una nica sentencia o un bloque, y sern lo
que se repita durante el proceso del bucle.
La i n i c i a l i z a c i n fija los valores iniciales de la variable o variables de
control antes de que el bucle f or se procese y ejecute solo una vez. Si se desea ini-
cializar ms de un valor, se puede utilizar un operador especial de los bucles f or
en J ava, el operador coma, para pegar sentencias. Cuando no se tiene que iniciali-
zar, se omite este apartado; sin embargo, nunca se debe omitir el punto y coma que
acta como separador.
La condi ci n d e t ermi na ci n se comprueba antes de cada iteracin del
bucle y ste se repite mientras que dicha condicin se evale a un valor verdadero.
Si se omite no se realiza ninguna prueba y se ejecuta siempre la sentencia f or .
Decisiones y bucles 81
El i n cremen to se ejecuta despus de que se ejecuten las sen t en ci a s y antes de
que se realice la siguiente prueba de la condicin de terminacin. Normalmente
esta parte se utiliza para incrementar o decrementar el valor de Mas variables de control
y, al igual que en la inicializacin, se puede usar en ella el operador coma para pegar sen-
tencias. Cuando no se tienen valores a incrementar se puede suprimir este apartado.
En esencia, el bucle f or comprueba si la condi ci n de t ermi naci n es
verdadera. Si la condicin es Verdadera, se ejecutan las sentencias del interior del
bucle, y si la condicin es,fulsa, se saltan todas las sentencias del interior del bucle, es
decir, no se ejecutan. Cuando la condicin es verdadera, el bucle ejecuta una iteracin
(todas sus sentencias) y a continuacin la variable de control del bucle se incrementa.
Nota:
Cada parte del bucle f or es opcional.
Es frecuente que 14s variables de control de un f or slo se necesiten en el
bucle, en cuyo caso pueden declararse en la zona de inicializacin.
Por ejemplo, para ejecutar una sentencia 1 O veces se puede utilizar cualquiera
de los dos siguientes bucles f or :
f or ( i nt i =l ; i <=l O; i ++) i nt i ;
Syst em. out . pr i nt l n( i ) ; f or ( i =l ; i <=l O; i ++j
Syst em. out . pr i nt l n ( i ) ;
/ / Syst er n. out . pr i nt l n( i j ; Syst em. out . pr i nt l n( i ) ;
//i no est def i ni da / / i val e 11
En estos ejemplos, la sentencia f or inicializa i a 1, comprueba que i es menor
o igual a 1 O y ejecuta la siguiente sentencia que muestra el valor de i. A continua-
cin se incrementa i y se compara con l O, como todava es menor, se repite el
bucle hasta que se cumpla la condicin de terminacin (i = 11).
Si en lugar de una sola sentencia se desea ejecutar un grupo de sentencias, stas
se encierran entre llaves.
for ( i =l ; i <=10; i ++)
{
Syst er n. out . pr i nt l n ( i ) ;
Syst em. out . pr i nt l n( " i * 10 = " +i *l Oj ;
\
El siguiente bucle f or, sin embargo, no ejecuta ninguna sentencia, slo la ini-
cializacin y los sucesivos incrementos de la variable de control hasta alcanzar la
condicin de terminacin:
for ( i nt i =l ; i <=2000000000; i +t ) ;
82
Java 2. Manual de programacin
Los ejemplos anteriores muestran un incremento de la variable de control del
bucle, con lo que la cuenta, realmente, era siempre ascendente. Un bucle f or puede
tambin decrementar su variable de control produciendo un bucle que cuente en
sentido descendente.
f or ( i nt 1=10; i >=l ; i - )
Syst em. out . pr i nt l n( i ) ;
Nota: La variable de control de una sentencia f or puede ser de cualquier tipo
simple.
for (dxble i =10; i >=l ; i -0. 5) for (&ar i='a' ; i <=' z' ; i ++)
Syst em. out . pr i nt l n( i ) ; Syst em. out . pr i nt ( i ) ;
La expresin de incremento de un bucle f or no siempre sern sumas o restas sim-
ples. Se puede utilizar cualquier expresin que tenga sentido en el problema que se est
resolviendo. As por ejemplo, para visualizar los valores 1 I 2 I 4 I 8 I 1 6 3 2 I 6 4 I 12 8
se puede utilizar la expresin i * 2 para realizar el incremento.
f or ( i =l ; i < 200; i *=2)
Syst em. out . pr i nt l n ( i ) ;
Es posible usar el operador coma en las clusulas de inicializacin e incremento
f or ( i =O, j =14; ( i +j >= O) ; i ++, j - =2)
i
Syst em. out . pr i nt ( i +" + " +j +" = " ) ;
Syst em. out . pr i nt l n( i +j ) ;
1
Cada parte del bucle f or es opcional, de forma que se pueden omitir las sec-
ciones de control si ese tratamiento es el adecuado para el problema a resolver. Por
ejemplo, el siguiente bucle f or incrementa la variable de control del bucle, con
independencia del mecanismo de iteracin:
f or ( i =l ; i < 10; ) i t +;
O bien se puede omitir la seccin de inicializacin:
i nt i =O;
f or ( ; i < 10; i ++)
Syst em. out . pr i nt l n ( i ) ;
Decisiones y bucles 83
Es posible poner como condicin en un bucle f or cualquier expresin de tipo
bool ean, incluso expresiones no relacionadas con la variable de control.
Ejercicio
Determinar si un nmero entero ledo desde teclado es o no primo.
i mpor t j ava. i o. *;
publ i c cl ass NumPr i mo
publ i c st at i c voi d mai n ( St r i ng ar gs [ I )
I nput St r eamReader i sr = new I nput St r eamReader ( Syst em. i n) ;
Buf f er edReader br = new Buf f er edReader ( i sr ) ;
St r i ng cadena;
t ry
i
Syst em. out . pr i nt ( " Deme un nmer o ent er o " ) ;
cadena = br . r eadLi ne ( ) ;
i nt i = 1nt eger . par seI nt ( cadena) ;
bool ean pr i mo = t r ue;
i nt r ai z2 = ( i nt ) Mat h. sqr t ( i ) ;
f or ( i nt d=2; pr i mo && d <= r ai z2; d++)
i f ( i % d == O)
pr i mo = f al se;
i f ( i == O 1 1 ! pr i mo)
el se
Syst em. out . pr i nt ( " El " +i +" es compuest o" ) ;
Syst em. out . pr i nt ( " El " +i +" es pr i mo" ) ;
i
cat ch( Except i on e)
i
1
Syst em. out . pr i nt l n ( " Cual qui er t i po de er r or " ) ;
3.6. LA SENTENCIA break
En apartados anteriores se us la sentencia br eak con la sentencia swi t ch para
abandonar dicha sentencia tras la ejecucin de las sentencias asociadas a una deter-
minada clusula case. La sentencia br eak se puede utilizar tambin con las sen-
tencias repetitivas, whi l e, do- whi l e y f or para romper o salir de un bucle
cuando se produce alguna situacin especial.
84
Java 2. Manual de programacin
public cl ass Br l
public stati c void mai n ( St r i ng[ ] ar gs)
1
i nt n;
for ( n=O; n<100; n++)
t
Syst em. out . pr i nt ( n+" " ) ;
i f ( n == 50) break;
I
1
I
Si hay bucles anidados, una sentencia break colocada en el bucle interno sus-
pende nicamente la ejecucin de dicho bucle interior.
public cl ass Br 2
public stati c void mai n ( St r i ng[ ] ar gs)
i
i nt n, m;
for ( m=O; m<10; m++)
i
f or ( n=O; n<100; n++)
i
Syst em. out . pr i nt ( n+" " ) ;
i f ( n == 50) break;
I
Syst em. out . pr i nt l n( ) ;
1
Para abandonar una serie de estructuras anidadas puede utilizarse break e ti -
que t a ; , donde la etiqueta puede ser cualquier identificador vlido. Cuando se eje-
cuta esta sentencia, el control se transfiere a la sentencia siguiente a un bloque
etiquetado con dicho nombre de eti queta seguido por el signo de dos puntos,
que, adems, debe ser el que contenga la sentencia break e t i q u e t a .
public cl ass Br 3
I
public stati c void mai n ( St r i ng[ ] args)
i
i nt n, m;
par ar :
t
for ( m = O; m < 10; mtt)
Decisiones y bucles 85
f or ( n = O; n < 133; n--1
if ( r n = y - 2 ) break parar;
Syl i tern.o;t . pr i nt ( n i " " ) ;
i f ( n 53) break;
Systeni .ou: . pr i nt l n ( ) ;
} / / f ; n del bl oque ccn l a et i quet a
Syct er n. out . pr i nt l n0;
Syctern. out . pr i nt l n ( " FI N" ) ;
3.7. LA SENTENCIA continue
La sentencia cont i nue es similar a br eak, pero slo se puede usar en bucles,
y, adems, cont i nue no salta fuera del bucle, simplemente salta sobre las sen-
tencias restantes del bucle y transfiere el control al final del bucle ejecutndose la
siguiente iteracin del mismo. En consecuencia, una sentencia cont i nue se uti -
liza para comenzar inmediatamente la siguiente iteracin de un bucle. Se puede
utilizar cont i nue con bucles f or , whi l e y do- whi l e. El formato de CCR-
t i nue es:
conti nue ;
Una sentencia cont i nue en cualquier bucle f or salta inmediatamente a la
expresin de control del bucle. En otras palabras, dado este bucle:
f or ( s e nt e nc i a; expresini; expresin2)
i
i f ( e x pr e s i j n3) conti nue;
sen t enci a ;
i
si expr esi n3 es verdadera, la sentencia cont i nue hace que se evalUe inme-
diatamente expr esi n2, saltndose todas la/s sentencia/s a ejecutar que viene/n
despus de ella. J ava permite el uso de etiquetas en la sentencia cont i nue
conti nue e ti que t a ;
86 Java 2. Manual de programacin
con las que especificar el bloque al que se aplica.
publ i c class Ccr t i
public stati c voi d rnai r: (c;t r:ncj [ 1 clrcq:;)
i nt n, rn;
uno :
f or (rn =O; r r <l O ; m t t )
f or ( n=O; n i l O C ; n++)
Syst em. out . pr i r . t ( ni " " ) ;
i f (r. == 59) conti nue uno;
Cyst er . oct . pr i nt . . n ( ) ;
Syst en. oct . pr i nt l n0 ;
Cystem.ci t . pr i nt l n ( " F I N " ) ;
3.8. DIFERENCIAS ENTRE continue Y break
La sentencia cont i nue fuerza una nueva iteracin, mientras quc break fuerza la
salida del bucle. En el siguiente ejemplo, se muestra la diferencia entre ambas sen-
tencias. En el se observa como el mensaje " E l bucl e" nunca se visualiza, pero
en cada bucle por una causa diferente ( br eak en el primero y cont i nue en el
segundo).
t
break;
Sys: ern. out . pr i n~l n ( " 21 bucl e" ) ;
f or ( 1 =C; - <=; o; 1 j t t )
conti nue ;
Cyst er n. out . pr l nt i n ( " E l bucl e" ) ;
Otro ejemplo ms completo para observar la diferencia de funcionamiento entre
break y cont i nue es el que se muestra a continuacin:
L
i
Decisiones y bucles 87
publ i c cl ass BryC
i
publ i c stati c voi d mal - , ( Y t - i n j [ ] .,LJ L)
i f (cuenta > 5) conti nue;
Cys t em. out . j r i nt (ciier.t,i.+" " 1 ;
I
Cyctem.o?i t . pr ~nt l r , ( ) ;
Syst em. out . pr i nt i n ( " Despus del bi cl e: ci enta = ' I - -" - 2cT. : <) ;
Cyst em. out . pr i nt 1n ( "Comi eri zc bel bucl e ' co?, r r c k " ) ;
f or ( c; i enta, 7 1; c1uent.a 112; (,L i entat+)
{
i f ( cuent a > 5) break;
Cyst em. out . pr i nt (cue::t.ci+" " ) ;
I
Syst em. out . pr ; r, t 1 n ( ) ;
Syst em. out . pr i nt l n ( " 3espus del sucl e: cuenta 1 "~cuer.:a) ;
I
AI ejecutar el programa se observa que los bucles f or cuentan hasta 5 y se
detienen. Despus del primer bucle, sin embargo, el valor de cuenta es 11, y
despus del segundo es 6. La razn es que en el segundo bucle br eak fuerza la
terminacin y salida del bucle. Sin embargo, la sentencia conti nue, al igual
que break, slo debe utilizarse cuando no existe otra alternativa. Por ejeniplo.
el listado
publ i c class Cont 2
publ i c stati c voi d mai n ( Ct r i nq: ; ar qc)
i
f or ( i nt 2 = O ; i < 10; i t +)
t
if (i != 2) conti nue;
~yst em. out . pr i nt l n( " ; = " - 1) ;
88
Java 2. Manual de programacin
muestra slo una lnea, i 2. Si i es igual a O I 1, 3 I 4, 5, 6, 7 I 8, 9,
cont i nue salta sobre la sentencia Syst em. out . pr i nt l n. Este caso es un mal
ejemplo de aplicacin de cont i nue, ya que se puede evitar reescribiendo el cdi-
go de esta manera:
=
publ i c class Si nCont
publ i c stati c void r ai n ( St r i ng[ ] a r T s )
f or ( i nt : = O ; I < 13; ;tt)
if (: == 2 )
Cyst em. o 1 t . pr i nt I ri ( " i =
"ti) ;
3.9. LA SENTENCIA while
El bucle whi l e ejecuta una sentencia o bloque de sentencias mientrus se cumple
una determinada condicin; es decir, la accin o acciones se repiten mientras la con-
dicin es verdadera. La sintaxis general de la sentencia whi l e es:
whi l e ( expresin) whi l e (expres i n)
sen ten ci a ;
{
//secuenci a de sent enci a- .
\
Si expresin es verdad, la sentencia o grupo de sentencias se ejecutan.
Cuando la expresin es falsa, el bucle whi l e se termina y el programa reanu-
da su qjecucin en la primera sentencia despus del bucle.
i nt i =l ;
whi l e ( 1 <= 100)
Cyct em. out . pr i nt l n ( " i = " +I ) ;
:++:
iiiilc ejectitd la primera iteracin ya que 1 tiene un valor menor que 100.
t incrementa su valor en 1 a cada iteracin, cuando I sea igual a 1 O 1, la i
I
1 ~ <=I O O ser falsa y el bucle se terinina.Un ejeniplo de su aplicacin es
i 1 < . ;-)I ogi aina:
Decisiones y bucl es 89
i mpor t j ava. i o. *;
publ i c cl ass Whi l e1
i
publ i c st at i c voi d mai n ( St r i ng ar gs [ I )
i
I nput St r eamReader i sr = new I nput St r eamReader ( Syst em. i n) ;
Buf f er edReader br = new Buf f er edReader ( i sr ) ;
St r i ng cadena;
i nt n=O ;
t ry
i
Syst em. out . pr i nt ( " Deme un nmer o ent er o " ) ;
cadena = br . readL i ne ( ) ;
n = I nt eger . par seI nt ( cadena) ;
1
cat ch ( Except i on e)
i 1
i nt i =l ;
whi l e ( i <= n)
i
Syst em. out . pr i nt l n ( " I t er aci n: " +i ) ;
i ++;
1
1
1
La sentencia whi l e es adecuada para muchas tareas. Un uso tpico de whi l e
en programacin es asegurar entradas de usuario vlidas. El programa solicita al
usuario si desea o no continuar con el programa mediante mensajes adecuados y
mientras el usuario no indica expresamente una respuesta negativa, no (por ejem-
plo, mediante la pulsacin de la letra n o N), se sigue ejecutando el bucle.
i mpor t j ava. i o. *;
publ i c cl ass Whi l e2
i
publ i c st at i c voi d mai n ( St r i ng[ ] ar gs)
i
t ry
i
Syst em. out . pr i nt ( " ; Desea cont i nuar ? ( C / N ) " ) ;
char r esp =( char ) Syst em. i n. r ead( ) ;
i nt num = Syct em. i n. avai l abl e~) ;
Syst em. i n. ski p ( num) ;
whi l e ( r esp != ' n' && r esp != ' N' 1 1 num != 2)
Cyct em. out . pr i nt l n ( " Pul se n o N y RETERN par a sal i r " ) ;
Cyst em. out . pr i nt (" Desea cont ; nuar ? ( S I " ) " ) ;
r esp =( char ) Syst em. i n. r eadO;
90
Java 2. Manual de programacin
catchii ., I II 1
Al e-jecutar el prograiiia se solicita ti na rcspiicstn al iisiiario y. iiiicntras el carc-
ter tecleado iio sea i i i i a letra N o n. el bucle se i-cpetiri iiideliriid~iiiiciitc. Otro tiso tpi-
co de wh: l e es procesar entradas de teclado. 1;ii i i i i i chx aplicacioiies se cuele
so 1 i c i t ar a I ti siia r i o q Liei n t roduzca datos re pe t i daiiie ii t e h ;i s t a q i i e d i c h o tis i i ar i o i n t ro-
diizca iin \.alar que se coiisiciera de /c./.ini/itrc,iti/i. t;l lisndo qiie se iiiuestra a conti-
nuacin suiixi una secuencia arb traria de iiiiiiictos iiitroclucidos por teclado hasta qiie
se produce uii valor concreto (cii niicstro c:iso cl cero) qiic tcriiiina el bucle.
import i r * 3. 1 .';
publ i c cl ass 15 11-
publ i c stati c void I I ( 1 1 7 ~ 1 1 I )
Decisiones y bucles 91
La sentencia whi l e ejecuta el bloque de sentencias, mientras que num no sea
igual a cero. Cuando el usuario introduce un valor de entrada cero se termina el
bucle y se presenta en consola la suma resultante. Si el usuario comienza por intro-
ducir un cero, el bucle no se ejecutar y la suma ser cero. Otro uso comn de la
sentencia whi l e es procesar dalos desde un archivo en disco. Esta operacin es
similar a la entrada de datos por teclado con la diferencia de que los valores de
entrada se leen desde el archivo.
Un problema frecuente en programacion se produce cuando aparecen bucles
infinitos. Un bucle infinito es aquel que nunca termina. Los bucles whi l e infinitos
se producen debido a que la condicin que se comprueba nunca se hace falsa, de
modo que el bucle whi l e ejecuta repetidamente sus sentencias una y otra vez. Si
se entra en un bucle infinito se podr salir de l mediante la pulsacin conjunta de
las teclas GYRI, y BRFAK ( r xi , tr i i ?mi <)
3.10. LA SENTENCIA do-while
La sentencia do- whi l e es similar a la sentencia whi l e, excepto que la e x pr e -
sin se comprueba despus de que el bloque de sentencias se ejecute (mientras
que la sentencia whi l e realiza la prueba antes de que se ejecute el bloque de sen-
tencias). La sintaxis de la sentencia do- whi l e es:
do
while (expresin) ;
sen t en ci a ;
do
sentencias;
while (expresin) ;
La/s s e n t e n c i a / s se ejecutan y, a continuacin, se evala la e x pr e s i n.
Si la expresin se evala a un valor verdadero, las sentencias se ejecutan de nuevo.
Este proceso se repite hasta que expresin se evala a un valor falso, en cuyo
momento se sale de la sentencia do- whi l e. Dado que el test condicional se rea-
liza al final del bucle la sentencia o bloque de sentencias se ejecuta al menos una
vez.
Ejemplo
public class DoWhi l el
i
public static void mai n ( St r i ng[ ] args)
i
int i = 1;
while ( i < 6)
i
92
Java 2. Manual de programacin
Cyst em. out . pr i nt l n ( " Bucl e whi l e " t i ) ;
it+;
i
i = 1;
do
i
Syst em. out . pr i nt l n ( " Bucl e d o - W~L Lc "+i ) ;
i t +;
while ( i < 6) ;
Cuando se ejecuta este programa, se visualiza:
Si se modifica el archivo anterior de modo que la expresin sea falsa la primera
vez que se ejecutan los bucles se puede observar la diferencia entre las sentencias
whi l e y do- whi l e.
Ejemplo
public class DoWhi l e2
public static void mai n ( St r i ng/ ] ar gs)
int i = 6;
while ( i < 6)
t
Syst em. out . pr i nt l n ( " Bucl e whi l e " t i ) ;
i +t ;
}
i = 6;
do
i
Syst em. out . pr i nt l n ( " Bucl e do- whi l e " t i ) ;
i t +;
while ( i < 6) ;
1
Decisiones y bucles 93
Al ejecutar el programa anterior, se visualiza:
Bucl e do- whi l e 6
Ejemplo
Calcular el nmero de aos que ha de estar invertido un capital para que se dupli-
que. Se proporcionarn desde teclado el tanto por ciento de inters y el capital
inicial.
import j ava. i o. *;
public class I nt er es
i
public static void mai n ( St r i ng[ ] ar gs)
t
I nput Ct r eamRedder i sr = new I nput St r eamReader ( Syst em. i nj ;
Buf f er edReader br = new Buf f er edReader ( i sr j ;
St r i ng cadena;
double capi t al I ni ci a1 = O;
double capi t al Fi na1 = O;
double i nt er es=O;
t ry
(
Cyst er n. out . pr i nt ( " I ndi que el capi t al i ni ci al " ) ;
cadena = br . r eadLi ne ( ) ;
Doubl e dl = new Doubl e( cadena) ;
capi t al I ni ci a1 = dl . doubl eVal ue( ) ;
capi t al Fi na1 = Capi t al I ni ci al ;
Syst em. out . pr i nt ( " I ndi que el % de i nt er s " ) ;
cadena = br . r eadLi ne( ) ;
dl = new Doubl e( cadena) ;
i nt er es = dl . doubl eval ue ( ) ;
int aos = 0;
do
I
aos = aos + 1;
capi t al Fi na1 = capi t al Fi na1 + capi t al Fi nal *i nt er es/ l GO;
1
while ( capi t al Fi na1 < 2 * capi t al I ni ci al ) ;
Syst em. out . pr i nt l n ( " El nmer o de aos que ha de "+
" est ar i nver t i do par a poder "+
" dupl i car se es "+ aos) ;
I
cat ch( Except i on e)
(
1
1
1
Importante: En un bucle do - whi 1 e si la expresin se evala a un valor ver-
dadero, las sentencias se ejecutan de nuevo.
4.3.
4.4.
4.5.
4.6.
4.7.
4.8.
4.9.
4.1 O.
4.1 I .
4.12.
4.13.
Acceso a Datos y Mtodos.
Utilizacin de mtodos.
Paso de parmetros.
Paso de parmetros por valor.
Paso de parmetros por referencia.
Constructores.
Modificadores de acceso.
pr i vat e.
pr ot ect ed.
publ i c.
Recursividad.
95
96
Java 2. Manual de programacin
La programacin en lenguajes procedimentales -tales como
BASIC, C, Pascal, Ada y COBOL- implica estructura de datos,
diseo de algoritmos y traduccin de algoritmos en cdigo. La pro-
gramacin orientada a objetos es un tipo de programacin que
introduce construcciones especficas llamadas objetos, que a su
vez contienen datos y procedimientos. Los objetos hacen la pro-
gramacin ms fcil y menos propensa a errores. Un programa en
J ava implica un conjunto o coleccin de objetos que cooperan
entre s. En este captulo se introducen los fundamentos de pro-
gramacin orientada a objetos: conceptos de clases y objetos,
declaracin de clases, creacin de objetos, manipulacin de obje-
fos y cmo trabajan los objetos entre s.
4.1. OBJETOS Y CLASES
Un objeto es una coleccin de datos y las subrutinas o mtodos que operan sobre ellos.
Los objetos representan cosas fsicas o abstractas, pero que tienen un estado y un com-
portamiento. Por ejemplo, una mesa, un estudiante, un crculo, una cuenta corriente, un
prstamo, un automvil, ... se consideran objetos. As, ciertas propiedades definen a un
objeto y ciertas propiedades definen lo que hace. Las que definen el objeto se conocen
como campos de datos y el comportamiento de los objetos se define como mtodos.
La Figura 4.1 muestra un diagrama de un objeto con sus campos de datos y mtodos.
I campodato
1 I
campo dato
E L I
I mtodo2 1
Objeto
Fi gura 4.1. Un objeto contiene datos y mtodos
Clases, objetos y mtodos 97
Un objeto Ci rcul o contiene un campo de dato r adi o que es la propiedad que
caracteriza un crculo. El comportamiento de un crculo permite calcular su super-
ficie y su longitud. As, un objeto Ci rcul o se muestra en la Figura 4.2.
campo dato: r adi o
objeto Ci rcul o
mtodo: cal cul ar supe r f i ci e
Figura 4.2.
Las clases son estructuras o plantillas que sirven para definir un objeto. En
una clase J ava, se pueden utilizar datos para describir propiedades y mtodos
que definen su comportamiento. Una clase de un objeto contiene una coleccin
de mtodos y definiciones de datos. Si se disea una clase que representa a un
cliente, no se ha creado un objeto. Un objeto es una instancia (ejemplar, caso) de
la clase C1 i ent e y, por consiguiente, puede, naturalmente, haber muchos obje-
tos de la clase Cl i ente. La creacin de una variable especfica de un tipo par-
ticular de clase se conoce como instanciacin (creacin de instancias) de esa
clase.
Una clase describe la constitucin de un objeto y sirve como plantilla para
construir objetos, especificando la interfaz pblica de un objeto. Una clase tiene
un nombre y especifica los miembros que pertenecen a la clase, que pueden ser
campos (datos) y mtodos (procedimientos). Una vez que se define una clase, el
nombre de la clase se convierte en un nuevo tipo de dato y se utiliza para:
Declarar variables de ese tipo.
Crear objetos de ese tipo.
El siguiente ejemplo representa una clase Ci rcul o que se utilizara para cons-
truir objetos del tipo Ci rcul o:
class Ci r cul o
{
double r adi o =5. 0;
double cal cul ar super f i ci e0
i
return r adi o*r adi o*3. 141592;
98
Java 2. Manual de programacin
objeto 1 de Ci r cul o
Esta clase Ci r cul o es, simplemente, una definicin que se utiliza para decla-
rar y crear objetos Ci r cul o. La clase Ci r cul o no tiene un mtodo mai n y por
consiguiente no se puede ejecutar. Corno estilo de escritura, en este libro se utiliza-
rn nombres que comienzan por maysculas para las clases. La clase se declara con
el siguiente formato:
objeto 2 de Ci r cul o
class Kcmbre
i
/ / cLer po de l a cl ase
El cuerpo de la clase define los miembros uto, mietnbro.s mtodo o ambos.
Excepto en el caso de sohrecurgu, todos los miembros deben tener nombres
distintos.
4.2. DECLARACIN Y CREACIN DE UN OBJETO
Una clase es una plantilla que define los datos y los mtodos del objeto. Un objeto
es una instancia de una clase. Se pueden crear muchas instancias de una clase. La
creacin de una instancia se conoce como insluncicrcicjn.
clase Ci r cul o
\
Fi gura 4.3. Una clase puede tener muchos objetos diferentes
Como ya se ha comentado, una vez que se define una clase, el nombre de la
clase se convierte en un nuevo tipo de dato y se utiliza tanto para declarar varia-
bles de ese tipo, como para crear objetos del inisino. La sintaxis para declarar un
objeto es:
NcrnbreClase combreObj e to;
Ejemplo
Ci rci l o mi ci r cul o; / / decl ar a l a var i abl e mi ci r cul o
Clases, objetos y mtodos 99
La variable mi ci r cul o es una instancia de la clase Ci r cul o. La creacin de
un objeto de una clase se llama creacirjn de una instancia de la clase. Un objeto es
similar a una variable que tiene un tipo clase. La creacin de variables de un tipo de
dato primitivo se realiza simplemente declarndolas, esta operacin crea la variable
y le asigna espacio en memoria:
i n t j ;
I . Creucin de la clase.
2. Declarar los objetos.
3. Crear los objetos.
Una vuriuhle de tipo chse es una vuriable referencia, que puede contener la direc-
cin de en memoria (o referencia) de un objeto de la clase o nul l para una referen-
cia no vlida. La declaracin de un objeto simplemente asocia el objeto con una clase,
haciendo al objeto una instancia de esa clase. Lu declaracin no crea el objeto. Para
crear realmente mi ci r cul o (objeto de la clase Ci r cul o) se necesita utilizar el ope-
rador new con el objeto de indicar a la computadora que cree un objeto mi ci r cul o
y asigne espacio de memoria para ella. La sintaxis para crear un objeto es:
nombr eobj et o = n e w Nombr ecl ase 0 ;
Ejemplo
La siguiente sentencia crea un objeto, mi ci r cul o, y le asigna memoria:
mi ci r cul o = n e w Ci r cul o O ;
Declaracin e Instanciacin
Se pueden combinar la declaracin y la instanciacibn en una sola sentencia con la
siguiente sintaxis:
Nombr eCl ace nombr eobj et o = n e w Nombr eCl aseO;
Ejemplo
Creacin e instanciacin de mi ci r cul o en una etapa:
Ci r cul o mi ci r cul o = n e w Ci r cul o ( ) ;
100 Java 2. Manual de programacin
4.3. ACCESO A DATOSY MTODOS
Despus de que se ha creado un objeto, se puede acceder a sus datos y mtodos uti-
lizando la notacin siguiente:
nombr e0bj et o. dat os
nombr eObj et o. met odo( )
Referencia a un dato de un objeto
Referencia a un mtodo de un objeto
Ejemplo
mi Ci r cul o. r adi o radio de mi ci r cul o
mi Ci r cul o. cal cul ar Cuper f i ci e( ) devuelve la superficie de mi ci r cul o
4.4. UTILIZACIN DE MTODOS
Los miembros de un objeto son los elementos dato, a los que tambin se puede
denominar variables de instancia, y los mtodos. Los mtodos son accioncs que se
realizan por un objeto de una clase. Una invocacin a un mtodo es una peticin al
mtodo para que ejecute su accin y lo haga con el objeto mencionado. La invoca-
cin de un mtodo se denominara tambin llamar a un mtodo y pasar un mensa-
j e a un objeto.
Existen dos tipos de mtodos, aquellos que devuelven un valor nico y aquellos
que ejecutan alguna accin distinta de devolver un nico valor. El mtodo
readI nt es un ejemplo de un mtodo que devuelve un nico valor de tipo i nt .
El mtodo pr i nt l n es un ejemplo de un mtodo que realiza alguna accin distin-
ta de devolver un valor nico.
Nota: Existen dos tipos de mtodos: aquellos que devuelven un nico valor y
aquellos que realizan alguna accin distinta de devolver un valor. Los mto-
dos que realizan alguna accin distinta de devolver un valor se denominan
mtodos void.
La implementacin de los mtodos podra ser como sta:
public class Cuent acor r i ent e
i
private double sal do;
public void deposi t ar (double cant i dad)
sal do = sal do + cant i dad;
sal do = sal do - cant i dad;
public double ot>t.c:rierS~i 1 do ( )
.
return cal do;
La ilumudu o invocucin a un mtodo se puede realizar de dos formas, depen-
diendo de que el mtodo devuelva o no un valor.
1. Si el mtodo devuelve un valor, la llamada al mtodo se trata normalmente
como un valor. Por ejemplo,
int mayor -- mx ( 3, 4) ;
llama al mtodo max (3, 4 ) y asigna el resultado del mtodo a la variable
mayor . Otro ejemplo puede ser la llamada
Syst em. out . pr i nt l n( max( 3, 4) ) ;
que imprime el valor devuelto por la llamada al mtodo max ( 3, 4 ) .
2. Si el mtodo devuelve voi d, una llamada al mtodo debe ser una sentencia.
Por ejemplo, el mtodo pr i nt l n ( ) devuelve voi d. La siguiente llamada
es una sentencia
Syst em. out . pr i nt l n (Ci erra de Cazor l a) ;
Si se considera ahora un objeto mi cuent a de la clase Cuent acor r i ent e
Cuent acor r i ent e mi cuent a;
una invocacin al mtodo depositar tendr el formato
mi Cuent a. deposi t ar ( 2400) ;
Cuando un programa llama a un mtodo, el control del programa se trans-
fiere al mtodo llamado. Un mtodo llamado devuelve el control al llamador
cuando se ejecute su sentencia r et ur n o cuando se alcance la llave de cie-
rre 0).
102 Java 2. Manual de programacin
4.5. PASO DE PARMETROS
La cabecera de un mtodo especifica el nmero y tipo de parmetros formales
requeridos. J ava no soporta parmetros opcionales o de longitud variable. En el
interior de una clase, un mtodo se identifica no sOlo por SLI nombre, sino tambin
por su lista de parmetros formales. Por consiguiente, el mismo nombre de mtodo
se puede definir ms de una vez con diferentes parmetros formales para conseguir
la sobrecarga de mtodos.
Cuando se llama a un mtodo, se deben proporcionar un nmero y tipo
correctos de argumentos. Los argumentos incluidos en la llamada a un mtodo se
conocen como argumentos (parmetros) reales o simplemente argumentos. La
llamada a un mtodo exige proporcionarle parmetros reales (actuales) que se
deben dar en el mismo orden que la lista de parmetros formales en la especifi-
cacin del mtodo. Esta regla se conoce como asociocicii tiel orden de 10s pur&
m etr'os .
Ejemplo
El mtodo i mpr i mi r N imprime un mensaje n veces:
void i rnpri rni rN(Stri ng mensaj e, int n)
i
for (int i =O; i <n; i ++)
Systern.out . pr i nt l n ( mensaj e) ;
1
1. Invocacin correcta
Una invocacin i mpr i mi r N ( "Car chel ej o" , 4 ) imprime la palabra Car chel ej o
cuatro veces. El proceso es el siguiente.
La invocacin a i mpr i mi r N pasa el parametro real cadena,
" Car chel ej o" , al parametro formal mensaj e y el parametro real
4 a la variable n.
Se imprime 4 veces la frase Car chel ej o.
2. Invocacin incorrecta
La sentencia i mpr i mi r N( 4, "Car chel ej o") es incorrecta, ya que el tipo de
dato 4 no coincide con el tipo del parmetro mensaj e y, de igual modo, el
segundo parmetro " Car chel e j o' ' tampoco coincide con el tipo del segundo
parmetro formal n.
Clases, objetos y mtodos 103
La operacin de enlazar (hitiding) los argumentos reales a los argumentos for-
males se denomina puso de urgumetitos. Cuando se llama a un mtodo con ms de
un argumento, dichos argumentos se evalan de modo secuencial, de izquierda a
derecha. Existen dos tipos de paso de parmetros: por valor y por referencia.
4.6. PASO DE PARMETROS POR VALOR
Todos los tipos de datos priinitivos ( i nt , l ong, f l oat , bool ean) se pasan en
los mtodos por valor. En otras palabras, sus valores se copian en nuevas posicio-
nes, que se pasan a la subrutina (mtodo); como consecuencia de esto, si un argu-
mento se cambia dentro de un mtodo, no se cambiar en el programa llamador
original. El siguiente mtodo no producir un cambio en x:
void cambi ar ni dades (f l oat x, f l oat f actor)
. ..
t
x = x * f .,ctor; / / x no se pUede mcdi f i car ec e- --a;acior
El nico mtodo sencillo para obtener un valor que se calcula dentro de una clase
es utilizar un mtodo cuyo tipo no sea voi d que especficamente devuelva un valor.
f l oat cay-oiar (f l oat x, f l oat f act or )
return ( x* f act- or) ; / / el nuevc x se aev;l el ve ai Ll amaaor
I
4.7. PASO DE PARMETROS POR REFERENCIA
Los objetos, incluyendo arrays, se llaman tipos referencia, ya que se pasan en los
mtodos por referencia en lugar de por valor. AI igual que se pueden pasar tipos pri-
mitivos, se pueden tambin pasar objetos a mtodos como parmetros reales.
Existe una diferencia importante entre el paso de un valor de variables de tipos
de datos primitivos y el paso de objetos. El paso de una variable de un tipo primiti-
vo significa, como ya se ha comentado, que el valor de la variable se pasa a un par-
metro formal. El cambio del valor del parmetro local en el interior del mtodo no
afecta al valor de la variable en el exterior del mtodo.
El paso de un objeto significa que la referencia del objeto se pasa a un parme-
tro formal. Cualquier cambio al objeto local que suceda dentro del cuerpo del mto-
do afectar al objeto original que se pasa como argumento. Este tipo de paso de
parmetros se denomina paso por refkrencia.
104 Java 2. Manual de programacin
Ejemplo
El objeto mi ci r cul o de la clase Ci r cul o se pasa como argumento al mtodo
i mpr i mi r ci r cul o ( ) ;
Ci rcul o mi ci rcul o = new Ci r cul o ( 10. O ) ;
i rnpri mi rCi rcul o( mi Ci rcu1o) ;
4.8. CONSTRUCTORES
Un constructor es un tipo especial de mtodo que permite que un objeto se inicia-
lice a valores definidos para sus datos. El constructor tiene exactamente el mismo
nombre que la clase a la cual pertenece; es un mtodo publ i c, es decir, un mto-
do al que puede accederse desde cualquier parte de un programa.
Ejemplo
class MiClase
int micampo ;
public Mi Cl ase (int val or) / / const r uct or
i
1
micampo = val or;
1
El constructor de una clase comienza con la palabra reservada publ i c y despus de
la palabra reservada pub1 i c viene el nombre del constructor seguido por sus argumen-
tos entre parntesis. Cuando se crea un objeto de la clase se deben proporcionar tambin
los argumentos requeridos por el constructor. Los constructores se pueden sobrecargar,
lo que permite construir objetos con diferentes tipos de valores iniciales de datos.
Ejemplo
En la clase Ci r cul o se pueden aadir los siguientes constructores:
Ci rcul o (double r)
i
radi o = r;
Ci rcul o ( )
i
radi o = 4. 0
Clases, objetos y mtodos 105
Para crear un nuevo objeto Ci r cul o de radio 6. O se puede utilizar la siguien-
te sentencia que asigna un valor 6. O a mi ci r cul o. r adi o:
mi ci r cul o = new Ci r cul o ( 6. O) ;
Si se crea un crculo utilizando la sentencia siguiente, se utiliza el segundo cons-
tructor que asigna el radio por defecto 4. O a mi ci r cul o. r adi o:
mi ci r cul o = new Ci r cul o ( ) ;
Advertencia: Los constructores son mtodos especiales que no requieren un
tipo de retorno, ni incluso voi d.
Si una clase no tiene constructores, se utiliza un constructorpor defecto que no
inicializar los datos del objeto. Si no se utilizan constructores, todos los objetos
sern el mismo.
Ejemplo
Dada la clase
c l a s s Mi Cl ace
{
i n t mi campo;
publ i c Mi cl ase( i n t val or )
t
1
mi campo = val or ;
1
Si se desea crear un objeto de una clase Mi cl ase, se debe proporcionar un
valor entero que la clase utiliza para inicializar el campo dato mi campo. Este ente-
ro es el nico argumento del constructor de Mi Cl ase. Se crear un objeto de la
clase con una sentencia como sta:
Esta lnea de programa no slo crea un objeto de la clase Mi Cl ase, sino que
inicializa el campo mi campo al valor 5.
Ejercicio
El siguiente programa crea dos objetos C i r cu 1 o, de radios 1 O y 2, y visualiza sus
superficies.
106 Java 2. Manual de programacin
class TestConstructoresCi r- ul o
i
public static void mai n ( St r i ng [ ! ar gs)
i
/ / Ci r cul o de r adi o 10. C
Ci r cul o mi ci r cul o y new C i r ci i i l o (1: ). t i ) ;
Cyst em. out . pr i nt l n( " La super f i ci e del ri r cul o de r adi o ''A
mi Ci r cul o. r ddi ot " es "t
mi Ci r cul o. cal c, J l ar Super f i ci e ( ) ) ;
/ / Ci r cul o con r adi o por def ect o
Ci r cul o suCi r cul o = new Ci rci i l o ( ) ;
Syst em. out . pr i nt l n ( " L a super f i ci e del ci r cul o de r adi o "f
suCi r cul o. r adi o+" es "+
suCi r cul o. cal cul ar Cuper f i ci e( ) ) ;
1
1
class Ci r cul o
I
double r adi o;
Ci r cul o (double r)
r adi o = r ;
1
Ci r cul o ( )
r adi o = 2. 0;
i
double cal cul ar super f i ci e0
return r adi o*r adi o*3. 14?592;
I
S a l i d a
La super f i ci e del c r cul o de r adi o 10. 0 es 314. 1592
La super f i ci e del c r cul o de r adi o 2. 0 es 12. 566368
Notas: La clase Ci rcul o tiene dos constructores. Se puede especificar un
radio o utilizar el radio por defecto para crear un objeto Ci rcul o. As:
1. ElconstmctorCirculo (10. O ) seutilizaparacrearuncrculoconunradio 10.0.
2. El constructor Ci rcul o ( ) se utiliza para crear un crculo con un radio por
defecto de 2.0.
Los dos objetos creados mi ci rcul o y suci r cul o comparten los mismos
mtodos y por consiguiente se pueden calcular sus superficies utilizando el
mtodo cal cul ar super f i ci e .
Clases, objetos y mtodos 107
4.9. MODIFICADORES DE ACCESO
J ava proporciona modificadores para controlar el acceso a datos, mtodos y cla-
ses, con lo que se consigue proteger a las variables y los mtodos del acceso de
otros objetos. En J ava, se pueden utilizar especificadores de acceso para prote-
ger a variables y mtodos de una clase cuando sta se declara. Existen cuatro
diferentes niveles de acceso: pri vate, protected, publ i c y, si se deja sin
especificar, package. La Tabla 4.1 proporciona un resumen de los modifica-
dores.
Tabla 4.1. Modificadores de acceso
__ ~~ - ~
Modificador Clase Mtodo Datos Comentario
(por defecto) -\I 4 4 Una clase, mtodo o dato es visible en este paquete
publ i c < v v Una clase, mtodo o dato es visible a todos los programas
de cualquier paquete
pri vate \ t Un mtodo o dato es slo visible en esta clase
protected v \ Un mtodo o datos es visible en este paquete y en las
subclases de esta clase en cualquier paquete
Nota: Un modificador que se puede aplicar a una clase se llama modificador
de clase. Un modificador que se aplica a un mtodo se llama modificador de
mtodo. Un modificador que se puede aplicar a un campo dato se llama modi-
ficador de datos.
Nota: El modificador pri vate slo se aplica a variables o a mtodos. Si
public o pri vate no se utilizan, por defecto, las clases, mtodos y datos
son accesibles por cualquier clase del mismo paquete.
Precaucin: Las variables asociadas con los modificadores son los miembros
de la clase, no variables locales interiores a los mtodos. Utilizando modfica-
dores en el interior del cuerpo de un mtodo producir un error de compila-
cin.
1 O8 Java 2. Manual de programacin
4.10. private
El nivel de acceso ms restrictivo es pr i vat e. Un miembro privado slo es acce-
sible en la clase en que est definido. Se utiliza este nivel de acceso para declarar
los miembros que se deben utilizar slo en la clase. En realidad define los mtodos
y los datos a los que slo se puede acceder dentro de la clase en que estn defini-
dos, pero no por las subclases.
El objetivo de pr i vat e es proteger la informacin contenida en variables para
evitar que al ser accedido por un ((extrao)) pongan al objeto en estado inconsisten-
te o bien para proteger a mtodos que si se invocan desde el exterior puedan cam-
biar el estado del objeto o el programa en que se est ejecutando. De hecho, los
miembros privados son como secretos que no se difunden a ((extraos)).
Para declarar un miembro privado, se utiliza la palabra reservada pr i vat e en
su declaracin. La clase DemoPr i vado contiene dos miembros privados: una
variable y un mtodo.
public cl as s DemoPr i vado
private i nt dat opr i vado;
private void met odoPr i vado ( 1
i
Syct em. out . pr i nt l n ( " Es un mt odo pr i vado" ) ;
Funcionamiento
1. El cdigo del interior de la clase DemoPr i vado puede inspeccionar o modi-
ficar la variable dat opr i vado y puede invocar al mtodo
met odoPr i vado, pero no lo puede hacer ningn cdigo perteneciente a
otra clase.
2. Otra clase externa, Ext er naDemo, no puede acceder a los miembros de
DemoPr i vado.
cl as s Ext er naDemo
i
void r net odoAcceco ( )
i
DemoPr i vado d = new DemoPr i vado ( ) ;
d. dat opr i vado =l oo; / / no l egal
d. met odoPr i vado ( 1 ; / / no l egal
1
Clases, objetos y mtodos 109
3. Cuando una clase intenta acceder a una variable a la que no tiene acceso el
compilador imprime un mensaje de error similar al mostrado en la Figura 4.4
y no compila el programa.
Figura 4.4. Error.
4. Sucede igual accin si se trata de acceder a un mtodo privado.
4.11. protected
El especificador protected permite que la propia clase, las subclases y las cla-
ses del mismo paquete, accedan a los miembros. Los miembros protegidos son
como los ((secretos familiares)) compartidos por familiares, e incluso por amigos,
pero no por ((extraos)). Los miembros protegidos se declaran con la palabra re-
servada protected. Consideremos la clase DemoProtegido que se declara
dentro de un paquete denominado Demo y que tiene una variable y un mtodo pro-
tegidos.
package : ~cr o. Ter nzC4. eno;
public cl as s CemsProtegi do
I
protected i nt datcP roteqxi o;
protected voi d metadc2rotegi ci cO
S yctem. o' i t . pri nt; n ( " Es un Tt odo protegi ua") ;
1
Compilacin
C:\l i bro\TernaG4\Derno>j avac DemoFr ozeg; do. ] ava
1 10 Java 2. Manual de programacin
Funcionamiento
1. La clase Ot r aDemo es del paquete Demo, pero no es subclase de
DemoPr ot egi do. La clase Ot r aDemo puede acceder legalmente a la
variable dat opr ot egi do e invocar al mtodo met odoPr ot egi do:
package l i br o. Tema04. Demo;
cl as s OCr aDemo
void Vet odoAcceso ( )
DemoPr ot egi do d = new DemoPr ot egi do ( ) ;
d. dat oFr ot egi do = 100; / / l egal
d. met odoPr ot egi do( ) ; / / l egal
No produce problemas en la compilacin
: \ ~~br o ~~e ma C4\ De mo >~a v a c Ot r aDemo. l ava
2. Si Ot r aDemo fuera una subclase de DemoPr ot egi do este cdigo sera tam-
bin legal, ya que la clase esta en el mismo paquete que DemoPr ot egi do .
3. Las subclases externas del paquete de la superclase tambin tienen acceso a
los miembros protegidos pero a travs de una referencia al objeto:
package l i br o. Ter na34. DemoBi c;
import l i br o. Tema04. Demo. " ;
cl as s NLeva extends CemoPr ot egi do
void ?, et odoAcceco ( DemoPr ot egi do d, Nueva n)
t
d. dat opr ot egi do = 100; / / no l egal
nAat cFr ot egi do = 100; / / l egal
d. met odoPr ot eqi do ( ) ; / / no l egal
n. met ouoPr ot eg; do( ) ; / / l egal
1
Se puede acceder a los miembros protegidos a travs de un objeto de la clase
Nueva, pero no a travs de un objeto de la clase DemoPr ot egi do que no seria
vlido.
AI compilar el programa se producen errores (Fig. 4.5).
Clases, objetos y mtodos 11 1
Figura 4.5. Errores
Aunque en algunos ejercicios ya se han usado paquetes y se ha visto de forma
prctica como trabajar con ellos, los conceptos sobre paquetes se explican con deta-
lle en el Captulo 6.
4.12. public
El especificador de acceso publ i c es aquel que define las clases, mtodos y datos
de modo tal que todos los programas pueden acceder a ellos. Los miembros se
declaran pblicos slo si este acceso no puede producir resultados no deseables si
un ((extrao)) a ellos los utiliza. Se declara a un miembro pblico utilizando la pala-
bra reservada publ i c. Por ejemplo:
package NegocLos;
public class EBusi nesc
publ i c - i nt cant i dad;
void oper ar 0
Syst em. out . pr i nt l n ( Es .n mt odo pbi l cr ) ;
4.1 3. RECURSIVIDAD
Un mtodo es recur.sivo cuando directa o indirectamente se llama a s mismo. La
utilizacin de la recursividad es apropiada cuando el problema a resolver o los datos
a tratar han sido definidos de forma recursiva, aunque esto no garantiza que la mejor
forma de resolver el problema sea la recursiva. La recursin es una alternativa a la
iteracin y las soluciones iterativas estn ms cercanas a la estructura de la compu-
tadora. La definicin de factorial de un nmero (n ! = n * (n - 1) ! ) para todo
nmero n mayor que O, teniendo en cuenta que 0 ! = 2 , es recursiva. La imple-
1 12 Java 2. Manual de programacin
mentacin se realiza de forma recursiva mediante un mtodo f act or i a 1 que se
llama sucesivamente a s mismo.
publ i c class Funci on
/ / f act or i al r ecur si vo
publ i c stati c l ong f act or i al ( i nt n)
!
i f ( n < O )
return -1;
i f ( n == O )
return 1;
else
return n * f act or i al ( n- 1) ;
publ i c class Pr ueba
t
publ i c stati c voi d mai c ( St r i ng' ] ar gs )
Funci on f = new Funci on ( ) ;
Cyst er k. out . pr i nt l n( f . f act or i al ( 4) ) ;
La funcin f act or i al tambin podra haber sido resuelta de forma iterativa
de la siguiente forma:
publ i c cl ass Funci or . 2
/ / f act or i al i t er at i vo
publ i c stati c l ong f act or i al (i ;nt n)
i f (7. < O )
return -1;
l ong f act = 1;
whi l e (n > O)
f act = f act * n;
n- - ;
return f act ;
Todo algoritmo recursivo puede ser transformado en iterativo, para esta trans-
formacin, en ocasiones, resulta necesario utilizar una pila. En el diseo de una
algoritmo recursivo es preciso tener en cuenta que:
Clases, objetos y mtodos 1 13
La recursividad puede ser directa o indirecta.
El instrumento necesario para expresar los algoritmos recursivamente es el
mtodo.
Un mtodo presenta recursividad directa cuando se llama a s mismo dentro
de su definicin.
La recursividad indirecta consiste en que un mtodo llame a otro que, a su vez,
contenga una referencia directa o indirecta al primero.
Un mtodo recursivo debe disponer de una o varias instrucciones selectivas
donde establecer la condicin o condiciones de salida.
Cada llamada recursiva debe aproximar hacia el cumplimiento de la o las con-
diciones de salida.
Cada vez que se llame al mtodo los valores de los parmetros y variables
locales sern almacenados en una pila.
Durante la ejecucin de dicho mtodo, parmetros y variables tomarn nuevos
valores, con los que trabajar el procedimiento o funcin.
Cuando termine de ejecutarse el mtodo, se retornar al nivel anterior, recupe-
rndose de la pila los valores tanto de parmetros por valor como de variables
locales y continundose la ejecucin con la instruccin siguiente a la llamada
recursiva. Hay que tener en cuenta que la recuperacin de los datos almacena-
dos en una pila se efecta siempre en orden inverso a como se introdujeron.
Los algoritmos recursivos en los que distintas llamadas recursivas producen
los mismos clculos es conveniente convertirlos en iterativos. Un ejemplo de
esta situacin es el clculo de los nmeros de Fi bonacci , que se definen por
la relacin de recurrencia f i bonac c i . . = f i bonac c i - i f i bonac -
ci?.:, es decir, cada trmino se obtiene sumando los dos anteriores excepto
f i bonac c i = O y f i b o n a c c i = 1. La definicin dada es recursiva y
su implementacin se muestra a continuacin tanto de forma recursiva como
iterativa. Obsrvense los diferentes tiempos de ejecucin segn se utilice uno
u otro algoritmo.
public class Fi bcri acci
/ / Fi bonacci recursi vo
public stati c l ong f i bor.aci r ( i nt n)
i f ( n < O )
i f ( n == O )
el se
return -1;
return ( O ) ;
i f (I : := 1)
else
return ( 1 1 ;
return(f i bTnacci r ( r i - 1) - f i bonacc; r (ri - 2) ) ;
1
11 4 Java 2. Manual de programacin
/ / Fi bsnacci i zer azi vo
public stati c l ong f i bonacci i ( i nt n)
l ong f = 3, f si g = 1;
f or ( i nt 1 = C ; i < n; i t+)
l ong aux = f si g;
f si g += f ;
f = aux;
return ( f ) ;
i
publ i c stati c void mai n (Str;-,g [ ] ar gs) throws Excepti on
Sysz e~~. out . pr i nt l n ("V ersi n I t er at i va: " ) ;
f or ( i nt i = O ; i <= 38 ;i t+)
Systern.oui . pr ; r tl n ("Fi bonacci - i t er at i vo ("+;+") "+
f i bonacci i ( i ) ) ;
C$'stem.cYt .pri nt:?. ( " \ r, Pul se RETURN par a conti ?,'J ar\n") ;
Syszer;. i r.. read ( ) ;
C ys~em. i n. ski s( Syc~em. ; ~. . avai l abl e 0 ) ;
Syst em. ouz. pr : nt l n ("V ersi n r ecur si va: " ) ;
f or ( i nt i = U; i <= 38 ; I ++)
Syst em. out . pr i r . tl n ("Fi bonacc;- recursi vo ( " +i +" ) = "+
,
f i bonacci r ( i ) ) ;
En general, la recursividad debe ser evitada cuando el problema se pueda
resolver mediante una estructura repetitiva con un tiempo de ejecucin signi-
ficativamente ms bajo o similar. Teniendo en cuenta esta afirmacin, la recur-
si\ idad debiera evitarse siempre en subprogramas con recursin en extremo
final que calculen valores definidos en forma de relaciones de recurrencia
si in pl es.
Ejercicio
Disear una clase Funci on3 con un mtodo que permita calcular el mximo
comn divisor de dos nmeros enteros y positivos por el algoritmo de Euclides.
Para obtener el mximo comn divisor de dos nmeros enteros y positivos, a y b
por el algoritmo de Euclides, debe dividirse a ente b y, si el resto es distinto de cero,
repetir la divisin tras dar a a el valor de b y a b el resto. La condicin de termi-
nacin o de salida ser cuando el resto sea cero.
publ i c class Funci on3
Clases, objetos y mtodos 1 15
/ / Mxi mo comn di vi sor
publ i c stati c i nt mcd(i nt a, i nt b)
i f (a < O I 1 b < O )
return - 1;
i f (a '? b == O )
return b;
else
return mcd ( b, a b) ;
1
/ / Pr ogr ama par a pr obar l a cl ase cr eaaa
i mport j ava. i o. *;
publ i c cl ass Pr ueba3
i
Funci on3 f = new Funci on? ( ) ;
I nput St r eamReader i s r = new I nput Ct r eamReacl er ( Syst em. i n) ;
Buf f er edReader br = new Buf f er edReaci er ( i sr ) ;
i nt nl = O , n2 = O;
tr y
i
Syst em. out . pr i nt ( " Deme un nmer o " ) ;
nl = I nt eger . par seI nt ( br . r eadLi r . e ( ) ) ;
Syst em. out . pr i nt ( " Deme ot r o r.,Amero " ) ;
\ n2 = I nt eger . par seI nE ( br . r eadl i ne ( ) ) ;
Cyst em. out . pr i ct ( f . mca( nl , n2) ) ;
Cyst em. out . pr i nt ( " es el mxi mo comn di vi sor entze " ) ;
Syst em. out . pr i nt l n( p1 + " y " + n2) ;
I OExcept i on e )
em. er r . pr i nt l n ( " Er r or de l ect ur a" ) ;
Existen una serie de tcnicas para el diseo de algoritmos que usan recursivi-
dad, entre las que destacan la estrategia de dividey vencers y la de retroceso o
backtracking. La tcnica divide y vencers consiste en dividir un problema en dos
o ms subproblemas, cada uno de los cuales es similar al original pero ms peque-
o en tamao. Con las soluciones a los subproblemas se debe poder construir de
manera sencilla una solucin del problema general. Para resolver cada subpro-
blema generado existen dos opciones, o el problema es suficientemente pequeo
o sencillo como para resolverse fcilmente de manera cmoda o si los subproble-
mas son todava de gran tamao, se aplica de forma recursiva la tcnica de divide
y vencers.
1 16 Java 2. Manual de programacin
Hay un gran nmero de problemas cuya solucin requiere la aplicacin de mto-
dos de tanteo de forma sistemtica, es decir, ir probando todas las opciones posi-
bles. La tcnica de backtracking divide la solucin del problema en pasos y define
la solucin del paso i-L;simo en funcin de la solucin del paso i-&.sirno + 1. Si no
es posible llegar a una solucin se retrocede para probar con otra posible opcin.
I 5
Herencia
CONTENIDO
5.1. Descripcin de herencia.
5.2. La clase base Obj ect .
5.3. El mtodo cl one.
5.4. El mtodo equal s.
5.5. El mtodo f i nal i ze.
5.6. El mtodo t ost r i ng.
5.7. El mtodo get cl ass.
5.8. Ventajas de la herencia.
5.9. Superclases y subclases.
5.1 O. Modificadores y herencia.
5.1 1. Clases abstractas.
5.1 2. Mtodos abstractos.
5.1 3. Interfaces.
5.14. Definicin de una interfaz.
117
1 18 Java 2. Manual de programacin
~~~~~
Una de las propiedades ms sobresalientes de la programacin
orientada a objetos es la herencia, un mecanismo que sirve para
definir objetos basados en otros existentes. J ava soporta herencia
con extensin de clases, que permite definir una nueva clase
basada en otra clase ya existente sin modificarla. Tal nueva clase,
llamada subclase o clase extendida, hereda los miembros de una
superclase existente y aade otros miembros propios.
J ava soporta herencia simple a travs de extensin de clases.
En herencia simple una clase se extiende a partir de una nica
superclase. Por ejemplo, una subclase Cuentacorri ente se
puede extender (ampliar) de una superclase Cuenta o bien
Gerente de Empleado. Algunos lenguajes orientados a objetos,
como C++, soportan herencia mltiple, que es aquella en que una
subclase puede tener varias superclases. J ava, por el contrario, no
soporta herencia mltiple aunque su funcionalidad puede ser con-
seguida mediante interfaces.
Este captulo introduce al concepto de herencia. Especfica-
mente examina superclases y subclases, el uso de palabras reser-
vadas, super y thi s, 10s modificadores protected, f i nal y
abstract, diferentes clases tiles y el diseo de interfaces.
5.1. DESCRIPCIN DE HERENCIA
En terminologa J ava, la clase existente se denomina superclase. La clase derivada de
la superclase se denomina la subclase. Tambin se conoce a la superclase como clase
padre y una subclase se conoce como clase hija, clase extendida o clase derivada.
La Figura 5.1 contiene la definicin de una clase para estudiantes. Un estudian-
te es una persona, por lo que se puede definir la clase E s t udi ant e que se deriva
de la clase Per sona. Una clase derivada es una clase que se define aadiendo
variables de instancia y mtodos a una clase existente. En el ejemplo de la Figura
5.1, la clase Per sona es la clase base y la clase Est udi ant e es la clase deriva-
da, Las clases derivadas tienen todas las variables de instancia y los mtodos de la
clase base, ms las variables de instancia y mtodos que se necesiten aadir.
Persona 7
Fi gura 5.1. J erarqua de clases.
Herencia 119
La definicin de una subclase tiene la sintaxis siguiente:
public class nombrecldre extends Cl a c e Ba c e
Un ejemplo puede ser:
public class Est u=- ant e extends Percoza
Nota: La herencia es siempre trunsitiva, de modo que una clase puede here-
dar caractersticas de superclases de muchos niveles.
Si la clase Per r o es una subclase de la clase Mam f er o y la clase
Mam f er o es una subclase de la clase Ani mal , entonces Per r o heredar atri-
butos tanto de Mam f er o como de Ani mal . Se pueden reutilizar o cambiar los
mtodos de las superclases y se pueden aadir nuevos datos y nuevos mtodos de
las subclases. Las subclases pueden anular (redefinir) el comportamiento hereda-
do de la clase padre. Por ejemplo, la clase Or ni t or r i nco redefine el compor-
tamiento heredado de la clase Mami f er o, ya que los ornitorrincos ponen
huevos.
/,---
Animal y
--
.
+
- < - Mamfero
I
1 Perro y
A----- -.
%
-_
I i.
Ornitorrinco
~~ ~
-_
\\
Figura 5.2. Herencia y redefinicin de comportamientos.
5.2. LA CLASE BASE Object
En J ava todas las clases utilizan herencia. A menos que se especifique lo contrario,
todas las clases se derivan de una clase raz, denominada Ob] ect . Si no se pro-
porciona explcitamente ninguna clase padre, se supone implcitamente la clase
Obj ect . As, la definicin de la clase Mi Pr i mer Pr ogr ama:
120 Java 2. Manual de programacin
public class Mi Pr i mer Pr ogr ama
!
public static void mai n ( St r i ng [ I ar gsj
!
i
Syst em. out . pr i nt l n ( " Mi pr i mer pr ogr ama J ava" j ;
es igual que la siguiente declaracin:
import j ava. l ang. *;
public class Mi Pr i mer Pr ogr ama extends Obj ect
t
public static void mai n ( St r i ng [ I ar gsj
I
Cyst em. out . pr i nt l n( " Mi pr i mer pr ogr ama J ava" ) ;
1
i
La clase Ob] ect ' proporciona la funcionalidad mnima garantizada que es
comn a todos los objetos (Fig. 5.3).
Figura 5.3. Todas las clases son descendientes de la clase Obj ect
' http://java.sun.com/products/jdk/ I .3/docs/api/java/lanE/Object. htrnl
Herencia 121
La clase Ob j ect define e implementa el comportamiento que cada clase del sis-
tema necesita. La clase Obj ect esta en el nivel mas alto de la jerarqua y se
encuentra definida en la biblioteca j ava . l ang. Cada clase del sistema J ava es un
descendiente, directo o indirecto de la clase Ob j ect . Esta clase define el estado
bsico y el comportamiento que todos los objetos deben tener, tal como comparar
un objeto con otro objeto, convertir a una cadena, esperar una variable condicin,
notificar a otros objetos que ha cambiado una variable condicin o devolver la clase
del objeto. La clase Ob j ect proporciona una funcionalidad mnima que garantiza
un comportamiento comn a todos los objetos. Estos objetos incluyen los mtodos
siguientes:
publ i c bool ean equal s ( J ava . l ang . Obj ect ob j ) Determina si el objeto del
argumento es el mismo que el
receptor. Este mtodo se puede
anular para cambiar el test de
igualdad de clases diferentes.
Devuelve la clase del receptor,
un objeto de tipo Cl ass.
Devuelve un kalor aleatorio
para este objeto. Este mtodo
debe tambin ser anulado cuando
publ i c f i nal j ava. l ang. Cl ass get Cl acs0
publ i c i nt hashcode ( )
publ i c 1ava. l ang. St r i ng t os t r i ng0
el mtodo equal s se cambia.
Convierte el objeto a un valor
de cadena. Este mtodo se
anula tambin con frecuencia.
Regla: Los mtodos de la clase Ob j ect que se pueden anular o redefinir son:
cl one
equal s
f i nal i ze
t ost r i ng
Regla: Los mtodos que no se pueden anular en la clase Ob j e c t , ya que son
final, son:
get cl ass
not i f y
2
not i f yAl l
wai t
Los mtodos wa; t y not i f y se tratarn en el captulo destinado a la programacin multihilo.
122 Java 2. Manual de programacin
5.3. EL MTODO clone
Se puede utilizar el mtodo cl one para crear objetos de otros objetos del mismo tipo.
Por defecto, los objetos no son clnicos, de modo que la implementacin de este
mtodo del objeto lanza una excepcin Cl oneNot Cuppor t edExcept i on . Si se
desea que la clase sea clnica, se debe impleinentar la interfaz Cl oneabl e y anular
este mtodo.
protected C' bj er t cl or.e() throws Cl oneKot Cuppor t edYxcept l on;
5.4. EL MTODO equals
Se utiliza para determinar la igualdad de dos objetos. Este mtodo devuelve t r ue
si los objetos son iguales y f al se en caso contrario. El siguiente cdigo com-
prueba la igualdad de dos enteros ( I nt eger ) :
I ni eger Pr i mer o = new I nt eger ( i ) ;
I ni eger CeguEdc = new I nt eger ( i ) ;
i f ( i r i ~er o. eqLal s( Cegunas) )
Cyst em. ouz. pr i nZl n ("L os Obj etos son i gual es" ) ;
Este programa indicara que los objetos son iguales aunque referencian a obje-
tos distintos.
5.5. EL MTODO finalize
El mtodo f i nal i ze no hace nada. Se redefine f i nal i ze para ejecutar opera-
ciones especiales de limpieza antes de que se recoleccione la basura correspon-
diente al objeto o cuando el programa termina.
protected voi d f i nal i ze ( )
La llamada
Syst er . r xnFi nal i zer cOnExi t ( t r ue) ;
solicita la ejecucin de los mtodos f i nal i ze cuando un programa termina. Sin
la peticin los mtodos f i nal i ze no se invocan cuando termina un programa.
I En el Captulo 13 \e estudia el concepto de excepciones.
Herencia 123
Nota: Cuando se utiliza el operador new se reserva memoria, esta memoria no
es necesario liberarla, pues J ava realiza una recoleccin de basura automtica
mediante un hilo de baja prioridad, en realidad un demonio, proporcionado por
la mquina virtual de J ava.
5.6. EL MTODO tostri ng
El mtodo t ost r i ng de Obj ect devuelve una representacin St r i ng del obje-
to. Se puede utilizar t ost r i ng junto con Syst em. out . pr i nt l n para visuali-
zar una representacin de texto de un objeto, tal como el hilo (thread actual.
Syctern.out . pr i nt l n ( Thr ead. cur r ent - hr ead( ) . t ol t r: ng ( ) ) ;
La representacin St r i ng de un objeto depende totalmente del objeto. La
representacin St r i ng de un objeto I nt eger es el valor entero visualizado como
texto. La representacin St r i ng de un objeto Thr ead contiene diversos atribu-
tos sobre el hilo tal como su nombre y prioridad. Por ejemplo la salida de la ins-
truccin anterior podra ser:
Thr ead[ mai n, 5, mai nl
5.7. EL MTODO getclass
El mtodo get C l a s s es un mtodo final que devuelve una representacin en tiem-
po de ejecucin de la clase del objeto. Este mtodo devuelve un objeto Cl ass. Se
puede consultar el objeto Cl ass para obtener diversas informaciones sobre la
clase, tal como su nombre, su superclase y los nombres de los interfaces que im-
plementa.
public final j ava. l ang. Cl acs get cl as s 0
Ejemplo
void i mpr i mi r Nombr eOb~et o( 0bJ ect ob])
Cyst em. out . pr i nt l n ( " La cl ase del obj eto e s " +
obj . get cl ass ( ) . get Name ( ) ) ;
124 Java 2. Manual de programacin
Si el objeto ob) pasado como parmetro fuera de tipo I nt eger , la llamada a
este mtodo devolvera:
La cl ase del obl et o es j ava. l ang. I nt eger
5.8. VENTAJAS DE LA HERENCIA
El mecanismo de herencia presenta importantes ventajas:
Facilidad en la modificacin de clases. Evita la modificacin del cdigo exis-
tente al utilizar la herencia para aadir nuevas caractersticas o cambiar carac-
tersticas existentes.
Extraccin de commalidad de clases difirentes. Evita la duplicacin de
estructuras/cdigo idntico o similar en clases diferentes. Sencillamente, se
extraen las partes comunes para formar otra clase y se permite que sta sea
heredada por las dems.
Organizacin de objetos en jerarqua. Se forman grupos de objetos que con-
servan entre s una relacin ((es un tipo de)) (is u king oJ>. Por ejemplo, un
coche (carro) es un tipo de automvil, un deportivo es un tipo de coche
(carro), una cuenta corriente es un tipo de cuenta, un ingeniero de sistemas
es un tipo de empleado, una matriz cuadrada es un tipo de matriz, manzana
reineta es un tipo de manzana.
9 Adaptacin de programas para trabajur en situaciones similares pero dife-
rentes. Evita la escritura de grandes programas, si la aplicacin, sistema
informtico, formato de datos o modo de operacin es slo ligeramente
diferente, pues se debe utilizar la herencia para modificar el cdigo exis-
tente.
5.9. SUPERCLASES Y SUBCLASES
Una clase extendida hereda todos los miembros de sus superclases, excepto
constructores y f i nal i ze, y afiade nuevos miembros especficos. En esencia,
una subclase hereda las variables y mtodos de su superclase y de todos sus
ascendientes. La subclase puede utilizar estos miembros, puede ocultar las varia-
bles miembro o anular (redefinir) los mtodos. La palabra reservada t hi s. per-
mite hacer referencia a la propia clase, mientras que super se utiliza para
referenciar a la superclase y poder llamar a mtodos de la misma (aunque esten
redefinidos).
Herencia 125
Regla: Una subclase hereda todos los miembros de su superclase, que son
accesibles en esa subclase a menos que la subclase oculte explcitamente una
variable miembro o anule un mtodo.
Regla: Los constructores no se heredan por la subclase.
Una clase extendida es una clase compuesta con miembros de la superclase
(miembros heredados) y miembros adicionales definidos en las subclases (miem-
, bros aadidos). Los miembros que se heredan por una subclase son:
Las subclases heredan de las superclases los miembros declarados como
publ i c o protected.
Las subclases heredan aquellos miembros declarados sin especificador de
acceso mientras que la subclase est en el mismo paquete que la superclase.
Las subclases no heredan un miembro de la superclase si la subclase declara un
miembro con el mismo nombre. En el caso de las variables miembros, la varia-
ble miembro de la subclase oculta (hides) la correspondiente de la superclase.
En el caso de mtodos, el mtodo de la subclase anula el de la superclase.
Las subclases no heredan los miembros privados de la superclase.
Nota: El trmino subclase se refiere simplemente a los mecanismos de cons-
truccin de una clase utilizando herencia y, es fcil de reconocer, a partir de la
descripcin del cdigo fuente por la presencia de la palabra clave extends.
5.1 O. MODIFICADORES Y HERENCIA
El lenguaje J ava proporciona diversos modificadores que se pueden utilizar para
modificar aspectos del proceso de herencia. Los modificadores que controlan el
acceso o visibilidad en la clase son: publ i c, protected y pri vate.
A ma caracterstica publ i c, mtodo o campo (dato pblico) puede acceder-
se desde el exterior de la definicin de la clase. A una clase pblica se puede
acceder fuera del paquete en el que est declarada.
A una caracterstica protected slo se puede acceder dentro de la definicin
de la clase en la que aparece, dentro de otras clases del mismo paquete o den-
tro de la definicin de subclases.
126 Java 2. Manual de programacin
A una caracterstica pr i vat e se puede acceder slo dentro de la definicin
de la clase en que aparece.
Otros componentes posibles de una declaracin de clase son st at i c, abs-
t r act y f i nal . Los campos dato y mtodos se pueden declarar como st at i c.
Un campo esttico se comparte por todas las instancias de una clase. Un mtodo
esttico se puede invocar incluso aunque no se haya creado ninguna instancia de la
clase. Los campos de datos y mtodos estticos se heredan de igual modo que los
no estticos, excepto que los mtodos estticos no se pueden anular (redefinir).
Regla:
st at i c Define datos y mtodos. Representa amplia informacin de la
clase que se comparte por todas las instancias de las clases.
publ i c Define clases, mtodos y datos de tal modo que todos los pro-
gramas puedan acceder a ellos.
pr i vat e Define mtodos y datos de tal modo que se puede acceder a ellos
por la declaracin de la clase, pero no por sus subclases.
Nota: Los modificadores st at i c y pr i vat e se aplican aisladamente a
variables o a mtodos. Si los modificadores publ i c o pr i vat e no se utili-
zan, por defecto las clases, mtodos y datos son accesibles por cualquier clase
del mismo paquete.
Precaucin: Las variables asociadas con modificadores son los miembros de
la clase, no variables locales dentro de los mtodos. Utilizando modificadores
dentro del cuerpo de un mtodo se producir un error de compilacin.
Los mtodos y las clases se pueden declarar abstractas ( abst r act ) . Una clase
abstracta no puede ser ((instanciada)). Es decir no se puede crear una instancia de
una clase abstracta utilizando el operador new. Tal clase slo se puede utilizar como
una clase padre para crear un nuevo tipo de objeto. De modo similar un mtodo
abst r act debe ser anulado (redefinido) por una subclase.
Un modificador alternativo, f i nal , es el opuesto de abst r act . Cuando se
aplica a una clase, la palabra reservada indica que la clase no se puede at ender: es
decir, que no puede ser una clase padre. De modo similar, cuando se aplique a un
mtodo la palabra reservada indica que el mtodo no se puede anular y, en conse-
cuencia, el usuario tiene garantizado que el comportamiento de una clase no puede
ser modificado por una clase posterior.
Herencia 127
Nota: Se puede utilizar el modificador f i nal para indicar que UT clase es
f i nal y no puede ser una clase padre.
Regla:
abst r act
f i nal
st at i c
La clase no puede ser instanciada.
Las clases no pueden ser subclasificadas.
Los campos static son compartidos por todas las instancias de
una clase.
Nota: Los modificadores se utilizan en clases y miembros de la clase (datos y
mtodos). El modificador f i nal puede utilizarse tambin en variables locales
en un mtodo. Una variable local f i nal es una constante interna al mtodo.
5.1 1. CLASES ABSTRACTAS
En ocasiones, una clase definida puede representar un concepto abstracto y como
tal no se puede instanciar. Consideremos, por ejemplo, la comida en el mundo real.
;Se puede tener una instancia (un ejemplar) de comida? No, aunque s se pueden
tener instancias de manzanas, chocolates, naranjas o peras. La comida representa el
concepto abstracto de cosas que se pueden comer y no tiene sentido que tenga ins-
tancias ya que no es un objeto concreto. Otro ejemplo puede ser la clase abstracta
Fi gur aTr esDi mensi ones; de ella se pueden definir clases concretas (espec-
ficas), tales como Esf er a, Ci l i ndr o, Cono, ...
Las clases abstractas son tiles para definir otras clases que sirvan para instan-
ciar objetos, pero de ellas no se pueden crear instancias utilizando el operador new.
El propsito de una clase abstracta es proporcionar una superclase a partir de la cual
otras clases pueden heredar interfaces e implementaciones. Las clases a partir de las
cuales se pueden crear instancias (objetos), se denominan clases concretas. Todas
las clases vistas hasta este momento son clases concretas, significando que es posi-
ble crear instancias de la clase.
Importante: Una clase abstracta es una clase que contiene los nombres de los
comportamientos sin las implementaciones que ejecutan esos comportamien-
tos. Los objetos no sepueden instanciar de una clase abstracta.
I
128 Java 2. Manual de programacin
Uno de los objetivos de la programacin orientada a objetos es reconocer los ele-
mentos que son comunes y agrupar esos elementos en abstracciones generales. Por
ejemplo, si se desea construir un marco de trabajo Ji-ameti?ork) de clases para figu-
ras geomtricas, se puede comenzar con la nocin general de una figuran como
clase base. A partir de esta clase base se pueden derivar las clases de figuras espe-
cficas, tales como C r cul o o Rect ngul o.
-
-
Figura >
-
-
c
,/ ------- -- -
/ -.
/
Rectngulo I
\
1
- --
/ Crculo
i t __/
Fi gura 5.4. Herencia y jerarqua de clases.
Una clase se declara abstracta con la palabra reservada abst r act . Una jerarqua
de clases no necesita contener clases abstractas, sin embargo, muchos sistemas orien-
tados a objetos tienen jerarquas de clases encabezadas por superclases abstractas. La
Figura 5.5 representa una jerarqua de figura de la que a su vez se derivan otras dos
clases abstractas, Fi gur a Dos Di men s i one s y Fi gu r aT r e s Di men s i one s .
_ - -
Figura
--* -~~
,,
,-/ -~-- -.
Figura 2 Dimensiones 3
----- 7-
I \
/
__
Figura 3 Dimension&
I - *- - %
Figura 5.5. J erarqua de herencia de clases Fi gur a.
Las clases abstractas son como las clases ordinarias con datos y mtodos, pero
no se pueden crear instancias de clases abstractas usando el operador new. Las cla-
ses abstractas normalmente contienen mtodos abstractos. Un mtodo abstracto es
una signatura de un mtodo sin implementacin. Su implementacin se proporcio-
na en sus subclases. Para declarar una clase abstracta tal como Fi gur a se puede
hacer con la siguiente sintaxis:
abstract class Fi gur a
I
Si se trata de instanciar una clase abstracta, el compilador visualiza un error
similar al mostrado en la Figura 5.6 y rechaza compilar el programa.
Herencia 129
1 4 1 I
Figura 5.6.
5.12. MTODOS ABSTRACTOS
Una clase abstracta es una clase definida con el modificador abst r act que puede
contener mtodos abstractos (mtodos sin implementacin) y definir una interfaz
completa de programacin. Los mtodos abstractos se implementan en las subclases.
Regla:
No todos los mtodos se pueden declarar abstractos. Los siguientes mtodos
no se pueden declarar como abstractos:
Mtodos privados.
Mtodos estticos.
Ejemplo
Definir una clase abstracta Ob j et oGeomet r i co. Esta clase debe contener entre
otros mtodos, los de clculo del rea y permetro de objetos geomtricos. Dado que
no se conoce cmo calcular reas y permetros de objetos geomtricos abstractos,
los mtodos cal cul ar Ar ea y Cal cul ar Per i met r o se definen como mto-
dos abstractos. Estos mtodos deben implementarse en las subclases. Suponiendo
una clase concreta Ci r cul o como subclase de Obj et oGeomet r i co.
La posible implementacin de la clase Ci r cul o es como sigue:
publ i c c l as s C i r c ~l o extends Obl et oGeomeLr i co
t
pri vate double radi o;
publ i c C i r r ul c (double Y , St r i ng nom)
super (ncn?) ;
r adi o = z;
I
130 Java 2. Manual de programacin
publ i c Ci r csl c ( )
/
thi s ( 1. O, " Bl anco" ) ;
publ i c double devol ver Radi o ( )
t
return r adi o;
I
publ i c double cal cul ar Ar ea ( )
return r adi o * r adi c * Mat h. FI ;
publ i c double cai cul ar Per i met r o ( )
return 2 * Mat h. PI * r adi o;
I
publ i c St r i ng t ost r i ng ( )
return " Nombr e = "t cuper . t cSt r i nq( ) t " r adi o = " t r adi o;
i
y la definicin de la clase abstracta Obj et oGeomet r i co es:
abstract cl ass Obj et oGeomet r i co
pri vate St r i ng nombr e;
publ i c Obj et oGeomet r i co( St r i nq nom)
r . ombr e = r om;
abstract publ i c double cal cul ar kr ea( ) ;
abstract publ i c double cal cul ar Per i met r o( ) ;
publ i c St r i ng t ost r i ng ( )
return nor br e;
I
Como clase de prueba, se puede utilizar la siguiente clase Pr ueba:
import ] ava. i o. *;
publ i c cl ass Pr ueua
publ i c stati c void mai r ( St r i ng' ] ar gc)
Herencia 131
I nput St r eamReader i sr = new I nput St r eamReader ( Cyst em. ; n) ;
Buf f er edReader br = n e w Buf f er edReader ( i cr ) ;
t=Y
i
Ci r cul o unci r cul o n e w Ci r cul o ( ) ;
S ys tern. out . r>r i n t 1 ri ( i i nC i r cu 1 o . t os t r i ng ( ) ) ;
Cyst em. out . pr l nt . l n( " Ar ea del ci r cul o = " +
Syst em. out . pr i nt l n ( " Longi t ud de l a ci r cunf er encl a = " +
Syst er n. out . pr i nt l n ( " I nt r oduzca el nomi r e y pul se RESi J RN") ;
St r i ng cadena = br . r eadLi ne ( ) ;
Syst em. out . pr i nt i n ( " I nt r oduzca el r adi o y pul s e RETURN" ) ;
St r i ng numer o = br . r eadLi ne ( ) ;
Doubl e d = n e w Doubl e( nuner 0) ;
double r eal y d. doubl eVal Ee ( ) ;
Ci r cul o ot r oCi r c' J l o = n e w Ci r cul o ( r eal , cadei . a) ;
Syst er n. out . pr i nt l n( ot r cCi r cul o. t oSt r i ng( ) 1 ;
Syst em. out . pr i nt l n ( " Ar ea del ci r cul o = " +
Cyst em. out . pr i nt l n ( " Longi t ud de l a r i r cunf er ecci a = " +
unCi r cui o. cal cul ar Ar ea( ) ) ;
unCi r cul o. cal cul ar Per i met r o( ) ) ;
ot r oCi r cul o. cal cxl ar Ar ea( ) 1 ;
ot r oci r cul o. ca1cul arPer rne: ro ( ) ) ;
1
cat ch( Except i on e )
Cyst em. out . pr i nt l n ( " Er r or " ) ;
Naturalmente se podr crear tambin una subclase Ci l i ndr o que se extien-
de C r cul o.
1..
._
--_
-~ _ -
Objeto Geomtrico ,
-
_ _ ~ - --
A
1
Crculo /
4
- _
CiI indro /
Fi gura 5.7. Ci l i ndr o es una subclase de Ci r cul o y Ci r cul c
es una subclase de Obj et oGeomet r i co.
132 Java 2. Manual de programacin
Consejo: Utilice clases abstractas para generalizar propiedades comunes y
mtodos de subclases y utilice mtodos abstractos para definir los mtodos
comunes que deben ser implementados en subclases.
Precaucin: Un mtodo abstracto no puede estar contenido en una clase no
abstracta. En una subclase no abstracta extendida de una clase abstracta todos
los mtodos abstractos deben ser implementados, incluso si no se utilizan en
la subclase.
Ejemplo
, Rectangulo
- _ .
ObjetoGrfico
Lnea Crculo Cuadrado
Fi gura 5.8. Las clases heredan cierto estado y comportamiento
de su clase padre comn Ob~eto~<raf i co.
abstract cl ass Sbj et oGr df i x
i nt x, y;
/ / . . .
void moveTo ( i nt nuevaX, i nt r i i ~c ~w Y )
t
1
/ / . . .
abstract void di bc j ar ( 1 ;
cl ass Ci rcul o extends Obj et osr af i co
void d; bu j ar ( )
i
/ / . . .
cl ass Reerangul c! extends Cbj eto(; r, i f i cc
void di buj r ( )
i
}
/ / . . .
Herencia 133
Advertencia: Java vs. C++
Una diferencia fundamental entre mtodos C++ y mtodos J ava es que los
mtodos J ava son virtuales por defecto. En otras palabras, J ava proporciona el
mecanismo de envo virtual con cada jerarqua de clases, de modo que un
objeto, basado en su tipo y posicin en la jerarqua, podr invocar la imple-
mentacin correcta de un mtodo.
Cuando una clase derivada anula un mtodo abstracto y proporciona una
implementacin, debe hacerlo con el mismo nombre de mtodo, lista de argu-
mentos y tipo de retorno.
Reglas:
J ava utiliza la palabra reservada abst r act
abstract public double cal cul ar Ar ea0;
que sirve como un modificador al mtodo cal cul ar Ar ea ( ) . Cuando una
clase contiene al menos un mtodo abstracto, el modificador abst r act debe
aplicarse tambin a la declaracin de clases
abstract cl ass Obj et oGeomet r i co
No se pueden crear instancias de clases abstractas. Por ejemplo, la senten-
cia siguiente es ilegal:
Obj et oGeomet r i co al gunaFi gur a =new Obj et oGeomet i co ( " Bl anco" ) ;
/ / Er r or
Ejemplo
Definamos la superclase E s t udi ant e y sus dos subclases, clases derivadas,
Est udi ant ePr egr ado y Est udi ant epost gr ado. En principio no parece
que tenga sentido crear instancias de la clase Est udi ant e, ya que un estudiante
puede ser de pregrado, de postgrado o puede ser otro tipo de estudiante (de forma-
cin profesional, idiomas, bachiller, etc.), por tanto, declararemos la clase estudian-
te como abstracta.
abst ract c l a s s Est udi ant e
i
protected f i na l s t a t i c i n t NUM- DE- PRUEBAS = 3 ;
protected St r i ng nombr e;
134 Java 2. Manual de programacin
/ / vea el cap t ul o sobr e ar r ays
protected i nt [ ] pr ueba;
protected St r i ng cal i f i caci on;
publ i c Est udi ant e ( )
thi s ( " Ni ngun nombr e" ) ;
1
public Sst udi ant e( Ct r l ny nor nbr eEst udi ant e)
nombr e = nombr eEst udi ant e;
pr ueba = new i nt [ NUM - DE- PRUEBAS] ;
cal i f i c- ci on = "*****".
I
/ / rretodo abst r act o
abstract publ i c voi d ~al cul ar Cdl i f i cdci on( ) ;
publ i c St r i ng 1eer Nombr e ( )
i
return nombr e;
I
publ i c i nt 1eer Not acPr uebas ( i nt ri umPri i cha)
return pr neba [ numPr ueba - 1 I ;
1
publ i c voi d poner Nombr e ( St r i ng ni i evoNombr e)
t
1
nombr e = nuevoNombr e;
publ i c voi d f i j ar Not acPr uebas ( i nt numPr ueba, i nt not apr ueba)
t
1
pr ueba [ numPr ueba - 11 = not apr ueba;
\
5.1 3. INTERFACES
El lenguaje J ava soporta interfaces que se utilizan para definir un protocolo de com-
portamiento que se puede implementar por cualquier clase en cualquier parte de la
jerarqua de clases.
Definicin: Una interfaz (intersace) en J ava es una descripcin de comporta-
miento.
Herencia 135
En esencia, una interfaz es un sistema o dispositivo que utiliza entidades no rela-
cionadas que interactan. Ejemplos de interfaces son un mando a distancia para
televisin, que es una interfaz entre el espectador y un aparato de televisin, un
navegador de Internet, que es una interfaz entre el internauta y la red Internet.
Las interfaces en J ava tienen la propiedad de poder obtener un efecto similar a
la herencia mltiple que soportan otros lenguajes como C++. Si se utiliza la palabra
reservada ext ends para definir una subclase, las subclases slo pueden tener una
clase padre. Con interfaces se puede obtener el efecto de la herencia mltiple. Una
interfaz se considera como una clase especial en J ava. Cada interfaz se compila en
un archivo independiente bytecode tal como una clase ordinaria. No se pueden crear
instancias de una interfaz. En la mayora de los casos, sin embargo, se puede utili-
zar una interfaz de un modo similar a como se utiliza una clase abstracta. Una inter-
faz J ava define un conjunto de mtodos, pero no las implementaciones, as como
datos. Los datos, sin embargo, deben ser constantes y los mtodos, como se acaba
de indicar, slo pueden tener declaraciones sin implementacin.
,
Sintaxis
mo d i f i c a d o r interface No mb r e In t e r f a z
t
/ / decl dr aci ones de const ant es
/ / decl ar aci ones de l os mt odos
Definicin: Una interfaz es una coleccin con nombre de definiciones de m-
todos (sin implementaciones) que puede incluir tambin declaraciones de
constantes.
Una interfaz se puede considerar una clase abstracta totalmente y en ella hay que
tener en cuenta que:
Todos los miembros son pblicos (no hay necesidad de declararlos piblicos).
Todos los mtodos son abstractos (se especifica el descriptor del mtodo y no
Todos los campos son st at i c y f i nal (proporcionan valores constantes tiles).
hay ninguna necesidad de declararlos abst r act ) .
5.1 4. DEFINICIN DE UNA INTERFAZ
Una definicin de interfaz consta de dos componentes (Fig. 5.9): la declaracin de
la inteyfaz y el cuerpo de la intwfaz.
136 Java 2. Manual de programacin
declaracin
de interfaz
+public interface Compar ar obj et os
i
public static final int MENOR ~ 1;
de public static final int I CI J A1 O ;
public static final int MAY OR - 1;
cuerpo de constantes
la interaz
public int compar ar ( Compar ar Ob j et os ot r oOb1et o) ;
1
de mtodos
Figura 5.9. Definicin de una interfaz.
La declaracin de la interfaz declara diversos atributos acerca de la interfaz, tal
como su nombre y si se extiende a otra interfaz. El cuerpo de la interfaz contiene
las declaraciones de mtodos y constantes dentro de la interfaz.
Consejo: Las clases abstractas y los interfaces se pueden utilizar para conse-
guir programacin genrica. Se deben utilizar interfaces si se necesita heren-
cia mltiple. Si la herencia que se necesita es simple, es suficiente el uso de
clases abstractas. Normalmente el uso de una clase abstracta es mayor que el
uso de una interfaz.
Ejemplo
Disear un mtodo de ordenacin genrico para ordenar elementos. Los elemen-
tos pueden ser un array de objetos tales como estudiantes, crculos y cilindros.
En este caso se necesita un mtodo genrico comparar para definir el orden de
los objetos. Este mtodo deber adaptarse para que pueda comparar estudiantes,
crculos o cilindros. Por ejemplo, se puede hacer uso del nmero de expediente
como clave para la comparacin de estudiantes, del radio como clave para la com-
paracin de crculos y del volumen como clave para la comparacin de cilindros.
Se puede utilizar una interfaz para definir el mtodo genrico comparar del modo
siguiente:
public interface Compar ar Obl et o
public static final int MENOS = - 1;
public static final int I GUAL = O;
public static final int MAYOR = 1;
public int compar ar ( Compar ar 0bj et o unobj et o) ;
Herencia 137
El mtodo compar ar determina el orden de los objetos a y b del tipo
Compar ar Obj et o. La instruccin a. compar ar ( b) devuelve un valor -1 si a
es menor que b, un valor de O si a es igual a b o un valor de 1 si a es mayor que
b. Un mtodo genrico de ordenacin para un array de objetos Compar ar Ob j eto
se puede declarar en una clase denominada Or denar :
public class Or denar
public void or denar ( Compar ar Obj et o [ ] x)
t
/ / vea el cap t ul o sobr e ar r ays
Compar ar Obj et o maxAct ual ;
int i ndi ceMaxAct ua1;
f or (int i = x. l engt h- 1; i >= 1; i - - )
i
maxAct ua1 = x[ 11;
i ndi ceMaxAct ua1 = i ;
for (int 7 = i - 1; j >= O; I - - )
if ( maxAct ua1. compar ar ( x [ 7 ] j ==- 1)

r naxAct ua1 = x[ ] I ;
i ndi ceMaxAct ua1 = 1;
/ * i nt er cambi ar x [ i ] r on x[ i ndi ceMaxAct ua: ;
si f uer a necesar i o */
if ( i ndi ceMaxAct ua1 ! = i j
x [ i ndi ceMaxAct ua1 I = x [ i l ;
x[ i ] = maxAct ual ;
I
I
Nota: La clase Ordenar contiene el mtodo ordenar. Este mtodo se basa
en algoritmos de ordenacin.
138 Java 2. Manual de programacin
Precaucin: La definicin de una interfaz es similar a la definicin de una
clase abstracta. Existen, sin embargo, unas pocas diferencias:
En una interfaz los datos deben ser constantes; una clase abstracta puede
tener todo tipo de datos.
Cada mtodo de una interfaz tiene slo una signatura sin implementacin;
una clase abstracta puede tener mtodos concretos.
Ningn modificador abstracto aparece en una interfaz; se debe poner el
modificador abst r act antes de un mtodo abstracto en una clase abstracta.
Un mtodo genrico de bsqueda de un determinado objeto en un array de obje-
tos Compar ar Ob j eto ordenado ascendentemente se puede declarar en una clase
denominada Buscar como la que se expone a continuacin. Los mtodos de orde-
nacin y bsqueda se explican en el captulo destinado a arrays,
publ i c class Bcscar
pr i vat e i nt Busquej a- bi nar i a ( Compar ar Obj et o [ 1 x, i nt i z,
i nt de, Compar ar Cbj et o unobj et o)
i nt cent r al = ( i z+de) / 2;
i f ( de < i z)
/ devuel ve un r . . er o Regat i vo cuando no encuent r a el el ement o
if ( i nObJ eto. compar ar ( x [ cent r al ] ) == Compar ar Obj et o. MEN0S)
el se if ( ur . 3bj et o. cor npar ar ( x [ cent r al ] ) == Compar ar Obj et o. MAYOR)
el se
r et ur n( - i z) ;
r et ur n ( Busqceda- bi nar i a ( x, i z, cent r al - 1, unobj et o) ) ;
r et ur n ( E. J squeda- Di nar i a ( x, cent r ai t 1, de, .dnOb j et o) ) ;
/ / devuel ve l a posi ci n donde se encuent r a el el ement o
r et ur n( cent r a1) ;
i
publ i c i nt bbi n ( Compar ar Cb] et c[ ] x, Compar ar Obj et o unobj et o)
r et ur n( BLsqJ eda - t i nar i a ( x, O, x. , engt h, un0bj et o) ) ;
Regla: Una vez que se ha definido una interfaz, el nombre de la interfaz se
convierte en el nombre de un tipo. Cualquier clase que implemente la interfaz
se convierte en un subtipo de ella. Una interfaz es un contrato entre proveedo-
res y clientes de un servicio particular. El diseo de una interfaz afecta a las
funcionalidades y capacidad en el lado proveedor y las complejidades y con-
veniencias en el lado cliente.
Herencia 139
Ejemplo
Considerar una interfaz Or denabl e.
public interface Or denabl e
i
/ * Compar ar el ement os i y J
par a el el ement o ~ i >, == , < el ement o - j devuel ve
>O, O, <O si l a di r ecci n est a CRECI ENDO
<O, O, >O si l a di r ecci n est a DECRECTENDO
*/
int compar ar ( i nt i , int j ) ;
/ / I nt er cambi a el ement os i y j
void i nt er cambi o( int i , int j ) ;
/ / I ndi ce del pr i mer el ement o
int pr i mer o ( ) ;
/ / I ndi ce del l t i mo el ement o
int ul t i mo ( ) ;
/ / Bander a par a i ndi car di r ecci n de or der . aci n
boolean or denado ( ) ;
void or denado (boolean b) ;
/ * I ndi cador de di r ecci n par a
CRECI ENDO o DECRECI ENDO
*/
void di r ecci on (int di r ) ;
int di r ecci on ( ) ;
/ / Val or es de i ndi cador es de di r ecci ones posi bl es
static final int CRECI ENTE = 1;
static final int DECRECI ENTE = - 1;
6
Encapsulamiento
y poiimortismo
CONTENIDO
6.1. Encapsulamiento.
6.2. Modificadores de clases.
6.3. Modificadores de variables.
6.4. Modificadores de mtodos.
6.5. Clases internas.
6.6. Paquetes.
6.7. Declaracin de un paquete.
6.8. Paquetes incorporados.
6.9. Acceso a los elementos de un paquete.
6.10. Importacin de paquetes.
6.1 I . Control de acceso a paquetes.
6.1 2. Polimorfismo.
6.1 3. Ligadura.
6.1 4. Ligadura dinmica.
141
142 Java 2. Manual de programacin
Este captulo examina las importantes propiedades de J ava en-
capsulamiento y polimorfismo. La programacin orientada a objetos
encapsula datos (atributos) y mtodos (comportamientos) en
paquetes denominados objetos. La ocultacin de la informacin y
abstraccin, como trminos sinnimos, gestiona la visibilidad de los
elementos de un programa.
Encapsulamiento es un trmino muy utilizado para significar
que los datos y las acciones se combinan en un nico elemento (un
objeto de las clases) y que los detalles de la implementacin se
ocultan. El trmino polimorfismo significa <<mltiples formas,, (poly
=muchos, morphos =forma). En lenguajes orientados a objetos, el
polimorfismo es un resultado natural de la relacin es-un y los
mecanismos del paso de mensajes, herencia y el concepto de sus-
titucin. El polimorfismo es una de las propiedades clave de un tipo
de programacin conocida Como programacin orientada a objetos.
El polimorfismo permite a los programadores enviar el mismo men-
saje a objetos de diferentes clases. Existen muchas formas de poli-
morfismo en J ava. Por ejemplo, dos clases diferentes pueden tener
mtodos con el mismo nombre.
6.1. ENCAPSULAMIENTO
Encapsulamiento es un trmino que se utiliza en las modernas tcnicas de programa-
cin. Encapsulamiento significa que los datos y las acciones se combinan en una sola
entidad (es decir, un objeto de la clase) y se ocultan los detalles de la implementa-
cin. La programacin orientada a objetos (POO) encapsula datos (atributos) y
mtodos (comportamientos) en objetos. Los objetos tienen la propiedad de ocultacin
de la informacin. Esta propiedad significa que aunque los objetos pueden conocer
cmo comunicarse unos con otros a travs de interfaces bien definidas, no pueden
conocer cmo estn implementados otros objetos (los detalles de la implementacin
estn ocultos dentro de los propios objetos). sta es una situacin muy frecuente del
mundo real. Es posible conducir con eficacia un automvil sin conocer los detalles
internos de cmo funciona el motor, el tren de engranajes o el sistema de frenos.
En J ava se tiene un gran control sobre el encapsulamiento de una clase y un objeto.
Se consigue aplicando modificadores a clases, variables de instancia y de clases, y mto-
dos. Algunos de stos modificadores se refieren al concepto de paquete, que se puede
considerar bsicamente como un grupo de clases asociadas.
6.2. MODIFICADORES DE CLASES
Se puede cambiar la visibilidad de una clase utilizando una palabra reservada, modifi-
cador, antes de la palabra reservada cl ass en la definicin de la clase, por ejemplo:
Encapsulamiento y polimorfismo 143
public cl ass P er sona
I
. . .
i
Una clase pblica se define dentro de su propio archivo y es visible en cualquier
parte. Una clase que es local a un paquete especfico no tiene modificador y se
puede definir dentro de un archivo que contiene otras clases. Como mximo, una de
las clases de un archivo puede ser una clase pblica.
6.3. MODIFICADORES DE VARIABLES
La cantidad de encapsulamiento impuesta por una clase se establece a discrecin del
programador. Puede permitirse el acceso completo a todo el interior dentro de la
clase o se pueden imponer diversos niveles de restricciones. En particular, se puede
controlar cunto es el acceso a otra clase que tiene la instancia y las variables de
clase de una clase. Se consigue esta accin utilizando un modificador, palabra reser-
vada, antes del tipo de la variable. Por ejemplo:
public stati c i nt VALOR-MAX =65;
protected S t r i ng nombre ="Pepe Mackoy" ;
pri vate i nt cuent a = O ;
La Tabla 6.1 lista los modificadores y sus significados. Normalmente es una
buena idea imponer tanto encapsulamiento como sea posible. En consecuencia,
debe ocultarse todo lo que se pueda, excepto lo que se desea hacer visible a otras
clases, en cuyo caso se debe permitir la cantidad mnima de visibilidad.
Tabla 6.1. El efecto de un modificador de mtodo o variable
Modificador Significado
publ i c
ningn modificador Visible en el paquete actual
pr ot ect ed
pr i vat e
Visible en cualquier parte (la clase tambin debe ser pblica)
Visible en el paquete actual y en las subclases de esta c!ase en otros paquetes
Visible slo en la clase actual
Observacin: El modificador protect e d es ms dbil que el uso de ningn
modificador. No se debe utilizar ningn modificador con preferencia a
protected.
144 Java 2. Manual de programacin
6.4. MODIFICADORES DE MTODOS
Se puede limitar tambin el acceso de otras clases a mtodos. Esta accin se reali-
za utilizando una palabra reservada (modificador), antes del tipo de retorno del
mtodo. Los modificadores son los mismos que para las variables.
public void l eer Nombr e ( St r i ng nombr e)
i
1
. . .
pri vate stati c i nt cont ar Obj et os0
i
1
protected fi nal Obj ect encont r ar l l ave0
t
1
*. .
. . .
6.5. CLASES INTERNAS
J ava permite definir clases e interfaces dentro de otras clases e interfaces. Una clase
que no se anida dentro de otra se denomina clase de nivel superior. Esto significa
que prcticamente todas las clases iitilizadas hasta ahora son clases de nivel supe-
rior. Las clases internas se definen dentro del mbito de una clase externa (o de
nivel superior). Estas clases internas se pueden definir dentro de un bloque de sen-
tencias o (annimamente) dentro de una expresin. La clase Empl eado tiene dos
clases internas que representan una direccin y un sueldo (Fig. 6. I ), El cdigo fuen-
te de la clase Empl eado y sus dos clases internas Di recci on y Suel do es:
Ejemplo
public cl ass Empl eado
t
i nt edad = 0;
public St r i ng nombr e = " Mackoy" ;
double t asa = 16. 00;
Di r ecci on di r ecci on;
Suel do suel do;
public Empl eado ( St r i ng unNombr e, i nt numer o,
St r i ng unacal l e, St r i ng unaci udad,
double t asaHor a, i nt hor as)
t
Encapsulamiento y polimorfismo 145
nombr e = unNombr e;
t asa = t asaHor a;
di r ecci on = new Di r ecci on ( numer o, unal al l e, unaci udad) ;
suel do = new Suel do ( hor as) ;
I
/ / cl ase i nt er na
cl ass Di r ecci on
i
i nt numer o = O;
St r i ng cal l e = "";
St r i ng ci udad = "";
Di r ecci on( i nt num, St r i ng unal al l e, St r i ng unaci udad)
I
numer o = nun;
cal l e = unacal l e;
ci udad = unaci udad;
I
voi d vi sual i zar Det a1
i
Cyst em. out . pr i nt l n
I
1
es 0
numer o+" " +cal l e+" , "t ci udad) ;
/ / cl ase i nt er na
cl ass Suel do
t
i nt hor asTr abaj adas = O;
Suel do ( i nt hor as)
I
hor asTr abaj adas = hor as;
1
voi d Vi sual i zar Det al l es ( )
i
1
Cyst em. out . pr i nt l n ( " Sal ar i o = "t hor asTr abaj adas * t asa) ;
publ i c st at i c voi d mai n ( St r i ng ar gs[ ] )
i
Empl eado e = new Empl eado ( " Mackoy" , 45, " Cal l e Real " ,
e. i mpr i mi r Dat os ( ) ;
" Cazor l a" , 15. 25, 35) ;
publ i c voi d i r npr i mi r Dat os ( )
i
Syst em. out . pr i nt l n ( " \ nFi cha Empl eado: " t nombr e) ;
di r ecci on. vi sual i zar Det al l es( ) ;
suel do. vi sual i zar Det al l es 0 ;
146 Java 2. Manual de programacin
El resultado de la ejecucin de esta aplicacin es:
Fi cha Empl eado: Mackoy
45 Cal l e Real , Cazor l a
Sal ar i o = 533. 75
Empleado
Variables de instancia
edad, nombre, direccin, tasa, sueldo.
I
1 ;
I
I
I I Clase interna Direccin
I
1
I I 1
I I Clase interna Sueldo
I
I
I
1
1 1 "::Y 1
Imprimir Datos ( )
Figura 6.1. Estructura de la clase Empl eado.
Las clases internas no se pueden utilizar fuera del mbito. Por consiguiente, las
clases externas de la clase Empl eado no pueden acceder a la clase interna (a
menos que sean subclases o estn en el mismo paquete, dependiendo de la visibili-
dad en la definicin de la clase).
En la prctica, la clase de nivel superior acta como un paquete de objetos
que contienen cero o ms clases internas. Esto es particularmente til en desa-
rrollo de software orientado a objetos. Por otra parte, la capacidad para definir
un cdigo determinado que se puede crear y pasar donde se necesite es muy
importante.
Sintaxis: C posee punteros a funciones. El lenguaje Smalltalk utiliza objetos
que representan cdigo (objetos bloque). Java posee clases internas.
Encapsulamiento y polimorfismo 147
Ejemplo
class A
I
int l ongi t ud;
float val or ;
/ / var i abl es dur ant e l a ej ecuci bn
public A( ) / / const r uct or de A
i
1
public float l eer Val or 0 / / devuel ve val or de una cl ase
i
1
return val or ;
class B
i
public B O
I
1
/ / def i ni ci n de B
/ / const r uct or de B
public int l eer cuent a ( )
i
/ / accede a l ongi t ud de l a cl ase ext er na
return 5*l ongi t ud;
1
1
/ / f i n de l a cl ase B
1 / / f i n de l a cl ase A
Una clase annima es aquella que no tiene nombre y, cuando se va a crear un
objeto de la misma, en lugar del nombre se coloca directamente la definicin.
I Regla: Estas clases se utilizan principalmente en el manejo de sucesos.
I
Ejemplo
Programa que permite la e!eccin de una opcin de un componente Choi ce y pre-
senta en pantalla la opcin seleccionada (vea los Captulos 9 y 1 O). Para el cierre de
ventana, en lugar de crear la clase Ci er r e:
class Ci er r e extends Wi ndowAdapt er
t
public void wi ndowCl osi ng( Wi ndowEvent e)
i
}
Syst em. exi t ( O) ;
1
148 Java 2. Manual de programacin
utiliza una clase annima; es decir, coloca, donde es necesario, directamente la defi-
nicin.
As, en lugar de
addWi ndowLi st ener ( new Ci er r e0 ) ;
se utiliza
addWi ndowLi st ener ( new Wi ndowAdapt er O
I
publ i c voi d wi ndowCl osi ng(Wi nci owEvenz e)
i
1
1 ) ;
Syst em. exi t ( O) ;
La implementacin del ejemplo propuesto es:
i mpor t j ava. awt . *;
i mpor t j ava. awt . event . *;
publ i c cl ass Ej Anoni ma ext ends Fr ame i mpl ement s I t emLi st ener
i
pr i vat e Choi ce sel ecci n;
St r i ng el ement o = " ' I ;
publ i c E] Anoni ma ( )
t
/ / empl eo de una cl ase anni ma par a ef ect uar el ci er r e de l a vent ana
addWi ndowLi st ener ( new Wi ndowAdapt er O
i
publ i c voi d wi ndowCl osi ng( Wi ndowEvent e)
i
Syst em. exi t ( O) ;
}) ;
sel ecci n = new Choi ce ( ) ;
sel ecci n. addI t em( " Wi ndows 95" ) ;
sel ecci n. addI t em( " Wi ndows 98" ) ;
sel ecci n. addI t em( " Wi ndows NT" ) ;
/ / Opci n pr esel ecci onada
sel ecci n. sel ect ( 1) ;
sel ecci n. addI t emLi st ener ( t hi s) ;
add ( sel ecci n) ;
I
publ i c st at i c voi d mai n ( St r i ng ar gs [ ] )
I
Encapsu/arniento y poiirnorfismo 149
Ej Anoni ma ver i t ana = new Ej Anoni ma( ) ;
vent ana. cet Layout ( new Fl ow; ayqLt ( ) ) ;
vent ai i a. cet Ti t l e ( " El AWT" ) ;
vent ana. cet Ci ze( 400, 150 ) ;
vent ana. set Vi si bl e( t r ue) ;
public void pai r , t ( Gr aphi cs g)
I
el ement o = sel ecci n. get Sel ect edI t em( ) ;
g. dr awst r i ng ( " El ement o sei ecci onado " +el ement o, 20, i 30) ;
public void i t emCt at eChanged( 1t emEvent e)
i
1
r epai nt ( ) ;
Compilacin
C : \ l i br o\ TemaO 6> J avac E] Anoni ma . j ava
Ejecucin
C: \ l i br o\ TemaOG>j ava Ej Anoni ma
Elemento seleccionado Windows 98
Figura 6.2. Resultado de la ejecucin del ejemplo de clase annima.
6.6. PAQUETES
Un paquete es una coleccin de clases que se compilan en una unidad de compila-
cin. Los paquetes proporcionan un medio adecuado para organizar dichas clases.
Se pueden poner las clases que se desarrollan en paquetes y distribuir los paquetes
a otras personas, por tanto, se puede pensar en los paquetes como bibliotecas que se
pueden compartir por muchos usuarios.
150 Java 2. Manual de programacin
Es posible llevar un conjunto de clases relacionadas juntas a una nica unidad
de compilacin definindolas todas dentro de un archivo. Por defecto, se crea un
paquete implcito (sin nombre); las clases pueden acceder a variables y mtodos que
slo son visibles en el paquete actual y slo una de las clases puede ser visible
pblicamente (la clase con el mismo nombre que el archivo). Un enfoque mejor
sera agrupar las clases en un paquete explcito con nombre.
El lenguaje J ava viene con un conjunto rico de paquetes que se pueden utilizar
para construir aplicaciones. Por ejemplo, el paquete j ava . i o agrega las clases de
entrada y salida de datos en un programa. Un paquete puede contener a otros paque-
tes. Los paquetes sirven para organizar las clases en grupos para facilitar el acceso
a las mismas cuando sean necesarias en un programa.
La referencia a una clase de un paquete se hace utilizando un nombre completo,
excepto cuando el paquete haya sido importado implcita o explcitamente. Por
ejemplo j ava. awt . But t on indica que But t on es una clase del paquete awt y
que awt es un paquete dentro del paquete j ava.
Los paquetes son unidades encapsuladas que pueden poseer clases, interfaces y
subpaquetes. Los paquetes son muy tiles:
Permiten asociar clases relacionadas e interfaces.
Resuelven conflictos de nombres que pueden producir confusin.
Permiten privacidad para clases, mtodos y variables que no sern visibles
fuera del paquete. Se puede poner un nivel de encapsulamiento tal que slo
aquellos elementos que estn concebidos para ser pblicos puedan ser accedi-
dos desde el exterior del paquete.
6.7. DECLARACIN DE UN PAQUETE
Cada clase de J ava pertenece a un paquete. La clase se aade al paquete cuando se
coin pi la.
Un paquete explcito se define por la palabra reservada package en el comien-
zo del archivo en el que se definen una o ms clases o interfaces. Para poner una
clase en un paquete especfico se necesita aadir la siguiente lnea como la prime-
ra sentencia no comentario:
package nombr epaqcet e;
Por ejemplo:
package di buj os;
incapsuiamiento y poiimorfismo 151
Los nombres de los paquetes deben ser nicos para asegurar que no hay con-
flictos de nombres. J ava impone un convenio de nombres por el que un nombre de
paquete se construye por un nmero de componentes separados por un punto (sepa-
rador . ). Estos componentes corresponden a la posicin de los archivos. En el caso
siguiente, los archivos del paquete
package pr uebac. di buj os;
estn en un directorio llamado di buj os dentro de un directorio llamado prue-
bas. Por otra parte, si los archivos de un paquete especfico estn en un directorio
llamado concur so, dentro de un directorio llamado pr uebas, el nombre del
paquete es
package pr uebas. concur so;
Observe que esto supone que todos los archivos asociados con un nico paque-
te estn en el mismo directorio. Cualquier nmero de archivos se puede convertir
en parte de un paquete, sin embargo, un archivo slo se puede especificar en un
nico paquete.
Nota: Un paquetp, es una coleccin de clases relacionadas e interfaces que pro-
porcionan proteccin de acceso y gestin de espacio de nombres.
- 1
6.8. PAQUETES INCORPORADOS
J ava proporciona miichos paquetes tiles:
Paquete j ava . appl et : permite la creacin de upp1rt.s a traves de la clase Appl et , propor-
ciona interfaces pars conectar un applet a un documento Web y para audicin de audio.
Paquete j ava. awt : proporciona un Abst r act Wi ndow T ooi ki t para programacin CUI
independiente de la plataforma, grficos y manipulacin de imgenes.
Paquete j ava. i o: soporta flujos de entrada y salida J ava.
Paquete j ava . l ang: contiene clases esenciales para el lenguaje J ava.
- Para programacin: St r i ng, Obj ect , Mat h, Cl ass, Thr ead, Syst em, t ype
Wr apper cl asses y los interfaces Copi abl e ( Cl oneabl e) y
Ej ecut abl e( Runnab1e) .
- Para operaciones de lenguaje: Compi l er , Runt i me y Sec~J r i t yManager .
- Para errores y excepciones: Except i on, Thr owabl e y muchas otras clases.
El paquete j ava . l ang es el nico que se importa automticamente en cada programa J ava.
Paquete j ava . mat h: proporciona clculos en entero grande y real grande (big,flout).
152 Java 2. Manual de programacin
Paquete j ava. net : soporta facilidades de red (URL, sockets TCP, sockets UDP, direcciones IP,
Paquete l ava . r mi : soporta invocacin de mtodos remotos para programas J ava.
Paquete j ava. ut i l : contiene diversas clases de utilidad (conjuntos de bits, enumeracin, con-
tenedores genricos. Vect or y Hasht abl e, fecha, hora, separacin de token)), generacin de
nmeros aleatorios, propiedades del sistema).
conversin binario a texto).
6.9. ACCESO A LOS ELEMENTOS DE UN PAQUETE
Existen dos medios para acceder a un elemento de un paquete: 1) nombrar total-
mente ill elemento, inchyelido elpaquete, 2) utilizar sentencias i mpor t . Por ejem-
plo, cuando se elige nombrar totalmente al elemento, se puede especificar la clase
Panel proporcionando su definicin completa
1 ava. awt . Panel
como ocurre en la siguiente cabecera:
publ i c abstract cl ass Bot on ext ends j ava. awt . Pane1
I
Esta sentencia indica al compilador dnde buscar exactamente la definicin de
la clase Panel . Sin embargo, este sistema es un poco complicado para referirse a
la clase Panel un nmero dado de veces, la alternativa es importar la clase
j ava . awt . Panel :
import j ava. awt . Pane1;
publ i c abstract cl ass Bot on ext ends Panel
(
. . .
Hay ocasiones en que se desea importar un nmero grande de elementos de otro
paquete. En este caso, en lugar de colocar una larga lista de sentencias de importa-
cin ( i mpor t ) , se pueden importar todos los elementos de un paquete en una sola
accin utilizando el carcter (comodn)) *. Por ejemplo:
import 2 21;s. awt . * ;
i i i i poi tn todos los elementos del paquete j ava . awt al paquete actual.
Encapsu/arniento y poiirnorfisrno 153
6.10. IMPORTACIN DE PAQUETES
Como se acaba de comentar, para utilizar una clase de un paquete en un programa, se
puede recurrir a aadir una sentencia i mpor t en la cabecera del mismo. Por ejemplo,
import r ni paquet e. Mi Pr ueba;
Las declaraciones i mpor t indican ai compilador J ava dnde buscar ciertas cla-
ses y nombres de interfaces, de forma que, una vez importado, el nombre de la clase
se puede utilizar directamente sin el prefijo del nombre del paquete.
Si se tienen muchas clases para utilizar del mismo paquete, se puede emplear el
caracter asterisco (*) para indicar el uso de todas las clases del paquete. Por ejemplo,
import mi paquet e. *;
importa todas las clases del paquete mi paquet e.
Existen dos formatos de i mpor t
1. i mpor t paquet eDest i no. UnTi po; importa la clase o interfaz
2. i mpor t paquet eDest i no. *; Importa todas las clases e interfaces del paquete
6.11. CONTROL DE ACCESO A PAQUETES
Java proporciona dos niveles de control de acceso: nivel de clase y nivel de paque-
te. Las reglas de acceso a nivel de clase se resumen en la Figura 6.3.
Fi gura 6.3. Control de acceso a nivel de clase.
154 Java 2. Manual de programacin
Un paquete consta de tipos (clases e inlerjuces) definidos en todos sus archivos.
El acceso a nivel de paquete para un tipo es publ i c o package. Slo los tipos
pblicos son accesibles desde otros paquetes (Fig. 6.4). Por consiguiente, la colec-
cin de todos los formatos de tipos pblicos de las interfaces externas de un paque-
te a los restantes paquetes. En otras palabras, una clase puede acceder a tipos
pblicos y sus miembros pblicos en otro paquete. Una subclase puede tambin
acceder a los miembros pblicos y protegidos de sus superclases en otro paquete.
Los cdigos interiores de un paquete pueden acceder a todos los nombres de tipo y
todos los mtodos, campos no declarados pri vate, en el mismo paquete.
\
/ Un paquete
tipos pblicos
~
,/ Tipos -\I
\, package ,i
_ - /
/
,
\ l- - _ - - -
Figura 6.4. Control de acceso a nivel de paquete
6.1 2. POLIMORFISMO
Polimorfismo es una palabra que significa ((mltiples formas)) y es una de las carac-
tersticas ms importantes de la programacin orientada a objetos. En realidad, poli-
morfismo es la propiedad por la que a la misma palabra se le asignan mltiples
definiciones. Existen muchas formas de polimorfismo en J ava. Por ejemplo, dos
clases diferentes pueden tener dos o mas mtodos con el mismo nombre.
En esencia, polimorfismo es la capacidad para enviar el mismo mensaje a obje-
tos totalmente diferentes, cada uno de los cuales responde a ese mensaje de un
modo especfico. Las aptitudes polimrficas de J ava se derivan de su uso como liga-
dura dinmica. Adems, el mismo nombre de mtodo se puede utilizar con par-
metros diferentes y se permite que parentemente el mismo mtodo sea declarado
un cierto nmero de veces dentro de la misma clase.
Polimorfismo puro, se produce cuando una nica funcin se puede aplicar a ar-
gumentos de una variedad de tipos. En polimorfismo puro hay una funcin (el cuer-
po del cdigo) y un nmero de interpretaciones (significados diferentes). El otro
ste es el trmino utilizado pot Timoty Budd en la segunda edicin de su libro Understanding Ohject-
Oriented Programming with Java, Addison-Wesley, 2000, p. 195.
Encapsulamiento y polimorfismo 155
enfoque se produce cuando se dispone de un nmero de funciones diferentes (cuer-
po del cdigo) todas representadas por el mismo nombre. Esta propiedad tambin
se conoce como sobrecarga y, en ocasiones, polimor-smo ad hoc. El polimorfismo
permite a los programadores enviar el mismo mensaje a objetos de clases diferen-
tes. Considrese la sentencia
cuent a. cal cul ar I nt er esesMensual 0;
donde cuent a se puede referir a un objeto Cuent acor r i ent e o a uno
Cuent aAhor r os. Si cuent a es un objeto de Cuent acor r i ent e, enton-
ces se ejecuta el mtodo cal cul ar I nt er esesMensua1 definido en
Cuent acor r i ent e. De igual modo, si cuent a es un objeto Cuent aAhor r os,
entonces se ejecuta el mtodo cal cul ar I nt er esesMensual definido en
Cuent aAhor r os. Esto quiere decir que enviando el mismo mensaje se pueden
ejecutar dos mtodos diferentes. El mensaje cal cul ar I nt er ese sMensual se
denomina un mensaje polimrfico, ya que dependiendo del objeto receptor se eje-
cutan mtodos diferentes. El polimorfismo ayuda al programador a escribir cdigo
ms fcil de modificar y ampliar.
Polimor-smo es, pues, la capacidad de un objeto para responder a un mensa-
je basado en su tipo y posicin en la jerarqua de clases. Una respuesta apropiada
implica la capacidad del objeto para elegir la implementacin del mtodo que mejor
se adapte a sus caractersticas. En C++el polimorfismo se debe disear en las cla-
ses, mientras que en J ava el polimorfismo es una caracterstica por omisin de las
clases. El trmino polimorfismo se utiliza para describir como objetos de clases
diferentes se pueden manipular de modo diferente. Mediante tcnicas polimrficas
es posible escribir cdigo que manipule objetos de muchas clases diferentes de un
modo uniforme y consistente con independencia de su tipo exacto. La flexibilidad
y generalidad de las estructuras polimrficas es una de las ventajas ms significati-
vas de la programacin orientada a objetos.
La estrategia para desarrollar una estructura polimrfica comienza con la identi-
ficacin de los mtodos comunes a travs de un grupo de tipos de objetos similares
pero no idnticos y organizando una jerarqua de clases donde los mtodos comu-
nes se sitan en la clase base, mientras que los restantes se organizan en clases deri-
vadas, deducidas de esta clase base. La interfaz de la clase base define una interfaz
a travs de la cual un objeto de cualquiera de las subclases especificadas se puede
manipular. Es importante considerar que los mtodos de la interfaz compartida se
deben declarar en la clase base.
Un mtodo abstracto es aquel que se declara en la clase base utilizando la pala-
ra reservada abst r act y termina con un punto y coma en lugar del cuerpo del
mtodo. Como ya se indic en el captulo anterior, una clase es abstracta si contie-
ne uno o ms mtodos abstractos o no proporciona una implementacin de un mto-
do abstracto heredado. Un mtodo se considera implementado si tiene el cuerpo de
156 Java 2. Manual de programacin
un mtodo. Si una clase derivada no implementa todos los mtodos abstractos que
hereda de una clase abstracta, entonces esta clase se considera tambin una clase
abstracta. En contraste, el trmino clase concreta se utiliza para referirse a una clase
en la que no se definen mtodos abstractos y tiene implementaciones para todos los
mtodos abstractos heredados. Una clase concreta representa un tipo de objeto espe-
cfico, prefijado. Dado que una clase abstracta no est totalmente especificada, sus
mtodos abstractos estn definidos pero no implementados, no es posible crear
objetos de las clases abstractas. En consecuencia, si la clase Ani mal es una clase
abstracta:
public abstract cl ass Ani mal
I
public abstract void mover 0 ;
I
el siguiente cdigo no es vlido:
Ani mal = new Ani mal ( . . . ) ;
Regla: No es posible crear un objeto de una clase abstracta, pero s es posible
tener una referencia a clases bases abstractas que se refieren a un objeto de una
clase concreta, derivada.
6.13. LIGADURA
El trmino ligadura se refiere al acto de seleccionar cul es el mtodo que se eje-
cutar en respuesta a una invocacin especfica. En algunos lenguajes, tales como
C, la ligadura se realiza totalmente en tiempo de compilacin, incluso si estn impli-
cados mtodos sobrecargados. La ligadura que se realiza en tiempo de compilacin
se denomina ligadura esttica ya que una vez que se establece la ligadura, sta no
cambia durante la ejecucin del programa. Sin embargo, cuando la conversin de
tipos (casting) y la herencia estn implicadas, la ligadura no se puede hacer total-
mente en tiempo de compilacin ya que el cuerpo real del cdigo que se ejecuta
cuando se invoca un mtodo puede depender de la clase real del objeto, algo que no
puede ser conocido en tiempo de compilacin. La ligadura dinmica se refiere a la
ligadura que se lleva a cabo en tiempo de ejecucin. El caso de ligadura dinmica
se produce cuando se combinan la conversin de tipos, herencia y anulacin de
mtodos.
Encapsulamiento y polimorfismo 157
6.1 4. LIGADURA DINMICA
La ligadura dinmica se ilustra mediante los siguientes dos ejemplos, que utilizan
la jerarqua de clases.
public cl as s Base
t
public void oper aci on ( )
public cl as s Der i vadal extends Base
i
/ / no se ancl a el mt odo oper aci on
1
public cl as s Der i vada2 extends Base
public void oper aci on ( )
En esta jerarqua de clases, se derivan dos clases de la misma clase base. La
clase Base y la clase Der i vada2 contienen una definicin de un mtodo llama-
do oper aci n. La clase Der i vadal no anula la definicin de oper aci on. El
siguiente segmento de cdigo ilustra la propiedad de ligadura dinmica.
Der i vadal pr i mer o = new Der i vadal ( . . . ) ;
Der i vada2 segundo = new Der i vada2 ( . . . ) ;
Base gener i ca;
gener i ca = ( Base) pr i mer o;
gener i ca. oper aci on0;
gener i ca = ( Base) segundo;
gener i ca. oper aci on0;
En la primera invocacin de oper aci on el objeto real es de la clase
Der i vadal . Ya que la clase Der i vadal no anula el mtodo oper aci on, la
invocacin producir la ejecucin del mtodo oper aci on de la clase Base. En
la segunda invocacin de oper aci on el objeto real es de la clase Der i vada2
que anula el mtodo oper aci on definido en Base. La pregunta que podemos
hacer es: jcul de los dos mtodos oper aci or i se invoca? Es decir, en el caso del
mtodo anulado (sustituido) oper aci n, cual de los dos mtodos se ejecuta bajo
las diferentes condiciones que implica conversin de tipos. En J ava, la ligadura
dinmica ejecuta siempre un mtodo basado en el tipo real del objeto. Por consi-
guiente, en el segmento de cdigo anterior la segunda invocacin del mtodo ope-
r aci n se enlaza al mtodo oper aci n de la clase Der i vada2. Yaque el tipo
real del objeto puede no ser conocido hasta el tiempo de ejecucin, la ligadura se
158 Java 2. Manual de programacin
conoce como dinmica para diferenciarlo de las ligaduras que pueden determinarse
en tiempo de compilacin. Por ejemplo, considere las clases siguientes:
public cl as s Aut omovi l
I
public void conduci r ( )
I
Syst em. out . pr i nt l n ( " Conduci r un aut omvi l " ) ;
1
I
public cl as s Car r o extends Aut omovi l
i
public void conduci r ( )
i
1
Syst em. out . pr i nt l n ( " Conduci r un car r o" ) ;
Estas dos clases se pueden utilizar en otra clase:
public cl as s Ej empl o
i
public s t at i c voi d mai n ( St r i ng ar gc [ ] )
(
Aut omovi l a = new Aut omovi l ( ) ;
Car r o c = new Car r o( ) ;
a. conduci r ( ) ;
c. conduci r ( ) ;
a = c;
a. conduci r ( ) ;
1
I
Compilacin
C: \ l i br o\ TemaGG>j avac Aut omovi l . j ava
C: \ l i br o\ TemaGG>j avac Car r o. j ava
C: \ l i br o\ TemaGG>j avac Ej empl o. j ava
Cuando se ejecuta esta aplicacin, la versin conduci r se define en la clase
Car r o dos veces, mientras que la versin de la superclase se llama slo una vez.
As, la ejecucin producir:
C: \ l i br o\ TemaGG>j ava Ej empl o
Conduci r un aut omvi l
Conduci r un car r o
Conduci r un car r o
Encapsu/amieno y po/imorfismo 1 59
La variable a se declar de tipo Aut omovi 1. Cuando se asign a la instancia de
Car r o y se recibi el mensaje conduci r , se responde con la versin conduci r
de Car r o, que se eligi en tiempo de ejecucin. La ligadura dinmica o posterga-
da se refiere, pues, al modo en el que J ava decide cul es el mtodo que debe eje-
cutarse. En lugar de determinar el mtodo en tiempo de compilacin (como sucede
en un lenguaje procedimental), se determina en tiempo de ejecucin. Es decir, se
busca cul es la clase del objeto que ha recibido el mensaje y entonces decide cul
es el mtodo que se ejecuta. Yaque esta decisin se realiza en tiempo de ejecucin,
se consume un tiempo de ejecucin suplementario, pero, por el contrario, presenta
flexibilidad. Cuando J ava selecciona un mtodo en respuesta a un mensaje, lo hace
utilizando tres cosas:
La clase del objeto receptor.
El nombre del mtodo.
El tipo y orden de los parmetros.
Es decir, se pueden definir varios mtodos en la misma con el mismo nombre
pero con parmetros diferentes. El sistema selecciona el mtodo que desea llamar
en tiempo de ejecucin examinando los parmetros.
publ i c cl ass Gol f ext ends Aut omovi l
i
publ i c voi d car gar ( i nt i )
i
i
Syst em. out . pr i nt l n ( " Car gando dat os "+ i ) ;
publ i c voi d car gar ( St r i ng s )
I
1
Syst em. out . pr i nt l n ( " Car gando cadenas "+ s ) ;
\
La clase Gol f tiene dos mtodos denominados car gar , cada uno con un par-
metro de tipo diferente. Este cdigo significa que J ava puede diferenciar entre los
dos mtodos y no se producen conflictos.
A 7
Arrays
CONTENIDO
7.1. Concepto de array.
7.2. Proceso de arrays.
7.3. Arrays de objetos.
7.4. Copia de arrays.
7.5. Arrays mu I tid i m e ns i on al es.
7.6. Ordenacin de arrays.
7.7. Seleccin.
7.8. Burbuja.
7.9. Insercin.
7.10. Shel l .
7.1 1. Ordenacin rpida.
7.1 2. Bsqueda.
7.1 3. Implementacin genrica de los mtodos
de ordenacin.
161
162 Java 2. Manual de programacin
7.1.
En captulos anteriores se han utilizado variables para hacer los
programas ms flexibles. Gracias a las variables se pueden alma-
cenar, convenientemente, datos en los programas y recuperarlos
por su nombre. Se pueden tambin obtener entradas del usuario del
programa. Las variables pueden cambiar constantemente su valor.
Sin embargo, en algunos casos se han de almacenar un gran
nmero de valores en memoria durante la ejecucin de un progra-
ma. Por ejemplo, suponga que desea ordenar un grupo de nme-
ros, stos se deben almacenar en memoria ya que se han de utilizar
posteriormente para comparar cada nmero con los restantes.
Almacenar los nmeros requiere declarar variables en el programa
y es prcticamente imposible declarar variables para miembros
individuales, se necesita un enfoque organizado y eficiente.
Todos los lenguajes de programacin, incluyendo J ava, propor-
cionan una estructura de datos, array (<matriz, vector,,) capaz de
almacenar una coleccin de datos del mismo tipo. J ava trata estos
arrays como objetos.
CONCEPTO DE ARRAY
Un army (((matriz, vector, lista))) es un tipo especial de objeto compuesto por una
coleccin de elementos del mismo tipo de datos que se almacenan consecutiva-
mente en memoria. I,a Figura 7.1 es un array de 10 elementos de tipo doubl e y se
representa por un nombre, 1 i s t a, con ndices o subndices.
l i st a [ O]
l i st a [ l ]
l i st a [ Z ]
l i st a [ 3]
l i st a [ 4]
l i st a [51
l i st a [ 6]
l i st a [71
l i st a [81
l i st a [91
I I
l i st a - nombre
[ i ] - ndice
F
Figura 7.1. El array l i st a de 10 elementos, con ndices de O a 9.
Arrays 163
Otra forma de representar grficamente un array es en forma de lista horizontal.
l i st a [ O ] l i st a [ l ] l i st a [ 2 ] l i st a [31 l i st a [ 4] . . .
Figura 7.2. Array l i st a de 10 elementos.
Los arrays pueden ser unidimensionales (Figs. 7.1 y 7.2), conocidos tambin
como listas o vectores, y multidimensionales, conocidos tambin como tablas o
matrices, que pueden tener dos o ms dimensiones.
Ejemplo
El array t emper at ur as de ocho elementos consta de los siguientes componentes:
t emper at ur as
t emper at ur as
t emper at ur as
t emper at ur as
t emper at ur as
t emper at ur as
t emper at ur as
t emper at ur as
Regla: Un array tiene un nombre o identificador, un ndice que es un entero
encerrado entre corchetes, un tamao o longitud, que es mero de elemen-
tos que se pueden almacenar en el array cuando se le asigna espacio en memo-
ria. Un array se representa por una variable array y se debe declarar, crear,
iniciar y utilizar.
7.2. PROCESO DE ARRAYS
El proceso que se puede realizar con arrays abarca las siguientes operaciones:
declaracin, creacin, inicializacin y utilizacin. Las operaciones de declaracin,
creacin e inicializacin son necesarias para poder utilizar un array.
164 Java 2. Manual de programacin
7.2.1. Declaracin
La declaracin de un array es la operacin mediante la cual se define su nombre con
un identificador vlido y el tipo de los elementos del array. La sintaxis para decla-
rar un array puede adoptar dos formatos:
tipoDato [ 1 nombreArray
zipo3ato nombreArray[ ]
Ejemplo
double [ j mi Li st a;
double mi Li st a[ ] ;
}Se declara un array r r i l i st a de tipo doubl e
f l oat t emper at ur a[ j ;
f l oat [ ] t emper at ur a;
}Se declara un array t emper at ur a de tipo f l oat
Las declaraciones no especifican el tamao del array que se especificar cuando
se cree el mismo.
7.2.2. Creacin
Un array J ava es un objeto y la declaracin no asigna espacio en memoria para el
array. No se pueden asignar elementos al array a menos que el array est ya creado.
Despus que se ha declarado un array se puede utilizar el operador new para crear
el array con la sintaxis siguiente:
nombr eAr r ay = new tipoDato [ t arnaf i o] ;
nombreArray es el nombre del array declarado previamente, t i poDa to es el
tipo de dato de los elementos del array y tamao es la longitud o tamao del array
y es una expresin entera cuyo valor es el nmero de elementos del array.
Ejemplo
mi Li st a = new doubl e [ 8! ; / / ar r ay mi Li st a de 8 el ement os
t emper at ur a = new f l oat 1301; / / ar r ay t emper at ur a de 30 el ement os
Consejo: El formato ms conveniente es tipoDato[ ] nornbreArray. El forma-
to tipoDato nornbreArray[ ] se suele utilizar si se desea seguir el estilo de
escritura C/C++.
Arrays 165
Regla: Se pueden combinar la declaracin y la creacin de un array con una
sola sentencia.
t i poDa to [ ] nombreArray = new t i poDa to [ tamao] ;
tipoDa to nombreArray[ ] = new t i poDa t o [ t amao] ;
-
Ejemplo
doubl e; ] mi Li ct a = new aoub; e[ 8] ;
f l oat t emper at ur al j = new f l oat . 3CI ;
Precaucin: Una vez que un array se ha creado su tamao no se puede modi-
ficar.
7.2.3. Ini ci al i zaci n y ut i l i zaci n
Cuando se crea un array, a los elementos se les asigna por defecto el valor cero para
las variables numricas de tipos de datos primitivos, \ u O O O para variables de
tipo carcter, char , f al se para variables lgicas, bool ean, y nul l para varia-
bles objetos. A los elementos del array se accede a travs del ndice. Los ndices del
array estn en el rango de O a t amao- l . As, mi Li st a contiene 8 elementos y
sus ndices son O , 1, 2, . . . , 7.
Cada elemento del array se representa con la siguiente sintaxis:
nombr eAr r ay[ ndi ce] ;
Ejemplo
mi l i st a [ 7 ; representa el ltimo elemento del array
Regla: En J ava, un ndice del array es siempre un entero que comienza en cero
y termina en tamao-i .
Precaucin: Al contrario que en otros lenguajes de programacin, los ndices
siempre se encierran entre corchetes:
temperaturas [ i s] ;
166 Java 2. Manual de programacin
Un array completo se puede inicializar con una sintaxis similar a
doubl e[ ] mi Li st a = { 1. 5, 2. 45, 3. 15, 7. 25, 8. 4 };
esta sentencia crea el array mi Li s t a que consta de cinco elementos.
Clculo del tamao
El tamao de un array se obtiene con una variable instancia l engt h. As, por ejem-
plo, si se crea un array mi l i st a, la sentencia mi Li st a. l engt h devuelve el
tamao del array mi Li st a (10, por ejemplo).
Utilizacin de los elementos del array
Las variables que reperesentan elementos de un array se utilizan de igual forma que
cualquier otra variable. Por ejemplo:
int[l = new int[50];
int 1 = O, j = O;
/ / . . .
j = n[ l ] + n[ 10] ;
Algunas sentencias permitidas en J ava:
1. t emper at ur a[ 5] = 45;
t emper at ur a [ 8] = t emper at ur a [ 5] + 10;
Syst em. out . pr i nt l n( t emper at ur a[ 8] ) ;
2. int punt o = 5;
t emper at ur a [ punt o+31 = 55;
Syst em. out . pr i nt l n ( " La t emper at ur a 8 es 'I +
t emper at ur a[ punt o+3] ) ;
3. Syst em. out . pr i nt 1n ( " La segunda ent r ada es ' I +
ent r ada[ 2] ) ;
Reglas:
temperatura n+3 I = 45;
valor de la variable de ndice
ndice i - (elemento del array)
+
nombre del array
Arrays 167
Se pueden procesar elementos de un array mediante bucles (por ejemplo, f or)
por las siguientes razones:
Todos los elementos del array son del mismo tipo y tienen las mismas propie-
dades; por esta razn, se procesan de igual forma y repetidamente' utilizando
un bucle.
El tamao de un array se conoce, por lo que el bucle mas idneo es f or.
Ejemplo
1. El bucle f or siguiente introduce valores en los elementos del array. El tama-
o del array se obtiene en mi l i st a. l engt h.
for ( i nt i = O; i < mi Li st a. i engt h; i++)
mi Li st a[ i l = ( doubl e) i ;
2. i nt [ l cuent a = new ~ ~ ~ [ I o c I ;
i nt i ;
for ( 1 = O; i < cuent a. l engt h; i ++)
a[ i ] = O;
7.3. ARRAYS DE OBJETOS
Los ejemplos anteriores han creado arrays de elementos de tipos primitivos. Es
posible tambin crear arrays de cualquier tipo de objeto, aunque el proceso es un
poco ms complicado. Por ejemplo, la siguiente sentencia declara un array de 10
objetos Ci r cul o (Ci rcul o es una clase definida previamente):
Ci r cul o [ ] ar r ayci r cul o = new Ci r cul o [ I O] ;
El array de objetos se inicializa de modo similar a un array ordinario:
for ( i nt i = O; i < ar r ayCi r cul o. 1engt h; i+t)
ar r ayci r cul o [ i ] = new Ci r cul o ( ) ;
Representacin grfica
Crear un array de objetos Per sona (clase Per sona) .
Per sona[ ] p = new Per sonaL51;
168 Java 2. Manual de programacin
2 def : ne LX ar r ay de obl et os
de t i po Per sona , que puede conr ener 5 o~: et os
Se crea UI I ar r ay de ooj etos 1
Per soza
~
I new Persona ( ) 1
i
Se neceSAt a cr ear l os
ob- et os de. ar r ay
.- - - A
Fi gura 7.3. Creacin de un array de objetos.
1 Persona
\
Figura 7.4. Estructura completa del array.
Crear un array de 50 objetos pertenecientes a la clase Raci onal .
La clase Raci onal representa los nmeros racionales. Un nmero racional es
un nmero con un numerador y un denominador de la forma n/ d; por ejemplo,
1 / 5, 2 / 7 y 3 / 4. Un nmero racional no puede tener un denominador de valor O.
Los enteros son equivalentes a nmeros racionales de denominador 1, es decir,
n/ l . El siguiente programa crea un ar r ayRaci ona1, que se compone de 50
objetos Raci onal , lo inicializa con valores aleatorios y a continuacin invoca al
mtodo suma ( ) para sumar todos los nmeros racionales de la lista.
public cl ass Pr uebaAr r ayDeObj et os
public stati c void mai n ( St r i ng[ ] ar gs)
/ / cr ear e i ni ci al i zar ar r ayRaci ona1
Arrays 169
Raci onal [ ] ar r ayRaci ona1 = new Raci onal [ 501 ;
/ / i ni ci al i zar ar r ayRaci ona1
Syst em. out . pr i nt l n ( " Los nmer os r aci onal es son " ) ;
for ( i n t i = O; i < ar r ayRaci onal . l engt h; it+)
i
ar r ayRaci ona1 [ i ] = new Raci onal ( ( i n t ) ( Mat h. r andom( ) *50) ,
Syst em. out . pr i nt ( ar r ayRaci onal [ i ] +" " ) ;
l + ( i n t ) ( Mat h. r andom( ) *l O) ) ;
}
Syst em. out . pr i nt l n ( " " ) ;
/ / cal cul ar y vi sual i zar el r esul t ado
Syst em. out . pr i nt l n ( " La suma de l os nmer os r aci onal es es "+
suma ( ar r ayRaci ona1) ) ;
1
publ i c s t a t i c Raci onal suma( Raci onal [ ] ar r ayRaci ona1)
t
Raci onal suma = new Raci onal ( O, 1) ;
for ( i n t i = O; i < ar r ayRaci onal . l engt h; i ++)
return suma;
suma = sama. add ( ar r ayRaci ona1 [ i ] ) ;
Observaciones
1. El programa crea un array de 50 objetos Raci onal y pasa el array al mto-
do suma ( ) , que suma todos los nmeros racionales del array y devuelve su
suma.
2. Los nmeros racionales se generan aleatoriamente utilizando el mtodo
Mat h. r andom( ) .
3. Precaucin. Se ha de evitar un denominador O; para ello se puede aadir al
denominador un 1.
7.4. COPIA DE ARRAYS
Con frecuencia se necesita duplicar un array o bien una parte de un array. Existen
dos mtodos para copiar arrays: copiar elementos individuales utilizando un bucle
y utilizar el mtodo ar r aycopy.
Mtodo 1
Un mtodo para copiar arrays es escribir un bucle que copia cada elemento desde
el array origen al elemento correspondiente del array destino.
170 Java 2. Manual de programacin
Ejemplo
El siguiente cdigo copia ar r ayFuent e en ar r ayDest i no:
for ( i nt i = O; i < ar r ayFuent e. l engt n; l i t )
ar r ayDect i no[ i l = ar r ayFuent e[ i ] ;
Este mtodo plantea problemas si los elementos del array son objetos.
Mtodo 2
Los inconvenientes anteriores se resuelven usando el mtodo Syc tern. ar r ay-
copy ( ) que copia arrays en lugar de utilizar un bucle y que tiene el siguiente for-
mato:
publ i c st at i c voi d ar r aycopy( j ava. i ang. 0bj ect
arrayruente, i nt pos - in;, l ava. l ang. 0bj ect ar r ayCes t i , ?o,
i nt pos - f i n, i nt l e n g t h )
, .
La sintaxis del mtodo ar r aycopy ( ) es:
ar r aycopy ( ar r ayFuent e, pos- i ni , arrayDest.i no, 90s- f :I-., l ongi t, ~d) ;
i nt l ] ar r ayFuent e = {4, 5, 1, 25, i C0) ;
i nt [ l ar r ayDest i r o = new i nt [ ar r ayFuent e. l engt h] ;
Syct er n. ar r aycopy( ar r ayFuent e, 0, ar r ayDect i no, 3, ar r ayFuent e. l engt h) ;
~ ~ ~
Notas:
1. El mtodo arraycopy ( ) puede copiar cualquier tipo (tipo primitivo o
tipo Ob] ect) de elementos del array.
2. En J ava, se pueden copiar tipos de datos primitivos utilizando sentencias de
asignacin, pero no objetos ni arrays completos. La asignacin de un obje-
to a otro objeto hace que ambos objetos apunten a la misma posicin de
memoria.
Arrays 171
7.5. A R RAYS MU LTI DIM ENS I ON AL ES
Las tablas o matrices se representan mediante arrays bidimensionales. Un array
hidimensional en J ava se declara como un array de objetos array.
tipo nombre [ ] [ 3 ;
Las tablas de valores constan de informacin dispuesta enfilas y columnas. Para
identificar un elemento de una tabla concreta se deben especificar los dos subndi-
ces (por convenio, el primero identifica la fila del elemento y el segundo identifica
la columna del elemento).
o 1 2 3 4 5
(a) Array de una dimensin
(b) Array bidimensional
Fi gura 7.5. Arrays: (a) Una dimensin; (b) Dos dimensiones (bidimensional).
La Figura 7.6 ilustra un array de doble subndice, a, que contiene tres filas y cua-
tro columnas (un array de 3 x 4). Un array con rn filas y n columnas se denomina
arra-t mgor-n.
Columna O Columna 1 Columna 2 Columna 3
-+ Subndice columna
-* Nombre del array
-- ---- Subndice fila
-~ _ _ _ ~
Fi gura 7.6. Un array de dos dimensiones con tres filas y cuatro columnas.
172 Java 2. Manual de programacin
Cada elemento del array a se identifica como tal elemento mediante el formato
a [ i 3 I. j ] ; a es el nombre del array, e i, j son los subndices que identifican un-
vocamente la fila y la columna de cada elemento de a, observse que todos los ele-
mentos de la primera fila comienzan por un primer subndice de O y los de la
columna cuarta tienen un segundo subndice de 3 (4- 1).
7.5.1. Declaracin de arrays multidimensionales
Los arrays multidimensionales se declaran de la misma forma que los bidimensio-
nales, es decir, con un par de corchetes para cada dimensin del array.
t i p o nombre [ I [I [ I . . . ;
Ejemplo
1. Un array b de 2x2 dimensiones se puede declarar e inicializar con:
2. La declaracin
crea un array de dos filas y tres columnas, en el que la primera fila contiene
4, 5, 6.
Los arrays con mltiples subndices con el mismo nmero de columnas en cada
fila se pueden asignar dinmicamente. Por ejemplo, un array de 3x3 se asigna
como sigue:
int b[ l [ I ;
b = new int[3] [3];
Los arrays con subndices mltiples en los que cada fila contiene un nmero
diferente de columnas se pueden asignar dinmicamente, como sigue:
int b [ ] [; ;
b = new int[3] [ j ; / / asi gna f i l as
b[O] = new int[5]; / / asi gna 5 col umnas a l a f ; l a O
b[ l ] = new int[4]; / / asi gna 4 col umnas a :a f i l a 1
b[ 2] = new int[3]; / / asi gna 3 col umnas a ;a f i l a 2
La expresin b . l engt h devuelve el nmero de filas del array, mientras
b [ 1 ] . l engt h devuelve el nmero de columnas de la fila 1 del array.
Ejemplo
Declarar y crear una matriz de 5x5
intr; [ I ma:ri z = new int[5] [ 51;
O bien
int mat r i z[ ] [ I = new int[5: [ 5] ;
Se puede utilizar tambin una notacin abreviada para declarar e inicializar un
array de dos dimensiones:
int[] [ I mat r i z =
I
I
La asignacin de valores a un elemento especfico se puede hacer con sentencias
similares a:
mat r i z[ 2] [ O] = 3;
Un medio rpido para inicializar un array de dos dimensiones es utilizar bucles f or:
t abl a[ x] [ y ] = 5;
1
174 Java 2. Manual de programacin
Los hiicles crnidudos funcionan del modo siguiente. El bucle externo, el bucle x,
arranca estableciendo x a O. Como el cuerpo del bucle x es otro bucle, a continua-
cin arranca dicho bucle interior, bucle y, fijando y a O. Todo esto lleva al progra-
ma a la lnea que inicializa el elemento del array tabl a [ O ] [ O ] al valor 5. A
continuacin el bucle interior establece y a 1, y con ello tabl a [ O I [ 1 ] toma el
valor 5. Cuando termina el bucle interno el programa bifurca de nuevo al bucle
externo y establece x a 1. El bucle interno se repite de nuevo, pero esta vez con x
igual a 1, y tomando y valores que van de O a 2. Por ltimo, cuando ambos bucles
terminan el array completo se habr inicializado.
Ejemplo
1. Inicializacin de los elementos del array.
O
O O
1 4
2 ' 8
3 12
~~
t
1 2 3
5 ~ 6 - 1 7
1 13 14 15
~~ 1 1 2 3
9 10 1' 1
Tras crear y declarar el array tabl a
i nt ab- ar; [ = new i nt [ ? 131;
El listado siguiente inicializa el array:
f or ( i nt x = 9; x < 3 ; I -x)
f or ( i nt y = C ; y < 3; i +y)
: aul s[ x] :y1 xx4 + y;
2. Declarar. crear e inicializar un array de 8 filas y 10 columnas con 80 enteros
de ~al or cero
i nt ?uner as I I 1 ; //decl arar e l array
- , uner as = new i nt[ 81 : l o] ; //crear el array en memori a
f or ( i nt x = 3; x < 8 ; t+x)
ri rrercc[xI [y1 = U;
f or ( i nt y = C; y < 13; - +y)
Normalmente, la asignacin de valores a arrays bidimensionales se realiza median-
te bucles anidados, por ejemplo anidando bucles f or. Es decir que, supuesto un array
a de dos dimensimes, mediante dos bucles f or, uno externo y otro interno, es
posible leer y asignar valores a cada uno de los elementos del array. El recorrido de
un array, por ejemplo para mostrar la informacin almacenada en l, tambin se rea-
liza utilizando bucles f or anidados, ya que los bucles facilitan la manipulacin de
cada uno de los elementos de un array. Como se coment con anterioridad, dado un
array, denominado por ejemplo a, la expresin a. l engt h determina su nmero de
filas y, si se usa una estructura f or con una variable de control, i, que recorra
dichas filas a [ i ] . l engt h devolver el nmero de columnas en cada fila.
Ejemplo
1 . La siguiente estructura declara, crea, inicializa y muestra el contenido del
array a, en el que cada fila contiene un nmero diferente de columnas:
i nt a[ ] [ I ;
a = new i nt [ 3] [ I ; / / as: gna f i l as
a[O] = new i nt [ 5: ; / / asi gna 5 rol ui .ras a l a f i l a C
a[ l ; = new i nt [ 7] ; / / asi gna 7 c c l xLz ac a l a f i l s 1
a[ 21 = new i nt [ 3] ; / / asi gna 3 col umnas a IC f i l a 2
f or ( i nt 1 = O; < a. l engt h; i +- )
f or ( i nt j = 3; J < a[:] . l engt h; j ++>
a[:] [ j ] = j + 1;
/ / pr esext a por consol a el cont eni ac =el ar r ay
f or ( i nt I = C; i < a. l engt ; i ; ;++)
t
f or ( i nt j = 3; 7 < a!:] . l ength; j - +)
Sys t em. out . or i nt l n0;
Cyct em. out . pr i nt ( o[ i ] [ j : - " " 1 ;
1
2. Declarar, crear e inicializar un array de 8 filas y 10 columnas con 80 enteros
de valor cero.
i nt numer oc [ j 1 1 ;
numer oc = new i nt ; 8] [ l o; ;
f or ( i nt x = 3; x < numer os. l engt h; ++X I
f or ( i nt y = 3; y < numer oc[ x; . l engt h; ++y)
nuni er oc[ x] [ y] = 3;
Ejercicio (aplicacin)
La siguiente aplicacin crea e inicializa un array de dos dimensiones con 10 colum-
nas y 15 filas. A continuacin presenta en pantalla el contenido del array.
publ i c class Tabl a1
176 Java 2. Manual de programacin
stati c i nt t abl a [ 3 [ I ;
stati c voi d l l enar ( )
t abl a = new i nt[l 51 [ l o] ;
f or ( i nt x = O ; x < 15; x++)
f or ( i nt y = O ; y < 10; y++)
t abl a[ x] [ y] = x * 10 t y;
stati c voi d most r ar 0
f or ( i nt x = O; x < 15; x++)
I
f or ( i nt y = O ; y < 10; y++)
Syst em. out . pr i nt l n0;
Syst em. out . pr i nt ( t abl a[ x] [ y] +" \ t " ) ;
publ i c stati c voi d mai n ( St r i ng[ ] ar gs)
l l enar ( ) ;
most r ar ( ) ;
Ejercicio (applet)
El Appl et Tabl al , se comporta de forma similar a la aplicacin anterior, tambin
crea e inicializa un array de dos dimensiones con 1 O columnas y 15 filas. A continua-
cin imprime el contenido del array en el rea de visualizacin del upplet, de modo que
se puede ver que el array contiene realmente los valores a los que se ha inicializado.
package l i br o. Tema07;
i mport j ava. awt . *;
i mport j ava. appl et . *;
publ i c class Appl et Tabl al extends Appl et
t
i nt t abl a [ ] [ ] ;
publ i c voi d i ni t ( )
t abl a = new i nt[l 51 [ i o ] ;
f or ( i nt x = O ; x < 15; x++)
f or ( i nt y = O ; y < 10; y++)
t abl a[ x] [ y] = x * 10 + y;
1
publ i c voi d pai nt ( Gr aphi cs g)
f or ( i nt x = 3 ; x < 15; xt +)
for (int y = O; y < 10; y++)
i
St r i ng c = St r i ng. val ueOf ( t abl a [ XI [ y] ) ;
g. dr awSt r i ng( s, 50+y*25, 50+x*15) ;
I
Para ejecutar el applet (vea el Captulo 11, ((Appletw), ser necesario:
1. Su compilacin
Mediante una instruccin como la siguiente:
C: \ l i br o\ Tema07>] avac Appl et Tabl a1. j ava
cuando se trabaja con el jdkl.3
Usando el modificador target durante la compilacin para generar un archivo
class especfico para una determinada mquina virtual, ya que no siempre es
seguro que el navegador utilizado para ejecutar el cdigo HTML con la marca
APPLET soporte todas las caractersticas incorporadas a la versin del J DK
con la que el applet ha sido compilado. As, con el jdkl.4 se emplea
C: \ l i br o\ Tema07>j avac - t ar get 1. 1 Appl et Tabl al . j ava
con la finalidad de que el applet pueda ser ejecutado por los navegadores
(browsers) habituales.
Otra forma ms adecuada para que un applet complilado en la versin 1.4 del
jdk pueda ser ejecutado por los browsers habituales consiste en utilizar Plug-in
(vese el Apndice F, ((Contenido del CDD)
2 . Crear un archivo A t 1 . html con el siguiente contenido:
Archivo HTML ( At l . ht ml )
<HTML>
<APPLET
WI DTH=350
HEI GHT=300
code=l i br o. Tema07. Appl et Tabl al . cl ass>
</ APPLES>
</ FI TML>
Al abrir la pgina, usando por ejemplo Microsoft Internet Explorer, el applct se
carga y ejecuta automticamente. La salida obtenida se muestra en la Figura 7.7.
178 Java 2. Manual de programacin
O 1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19
20 21 22 23 24 25 26 27 28 29
30 31 32 33 34 35 36 37 38 39
40 41 42 43 44 45 46 47 48 49
50 51 52 53 54 55 56 57 58 59
60 61 62 63 64 65 66 67 68 69
70 71 72 73 74 75 76 77 78 79
80 81 82 83 84 85 86 87 88 89
90 91 92 93 94 95 96 97 98 99
100 101 102 103 104 105 106 107 108 109
110 111 112 113 114 115 116 117 118 119
120 121 122 123 124 125 126 127 128 129
130 131 132 133 134 135 136 137 138 139
140 141 142 143 144 145 146 147 148 149
Figura 7.7. Ejecucin del applet en Microsoft Internet Explorer
7.6. ORDENACIN DE ARRAYS
La clasificacin de datos es una de las operaciones ms usuales en programacin y
podr considerarse de dos tipos:
Interna, es decir, con los datos almacenados en memoria.
Externa, con la mayor parte de los datos situados en un dispositivo de almace-
namiento externo.
Dentro de la ordenacin interna habra que considerar la ordenacin tanto de
arrays como de listas(vea el captulo sobre estructuras de datos), pero para explicar los
mtodos de ordenacin se estudiar exclusivamente la ordencrcidn de arrays. Adems,
los mtodos de ordenacin interna se aplicarn a arrays unidimensionales, aunque su
uso puede extenderse a otro tipo de arrays, bidimensionales, tridimensionales, etc.,
considerando el proceso de ordenacin con respecto a filas, columnas, pginas, etc.
El concepto de ordenacin se puede definir de la siguiente hrma: dado un array
unidimensional X y dos ndices i y j que permiten recorrerlo, se dir que est orde-
nado ascendentemente si para todo i < j se cumple siempre que X [ i ] <= X [ j ] .
El array estar ordenado en orden descendente si cuando i < j se cumple siempre,
para todos sus elementos, que X [ i I >= X [ j I .
Los mtodos de clasificacin interna ms usuales son: Seleccin, Burbuja,
Insercin, Insercin binaria, Shell, Ordenacin rpida (Quick Sort).
Arrays 179
7.7. SEL ECCI ~N
El algoritmo de ordenacin por seleccin de un array con n elementos tiene los
siguientes pasos:
1. Encontrar el elemento menor del array.
2. Intercambiar el elemento menor con el elemento de subndice 1.
3. A continuacin, buscar el elemento menor en la sublista de subndices 2 . . n,
e intercambiarlo con el elemento de subndice 2. Situndose, por tanto, el
segundo elemento menor en la posicin 2.
4. Despus, buscar el elemento menor en la sublista 3. . n, y as sucesivamente.
Por ejemplo, dada la siguiente lista 7 4 8 1 12 .
Se compara a [ i ] con los siguientes elementos:
- 7 4 8 1 12
- 4 I 8 1 12
- 4 7 8 12
- 1 I 8 4 12
con lo que el elemento menor queda seleccionado en a [ i ]
Se compara a [ 2 j con los siguientes elementos:
- 7 8 4 12
- I 8 4 12
- 4 8 7 12
con los que el elemento menor queda.seleccionado en a [ 2 ] .
Se compara el elemento a 13 ] con los siguientes:
- 8 7 i 2
- 7 8 12
con lo que el elemento menor queda en a[3].
Se compara el elemento a[4] con los siguientes:
- 8 12
con lo que el array quedara 1 4 l a 12.
Tambin se podra buscar el elemento mayor y efectuar la clasificacin en orden descendente.
Codificacin
publ i c class Pruebas
publ i c stati c void mai n ( St r i ng [ 1 ar gs)
r
i nt a[ ] = {7, 4, 8, 1, 12};
i nt menor ;
f or ( i nt i = O; i < a. l engt h- 1; I ++)
I
menor = 1;
for ( i nt j = i +l ; 1 < a. l er gt h; j ++)
180 Java 2. Manual de programacin
if ( a[ : ] < a[ r nenor J )
menor = 7;
i nt auxi = a[ i J ;
a; i J =a[ menor ] ;
a [ menor ] =auxi ;
1
/ / Pr esent aci n de l os r esul t ados
f or ( i nt i = O ; i < 5; i ++)
Cyst em. out . pr i nt l n( a[ i ] ) ;
1
7.8. BURBUJA
La ordenacin por burbuja (buble sort) se basa en comparar elementos adyacentes
del array e intercambiar sus valores si estn desordenados. De este modo se dice que
los valores ms pequeos burbujean hacia la parte superior de la lista (hacia el pri-
mer elemento), mientras que los valores ms grandes se hunden hacia el fondo de
la lista.
Si se parte de la misma lista que en el mtodo anterior, 7 4 8 1 12:
7 4 8 1 12
4 7 - a 1 12
4 7 8- 1 12
4 7 i 8 - 12
4- I 1 8 - 12
4 7- 1 8
4 1 7 - 8
4- 1 7 - 8
1 4- 7
quedando el 7 en tercera posicin:
1- 4 -
quedando el cuatro en la segunda posicin:
quedando el 12 al final de la lista:
quedando el 8 en penltima posicin:
7
1 - 4
-
con lo que la lista resultante sera 1 4 7 8 12.
Codificacin
publ i c cl ass Pr uebaB
t
publ i c stati c voi d mai n ( St r i ng [ ] ar gs)
i nt a[ ; = {7, 4, 8, 1, 12};
f or ( i nt i = 1; 1 < a. l engt h; i ++)
Arrays 181
f or ( i n t j = O; j < a. l engt h- i ; j ++)
i f ( a[ j +i l < a[ j l )
t
i n t auxi = a[ j I ;
a[ j ] = a[ j +l ] ;
a[ j +l ] = auxi ;
/ / Pr esent aci n de l os r esul t ados
f or ( i n t i = O; i < 5; I ++)
Syst em. out . pr i nt l n( a [ i ] ) ;
I
Una optimizacin del mtodo anterior que aprovecha posibles ordenaciones ini-
ciales en el array es:
publ i c c l a s s Pr uebaBOp
t
publ i c s t a t i c voi d mai n ( St r i ng [ ] ar gs)
I
i n t a[ ] = {7, 4, 8, 1, 12};
i n t i = 1;
boolean or denado;
do
i
or denado = true;
f or ( i n t j = O; j < a. l engt h- i ; j ++)
if ( a[ j +l l < a[ j l )
t
or denado = false;
i n t auxi = a[ j l ;
a[ j l = a[ j +l l ;
a[ j +l ] = auxi ;
1
i ++;
1
whi l e ( or denado == false) ;
/ / Pr esent aci n de l os r esul t ados
for ( i = O; i < 5; i ++)
Syst em. out . pr i nt l n( a[ i ] ) ;
7.9. I NSERCI ~N
El mtodo est basado en la tcnica utilizada por los jugadores de cartas para clasi-
ficar sus cartas, donde el jugador va colocando, insertando cada carta en su posicin
correcta. Por tanto, el mtodo se basa en considerar una parte del array ya ordena-
182 Java 2. Manual de programacin
do y situar cada uno de los elementos restantes en el lugar que le corresponda por
su valor. Inicialmente la parte ordenada consta de un nico elemento, ya que un
nico elemento que se podr considerar siempre ordenado.
El lugar de insercin se puede averiguar mediante bsqueda secuencia1 en la parte
del array ya ordenada, mtodo de insercin directa, o efectuando una bsqueda bina-
ria (la bsqueda binaria se comentar ms adelante en este mismo captulo), con lo
que el mtodo pasar a denominarse de ordenacin por insercin binaria.
Los elementos de la lista, 7, 4, 8, 1, 12, van tomando los siguientes valores:
7.4 8 1 12 seguarda en auxi a[ i , , secompara auxi con a[Gl y,
como a [ O ] es mayor, se desplaza hasta a [ 1 ] y en a [ C ] se
pone auxi
\-1
4 ' auxi
~
4 7 8 1 12 no hay desplazamiento. pues auxi (donde se ha guardado
a [ 2] ) es mayor que a [ 11
\--,
8 auxi
I _ _ .
4 7 8 , . 1 12 seguardaenauxi conai 31 ysecomparacona[21
Hay desplazamiento de a [ 2 ] a a [ 3 I
\
' , - 1
1 auxi
LA
4 7 , + 8 8 12 \e compara auxl con a [ 1 ] y. como e\ mayor a . 1 ] que
auxi , hay deiplazamiento de a L 11a a [ 2 I
\-
1
4,-7 8 12 \e compara auxi con a : O 1 . Se de\plaza a [ O I a a [ 11
4 4 7 8 12 secol ocael l ena[ O]
1 4 7 8 12 a [ 4] se guarda en auxi , se compara con a [ 3] y no hay
desplazamientos.
Codificacin
/ / i nser ci n di recEa
publ i c cl ass PruebaI D
publ i c stati c void mair. ( St r i ng [ 3 args)
I
i nt a[ ] = {7, 4, 8, 1, 12! ;
i nt i , j , auxi ;
boolean encont r adosi t i o;
for ( i = 1; i < a. l engt h; i +i )
Arrays 183
auxi = a[ i : ;
er . cont r adosi t i o = false;
while ( 2 >= C & & ! eccont r adosi t i o)
j = 1- 1;
if ( a[ ] ] > a.J xi )
else
encont r ados: t i o = tre;
a [ j +1] =a u x i ;
i
/ / Pr ese- t ar i c de l os r esul t ados
for ( i = O; i < 5; i t +)
Syst en. out . pr ; nt l n( a[ i ] ) ;
I
7.10. Shell
Este mtodo se basa en realizar comparaciones entre elementos no consecutivos,
separados por saltos o intervalos mayores que 1. Estos saltos sufrirn sucesivos
decrementos. Es un mtodo elaborado que resulta ms eficiente cuando las listas
son grandes.
Considere el siguiente array: 6 1 4 7 2 (5 elementos). En una primera pasa-
da, las comparaciones se realizarn entre elementos separados por un intervalo de
5/ 2.
El primer intercambio se produce entre a [ O 1 y a [ 2 ] y luego entre a [ 2 ] y a [ 4 ] .
Puesto que ha habido intercambio entre a [ 21 y a [ 4 I hay que comprobar que
dicho intercambio no ha estropeado la ordenacin efectuada anteriormente, por
tanto, se retrocede y se comparan de nuevo a [ O ] con a [ 2 3 . Como resultado se
obtendr ahora 2 1 4 7 6. Los elementos a [ O ] , a [ 2 ] y a [ 4 ] se encuentran
ahora ordenados y por otra parte tambin a [ 1 ] y a [ 3 3 . Se repite el proceso con
salto o intervalo la mitad del anterior.
184 Java 2. Manual de programacin
Como hay intercambio entre a [ 3 ] y a [ 4 ] se retrocede para comprobar que no se ha estropeado la orde-
nacin entre a [ 2 3 y a [ 3 ] y como est bien no se retrocede ms.
1 1 2 ! 4 ; 6 ( 7 (
Resultado final
El proceso termina, pues se han comparado todos los elementos con un salto o intervalo de uno y el salto
ya no puede ser menor.
Codificacin
publ i c c l as s Pr uebaCh
publ i c s t a t i c voi d mai n ( St r i ng [ ] ar gs)
i
i n t a[ ] = ( 7, 4, 8, 1, 12};
i n t i , j , k , sal t o;
sal t o = a. l engt h / 2;
whi l e ( sal t o > O)
t
f or ( i = sal t o; i < a. l engt h; i ++)
i
j = i - sal t o;
whi l e ( j >= O)
i
k = j t sal t o;
i f ( a[ j ] <= a[ kl )
else
I
j = - 1;
i n t auxi = a[ j l ;
a[ j l = a[ kl ;
a[ k] = auxi ;
j -= sal t o;
}
sal t o /= 2;
1
/ / Pr esent aci n de l os r esul t ados
for ( i = O; i < 5; i ++)
Cyst em. out . pr i nt l n( a[ i l ) ;
!
!
Arrays 185
7.1 1. ORDENACI ~N RPIDA
El mtodo consiste en:
Dividir el array en dos particiones, una con todos los elementos menores a un
cierto valor especfico y otra con todos los mayores que l. Dicho valor es uno
cualquiera, tomado arbitrariamente, del vector, y recibe la denominacin de
pivote.
Tratar, anlogamente a como se expuso en el primer apartado cada una de las
particiones, lo que conduce a un algoritmo recursivo.
Codificacin
public class Pr uebaQS
i
public static void qui cksor t (int a [ I , int i z, int de)
(
int i = i z;
int J = de;
int pi vot e = a [ ( i z+de) / 2] ;
do
i
while(a[i] < pi vot e) {i ++; 1
whiie(a[j] > pi vot e) {I - - ; 1
if ( i <= j )
i
int auxi = a[ i l ;
a[ i ] = a[ j ] ;
a[ j ] = auxi ;
i ++;
j - - ;
1
1
while ( i <= j ) ;
if ( j > i z) {qui ckSor t ( a, i z, j ) ; }
if ( 1 < de) {qui ckCor t ( a, i , de);}
1
public static void mai n ( St r i ng [ ] args)
t
int[] a = {6, 1, 4, 7, 2, 5, 3};
qui cksor t (a, O, a. l engt h- 1) ;
for (int i = O; i < a. l engt h; i ++)
Syst en. out . pr i nt l n( a[ i ] ) ;
!
186 Java 2. Manual de programacin
7.12. B~SQUEDA
La bisc-/i/eda es una de las operaciones ms importantes en el procesamiento de la
informacin, y permite la recuperacin de datos previamente almacenados. Cuando
el almacenamiento se encuentra en memoria principal, la bsqueda se califica de
interna. Existen diversas formas de efectuar bsquedas en un array.
del array hasta alcanzar el final del mismo y, si en algn lugar del array se encuen-
tra el elemento buscado, el programa deber informar sobre lailas posiciniposicio-
nes donde ha sido localizado. El algoritmo se puede optimizar utilizando una
variable lgica que evite seguir buscando una bez que el dato se ha encontrado si
nicamente se desea obtener la posicin donde se localiza por primera vez al ele-
mento buscado.
array de forma ordenada. Consiste en comparar el elemento buscado con el ele-
mento que ocupa la posicin central y, segn sea mayor o menor que el central y el
array se encuentre clasificado en orden ascendente o descendente, se repite la ope-
racin considerando un si i har~. a~~ formado por los elementos situados entre el que
ocupa la posicin cent r al +l y el ltimo, ambos inclusive, o por los que se
encuentran entre el primero y el situado en cent r al - 1, tambin ambos inclusive.
El proceso finalizar cuando se encuentre el dato o el sz/hcrrra.v de hzsqz/edu se
quede sin elementos.
La bzisqz/ecr lined consiste en recorrer y examinar cada uno de los elementos
La biisqiieda hinrrria requiere que los elementos se encuentren colocados en el
Codificacin recursiva
La implementacin que se efecta es recursiva (una operacin se llama a s misma).
AI encontrar el elemento buscado se devuelve su posicin y, si no se encuentra,
devuelve un nmero negativo, cuyo valor absoluto representa la posicin donde
dicho elemento debiera ser situado si se quisiera aadir a la lista sin que sta per-
diera su ordenacin.
publ i c class Bbi n
pr i vat e i nt bucquedaB; nar ; a( i nt [ : a, i nt i z, i nt de, i nt c)
i nt cent r al = ( i z + de) / 2;
i f ( de < i r )
r et ur n( - i z) ;
r et ur n( bucque3aBi nar i a ( a, i z, cent r al - 1, 2) ) ;
i f ( a[ cent r al ] < c)
i f ( c < ar cect r al : )
el se
r et ur n( %usquedaEi nar i a ( a, cent zal +l , de, c) ) ;
Arrays 187
el se
r et ur n( cect r a1) ;
i
publ i c i nt bsqedaB( i nt [ ] a, i nt c)
r et ur n( b~squecaB1: i ar ; a ( a, 3, a. l eng~h, c) ) ;
i
1
publ i c cl ass Cl ass1
i
publ i c st at i c voi d mai r . (Str-n.g [ ] ar gs)
/ / er. el ar r ay a l os el emenLos est n col ocados ae f or ma or denada
i nt [ ] a = ! ?, 2, 5, 7, 8, 9, 11, 123;
/ / muest r a el ar r ay
f or ( i nt I = O; I < a. l engt h; :-+)
Cyst em. o' dt . pr i nt l n( a[ i : ) ;
Syst em. out . pr i nt l n( ) ;
Bbi n buscador = new Bbi n ( ) ;
/ / Busca el 1
i nt p = buscador . bsqaedaB( a, 1) ;
/ *I nt er pr et a l a i nf ormaci j n devuel t a por el
i f (p >= O)
pr oceso de bsqueda * I
Cyst en. out .pr:nt ( " El el ement o 1 est a en " ) ;
Syst em. out . pr i nt l n ( " l a posi ci n "+ pj ;
el se
Cyst em. out . pr i nt ( " El ei ement o no esza. " ) ;
Syst em. out . pr i nt ( " Su l ugar deber i a ser " j ;
Cyst em. out . pr i nt l n( " l a posi ci n " + Mat h. abs (p) ) ;
Importante: La bsqueda binaria es mucho ms eficiente que la lineal, pero
requiere que los elementos se encuentren colocados en el array de forma orde-
nada.
188 Java 2. Manual de programacin
7.13. IMPLEMENTACIN GENRICA DE LOS MTODOS
DE ORDENACIN
Antes de presentar una implementacin genrica de los distintos mtodos de orde-
nacin hay que tener en cuenta que cuando los elementos de un array se declaran
a partir de la superclase Obj ect , dicho array se podr utilizar para almacenar
objetos de distinta clase. Los mtodos de ordenacin y bsqueda deben imple-
mentarse de forma que respectivamente puedan ordenar y buscar informacin en
arrays con cualquier tipo de contenido; para ello, se define una interfaz,
Compar abl e y se declara la informacin almacenada en el array, en lugar de
Obj ect , como Compar abl e. La interfaz Compar abl e tendr la siguiente
estructura:
/ * I nt er f az bsi co est ndar de compar aci n, concebi do par a admi t i r
var i os cr i t er i os de or denaci n en est e caso el campo cr i t er i o
no ser usado*/
i nt erf ace Compar abl e
boolean menor que( Compar ab1e c, i n t cr i t er i o) throws Except i on;
\
El objeto a almacenar en el array implementar la interfaz Compar abl e; por
ejemplo:
/ / obj et o Compar abl e
publ i c c l as s Ent er o implements Compar abl e
i n t val or ;
Ent er o ( i n t val or )
t hi s. val or = val or ;
publ i c boolean menor que ( Compar abl e c, i n t cr i t er i o) throws
Except i on
i f ( ! ( c i nstanceof Ent er o) )
/ / Lanza una excepci n ( vea el cap t ul o sobr e excepci ones)
throw new Except i on ( " Ti po de compar aci n i nvl i do" ) ;
Ent er o e = ( Ent er o) c;
return ( val or < e . val or ) ;
1
I
Arrays 189
Los mtodos de ordenacin deben codificarse ahora de la siguiente forma:
public class Met or d
i
public void cel ecci on ( Compar abl e [ ] a, int cr i t er i o) throws
Except i on
t
int mesor;
for (int 1 = O; 1 < a. l engt h- ; i ++)
menor = 1;
for (int j = 1+l ; j < a. l engt h; I ++)
if
( a [ j ] . mezor que ( a [ r ; e>. or ] , cr i zer i o)
menor = j ;
Compar abl e auxi =a [ i I ;
a[ i ] =a[ menor ] ;
a [ menor ] =auxi ;
}
public void i ncer ci on ( Compar abl e [ ] a, int cr ; r er - c) throws
Except i on
Compar abl e dux;
int 1;
boolean encoct r adoci t i o;
for (int i = 1; i < a. l engt h; I ++)
i
aux = a[ i ] ;
encont r ados; t i o = false;
while ( j >= O && ! encont r adosi t i o)
( aux. mencr que ( a [ I I , cr i t er i o) )
1 = i - 1;
if
a[ j +l ] =a[ j l ;
j - - ;
else
encont r adosi t i o = true;
a [ j t l ] =aux;
public void bur bul a ( Compar abl e [ ] a, int cr i t er i o) throws
Except i on
Compar abl e auxi = a[ ] I ;
a[ j ] = a[ ] +l ] ;
a[ j +i ] = auxi ;
190 Java 2. Manual de programacin
publ i c voi d bur bul aMel or ada ( Compar abl e [ I a, i n t cr i t er i o)
throws Except i on
boolean or denado;
i n t i = 1;
do
or denaao = true;
for ( i n t 3 = O; < < a. l engt h- 1; I ++)
( a: j +1] .menorque ( a [ J ! , cr i zer i o) ) i f
or demdo = f al s e ;
Compar abl e aux: = a[]' ;
a[ ] ; = a[ j L l 1;
a[ : tl ] = aux:;
i-t;
whi l e ( or denado == f a l s e ) ;
publ i c voi d gC ( Compar abl e a [ 1 , i n t cr i t er i o) throws Except i on
i
ql - i ci Cor t ( a, cr i t er - o, O, a. LengLh- 1) ;
public void qui cksor t ( Compar abl e a[ ] , i nt cr i t er i o, i nt i z, i nt de)
i
throws Except i on
i n t : = :z;
i n t j = de;
Ccinparable pi vot e = a [ ( i z+de) / 2] ;
do
whi l e ( a[ i ; . menor que( pi vot e, cr i t er i c) {i t +; 1
whi l e (pi vote.rnenorque ( a [ J I , cr i t er i o) ) {I - - ; 1
i f ( i <= j )
Compar abl e aux: = a [ i ! ;
ai i ; = a[ ] ; ;
a[:] = auxi ;
i - +;
- - _ .
> I
whi l e ( i <= 1) ;
if ( j > i z) {qci ckSort(a, cr i t er i o, i z, 3) ; )
if (: < ae) {qui ckCort( a, cr i t er i o, i , de) ; }
Arrays 191
El programa de prueba podra ser:
publ i c c l a s s Pr uebaT
I
publ i c s t a t i c voi d ri di n ( St r i ng [ I ar gs) throws Except i cr
i
Encer o[ : a = new Znt er o[ 7] ;
a[ u] = new Ent er o( 6) ;
a[:] = new Ent er o( 1) ;
a[ 2] = new Ent er o( 4) ;
a[ 3] = new Ent er o( 7) ;
a[ 4] = new Ent er o( ?) ;
a[ 5] = new Ent er o( [ >) ;
a[ 61 = new Er t er o( 3) ;
Met cr d or denadcr = new Yet or do ;
or der ador . sel ecci or ( a, 3 ) ;
for ( i n t 1 = O; 1 < a. , ~qgt h; I ++)
Syst em. out . pr i nt l n a[ i ] . val or ) ;
1
Cadenas y fechas
CONTENIDO
8.1. Creacin de cadenas.
8.2. Comparacin de cadenas.
8.3. Concatenacin.
8.4.
8.5. La clase St r i ngTokeni zer .
8.6. La clase St r i ngBuf f er .
8.7.
8.8. La clase Dat e.
8.9. Los formatos de fechas.
Otros mtodos de la clase St r i ng.
Mtodos de la clase St r i ngBuf f er .
8.10. La Clase Cal endar .
193
194 Java 2. Manual de programacin
Una cadena (string) es una secuencia de caracteres. Los arrays y
las cadenas se basan en conceptos similares. En la mayora de los
lenguajes de programacin, las cadenas se tratan como arrays de
caracteres, pero en J ava, una cadena (string) se utiliza de modo
diferente a partir de un objeto array.
J ava proporciona la clase incorporada st r i ng para manejar
cadenas de caracteres. En el caso de que se desee modificar con fre-
cuencia estas cadenas, es conveniente usar la clase St r i ngBuf f er
en lugar de St r i ng con objeto de consumir menos memoria.
En algunas ocasiones es, necesario efectuar un anlisis gra-
matical bsico de una cadena y, para ello, se emplea la clase
Ct r i ngTokeni zer , que permite dividir una cadena en subcade-
nas en aquellos lugares donde aparezcan en la cadena inicial
unos determinados smbolos denominados delimitadores.
Los programas tambin necesitan manejar frecuentemente la
fecha del sistema. Para trabajar con fechas en los programas se
utiliza la clase Gr egor i anCal endar , mientras que la clase Dat e
se puede utilizar para medir el tiempo que una determinada tarea
tarda en ejecutarse.
En este captulo se comentan las caractersticas de cada una
de las clases, de uso frecuente, anteriormente citadas.
8.1. CREA CI ~N DE CADENAS
Una de las clases ms frecuentemente utilizadas en los programas J ava es la clase
St r i ng perteneciente al paquete J ava. l ang. Las cadenas S t r i ng de J ava no
son, simplemente, un conjunto de caracteres contiguos en memoria, como ocurre en
otros lenguajes, sino que son objetos con propiedades y comportamientos. La clase
St r i ng se declara en J ava como clase f i nal como medida de seguridad y, por
tanto, no puede tener subclasec.
public final class St r i nq extends Obl ect implements Cer i al i zabl e,
Cci i par abl e
Existen dos formas de crear una cadena en J ava, mediante un literal y mediante
el empleo de un constructor explcito. Cada vez que en un programa J ava se utiliza
una constante de cadena, automticamente se crea un objeto de la clase Str i ng.
Para crear una cadena con un literal y asignarle una referencia, puede emplearse una
sentencia como la siguiente:
St r i ng sal udo = Hcl a;
Cadenas y fechas 195
La cadena as creada se coloca en un lugar especial reservado para las mismas y,
si posteriormente se crea otra cadena con el mismo literal, no se aade un nuevo
objeto a dicho espacio, sino que utiliza el objeto existente, al que aade una nueva
referencia.
Ejemplo
Las siguientes lneas de cdigo producen el resultado que se muestra en la Figura 8.1 :
St r i ng ci udad = " Madr i d" ;
St r i ng mi ci udad = " Madr i d" :
_. - Ambas r ef er enci as amput an al
mi smo l i t er al f si co en el
espaci o r eser vado par a el
~~ _ _ ~ al macenami ent o de l i t er al es
St r i ng
ci udad 7: Madrid
mi ci udad
Figura 8.1. Creacin de cadenas con el mismo literal.
Otra forma de crear cadenas es usar un constructor explcito, por ejemplo:
char ar r [ ] = { ' H' , ' o' , ' 1' , 'a' };
St r i ng sal udo = new C; r i ng( ar r ) ;
Esta ltima sentencia coloca un objeto St r i ng en el montczdo (heap), en lugar de
situarlo en el espacio reservado para las cadenas anteriormente comentado. Entre los
diversos constructores que posee la clase Str i ng pueden destacarse los siguientes:
public St r i ng ( )
public St r , cg( char [ ] arr)
public Ct r i ng( j ava. l ang. St r i ng cad)
public St ri r. g ( j ava . l a=g. St r i ngsuf f er buffer)
Crea un objeto St r i nq sin
caracteres.
Crea un objeto sr r i ng a
partir de un array de
caracteres.
Crea un St r i ng con los
mismos caracteres que otro
objeto St r i ng, es decir.
realiza una copia.
Crea un objeto St r i ng con
una copia de los caracteres
existentes en un
Ct r i ngBuf f er , que es una
cadena dinmicamente
redimensionable.
196 Java 2. Manual de programacin
Nota: La sentencia cad2 = new St ri ng( cad1) ; permite efectuar la copia
de la cadena, en este caso cadl , que se pasa como argumento.
La sentencia cad2 = cadl ; copia la referencia cadl en cad2 y consigue
que ambas variables permitan acceder al mismo objeto.
La sentencia cad2 = cadl . t ost r i ng ( ) produce unos resultados
anlogos a la anterior, puesto que cadl . t ost r i ng ( ) devuelve el propio
objeto St r i ng.
Ejemplo
Tras la siguiente sentencia:
St r i ng ci udad2 = new St r i ng ( Madr i d) ;
ci udad2 no tiene un valor literal colocado en el espacio reservado para el almace-
namiento de literales St r i ng, sino que es parte de un objeto separado St r i ng.
ci udad2 - Madrid
ci udad - Madrid
mi c i udad f
Figura 8.2. Diferencias entre la creacin de cadenas con el mismo literal
y mediante el uso de un constructor explcito.
AI elegir entre uno u otro mtodo es importante recordar posteriormente cul se
ha usado, pues esto afecta a la forma en la que las cadenas St r i ngs se pueden
comparar.
Las cadenas de caracteres tambin se pueden leer desde teclado y el mtodo
habitualmente utilizado para ello es r eadLi ne de la clase Buf f er edReader
que lee una secuencia de caracteres de un flujo de entrada y crea un objeto de
tipo St r i ng devolviendo una referencia al mismo. Se ha de tener en cuenta que
para efectuar este tipo de entrada debe construirse previamente un objeto de la
clase Buf f er edReader sobre otro de la clase I nput St r eamReader aso-
ciado a Syst em. i n.
Otro aspecto importante de los objetos de tipo St r i ng es que no pueden ser
modificados en memoria. En realidad, lo que esto quiere decir es que para modifi-
car una cadena existente J ava crea un nuevo objeto St r i ng con las modificacio-
nes y deja la cadena inicial, sin utilidad, disponible para la recoleccin de basura.
Cadenas y fechas 197
Por tanto, un programa que necesite efectuar muchas manipulaciones de cadenas
St r i ng puede consumir grandes cantidades de memoria y, para evitarlo, en dichos
casos deben reemplazarse los objetos St r i ng por objetos de la clase
S t r i ngBuf f er .
8.2. COMPARACIN DE CADENAS
La comparacin de cadenas se basa en el orden numrico del cdigo de caracteres;
es decir, que, al comparar cadenas, J ava va comparando sucesivamente los cdigos
Unicode de los caracteres correspondientes en ambas cadenas y si encuentra un
carcter diferente o una de las cadenas termina detiene la comparacin. Para que
dos cadenas sean iguales, han de tener el mismo nmero de caracteres y cada carc-
ter de una ser igual al correspondiente carcter de la otra. Al comparar cadenas la
presencia de un carcter, aunque sea el blanco, se considera mayor que su ausencia.
Adems, la comparacin de cadenas distingue entre maysculas y minsculas pues-
to que su cdigo no es el mismo, las letras maysculas tienen un nmero de cdigo
menor que las minsculas.
A la hora de comparar cadenas hay que tener en cuenta que el operador ==com-
para solamente las referencias de objeto, mientras que el mtodo equal s compa-
ra los contenidos de los objetos.
public boolean equal s ( j ava. l ang. Obj ect un0bj ect )
As, cuando se crean cadenas mediante literales, stas podrn ser comparadas
tanto con el operador == como con el mtodo equal s.
Ejemplo
Comparar dos cadenas usando primero el mtodo equal s y a continuacin el ope-
rador ==.
import j ava. i o. *;
public class Cor npar ar cadenas
i
public static void mai n ( St r i ng[ ] ar gs)
t
St r i ng nor nbr el , ci udadl , nor nbr e2, ci udad2;
nombr e1 = " Ana" ;
ci udadl = " Madr i d" ;
nombr e2 = " Pedr o" ;
198 Java 2. Manual de programacin
ci udad2 = " Madr i d" ;
Syst em. oi i t . pr i nt l n ( " Compar aci hn con equal s" ) ;
i f ( ci uaaci l . eq~al s ( ci >~dad2) )
Syst em. . cut . pr i nt l n ( nombr el + " y "+ nc mbr e2~
" son de ;a mi saa ci udad" ) ;
else
Syscen. cuz. pr i st l n (nor?brel + " y "t nombr e2+
" son de di st i nt a ci udad" ) ;
Syct er . o ~ t . pr i nt l n ( " Cci par aci cc con ==" j ;
i f (c: i dadl == ci udad2)
Syst er r , . out . pr i nt l n ( nombr e1 t " y "+ nor?,bre2-
'' scn de l a rnis.3 c1~1aad") ;
el se
Syszem. out . pr i r . t l n ( ?, cr . br el + " y "+ ncmbr e2+
" son de di st i nt a ci udad" ) ;
t
Si se desea comparar cadenas creadas usando un constructor explcito. ser nece-
sario emplear el mtodo equal s.
Importante: Para comparar cadenas, lo ms seguro es usar siempre el mtodo
equal s, aunque en algunas ocasiones esta operacin nos devolvera un resul-
tado anlogo al empleo del operador ==.
Ejemplo
Comparar dos cadenas ledas desde teclado usando primero el mtodo equal s y a
continuacin el operador == .
import j ava. i c. * ;
public cl ass Compar ar cadenas2
public stati c Szr i ng l eer ( )
I r put St r eamRea&r i c r = new 1nput St r ear . Reader ( Syccer n. i n) ;
Buf f er edReader br = ne w Buf f er edReader ( i sr j ;
St r i ng cadena = "";
try
/ "
readL: ne: publ i c j ava. l ang. Ct r i ng r eadL; ne( ) ,
es an ri etodo de j ava. i c. Buf f er edReader
*/
cader a = br . r eadi r . e ( j ;
Cadenas y fechas 1%
i
cat ch( Except i cr e)
: i
r et ur n cadena;
St r i ng noi bzel , vi - dadl , noY .bre2, ci uaad2 ;
Syszem. out . pr i nt l r - ( " I ndl qJ e el nombr e y pu
no- cr el = l eer ( ) ;
Bys t e~. oi t . pr i r _ l n( " ~- di que l a ci uaad y pci
ci udad1 r l eer ( ) ;
se RET CW" ) ;
Cyst em. cut . pr i r i t l r . ("I nC;q,e el nombr e y pul se RETCZL" ) ;
nomcr e2 = l eer ( ) ;
Syst ei . out . pri r. tl n ( " I ndi que l a ci - dad y pul se R5;'J RN") ;
ci uaad2 = l eer ( ) ;
Cyst em. cu: . pr i nt l z ( " Compar aci n con eqi i al s") ;
i f ( ci udad1 . equal s ( ci uaad2) )
Syst em. out . pr i nt l n( nombr e1 + " y "+ nombr e2 +
" sor' de l a mi sma ci i dad" ) ;
Syst em. out . pr i nt l n( ncmbr e1 - " y "t nombr e2 t
" cor de di st i nt a ci udad" ) ;
el se
Cyscem. out . pr i nt l r . ( " Conpar aci r , ccn ==") ;
i f ( ci udaal == ci udad2)
Cyst e~. out . pr i nt l - ( nomhLel + " y "- ncmbr e2 +
" san de l a mi sma ci udad" ) ;
Cystem. out. pr i ntl r ( nombr el + " y ''& noi bre2 t
" son de di sti rta ci uaad" ) ;
el se
I
Si el mtodo l eer del programa anterior se sustituye por este otro:
publ i c st at i c Ct r i nq l eer()
I nput St r eamReader :sr = new 1np~~t St r eaaReader j Syst er n. i r . ) ;
Buf f er edReader br = new Buf f eredReacer(i srj ;
Stri ng cadena = "";
t r y
i
cadena = Icr . r eadLi ne ( ) . i nt er n ( ) ;
i
cat ch( Except i or , e )
t i
r et ur n cadena;
200 Java 2. Manual de programacin
el resultado obtenido al comparar con el operador == ser diferente, ya que el mto-
do i nt er n ( ) obliga a las cadenas a colocarse en el espacio reservado por J ava
para el almacenamiento de literales St r i ng.
emplearse el mtodo
Cuando se desean ignorar las diferencias entre maysculas y minsculas, debe
public boolean equal sI gnor eCase ( j ava. 1ang. St r i ng o t r a c a d )
y, por tanto, la ejecucin de las siguientes lneas de programa
if ( " ANA" . equal sI gnor eCase ( " Ana" ) )
Syst em. out . pr i nt l n ( " son i gual es" ) ;
mostrara que las cadenas son iguales.
Nota: compar eTo y compar eToI gnor eCase son mtodos habitualmen-
te utilizados en los programas que necesitan ordenar arrays de cadenas.
Otra forma de comparar cadenas es utilizar el mtodo compar eTo, cuyo for-
mato es el siguiente:
public int compar eTo ( j ava. l ang. St r i ng o t r a Ca d )
Este mtodo devuelve O cuando las cadenas son iguales, un nmero negativo si el
objeto St r i ng que invoca a compar eTo es menor que el objeto St r i ng que se le
pasa como argumento y un nmero positivo cuando es el argumento el que es mayor.
Ejemplos
I . St r i ng cadl = new St r i ng( " Ana" ) ;
St r i ng cad2 = new St r i ng ( " Anast asi a" ) ;
Syst em. out . pr i nt ( " La cadena " ) ;
if ( cadl . compar eTo ( cad2 ) < O)
else if ( cadl . compar eTo ( cad2 ) == O)
else
Syst em. out . pr i nt l n( cad1 t " es menor que " + cad2) ;
Cyst em. out . pr i nt l n( cad1 t " es i gual que "t cad2) ;
Syst em. out . pr i nt l n( cad1 + " es mayor que " + cad2) ;
el resultado es
La cadena Ana es menor que Anast asi a
Cadenas y fechas 201
2. if ( " Ana" . CGmpar eTG ( " ANASTASI A" ) < O)
Syst er n. out . pr i nt l n ( " es menor " ) ;
Syst er n. out . pr i nt l n ( " no es menor " ) ;
else
el resultado es
no es menor
3. Syst em. out . pr i nt l n ( " J uan" . cor npar eTo ( " J avi er " ) < o) ;
el re.sultado es
f al se
Para no diferenciar entre maysculas y minsculas, en lugar de compar eTo se
emplea compar e T o I gno r e Ca c e.
8.3. co N CATE N AC I N
Concatenar cadenas significa unir varias cadenas en una sola conservando el
orden de los caracteres en cada una de ellas. En J ava es posible concatenar
cadenas usando tanto el operador +como el mtodo concat .
El operador t en J ava tiene un significado especial de concatenacin de cadenas
y se puede utilizar con objetos de la clase St r i ng.
Ejemplo
St r i ng cadl = n e w St r i ng( " 4 + 2" ) ;
St r i ng cad2 = n e w St r i ng( " = " ) ;
St r i ng oper aci on = cadl + cad2;
/ / i mpr i me 4 + 2 =
Cyst er n. out . pr i nt l n( oper aci on) ;
En el caso de que uno de los operandos que intervienen en una expresin sea de
cadena, el operador t convierte a cadena los valores de otros tipos que intervienen
en la expresin y efecta concatenacin.
Ejemplo
SyStem. out. pri ntl n( operaci on t 4 t 2) ; / / Sal i da 4 + 2 = 42
En el estudio de la concatenacin de cadenas y teniendo en cuenta la imposibi-
lidad de modificar los objetos St r i ng, es importante comprender el funciona-
miento de las siguientes instrucciones:
202 Java 2. Manual de programacin
S:r:.ig av; co = new St r i ng ("Ura cader a" ) ;
avi so = ob-co - " puede zcntener caracteres numri cos";
Estas sentencias no cambian el objeto St r i ng original, sino que J ava adquiere
una nueva zona de memoria para un nuevo objeto St r i ng, donde quepa la nueva
cadena, copia el antiguo en el nuevo objeto y aade la nueva parte. La referencia
avi so apunta ahora hacia la nueva cadena. La vieja versin del St r i ng queda
disponible para la recoleccin de basura.
Estas sentencias se podran haber escrito de la siguiente forma:
Str i ng avi so = new Str i ng ("J na cadena" ) ;
aT~7:r.o t= 1' puede conzene r car ac t e re s n , mer 1 c o c " ;
es decir, es posible tambin usar el operador += en operaciones de concatena-
cin.
Otra forma de efectuar la concatenacin de cadenas es utilizar el mtodo con-
cat . Este intodo devuelve un nuevo objeto, resultado de aadir los caracteres del
objeto St r i ng especificado como parmetro a continuacin de los del objeto
St r i ng que invoca concat .
Ejemplo
Stri r.g rad1 = new Str i ng( " 4 t 2" ) ;
Stri 7.g cae2 = new C:rinq ( " = " ) ;
Srr:ng operaci or. = cacil. concat ( cad21 ;
//i:1,prime 4 t 2 =
C~ste~. c; t. pr: ntl i ( operari on) ;
8.4. OTROS MTODOS DE LA CLASE String
Entre los restantes mtodos de la clase St r i ng se pueden destacar:
I . , public i n t l ength ( ) )
El mtodo l engt h devuelve la longitud de la cadena
Ejemplo
C-ririg cad1 = new Ctri nq ("ANA") ;
Cys: em. out . pr:r.tl n (cad:. l er, gth ( ) ) ;
Cadenas y fechas 203
Nota: Referencia un carcter fuera de los lmites de una cadena Stri ng, es
decir, con ndice negativo o mayor o igual al tamao del St r i ng, produce
una St r i ngI ndexOut Of BoundsExcept i on.
2. /public char charA t (i nt i ndi ce)l
Devuelve el carcter de la cadena que se encuentra en la posicin
especificada mediante el parmetro i n d i c e , lo mismo que en el
caso de los arrays se considera que el primer carcter de una
cadena se encuentra situado en la posicin cero y el ltimo en
l engt h ( ) -1.
Ejemplo
public cl ass Ej char At
public stati c void rnair. ( St r - ng[ ] ar gs)
I
St r i ng cad1 = new St r i ng ("ANA") ;
for (i nt i = O ; I < cadl . ; engt k. ( ) ; itt)
Cystem. out. pr i nti n( caSl . char A t( l ) ) ;
i
1
h p r i t w e t i pri ri t ci l l ci
A
N
A
3U. /publ i c j ava. l ang. St r i ng subst r i ng ( i nt i ' i ci , i nt Z : R ) ~
36. publ i c j ava. i ang. St r i nq subst r i ng ( i nt i ni ci o) 1
El mtodo subst r i ng permite extraer una subcadena de una cadena
y puede ser invocado con el paso de uno o de dos parmetros a
eleccin del programador. Si se especifica un parmetro el mtodo
devuelve una nueva cadena que comienza donde indica i ni ci o
y se extiende hasta el final de la misma; si se especifican dos. la
nueva cadena estar formada por los caracteres existentes en la cadena
original entre la posicin i ni ci o y la f i n- 1, ambas inclusive.
public class Ej subst r i r , gs
I
204 Java 2. Manual de programacin
publ i c stati c void mai n ( St r i ng[ ] ar gs)
i
St r i ng cadl = new St r i ng ("ANA") ;
for ( i nt i = O ; i < cadl . l engt h( ) ; I ++)
Cyst em. out . pr i nt l n( cadl . subst r i ng( i , i t l ) ) ;
- ri me en pant al l a
A
N
A
4. lpublic cnar [ ] t oChar Ar r ay ( ) 1
Devuelve un array de caracteres creado a partir del objeto Str i ng.
Ejemplo
publ i c cl ass Ej t oChar Ar r ay
{
publ i c stati c void mai n ( St r i ng[ ] args)
Ct r i nq sal >J do = new St r i ng ( " hol a" ) ;
/ / Cr ea un ar r ay de car act er es a par t i r de l a cadena
char[; ar r = sal uci o. toCkarA rray();
/ / Eodi f i ca e l ar r ay de car act er es pasando cada
for ( i nt i =O; i <ar r . l engt h; i t t )
Cyscer r . out . pr i nt l n ( ar r ) ;
/ / La cader a no se ha modi f i cado
Syst en. o' ; t . pr i nt l n ( sal udo) ;
' J no de sus car act er es a mayscul as
arr[i ]=(char) ( ar r [ i ] - ( ' a' - ' A' ) ) ;
iinprime en pantalla
HOLA
hol a
Observacin: El mtodo l ength() devuelve la longitud de una cadena
mientras que la variable l engt h de un array informa sobre la longitud del
mismo:
cadl . l engt h ( ) ;
ar r . l engt h;
Cadenas y fechas 205
5. public boolean r egi onMat ches (boolean i g n o r a Di f , int i n i c i o l ,
j ava. l ang. St r i ng o t r a c a d , int i n i c i o 2 , int c uant os )
Compara una parte de una cadena con parte de otra y devuelve un resultado
bool ean. Si el primer parmetro es tr ue, no distingue entre maysculas y
minsculas. El significado de los restantes parmetros es:
i ni ci ol , posicin en la que comienza la comparacin para la cadena que
invoca al mtodo.
ot r a Cad, la segunda cadena. i n i c i o2 posicin de la segunda cadena en
la que empieza la comparacin.
cuantos nmero de caracteres a comparar.
6. [public boolean endcWi t h( j ava. 1ang. St r i ng s u f i j o ) I
Devuelve t r ue cuando la cadena termina con los caracteres
especificados como argumento.
7. lpublic boolean st ar t sWi t h( j ava. l ang. St r i ng p r e f i j o ) l
Devuelve t r ue cuando la cadena comienza con los caracteres
especificados como argumento.
8U.l public int i ndexof (int car ) ]
8b.l public int i ndexof ( j ava. l ang. St r i ng cad) I
Estos mtodos buscan la cadena o carcter especificados como parmetros
en la cadena fuente; y cuando los encuentran, interrumpen la bsqueda,
devolviendo la posicin donde aparece el carcter o donde comienza la cade-
na buscada en la cadena fuente. Si no encuentran el carcter o cadena bus-
cados, devuelven - 1,
i ndexof podra utilizarse para comprobar si la opcin elegida en un men
de opciones es vlida.
import j ava. i o. *;
public class Ver i f i caOpci on
i
public static void mai n ( St r i ng[ ] ar gs)
i
206 Java 2. Manual de programacin
/ / Cadena con el conj unt o de opci ones vl i das
St r i ng opci ones = " ABCS" ;
char opci on;
i nt n;
t ry
i
Syst em. out . pr i nt l n ( " MEN" ) ;
Syst em. out . pr i nt l n ( " A. Al t as" ) ;
Syst em. out . pr i nt l n ( " B. Baj as" ) ;
Syst em. out . pr i nt l n ( " C. Consul t as" ) ;
Syst em. out . pr i nt l n ( " S. Sal i r " ) ;
do
t
Syst em. out . pr i nt ( " El i j a opci n ( A, B, C, S) " ) ;
opci on =( char ) Syst em. i n. r ead( ) ;
n = Syst em. i n. avai l abl e( ) ;
Syst em. i n. ski p ( n) ;
) whi l e ( opci ones. i ndex0f ( opci on) == - 1 1 I n! =2) ;
swi t ch ( opci on)
i
case ' A' :
/ / Al t as
break ;
case ' B' :
br eak;
case ' C' :
/ / Consul t as
break:
case ' S I :
/ / Sal i r
/ / Baj as
1
1
cat ch ( Except i on e)
t }
9. l publ i c j ava. l anq. St r i nq r epl ace ( char ol dchar , char newChar ) l
Devuelve una nueva cadena resultante de reemplazar todas las apariciones
del ol dchar con el newchar .
1O. I pubi i c j ava. l ang. st r i ng t r i m0 I
Elimina los espacios en blanco que pudieran existir al principio o final de
una cadena.
11. l pubi i c j ava. i ang. st r i ng t oLower Case 0 1
Convierte a minsculas las maysculas de la cadena.
Cadenas y fechas 207
13d.
12. / publ i c j ava. l ang. st r i ng t oupper case 0 1
publ i c st at i c j ava. l ang. St r i ng val ueof (char [ ] dat os ,
i nt desplazamiento, i nt cont )
Convierte a maysculas las minsculas de la cadena.
13a. l publ i c st at i c j ava. l ang. St r i ng val ueOf ( boo1ean b)l
~~
13b. I publ i c st at i c j ava. l ang. St r i ng val ueOf ( char .>I
13~. bubl i c stati c j ava . l ang . St r i ng val ueof (char [ ] da t os) ]
13e. \ publ i c st at i c j ava. l ang. St r i ng val ueof (double d) l
13f. l pubi i c st at i c j ava. 1ang. St r i ng val ueof ( f i oat f);
13g. l p~bi i c st at i c j ava. l ang. St r i ng val ueOf ( i nt i)]
13h. l pubi i c st at i c j ava. l ang. St r i ng val ueof ( l ong
13i . l publ i c st at i c j ava. l ang. St r i ng val ueof ( j ava. l ang. Obj ect obj)1
Todos estos mtodos crean cadenas a partir del correspondiente parmetro y
devuelven dichas cadenas.
~ -
Recuerde: Para convertir una cadena de caracteres que representa un nmero
al valor correspondiente se utilizan mtodos de las clases Doubl e, Fl oat,
I nt eger , como doubl eval ue, f l oat val ue o par sei nt . En el caso
de doubl e y f l oat el primer paso ser construir un objeto Doubl e o Fl oat ,
mientras que en el caso de los tipos enteros no es necesario.
int ent er o = I nt eger . par seI nt ( cadena) ;
Doubl e d = n e w Doubl e( cadena) ;
double r eal = d. doubl eVal ue ( ) ;
208 Java 2. Manual de programacin
8.5. LA CLASE StringTokenizer
St r i ngTokeni zer pertenece al paquete j ava . ut i 1 y acta sobre St r i ng.
Proporciona capacidades para efectuar un anlisis gramatical bsico de cadenas, efec-
tuando su divisin en subcadenas por aquellos lugares donde aparecen en la cadena
inicial unos determinados smbolos denominados delimitadores. El primer paso para
efectuar el anlisis consiste en la creacin de un objeto St r i ngTokeni zer
mediante alguno de los siguientes mtodos:
la. public St r i ngTokeni zer ( j ava. l ang. St r i ng cad)
lb. public St r i ngTokeni zer ( j ava. 1ang. St r i ng cad, j ava. l ang. Ct r i ng
delim)
I C. public St r i ngTokeni zer ( j ava. 1ang. St r i ng c a d , j ava. l ang. St r i ng
delim, boolean devol verTokens)
El parmetro cad representa la cadena que se desea analizar y el parmetro,
del i mrepresenta los delimitadores; si no se especifica ningn parmetro se con-
sideran delimitadores por defecto, el espacio en blanco, tabulador, avance de lnea
y retorno de carro ( I ' \ t \ n \ r I ! ) , El parmetro que aparece en el tercer construc-
tor devol ver Tokens, de tipo booleano, permite establecer si se deben devolver
o no los delimitadores cuando se analiza una cadena. Otros mtodos interesantes de
la clase en estudio son los siguientes:
public j ava. l ang. St r i ng next Token0
Devuelve el siguiente t oken (unidad lexicogrfica) y cuando no lo encuentra lanza
una excepcin,
NoSuchEl ement Except i on
public j ava. l ang. St r i ng next Token( j ava. l ang. St r i ng delim)
Devuelve el siguiente t oken y permite cambiar la cadena delimitadora.
public bool ean hasMor eTokens ( )
Devuelve t r ue o f al se segn queden o no t okens en la cadena.
public int count Tokens ( )
Devuelve el nmero de t okens que aun no se han analizado.
Ejemplo
El siguiente ejemplo muestra el funcionamiento de S t r i ngTo keni zer a traves
del mtodo di vi de que recibe como parmetro una cadena con una expresin y
devuelve en un array de cadenas los operandos y operadores de la misma.
Cadenas y fechas 209
Cadena a analizar en el ejemplo
" ( 31. 4+5^2) * 7 . 3 "
Cadena delimitadora que se establece
I l + - * / A ( ) I 1
Salida en pantalla
(
31. 4
5
2
+
A
I
*
7 . 3
import j ava. ut i l . *;
public cl as s Ej St r i ngTokeni zer
t
pri vate s t a t i c St r i ng[ ] expr esi onDi vi di da;
pri vate static St r i ng [ ] di vi de ( St r i ng cad)
t
St r i ngTokeni zer st 2 = new St r i ngTokeni zer ( cad,
i nt cont = O;
while ( st 2. hasMor eTokens ( ) )
i
"+- */ " ( ) ' I , true) ;
cont ++ ;
st 2. next TokenO;
1
St r i ngTokeni zer st = new St r i ngTokeni zer ( cad,
St r i ng[ ] aux = new St r i ng[ cont ] ;
f or ( i nt i =O; i <aux. l engt h; i ++)
return dux;
"+- * / " ( ) " , t r u e ) ;
aux[ i ] = st . next Token( ) ;
1
public s t a t i c void mai n ( St r i ng[ ] ar gs)
{
St r i ng cad = " ( 31. 4+5^2) * 7 . 3 " ;
expr esi onDi vi di da = di vi de ( cad) ;
f or ( i nt i =O; i < expr esi onDi vi di da. l engt h; i t +)
Syst em. out . pr i nt l n( expr esi onDi vi di da[ i ] ) ;
8.6. LA CLASE StringBuffer
AI igual que Stri ng, la clase St r i ngBuf f er tambin pertenece al paquete
j ava. l ang y ha sido declarada como f i nal ; pero a diferencia de los objetos
Stri ng, con los que se necesita reservar una nueva rea en memoria para crear una
nueva versin, los objetos S t r ingBu f f e r son modificables, tanto en contenido
como en tamao.
public finai class St r i ngBuf f er extends Obj ect i ql ement s Ser i al i zabl e
21 0 Java 2. Manual de programacin
A la hora de elegir entre usar objetos St r i ng o St r i ngBuf f er hay que
tener en cuenta que los St r i ng mejoran el rendimiento cuando el objeto no se
modifica, mientras St r i ngBuf f er es la clase recomendada si el objeto va a
sufrir muchas modificaciones. Los objetos St r i ngBuf f er tienen una determi-
nada capacidad y, cuando sta se excede por la adicin de caracteres, crecen auto-
mticamente. En realidad J ava utiliza objetos de la clase S t r i ngBu f f e r por su
cuenta cuando se utilizan los operadores +o += para concatenar cadenas.
Constructores
public St r i ngBuf f er O
public St r i ngBuf f er (int longitud)
Construye un Ct r i ngBuf f er
sin caracteres, con capacidad
inicial para 16.
Construye un Ct r i ngBuf f er
sin caracteres, con capacidad
inicial para l ongi t ud carac-
teres.
public St r i ngBuf f er ( j ava. l ang. Ct r i ng cad) Construye un St r i ngBuf f er
con la misma secuencia de ca-
racteres que la cadena recibida
como parmetro. La capacidad
inicial del St r i ngBuf f er es
para 16 caracteres ms de los
almacenados en dicha cadena.
8.7. MTODOS DE LA CLASE StringBuffer
Los mtodos importantes de la clase S t r i ngBuf f e r son:
public int l engt h( )
Devuelve el nmero de caracteres actuales.
public int capaci t y
Devuelve la capacidad.
public synchronized void encur ecapaci t y (int minimacapacidad)
Establece una capacidad minima.
public synchronized void set Lengt h (int nuevaLongi tud)
Establece la longitud, si es menor que el nmero de caracteres actuales se trunca a la
longitud especificada.
public synchronized j ava. 1ang. Ct r i ngBuf f er append(boo1ean b)
Cadenas y fechas 21 1
publ i c synchr oni zed j ava. 1ang. St r i ngBuf f er append( char c)
publ i c synchr oni zed j ava. 1ang. St r i ngBuf f er append( char [ ] cad)
publ i c synchr oni zed j ava. 1ang. St r i ngBuf f er append( char [ ]
cad, i nt desplazamiento, i nt longitud)
publ i c j ava. 1ang. St r i ngBuf f er append( doub1e d)
publ i c j ava. 1ang. St r i ngBuf f er append( f 1oat f)
publ i c j ava. 1ang. Ct r i ngBuf f er append( i nt i)
publ i c synchr oni zed j ava. 1ang. Ct r i ngBuf f er append( 1ong 1)
publ i c j ava. l ang. St r i ngBuf f er append( j ava. l ang. 0bj ect o b j )
publ i c j ava. 1ang. St r i ngBuf f er append( j ava. l ang. St r i ng cad)
Los mtodos append aaden al final del St r i ngBuf f er la cadena resultante de la
transformacin del correspondiente argumento.
publ i c j ava. 1ang. St r i ngBuf f er i nser t ( i nt desplazamiento,
bool ean b)
publ i c synchr oni zed j ava. l ang. St r i ngBuf f er i nser t ( i nt
desplazamiento, char c)
publ i c synchr oni zed j ava. l ang. St r i ngBuf f er i nser t ( i nt
desplazamiento, char [ ] cad)
publ i c synchr oni zed j ava. 1ang. St r i ngBuf f er i nser t ( i nt i ndex,
char [ ] cad, i nt desplazamiento, i nt longitud)
publ i c j ava. l ang. St r i ngBuf f er i nser t ( i nt desplazamiento, doubl e d)
publ i c j ava. 1ang. St r i ngBuf f er i nser t ( i nt desplazamiento, f l oat f)
publ i c j ava. 1ang. St r i ngBuf f er i nser t ( i nt desplazamiento, i nt i)
publ i c j ava. 1ang. St r i ngBuf f er i nser t ( i nt desplazamiento, l ong 1)
publ i c synchr oni zed j ava. l ang. St r i ngBuf f er i nser t ( i nt
desplazamien to, j ava. l ang . Obj ect obj )
publ i c synchr oni zed j ava. 1ang. St r i ngBuf f er i nser t ( i nt
desplazamiento, j ava. 1ang. St r i ng cad)
Los mtodos i nser t colocan distintos tipos de datos, previamente transformados a
cadena, en una determinada posicin del St r i ngBuf f er .
publ i c synchr oni zed j ava. 1ang. St r i ngBuf f er del et e( i nt inicio,
i nt fin)
21 2 Java 2. Manual de programacin
Elimina del objeto St r i ngBuf f er los caracteres exitentes entre las posiciones i ni ci o
y f i n- 1.
public synchronized j ava. l ang. St r i ngBuf f er r epl ace (int i n i c i o ,
Sustituye los caracteres existentes entre las posiciones i ni ci o y f i n- i por los especifi-
cados mediante cad.
int f i n, St r i ng c a d )
public synchronized j ava. 1ang. St r i ngBuf f er r ever s e0
Invierte la cadena almacenada en el St r i ngBuf f er .
public j ava. l ang. St r i ng subst r i ng( i nt i n i c i o )
public j ava. l ang. St r i ng subst r i ng (int i n i c i o , int f i n )
Permite extraer un St r i ng de un St r i ngBuf f er y puede ser invocado pasndole dos
o bien un nico parmetro. Cuando slo se le especifica un parmetro el mtodo devuelve
una nueva cadena que comienza donde indica inicio y se extiende hasta el final de la mis-
ma, si los parmetros son dos la nueva cadena estar formada por los caracteres existentes
en la original entre la posicin i ni ci o y la f i n- 1, ambos inclusive.
public j ava. l ang. St r i ng t ost r i ng( )
Copia el St r i ngBuf f er en un St r i ng y devuelve dicha copia.
public synchronized char char At ( i nt i n d i c e )
Devuelve el carcter existente en una determinada posicin.
public synchronized void set Char At (int i n d i c e , char car)
Coloca el carcter car en una determinada posicin, sobreescibiendo el all existente con
el nuevo.
public synchronized void get char s (int f ue nt e I ni c i o, int f uent eFi n,
char [ I d e s t , int d e s t l n i c i o )
Copia en un array los caracteres del St r i ngBuf f er , devolviendo dicho array.
8.8. LA CLASE Date
En J ava 2 la clase Date representa fechas y horas y tiene dos constructores:
public Dat e0
public Dat e (long n u m)
Crea un nuevo objeto Dat e y coloca en e1
la fecha y hora actuales
Crea un nuevo objeto Dat e y coloca en el
la fecha obtenida al interpretar el parme-
tro como el nmero de milisegundos en
que debe incrementarse una fecha arbitra-
ria,] de enero de 1970.
Cadenas y fechas 21 3
Entre los mtodos de esta clase destacan:
public j ava. l ang. St r i ng t ost r i ng ( ) Convierte el objeto Dat e en una cadena
de caracteres.
public long get Ti r ne ( ) Devuelve el nmero de milisegundos
transcurridos desde una fecha arbitraria. 1
de enero de 1970.
import j ava. ut i l . *;
Dat e actual = new Dat e( ) ;
Systern. out. pri ntl n( actual ) ;
8.9. LOS FORMATOS DE FECHAS
Los formatos especiales para las fechas se establecen mediante la clase Dat eFor mat
del paquete j ava . t ext y se crea un objeto,formateador. For mat es la clase base
en el formate0 de informacin sensible a la localidad, como fechas y nmeros.
public abstract cl ass For mat extends Obj ect implements
Ser i al i zabl e, Cl oneabl e
y Dat eFor mat extiende For mat .
public abstract cl ass Dat eFor mat extends For mat
Los mtodos
public stati c fi nal j ava. t ext . Dat eFor mat get Dat eI nst ance0
Y
public stati c f i nal j ava. t ext . Dat eFor r nat get Ti r neI nst ance0
sin parmetros permiten crear unformateador con el estilo de formato local.
Ejemplo
import j ava. ut i l . *;
import 1ava. t ext . Dat eFor r nat ;
21 4 Java 2. Manual de programacin
. . .
Dat e act i al = new Dat e 0 ;
Dai eFor mat f or r at eador = Dat eFor mat . get Dat eI nst ance0;
Cyster.ot.pri ntl n(f ornateador.f or.f ormac(actua1));
Tambin es posible establecer un estilo especfico, utilizando el mtodo
publ i c stati c f i nal j ava. t ext . 3at eFor r at get 3at eI nct ance( i nt
esti l o)
y pasndole alguno de los siguientes valores como parmetro:
publ i c stati c f i nal i nt DEFAUL T
publ i c stati c f i nal i nt FULL
publ i c stati c f i nal i nt LONG
publ i c stati c f i nal i nt MEDI UM
e incluso establecer la localidad
publ i c stati c f i nal j ava. t ext . Dat eFor mat get Dat eI nct anc
( i nt e s t i l o , j ava. ut i l . Local e unalocalidad)
Observe que el segundo parmetro es de la clase Local e, algunas de cuyas
constantes son:
publ i c stati c f i nal j ava. ut ; l . Local e ENGLI SH
publ i c stati c f i nal j ava. ut : l . Local e GERMAN
Ejemplo
import l ava. ut i l . * ;
import l ava. t ext . *;
. . .
DaLe act ual = new Dat e 0 ;
Dat eFor mat f or mat eadcr = Cat eLor mat . get Dat e1nst ance
Cyct eI - . oct . pr i ?t l n( f or mat eador . f or mat ( act ual ) ) ;
( >at eFcr nat . LC! dG, Local e. ENGLI SH) ;
8.10. LA CLASE Calendar
La clase Cal endar y su subciase Gr egor i anCal endar representan datos de
tipo calendario. La clase Cal endar permite crear fechas especficas, establecien-
do el da, mes y ao, incluyendo la zona y los ajustes horarios y tambin permite
obtener todos ellos, as cdmo el da de la semana.
Cadenas y fechas 21 5
publ i c abstract cl ass Calendar extends Object implements
Ceri al i zabl e, Cloneable
publ i c cl ass GregorianCalendar extends Cal ezdar
Entre los mtodos de la clase Calenciar se pueden citar:
publ i c stati c synchroni zed j ava.uti l .Cal endar getI nstance0
Devuelve un objeto de tipo Gregoriar!Calendar inicializado con la fecha y hora
actuales y huso horario y sitio por omisin.
publ i c f i nal i nt get( i nt campo)
Devuelve parte de una fecha.
publ i c f i nal Date getTi me0
Devuelve el tiempo actual del calendario.
publ i c f i nal voi d set( i nt ao, i nt mes, i nt d i a )
publ i c f i nal voi d set( i nt ao, i nt mes, i nt d i a , i nt h o r a , i nt
minutos)
publ i c f i nal voi d set( i nt ao, i nt mes, i nt d i a , i nt h o r a , i nt
minutos, i nt segundos)
Establecen partes de una fecha.
publ i c f i nal voi d cetTime (Date unDatej
Establece el tiempo para el calendario con la fecha dada.
Constantes
publ i c stati c f i nal i nt J ANUARY
publ i c stati c f i nal i nt FEBRUARY
publ i c stati c f i nal i nt MON3AY
publ i c stati c f i nal i nt TUESDAY
. . .
Campos
publ i c stati c f i nal i nt DAY P - OF WEZK
publ i c stati c f i nal i nt DAY OF-YEAR
publ i c stati c f i nal i nt HOUE- OF~~AY
Ejercicio
El programa FechaCumpl determina cuantos das faltan para un cumpleaos.
21 6 Java 2. Manual de programacin
import j ava. i o. *;
import j ava. ut i l . *;
public class FechaCumpl
public static void mai n ( St r i ng[ ] ar gc)
I
I nput St r eamReader i sr = new I nput St r eamReader ( Syst em. i n) ;
Baf f er edReader br = new Buf f er edReader ( i sr ) ;
St r i ng nombr e;
try
Syst em. out . pr i nt l n ( " Escr i ba su nombr e y pul se RETURN" ) ;
nombr e = br . r eadLi ne ( ) ;
Syst em. out . pr i nt 111 ( " i ndi que el d a de su cumpl eaos" +
int di a = I nt eger . par seI nt ( br . r eadLi ne0) ;
Syst em. out . pr i nt l n ( " i ndi que el nmer o de mes en que" +
int mes = I nt eger . par seI nt ( br . r eadLi ne ( ) ) ;
Cal endar cal l = Cal endar . get i nst ance( ) ;
Cal endar cal 2 = Cal endar . get I nst ance( ) ;
ca12. set ( cal l . get ( Cal endar . YEAR) , mes -
int di f er enci a = ca12. get ( Cal endar . DAY- OF- YEAR) -
if ( di f er enci a > O)
else
" y pul se RETURN" ) ;
" naci y pul se RETURN" ) ;
1, di a) ;
cal l . get ( Cal endar . DAY- OF- YEAR) ;
Syst em. out . pr i nt l n ( " Fal t an " +di f er enci a+" di as" ) ;
if ( di f er enci a == O)
else
Syst em. out . pr i nt l n ( " FELI CI DADES" ) ;
Syst em. out . pr i nt l n ( " Su cumpl eaos f u hace " t
Mat h. abs ( di f er enci a) +" di as" ) ;
1
catch ( I OExcept i on e)
I
Syst em. out . pr i nt l n ( " Er r or " ) ;
1
CA Pl T 9
Interfaces I grficas I
de usuario
CONTENIDO
9.1. El AWT.
9.2.
9.3. La clase Component .
9.4. La clase Cont ai ner .
9.5. Ventanas.
9.6. Clase Panel .
9.7. Clase Label .
9.8. Clase But t on.
9.9. Clase Text component .
9.10. Clase Canvas.
9.1 1. Clase Choi ce.
9.12. Clase Checkbox.
9.1 3. Listas.
9.14. Clase Scr ol l bar .
9.15. Mens.
9.1 6. Administradores de diseo.
9.17. Swi ng.
Realizacin de dibujos: clase Gr aphi cs.
21 7
21 8 Java 2. Manual de programacin
~~
Las interfaces Grficas de Usuario (IGU)' ofrecen objetos visuales
sobre los cuales pueden los usuarios actuar y de esta forma comu-
nicarse con un programa. En la versin 2 de J ava, la biblioteca
denominada J ava Foundation Classes proporciona un conjunto de
clases destinadas al diseo de interfaces grficas, entre las que,
conjuntamente con las de j ava . awt , destacan las pertenecientes
al paquete j avax. swi ng. Los componentes Swing se ejecutan
uniformemente en cualquier plataforma y constituyen una mejora
sobre los del awt aunque no siempre los reemplazan. Los compo-
nentes de las IGU (botones, campos de texto, etc.) esperan a que
el usuario ejecute alguna accin sobre ellos; es decir, esperan un
evento (o suceso). Por eso se dice que la programacin con IGU
es una programacin dirigida por eventos. La gestin de eventos
se ver con mayor profundidad en el captulo diez.
AWT (Abstract Window> Toolkit) es un paquete en el que se encuentran clases capa-
ces de crear componentes de la IGU (GUI); es decir, clases capaces de crear obje-
tos visuales sobre los cuales pueden los usuarios actuar, mediante el empleo del
ratn o el teclado, para comunicarse con el programa, sustituyendo, por tanto,
dichos objetos la entradahalida clsicas. El aspecto de estos componentes puede
variar de una plataforma a otra, ya que existe una vinculacin con la IGU local.
Los componentes de la IGU (botones, campos de texto, etc.) se organizan en
contenedores y esperan hasta que el usuario ejecute alguna accin sobre ellos, es
decir, esperan un evento (suceso). Por eso se dice que la programacin IGU es una
programacin dirigida por eventos. Para el diseo de este tipo de programas es
necesario considerar, como se acaba de indicar, que las interfaces grficas estn
construidas por elementos grficos denominados componentes agrupados dentro de
otros que se denominan contenedores, pero adems hay que tener en cuenta que los
contenedores son a su vez componentes y pueden volver a ser agrupados en otros
contenedores. Habitualmente en un contenedor habr varios componentes y para
situarlos de forma conveniente pueden usarse los administradores de diseo.
' En ingles, Grupzicul U.yer Inrerfuce (CUI)
Interfaces grficas de usuario 21 9
publ i c abstract voi d copyArea(i nt pl, i nt p2, i nt p 3 , i nt p4,
i nt p5, i nt p6)
Copia un rea rectangular de la pantalla y la coloca en otro lugar; p1,p2 representan la
esquina superior izquierda del rea a copiar; p3 y p4 la anchura y altura de la misma y p5
y p6 un desplazamiento relativo con respecto a los dos primeros valores, a travs del cual
se obtiene el lugar donde se situar la esquina superior izquierda de la copia.
publ i c abstract j ava.awt.Graphi cs create0
Crea una nueva referencia para un contexto grfico.
Es interesante tambin conocer que los mtodos grficos de J ava se encuentran en
la clase Gr aphi cs, que permite dibujar rectngulos, arcos, polgonos, etc., y, median-
te el mtodo dr awst r i ng ( ), puede mostrar cadenas en una determinada posicin.
En resumen, las clases del paquete AWT pueden clasificarse en: grficos, com-
ponentes, administradores de diseo, manipuladores de sucesos y manipuladores de
imgenes y, para poder hacer uso de las mismas y gestionar los eventos que se pro-
duzcan, los programas deben incluir las siguientes sentencias:
i mport j ava.awt.*;
i mport j ava.awt.event.*;
9.2. REALIZACIN DE DIBUJOS: CLASE Graphics
Gr aphi cs es una clase abstracta que proporciona un conjunto de mtodos para dibu-
jar en pantalla -incluido uno para el dibujo de cadenas- y permite escribir programas
que usan grficos independientemente de la plataforma sobre la que van a ser ejecuta-
dos. Para efectuar dichos dibujos se necesita un objeto Gr aphi cs que no puede ser
instunciado, pero se puede obtener a travs de los mtodos pai nt y updat e que lo
reciben como parmetro; por tanto, para dibujar, se redefinen los mtodos pai nt y
updat e de componentes que soportan el dibujo (pintura) o visualizacin de imge-
nes. Los mtodos pai nt y updat e se explicarn al hablar de la clase Component ;
por ahora slo diremos que reciben como parmetro un objeto Gr aphi cs, que repre-
senta el contexto grfico del objeto al que pertenecen, y no hacen nada por omisin.
Dentro de los mtodos pertenecientes a la clase Gr aphi cs mencionaremos los
siguientes:
publ i c abstract voi d cl earRect ( i nt pl, i nt p2, i nt p3, i nt p4)
Dibuja un rectngulo cuya esquina superior izquierda es pl ,p2 y cuyas dimensiones son p3
y p4 (ancho y alto respectivamente) en el color actual del segundo plano.
public abstract voi d ci i pRect(i nt pl, i nt p2, i nt p3, i nt p4)
Establece una subzona en el contexto grfico donde se van a realizar las modificaciones con
las siguientes operaciones de dibujo; esta subzona ser la interseccin entre el rectngulo
formado por los parmetros pasados al procedimiento y el rectngulo anteriormente consi-
derado.
220 Java 2. Manual de programacin
publ i c abstract voi d drawArc(i nt p l , i nt p2, i nt p3, i nt p4,
i nt p 5 , i nt p)
Dibuja un arco de modo que pl y p2 son las coordenadas de la esquina superior izquierda de
un rectngulo que contuviera dicho arco; p3 y p4 especitican la altura y anchura de dicho rec-
tngulo y p5 y p6 son un ngulo de inicio y un ngulo de barrido, ambos expresados en gra-
dos. El arco se dibuja desde la posicin que indica el ngulo de inicio, recorriendo en sentido
contrario a las agujas del reloj los grados especificadas como ngulo de barrido.
publ i c abstract voi d drawL i ne(i nt pl, i nt p2, i nt p3, i nt p4)
Dibuja una lnea del color seleccionado que comienza en pi , p2 y termina en p3, p4.
publ i c abstract voi d drawOval (i nt pl, i nt p2, i nt p3, i nt p4)
Dibuja una elipse o un crculo. En el caso de la elipse, pl y p2 son las coordenadas para la
esquina superior izquierda de un rectngulo que contuviera a la elipse; p3 y p4 especifican la
altura y anchura de dicho rectngulo. Se obtiene un crculo cuando se enmarca en un cuadrado.
publ i c abstract voi d drawPoiygon ( i nt pl [ 1 , i nt p2[ 1 , i nt p3)
Dibuja una serie de lneas conectadas. Para que la figura est conectada el primer punto debe
ser igual al ltimo. El primer y segundo parmetro son las matrices que contienen las coor-
denadas y el tercero especifica el nmero de puntos.
publ i c voi d drawRect(i nt pl, i nt p2, i nt p3, i nt p4)
Dibuja un rectngulo cuya esquina superior izquierda es pl , p2 y cuyas dimensiones son p3
y p4 (ancho y alto respectivamente).
public voi d draw3DRect ( i nt pl, i nt p2, i nt p3, i nt p4, boolean p5)
Dibuja un rectngulo tridimensional en el color actual; pl y p2 son las coordenadas de la
esquina superior izquierda; p3 y p4 la anchura y altura del rectngulo, y p5 un valor boo-
leano que especifica si el rectngulo debe dibujarse hundido (f al se) o realzado (true).
publ i c abstract voi d drawstri ng (j ava .l ang. Stri ng pl, i nt p2, i nt p3)
Dibuja una cadena empleando la fuente y color actuales a situando el primer carcter de la
misma arriba y a la derecha del pixel especificado por los parmetros p2 y p3.
publ i c abstract voi d f i l l A rc( i nt p l , i nt p2, i nt p3, i nt p4,
i nt p5, i nt p6)
Dibuja un arco relleno.
publ i c abstract voi d f i l l Oval ( i nt pl, i nt p2, i nt p 3 , i nt p4)
Dibuja una elipse o un crculo rellenos.
publ i c abstract voi d f i l l Rect( i nt pl, i nt p2, i nt p3, i nt p4)
Dibuja un rectngulo relleno cuya esquina superior izquierda es pl ,p2 y cuyas dimensio-
nes son p3 y p4 (ancho y alto respectivamente).
publ i c abstract j ava.awt.Col or getl ol or( )
Permite obtener el color actual en el que se realizarn los dibujos.
publ i c abstract Font getFont ( )
Devuelve un objeto Font que representa la fuente actual.
Interfaces grficas de usuario 221
public abstract void set Col or ( j ava. awt . Col or pl)
Establece el color actual para dibujar en el contexto grfico. Las constantes y mtodos de
color se definen en la clase Col or . Constantes de color predefinidas son:
Col or . bl ack, Col or . whi t e, Col or . gr ay, Col or . l i ght Gr ay,
Col or . dar kGr ay, Col or . r ed, Col or . pi nk, Col or . or ange,
Col or . yel l ow, Col or . gr een, Col or . bl ue, Col or . cyan,
Col or . magent a.
public abstract void cet Font ( j ava. awt . Font pl)
Establece como fuente actual la especificada en el objeto Font . Para crear un objeto
Font con una determinada fuente, estilo y tamao se utiliza:
public Font ( j ava. l ang. St r i ng pl, int p2, int p3)
El primer parmetro es el nombre de la fuente, el segundo el estilo y el tercero el tamao
en puntos. La fuente puede ser cualquiera de las reconocidas por el sistema; si la elegida
no est disponible en el sistema donde luego se ejecuta el programa ser sustituida por la
fuente por omisin en dicho sistema. Constantes predefinidas en cuanto al estilo de fuen-
te son Font . PL AI N (normal), Font . I TALI C (cursiva), Font . BOLD (negrita).
Otra herramienta muy til de la clase Font es
public int get si ze ( )
que devuelve el tamao de la fuente actual en puntos.
public j ava. awt . Font Met r i cs get Font Met r i cs0
Devuelve los siguientes datos sobre la fuente actual: lnea de base (posicin del rengln
sobre el que se escribe), parte ascendente, parte descendente, anchura de los caracteres,
interlineado, altura de la fuente. Se utiliza en combinacin con otros mtodos:
public int get Ascent 0
public int get Descent 0
public int get Hei ght ( )
public int get l eadi ngo
public int [ ] get wi dt hs ( )
para obtener informacin sobre una determinada caracterstica de la fuente. Un ejemplo es:
int al t o = g . get Font Met r i cs ( ) . get Hei ght ( 1 ;
public abstract void set XORMode( j ava. awt . Col or pl)
Establece el modo de pintura XOR, que consigue que las figuras se transparenten y permitan
ver la que est debajo cuando se dibujan una encima de otra.
En los mtodos descritos se observa que para dibujar la primera accin que se
realiza es un posicionamiento; por tanto, es necesario conocer que la posicin 0,O
corresponde a la esquina superior izquierda de la superficie de dibujo, y adems,
como se ver ms adelante, que algunos contenedores tienen bordes, y el rea ocu-
pada por estos bordes se considera como parte integrante de la zona de dibujo, de
modo que, en estos casos, la posicin 0,O queda oculta por los bordes.
Otro aspecto interesante a tener en cuenta es que el modo de pintura por omisin
es el de sobrescritura y, as, cuando una figura se dibuja sobre otra la tapa, es posible
222 Java 2. Manual de programacin
modificar esta situacin y permitir que se vean ambas figuras estableciendo el
modo de pintura XOR. Para volver al modo sobrescritura se utiliza public
abstract void s et Pai nt Mode0.
Las aplicaciones que se disean pueden crear un gran nmero de objetos Graphi cs,
pero los recursos consumidos por los objetos Gr aphi cs obtenidos a travs de los
mtodos pai nt y updat e son liberados automticamente por el sistema cuando
finaliza la ejecucin del mtodo; por esta razn, en estos casos, no es necesaria una
llamada a di spose.
Recuerde: Gr aphi cs proporciona, entre otros, el mtodo dr awst r i ng
que permite el dibujo de cadenas y constituye una forma muy fcil de presen-
tar mensajes.
Nota: Para efectuar dibujos se redefinen los mtodos pai nt y updat e de
componentes que soportan la pintura o visualizacin de imgenes; sta es una
forma de obtener el objeto Gr aphi cs necesario.
9.3. LA CLASE Component
Component es una clase abstracta situada en la parte superior de la jerarqua de
clases del paquete AWT y que representa todo aquello que tiene una posicin, un
tamao, puede dibujarse en pantalla y adems recibir eventos. En esta clase se
definen mtodos para la gestin de los eventos producidos por el ratn o el tecla-
do, otros destinados a especificar el tamao, el color o tipo de fuente y otros que
permiten obtener el contexto grfico. Entre todos esos mtodos, de momento, se
destacarn los siguientes:
public void pai nt ( j ava. awt . Gr aphi cc pl)
El mtodo pai nt proporcionado por el componente debe ser redefinido por el progra-
mador; este mtodo recibe como parmetro el contexto grfico del objeto al que perte-
nece el mtodo y no tiene que ser invocado. La llamada a un mtodo pai nt se efecta
de dos formas:
Directamente por el sistema, por ejemplo cuando el componente se muestra por pri-
mera vez en pantalla, deja de estar tapado por otro o cambia de tamao. En este tipo
de llamadas el AWT determina si el componente debe ser repintado en su totalidad o
slo en parte.
Interfaces grficas de usuario 223
Por la aplicacin, que invoca al mtodo r epai nt , considerando que ste, indirecta-
mente, a travs de updat e llama a pai nt .
public void r epai nt ( )
Es el mtodo que permite a las aplicaciones, mediante invocaciones a dicho mtodo sobre
los componentes, ordenar la repintura de los mismos. Este mtodo hace que el intrprete eje-
cute una llamada al mtodo updat e, que en su implementacin por defecto llama al mto-
do pai nt . El formato mostrado es el bsico.
Figura 9.1. J erarqua de clases.
224 Java 2. Manual de programacin
public void r epai nt ( i nt pl, int p2, int p3, int p4)
Formato del mtodo comentado anteriormente en el que se especifica la regin a repintar,
para que el proceso sea ms rpido cuando no se necesita vover a pintar todo el rea.
public void r epai nt (long pl)
El parmetro especifica el mximo de milisegundos que pueden pasar antes de llamar al
mtodo updat e.
public void r epai nt (long pl, int p2, int p3, int p4, int p5)
Formato de r epai nt en el que se especifica tanto el tiempo como las dimensiones del rea
a repintar; pi y p2 son las coordenadas de la esquina superior izquierda, p3 la anchura y
p4 la altura.
public void updat e( j ava. awt . Gr aphi cs pl)
Este mtodo posibilita repinturas incrementales. AI igual que pai nt recibe como parme-
tro el contexto grfico del objeto al que pertenece y se invoca automticamente cuando una
aplicacin llama al mtodo r epai nt . Cuando no se sobreescribe, el mtodo updat e
borra el contexto grfico rellenando el fondo con el color de fondo por defecto y llama a
continuacin a pai nt para que dibuje de nuevo; estas operaciones hacen que se origine un
parpadeo. Una forma de evitar esto es sobrescribir updat e para que no borre el contexto
grfico; por ejemplo, escribiendo en l una simple llamada a pai nt .
Todos los elementos de la interfaz de usuario que aparecen en pantalla e inte-
ractan con el usuario son subclases de Component (Fig. 9.1).
9.4. LA CLASE Container
Cont ai ner es una subclase abstracta de Component que contiene mtodos adi-
cionales que van a permitir a los contenedores almacenar objetos Component .
Nota: Los objetos Cont ai ner tambin son Component y, por consiguiente,
resulta posible anidar Cont ai ner .
Los componentes se colocan en los contenedores empleando el mtodo add de
la clase Cont ai ner y los administradores de diseo acomodan los componentes
en el contenedor e intentan reajustarlos cuando el usuario redimensiona dicho con-
tenedor. Los administradores de diseo se asocian al contenedor mediante el mto-
do set Layout . El formato de los mtodos citados es:
public j ava. awt . Component add( j ava. awt . Cor nponent pl)
public void add( j ava. awt . Cor nponent pl, j ava. l ang. 0bj ect p 2 )
public j ava. awt . Component add( j ava. l ang. Ct r i ng pl,
public void set Layout ( j ava. awt . Layout Manager pl)
j ava. awt . Component p2)
Interfaces grficas de usuario 225
Los principales administradores de diseo son: Fl owLayout , Bor der Layout
y Gr i dLayout .
9.5. VENTANAS
La clase Wi ndow hereda de Cont ai ner y contiene mtodos para manejar venta-
nas. Fr ame y Di al og extienden Wi ndow y Fi l eDi al og extiende Di al og,
pudindose obtener as cuatro tipos bsicos de ventanas:
Wi ndow
Fr ame
Di al og
Fi l eDi al og
Ventana de nivel superior, sin barra de ttulo ni borde.
Marco, es decir, ventana con borde, ttulo y una barra de mens asociada.
Ventana de dilogo con borde y ttulo.
Ventana de dilogo especializada en mostrar la lista de archivos de un directorio.
9.5.1. Clase Frame
En las aplicaciones IGU se emplea Fr ame como contenedor ms externo, siendo
Bor der Layout su administrador de diseo por defecto. La clase Fr ame tiene los
siguientes constructores:
public Fr ame ( ) Crea una ventana estndar sin titulo.
public Fr ame ( j ava. l ang . St r i ng pi ) Crea una ventana con el titulo especificado.
El mtodo publicsynchronizedvoidsetTitle ( j ava. l ang. St r i ngpl )
permite cambiar el ttulo de un marco.
II
Figura 9.2. Marcos sin y con barra de mens.
Las dimensiones de una ventana tienen que ser establecidas despus de que sta
ha sido creada, y para ello se utiliza el mtodo public void set S i z e (int
pl, int p2) de j ava . awt . Component . Adems, las ventanas Fr ame
necesitan que se las haga visibles, para lo que se emplea el mtodo public void
set vi si bl e (boolean pl) de j ava. awt . Component .
226 Java 2. Manual de programacin
Cierre de la ventana de una aplicacin
Para cerrar una ventana, el mtodo usualmente aceptado es que el usuario efecte
clic sobre el botn de cierre de la misma m. La pulsacin de este botn genera un
suceso que puede ser detectado por el oyente Wi ndowLi st ener del paquete
j ava . awt . event , para ello se instancia y registra un objeto receptor de even-
tos de ventana.
addWi ndowLi st ener ( newRecept or Event oO)
y luego se define el receptor de eventos de forma que suplante y redefina el mto-
do wi ndowCl osi ng de Wi ndowAdapt er realizando la accin adecuada, que,
para el contenedor ms externo, es salir al sistema.
cl ass Recept or Event o ext ends Wi ndowAdapt er
publ i c voi d wi ndowCl osi ng( Wi ndowEvent e)
Syst em. exi t ( O) ;
Wi ndowAdapt er es una clase que proporciona implementaciones vacas de
los mtodos presentes en Wi ndowLi st ener y que resulta conveniente utilizar,
pues evita tener que codificar los muchos mtodos que requiere el uso de dicha
interfaz.
Wi ndowLi st ener
publ i c abst r act voi d wi ndowAct i vat ed( j ava. awt . event . Wi ndowEvent pl)
publ i c abst r act voi d wi ndowCl osed( ] ava. awt . event . Wi ndowEvent pl)
publ i c abst r act voi d wi ndowCl osi ng( ~ava. awt . event . Wi ndowEvent pi )
publ i c abst r act voi d wi ndowDeact i vat ed( j ava. awt . event . Wi ndowEvent pl)
publ i c abst r act voi d wi ndowDei coni f i ed( j ava. awt . event . Wi ndowEvent pl)
publ i c abst r act voi d wi ndowI coni f i ed( j ava. awt . event . Wi ndowEvent pl)
publ i c abst r act voi d wi ndowOpened( j ava. awt . event . Wi ndowEvent pl)
lnterfaces grficas de usuario 227
Los tipos Wi ndowEvent se generan cuando una ventana cambia de estado y se
procesan por los objetos que implementa la interfaz Wi ndowLi st ener .
Ejemplo
Un ejemplo de Fr ame que utiliza Gr aphi cs y permite el cierre de la ventana de
la aplicacin usando Wi ndowAdapt er es Ej Mar co.
I
Bienvenido ai A WT
I
Figura 9.3. Escribir en un marco.
import j ava. awt . *;
import j ava. awt . event . *;
public cl as s Ej Mar co extends Fr ame
i
public s t a t i c void mai n( St r i ng ar gs[ ] )
t
new Ej Mar co ( ) ;
public Ej Mar co ( )
t
addWi ndowLi st ener (new Ci er r e ( ) ) ;
set Ti t l e ( " Mar co" ) ;
set si ze ( 200, 100) ;
set vi si bl e (true) ;
1
public void pai nt ( Gr aphi cs g)
t
Font l et r er o = new Font ( " CancCer i f " , Font . I TALI C, 14) ;
g. set Font ( l et r er o) ;
g. dr awSt r i ng( " Bi enveni do al AWT", 42, 60) ;
1
cl as s Ci er r e extends Wi ndowAdapt er
I
public void wi ndowCl osi ng ( Wi ndowEvent e)
i
I
Cyst em. exi t ( O) ;
1
228 Java 2. Manual de programacin
El ejemplo anterior sin la utilizacin de Wi ndowAdapt er es:
import j ava. awt . *;
import j ava. awt . event . *;
public class Ej Mar co2 extends Fr ame implements Wi ndowLi st ener
t
public static void mai n( St r i ng ar gs[ ] )
I
new Ej Mar co2 ( ) ;
i
public Ej Mar co2 ( )
addWi ndowLi st ener (this) ;
set Ti t l e ( " Mar co" ) ;
set si ze ( 200, 100) ;
set vi si bl e (true) ;
public void pai nt ( Gr aphi cs g)
i
Font l et r er o = new Font ( " SansSer i f " , Font . I TALI C, 14) ;
g. set Font ( l et r er o) ;
g. dr awSt r i ng ( " Bi enveni do al AWT" , 42, 60) ;
public void wi ndowCl osi ng( Wi ndowEvent e)
i
Syst em. exi t ( 0) ;
i
public void wi ndowAct i vat edi Wi ndowEvent e)
i}
public void wi ndowCl osed( Wi ndowEvent e)
t i
public void wi ndowDeact i vat ed( W1ndowEvent e)
I !
public void wi ndowDei coni f i ed( Wi nd0wEvent e)
t i
public void wi ndowI coni f i ed( Wi ndowEvent e)
i!
public void wi ndowOpened( Wi ndowEvent e)
t i
hterfaces grficas de usuario 229
9.5.2. Clase Dialog
Los cuadros de dilogo son parecidos a las ventanas Frame, excepto porque no son
el contenedor ms externo, sino ventanas hijas de otras de nivel superior, y adems no
tienen barra de ineiis. Estos objetos pueden ser redimensionados, desplazados y
colocados en cualquier lugar de la pantalla, no estando su posicin restringida al inte-
rior de la ventana padre, pero no pueden ser maximizados ni minimizados.
Figura 9.4. Cuadro de dilogo.
A veces, cuando se muestra un cuadro de dilogo, lo que se persigue es que el
usuario introduzca o tome alguna informacin y cierre dicho cuadro de dilogo
antes de continuar, no se debe permitir el acceso a ninguna otra parte de la aplica-
cin mientras tanto. Para conseguir esto, habr que utilizar un cuadro de dilogo
modal. En contraposicin, los cuadros de dilogo sin modo dejan acceder a otras
ventanas mientras se exhibe el cuadro de dilogo. Los constructores son:
public Di al og ( 1 ava. awt . Fr ame pl)
El parinetro pl es la ventana de nivel superior padre del cuadro de dilogo.
public Di al og ( j ava. awt . Fr ame p i , boolean pZ)
El priiner parinetro sigue siendo la ventana de nivel superior, mientras que p2 permite
especificar si va a ser o no un cuadro de dilogo modal.
public Di al og( ] ava. awt . Fr ame pl, j ava. l ang. Ct r i ng p2)
Este formato permite especificar el titulo del cuadro de dilogo que se est creando
public Di al og( : ava. awt . Fr axe pl, j ava. l ang. St r i ng p2, boolean p 3 )
Incluye el ttulo y si es modal o no.
Despus de la creacin, se puede establecer el tipo de cuadro de dilogo (modal
o no modal) mediante el mtodo
public void set Modal (boolean pl)
Ejemplo
Muestra el funcionamiento de Di al og.
230 Java 2. Manual de programacin
import j ava. awt . *;
import j ava. awt . event . *;
public class Di al ogos
public static void mai n( St r i ng ar gs[ ] )
t
Mar co el Mar c0 = new Mar co( ) ;
el Mar co. set Ti t l e ( " Mar co" ) ;
el Mar co. set Ci ze( 400, 200 ) ;
el Mar co. set Vi si bl e( true ) ;
el Mar co. addWi ndowLi st ener ( new Cer r ar ( ) ) ;
Di al ogo di al ogoNoModa1 = new Di al ogo( el Mar co,
di al ogoNoModal . set Backgr ound( Col or . yel 10~) ;
di al ogoNoModal . get Gr aphi cs0;
/ * set Bounds col oca l a esqui na super i or de: di l ogo en l a
posi ci n 100, 100 con
r espect o a su cont enedor y est abl ece su anchur a en 300
pi xel s y su al t ur a en 100 */
" Di al ogo no modal " , false) ;
di al ogoNoModal . set Bounds( 100, 100, 300, 100) ;
di al ogoNoModal . addWi ndowLi st ener ( new Cer r ar ( di al ogoNoModa1) ) ;
di al ogoNoModal . set Vi si bl e( t r ue) ;
Di al ogo di al ogoModa1 = new ai al ogo (el kl arco,
di ai ogoModal . set Si ze( 300, i OO) ;
di al ogoModal . addWi ndowLi st ener ( new Cer r ar ( di al ogoModa1) ) ;
di al ogoModal . set Vi si bl e( t r ue) ;
" Di al ogo modal " , true) ;
1
class Mar co extends Fr ame
i
public void pai nt ( Gr aphi cs g )
Font l et r er o = new Font ( " Cour i er " , Font . BOLD, 12) ;
g. set Font ( l et r er o) ;
g. dr awSt r i ng( " Bi enveni d0 ai AWT" , 24, 70) ;
!
class Di al ogo extends Di al og
Di al ogo ( Fr ame vent ana, St r i ng t i t ul o, boolean modo)
super ( vent ana, t i t ul o, modo) ;
1
public void pai nt ( Gr aphi cs g)
interfaces grficas de usuario 231
i f ( super . i cModal ( ) )
g. dr awst r i ng ( " Ci r r eme par a poder acceder " +
" a ot r as vent anas" , 10, 40) ;
else
g. dr awCt r i ng ( " Desde est e cuadr o puede acceder " +
" a ot r as Vent anas" , 10, 40) ;
}
J
c l as s Cer r ar extends Wi ndowAdapt er
I
Di al ogo ot r oDi al ogo;
Cer r ar ( Di al ogo unDi al ogo )
i
ot r oDi al ogo = unDi al ogo;
I
Cer r ar ( )
ot r oDi ai ogo = nul l ;
i
publ i c voi d wi ndowcl osi ng( Wi ndowEvent evt )
t
i f ( ot r o3i ai ogo != nul l )
ot r oDi al ogo. di spose( ) ;
else
Syst em. exi t ( O) ;
Llr;S@ 0'1n u m u 11i ~ d 8 d c c e ~i 3 01t.35 irF<nlarid:
- J
Figura 9.5. Cuadros de dilogo modales y no modales.
232 Java 2. Manual de programacin
Nota: Un cuadro de dilogo modal, mientras no se cierra, no permite el acce-
so a ninguna otra parte de la aplicacin. Los cuadros de dilogo sin modo
dejan acceder a otras ventanas mientras se exhibe el cuadro de dilogo.
9.5.3. Clase FileDialog
Estos cuadros de dilogo heredan de la clase Di al og, son modales por omisin y
tienen ciertas capacidades incorporadas, como la de recorrer el rbol de directorios.
El aspecto que presentan depende del sistema de manejo de ventanas, as como del
subtipo de cuadro del que se trate: abrir archivos o guardar archivos, especificado
en el constructor.
Ejemplo
El programa Di al ogoA permite seleccionar un archivo mediante un cuadro
Fi l eDi al og (Fig. 9.6) y, si se selecciona alguno, muestra a continuacin un di-
logo informativo con el nombre completo del archivo seleccionado (Fig. 9.7).
3 Cei
d Die
ti Dit
2 Ve,
alventanas1
Dialogos d
lar clal Mi PC Archivo CLASS
Iioga4 & Disco de 3% [A 1 Archivo CLASS
Archivo CLASS
Archivo CLASS 1 E
Archivo CMCC 2:
lulo CI libro
Archivo CLASS
-J ,.,,a YYl Ul l l l l l l VI
Ttana a m
ID 1
Fi gura 9.6. Eleccin del archivo Fi l eDi al og. L OAD.
Archivo P6tt@tCondd
Fi gura 9.7. Dilogo informativo.
Interfaces grficas de usuario 233
import j ava . awt . * ;
import j ava. awt . event . *;
public class Di al ogoA
{
public static void mai n ( St r i ng ar gs [ ] )
i
}
Vent ana vent anas = new Vent ana ( ) ;
1
class Vent ana
i
St r i ng msg=" " ;
public Vent ana ( )
t
Fr ame el Mar co = new Fr ame ( ) ;
Fi l eDi al og di al ogoAr chi vos =new Fi l eDi al og( el Mar co,
di al ogoAr chi vos. set Vi si bl e( t r ue) ;
St r i ng nombr e = di al ogoAr chi vos. get Fi l e( ) ;
St r i ng di r ect or i o = di al ogoAr chi vos. get Di r ect or y0;
if ( nombr e != null)
{
" El i j a ar chi vo" , Fi l eDi al og. LOAD) ;
msg =" Ar chi vo sel ecci onado: "t di r ect or i o t nombr e;
Di al ogo2 di al ogoModa1 = new Di al ogo2( el Mar co,
di al ogoModal . set Si ze( msg. l engt h( ) *5+24, l OO) ;
di al ogoModal . addWi ndowLi st ener ( new Cer r ar 2( di al ogoModal ) ) ;
di al ogoModal . set Vi si bl e( t r ue) ;
" Di l ogo modal " , true, msg) ;
Syst em. exi t ( O) ;
1
class Di al ogo2 extends Di al og
I
St r i ng mensaj e;
Di al ogo2 ( Fr ame vent ana, St r i ng t i t ul o, boolean modo, St r i ng msg)
{
super ( vent ana, t i t ul o, modo) ;
mensaj e = msg;
1
public void pai nt ( Gr aphi cs g)
I
Font l et r er o = new Font ( " Hel vet i ca" , Font . PLAI N, 10) ;
g. set Font ( l et r er o) ;
g. dr awSt r i ng ( mensaj e, 12, 4O) ;
}
234 Java 2. Manual de programacin
class Cer r ar 2 extends Wi ndowAdapt er
{
Di al ogo2 ot r oDi al ogo;
Cer r ar 2( Di al ogo2 unDi al ogo )
ot r oDi al ogo = unDi al ogo;
i
public void wi ndowCl osi ng( Wi ndowEvent evt )
I
)
ot r oDi al ogo. di spose0;
9.6. CLASE Panel
Los objetos de la clase Panel carecen de barra de ttulo, barra de mens y borde,
se emplean para almacenar una coleccin de objetos a los que de esta forma se
organiza en unidades, no generan eventos y adquieren el tamao necesario para
que quepan los componentes que contienen. Esta clase es la superclase de Appl et
y su administrador de diseo por defecto es Fl owLayout .
Constructores
public Panel ( ) Crea un nuevo panel.
public Panel ( j ava . awt . Layout Manager pi ) Crea un nuevo panel y
establece un determinado
administrador de diseo para
l. Por ejemplo:
Panel pX = new Panel
(new Gr i dLayout ( ) ) ;
Para destacar un panel se establece un determinado color de fondo para l. El panel
se coloca en un contenedor mediante el mtodo add y, como l tambin es un conte-
nedor, se le pueden agregar componentes, incluidos otros paneles, mediante el
mtodo add.
9.7. CLASE Label
Label extiende la clase Component y permite mostrar texto esttico, es decir,
texto que no puede ser modificado por el usuario, en una IGU. Para crear un rtulo
con la clase Label es necesario declarar una referencia y llamar al constructor.
interfaces grficas de usuario 235
Constructores
public Label ( ) Crea una etiqueta sin texto.
public Label ( j ava. l ang. St r i ng pi ) Creaunaetiquetacuyotextoeslacadena
pasada como parmetro.
La cadena de caracteres que presenta la etiqueta puede modificarse con el
mtodo
public synchronized void set Text ( j ava. l ang. St r i ng p l )
y se devuelve mediante
public j ava. l ang. St r i ng get Text ( )
El procedimiento
public synchronized void set Al i gnment (int pi)
permite establecer la alineacin del texto. El parmetro p l puede ser cualquiera de
las siguientes constantes predefinidas:
public static final int CENTER
public static final ant LEFT
public static final int RI GHT
Como todos los componentes, las etiquetas se colocan en los contenedores median-
te el mtodo add de la clase Cont ai ner .
add (referencia-etiqueta)
I
Figura 9.8. Etiquetas, paneles. Empleo de colores de fondo
para destacar los paneles.
236 Java 2. Manual de programacin
El siguiente ejemplo muestra cmo crear etiquetas y paneles y establecer colores de
fondo.
i mpor t j ava. awt . *;
i mpor t j ava. awt . event . *;
publ i c cl ass Panel es ext ends Fr ame
i
publ i c Panel es ( )
t
addWi ndowLi st ener ( new Ci er r e30 ) ;
Panel pX = new Panel ( ) ;
pX. set Backgr ound( Col or . bl ack) ;
Panel pY =newPanel ( ) ;
pY. set Backgr ound( Co1or . r ed) ;
Label et i quet a1 = new Label ( " Los panel es se adapt an" ) ;
Label et i quet a2 = new Label ( " a nuest r o t amao" ) ;
et i quet al . set Backgr ound( Co1or . whi t e) ;
pY. add( et i quet a1) ;
pY. add( et i quet a2) ;
pX. add( pY) ;
add ( pX) ;
publ i c st at i c voi d mai n( St r i ng ar gs[ l )
i
Panel es vent ana = new Panel es 0 ;
vent ana. set Layout ( new Fl owLayout O) ;
vent ana. set Ti t l e ( " El AWT" ) ;
vent ana. set Si ze( 300, 120 ) ;
vent ana. set Vi si bl e( t r ue) ;
I
1
cl ass Ci er r e3 ext ends Wi ndowAdapt er
t
publ i c voi d wi ndowCl osi ng( Wi ndowEvent e)
t
I
Syst em. exi t ( O) ;
1
9.8. CLASE Button
Esta clase produce botones con etiqueta que provocan la ejecucin de una accin
cuando se efecta clic en ellos con el ratn. La clase But t on define los siguientes
constructores:
Interfaces grficas de usuario 237
publ i c But t on ( ) Crea un botn sin etiqueta.
publ i c But t on ( j ava. l ang . St r i ng pi ) Crea un botn cuya etiqueta es la cadena
pasada como parmetro.
y pone a disposicin del programador una coleccin de mtodos entre los que des-
tacan
publ i c synchroni zed voi d
addAct i onLi st ener ( j ava. awt . event . Act i onLi st ener pi)
Aade un receptor de eventos semnticos
publ i c synchr oni zed voi d
r emoveAct i onLi st ener ( ] ava. awt . event . Act i onLi st ener pi )
Elimina el receptor de eventos
publ i c j ava. l ang. St r i ng get l abel ( )
Devuelve la etiqueta del botn
publ i c synchr oni zed voi d set Label ( j ava. 1ang. St r i ng pi)
Establece la etiqueta del botn
Ejemplo
Colocacin de botones en un contenedor (Fig. 9.9).
Los botones de este ejemplo no ejecutan ninguna accin.
i mport j ava . awt . * ;
i mport j ava. awt . event . *;
publ i c cl ass Pr ueba ext ends Fr ame
i
publ i c Pr ueba ( )
I
addWi ndowLi st ener ( new Ci er r e30) ;
Panel panel Bot ones = new Panel ( ) ;
for ( i nt i = 1; i < 8 ; i ++)
panel Bot ones. add ( new But t on ( " Bot n " +i ) ) ;
/* Se ut i l i za el admi ni st r ador de di seo por def ect o en l a
cl ase Fr ame par a col ocar el panel en el r ea Sur */
add ( " Sout h" , panel Bot ones ) ;
publ i c st at i c voi d mai n( St r i ng ar gs[ J )
i
Pr ueba vent ana = new Pr ueba ( ) ;
238 Java 2. Manual de programacin
vent ana. set Ti t l e ( " El AWT" ) ;
vent ana. set Si ze( 400, 250 ) ;
vent ana. set Vi si bl e( t r ue) ;
1
La clase Ci er r e3 ya fue implementada en el Apartado 9.7.
Figura 9.9. Botones.
Aunque la gestin de eventos se tratar en el Captulo 10, es necesario advertir
que, cuando se colocan botones en un contenedor, tienen como objetivo reaccionar
ante su pulsacin. Para que se pueda reaccionar ante la pulsacin de un botn hay
que enlazarlo a Act i onLi st ener , interfaz definida en awt . event con un
nico mtodo a implementar denominado act i onper f or med, por lo que no
necesita adaptadores. Este mtodo tiene un parmetro del tipo Act i onEvent , que
puede informar a travs del mtodo get sour ce sobre el botn que ha sido pulsa-
do, y deber ser redefinido para establecer la reaccin adecuada ante la pulsacin
de un determinado botn. El marco en uso ser el responsable de la redefinicin del
mtodo act i onper f or med.
9.9. CLASE Textcomponent
La clase Text component dispone de ina gran coleccin de mtodos para fa ili-
tar la presentacin de texto en un programa IGU, pero no dispone de constructores
pblicos, por lo que no puede ser instanciada. Posee dos subclases, Text Fi el d y
Text Ar ea. Text Fi el d permite mostrar al usuario un area de una nica lnea,
mientras que Text Ar ea presenta varias lneas. El texto mostrado, tanto en uno
como en otro caso, puede ser editable o no.
Interfaces grficas de usuario 239
Los constructores de Text Fi el d son:
public Text Fi el d ( )
Crea un campo de texto por defecto.
public Text Fi el d (int pl)
Crea un campo de texto con p 1 caracteres de ancho, este nmero de caracteres no define la
anchura del campo, pues esto depende del tipo de letra y del administrador de diseo que se
empleen.
public Text Fi el d( j ava. 1ang. St r i ng pi)
Crea un campo de texto y lo inicializa con la cadena pl
public Text Fi el d ( j ava, l ang. St r i ng pi, int p2)
Crea un campo de texto, inicializndolo con la cadena pi y estableciendo su ancho a p2
caracteres.
Otros mtodos interesantes en el trabajo con campos de texto son:
public synchronized j ava. l ang. St r i ng get Text 0
Mtodo de lectura. Obtiene la cadena contenida en un campo de texto.
public synchronized void set Text ( j ava. l ang. Ct r i ng pi)
Mtodo de escritura. Establece el contenido de un campo de texto.
public synchronized void sel ect ( i nt pl, int p2)
Selecciona una serie de caracteres comenzando en pi y terminando en p2.
public synchronized void sel ect Al 1 ( )
Mtodo para seleccionar todos los caracteres pertenecientes a Text component .
public synchronized j ava. l ang. St r i ng get Sel ect edText 0
Obtiene el texto previamente seleccionado. La seleccin previa pudo realizarse por la orden
sel ect o directamente por el usuario.
public synchronized void set Edi t abl e (boolean pl)
Controla la editabilidad del campo.
public void set EchoChar (char pl)
Sirve para introducir contraseas, pues inhabilita el eco de los caracteres, exhibiendo en su
lugar el carcter especificado como parmetro.
En los cuadros de texto ser necesario tratar el evento que se produce al pulsar
la tecla RETURN. Este tratamiento consistir en enlazar el campo de texto a la inter-
faz Act i onLi st ener , y redefinir su mtodo act i onper f or med, que tiene
un parmetro capaz de informar sobre el campo de texto en el que ha sido pulsada
la tecla RETURN (INTRO).
240 Java 2. Manual de programacin
Ejemplo
Solicita el nombre y la edad del usuario mediante cuadros de texto. La edad se soli-
cita con un cuadro sin eco)), de forma que no se vea lo que se est tecleando. Tras
la pulsacin de RETURN en el cuadro edad, el programa transforma la cadena leda
en un nmero, muestra dicha edad, y se disculpa por su falta de confidencialidad
mediante la adicin al mensaje de la palabra J oven" . El ejemplo pretende resal-
tar que los cuadros de texto no permiten la lectura directa de nmeros. Utiliza
r epai nt y responde a eventos.
Intoduzca su nombre 5'
lntoduzca la edad en aosy pulse <RETURN> a continuacin
Figura 9.10. Cuadros de texto.
lntoduzca la edad en aosy pulse <RETURN> a continuacin
J oven de 86 aos
Figura 9.11. Salida mostrada por el programa
lnterfaces grficas de usuario 241
i mpor t j ava. awt . *;
i mpor t j ava. awt . event . *;
publ i c cl ass CText o ext ends Fr ame i mpl ement s Act i onLi st ener
t
i nt edad = 0;
Text Fi el d t ext o2;
publ i c CText o ( )
t
addWi ndowLi st ener ( new Ci er r e30) ;
Label et i quet a1 = new Label ( " I nt r oduzca su nombr e" ) ;
add( et i quet a1) ;
Text Fi el d t ext o1 = new Text Fi el d ( "", 35) ;
add( t ext o1) ;
Label et i quet a2 =new Label ( " I nt r oduzca l a edad en aos" +
add ( et i quet a2) ;
t ext o2 = new Text Fi el d( " " , 2) ;
t ext oZ. set EchoChar ( ' *' ) ;
add ( t ext o2) ;
t ext oZ. addAct i onLi st ener ( t hi s) ;
" y pul se <RETURN>a cont i nuaci n" ) ;
1
publ i c voi d pai nt ( Gr aphi cs g)
i
try
i
edad = I nt eger . par seI nt ( t ext o2 . get Text ( ) ) ;
g. dr awCt r i ng ( " J oven de " +edad+" aos" , 24, 150) ;
1
cat ch ( Except i on ex)
t }
1
publ i c voi d act i onper f or med ( Act i onEvent e)
i
i f ( e. get sour ce ( ) ==t ext o2)
r epai nt ( ) ;
i
publ i c st at i c voi d mai n( St r i ng ar gs[ ] )
I
CText o vt = new CText o ( ) ;
vt . set Layout ( new Fl owLayout 0 ) ;
vt . set Ti t l e( " El AWT" ) ;
vt . set Si ze( 400, 250 1;
vt . set Vi si bl e( t r ue) ;
I
i
La clase Text Ar ea efecta la presentacin de areas de texto en pantalla. Sus
constructores y algunos otros mtodos destacables son:
242 Java 2. Manual de programacin
public Text Ar ea ( )
Crea un rea de texto por defecto.
public Text Ar ea (int pl, int p 2 )
Crea un rea de texto con pi filas y p2 columnas.
public Text Ar ea( j ava. 1ang. St r i ng pl)
Crea un rea de texto y la inicializa con la cadena pi .
public Text Ar ea ( l ava. l ang. St r i ng pi, int p2, int p 3 )
Crea un rea de texto y la inicializa con la cadena p 1, estableciendo como nmero de filas
p2 y como nmero de columnas p3.
public synchronized j ava. l ang. St r i ng get Text 0
Mtodo de lectura. Obtiene el texto.
public synchronized void set Text ( j ava. 1ang. St r i ng pi)
Mtodo de escritura. Establece el contenido del rea.
public synchronized void append( j ava. 1ang. St r i ng pi)
Aade cadenas a un rea de texto.
public synchronized void set Edi t abl e (boolean pi)
Controla la editabilidad del campo.
public synchronized j ava. l ang. St r i ng get Sel ect edText ( )
Obtiene el texto seleccionado. Pertenece a j ava . awt . Text Component .
Si el texto a mostrar no cabe en el nmero de filas o columnas visibles aparecen
automticamente barras de desplazamiento en la direccin adecuada para que se
pueda acceder cmoda y rpidamente a toda la informacin.
Fi gura 9.12. Text Ar ea, el texto a mostrar no cabe en el nmero
de filas ni de columnas visibles.
Para capturar sus eventos, el objeto Text Ar ea se enlaza a la interfaz
Text Li st ener y se sobrescibe el mtodo t ext Val ueChanged.
9.10. CLASE Canvas
La clase Canvas hereda de Component , encapsulando una ventana vaca o lien-
zo, sobre el que se puede dibujar y que es capaz de recibir informacin por parte
lnterfaces grficas de usuario 243
del usuario en forma de eventos producidos por el ratn o el teclado. Los lienzos
no generan eventos, slo los reconocen. El constructor de Canvas no tiene par-
metros
publ i c Canvas ( )
Los lienzos no tienen un tamao por omisin y es necesario adjudicrselo; si no
se le adjudica, ste depender del administrador de diseo que se est utilizando y
podra llegar a ser demasiado pequeo o incluso invisible. El mtodo empleado con
esta finalidad pertenece a la clase Component y es
publ i c voi d set Si ze( i nt pl, i nt p2)
i mpor t j ava. awt . *;
i mpor t j ava. awt . event . *;
publ i c cl ass VLi enzo ext ends Fr ame
i
publ i c VLi enzo ( )
i
addWi ndowLi st ener ( new Ci er r e3 ( ) ) ;
Canvas 1 = new Canvas ( 1 ;
1. set si ze ( 300, 150) ;
l . set Backgr ound( Col or . yel 1ow) ;
add( 1) ;
// se est abl ece un col or de f ondo par a hacer r esal t ar el l i enzo
1
publ i c st at i c voi d mai n ( St r i ng ar gs [ ] )
VLi enzo vent ana = new VLi enzo ( ) ;
vent ana. set Layout ( new Fl owLayout O 1 ;
vent ana. set Ti t l e ( " El AWT" ) ;
vent ana. set Si ze( 400, 250 ) ;
vent ana. set Vi si bl e( t r ue) ;
Se puede observar tras la ejecucin del ejemplo que en el lienzo creado no apa-
rece ningn dibujo, slo un fondo amarillo. Los Canvas heredan de Component
el mtodo pai nt , pero como ya se coment anteriormente, para que este mtodo
haga algo es preciso redefinirlo y para ello es necesario crear una subclase de
Canvas. Un ejemplo ms completo sobre Canvas aparece en el apartado dedica-
do a los administradores de diseo.
244 Java 2. Manual de programacin
9.1 1. CLASE Choice
Este tipo de componentes permite seleccionar una nica opcin de entre una lista des-
plegable de ellas (Fig. 9.13). Cuando se agregan a un contenedor, slo muestran una
determinada opcin y una flecha que ser la que permita escoger las restantes opcio-
nes al efectuar clic sobre ella. El ancho que ocupan se establece automticamente
como el suficiente para mostrar las opciones incluidas en la lista. El constructor no
tiene parmetros y crea una lista vaca:
public Choi ce ( )
Las opciones son cadenas de caracteres y aparecen en el orden en que se aaden
mediante el mtodo
public synchronized void addI t em( j ava. 1ang. St r i ng pi)
A cada una de estas opciones le corresponder un ndice, de forma que el primer
elemento aadido tiene ndice O, el siguiente 1 y as sucesivamente. Los ndices se
pueden obtener con el mtodo
public int get Sel ect edI ndex ( )
y estos nmeros se utilizan frecuentemente como subndices de vectores que con-,
tienen informacin relativa a cada una de las opciones.
Figura 9.13. La clase Choi ce antes y despus de desplegar sus opciones.
Otros mtodos destacables son:
public synchronized j ava. l ang. St r i ng get Sel ect edI t em( )
Devuelve una cadena con el nombre del elemento seleccionado.
public synchronized void sel ect (int pi)
Permite especificar la eleccin por defecto.
El evento de seleccin de una opcin se tratar de la forma siguiente: se enlaza
el objeto Choi ce a la interfaz I t emLi st ener y se redefine su mtodo
i t emst at el hanged, que tiene un parametro de tipo I t emEvent .
lnterfaces grficas de usuario 245
Ejemplo
Construir un men de opciones con el componente Choi ce, a continuacin el
usuario selecciona una opcin y se presenta en la pantalla la opcin seleccionada.
i
1 Elemento seleccionado Dos
Figura 9.14. Presentacin de la opcin seleccionada.
import j ava. awt . *;
import j ava. awt . event . *;
public cl ass Ej Choi ce ext ends Fr ame implements I t emLi st ener
{
private Choi ce sel ecci n;
St r i ng el ement o = "";
public E j Choi ce ( )
I
addWi ndowLi st ener ( new Ci er r e30) ;
sel ecci n = new Choi ce ( ) ;
sel ecci n. addI t em( " Uno" ) ;
sel ecci n. addI t em( "DOS" ) ;
/* La l t i ma opci n se denomi na Ter cer o en vez de Tr es,
par a que se vea con mayor f aci l i dad l a anchur a que
adqui er en l os obj et os Choi ce aut omt i cament e */
sel ecci n. addI t em( " Ter cer o" ) ;
/ / Opci n pr esel ecci onada
sel ecci n. sel ect ( 1) ;
sel ecci n. add1t emLi st ener ( t hi s ) ;
add ( sel ecci n) ;
}
public s t at i c void mai n ( St r i ng ar gs [ ] )
t
Ej Choi ce vent ana = new Ej Choi ce 0 ;
vent ana. set Layout ( new Fl owLayout O ) ;
vent ana. set Ti t l e ( "El AWT" ) ;
246 Java 2. Manual de programacin
vent ana. set Si ze( 400, 250 ) ;
vent ana. set Vi ci bl e( t r ue) ;
1
public void pai nt ( Gr aphi cs g)
I
el ement o = sel ecci n.getSel ectedI tern();
g. dr awSt r i ng ( " El ement o sel ecci onado " + el ement o, 20, 230) ;
public void i t er nSt at eChanged( 1t emEvent e)
i
1
r epai nt ( ) ;
9.12. CLASE Checkbox
Las casillas de verificacin son componentes IGU con dos estados posibles: activa-
do ( t r ue) y desactivado (f al se). Estn formadas por un pequeo cuadro que
puede presentar o no una marca de verificacin y una etiqueta descriptora de la
opcin (Fig. 9.15).
r Casilla Verificacin
Figura 9.1 5. Casilla de verificacin desactivada.
Las casillas de verificacin pueden utilizarse individualmente y tambin pueden
agruparse en un CheckboxGr oup. Los CheckboxGr oup agrupan de 1 a n
casillas de verificacin de forma que no podr haber varias activadas al mismo
tiempo. El constructor de un grupo CheckboxGr oup crea un grupo vaco y la
forma de conseguir que las distintas casillas de verificacin se aadan al grupo ser
especificar el nombre del grupo cuando se creen las casillas de verificacin. La
clase CheckboxGr oup hereda de Obj ect y no es un Component , por lo que
los objetos CheckboxGr oup no pueden agregarse a un contenedor, lo que se har
es aadir individualmente cada una de las casillas que constituyen el grupo. Dentro
de los mtodos para manejar este tipo de objetos citaremos.
Constructor de un conjunto de un CheckboxGr oup.
public CheckboxGr oup ( )
public Checkbox( j ava. l ang. St r i ng p l , j ava. awt . CheckboxGr oup p2,
boolean p 3 )
Construye un Checkbox cuya etiqueta ser la cadena especificada como pnmer parmetro, su
estado (activado o desactivado) el tercer parmetro y lo agrega al CheckboxGr oup especifica-
do como segundo parmetro, que debe haber sido previamente creado. El formato de las casi-
llas de verificacin cambia y se convierten en circulares.
Interfaces grficas de usuario 247
public Checkbox ( )
Crea un Checkbox vaco y no seleccionado.
public Checkbox( j ava. l ang. St r i ng pl)
Crea un Che kbox no seleccionado cuya etiqueta es la cadena pasada como parametro.
public Checkbox ( j ava. l ang. St r i ng pl, boolean p2)
Crea un Chekbox cuyo estado inicial, seleccionado o no seleccionado, depender de lo
especificado como segundo parmetro y cuya etiqueta es la cadena pasada como primer
parmetro.
public j ava. awt . Checkbox get Sel ect edCheckbox0
Determina dentro de un grupo el objeto Checkbox seleccionado.
public boolean get st at e0
Obtiene el estado del Checkbox.
public j ava. l ang. St r i ng get l abel o
Obtiene la etiqueta de un Checkbox.
Para tratar el evento de seleccin de una opcin, se siguen lo mismos pasos que
se expusieron en el caso de Choi ce.
Ejemplo
Creacin de un CheckboxGr oup que trata el evento de seleccin de una opcin.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .....
C Primera opcin 6 !se.ci!.nd.a..oP.c!4!;
r Tercera opcin C Cuarta opcin
Elemento seleccionado Segunda opcin
Figura 9.16. CheckboxGr oup, el formato de las casillas de verificacin
cambia y se convierten en circulares.
248 Java 2. Manual de programacin
i mpor t j ava. awt . *;
i mport j ava. awt . event . *;
publ i c cl ass Ej CheckboxGr oup ext ends Fr ame i mpl ement s I t emLi st ener
i
pr i vat e Checkbox opl , op2, Op3, Op4;
pr i vat e CheckboxGr oup menu;
publ i c Ej CheckboxGr oup ( )
i
addWi ndowLi st ener ( new Ci er r e30) ;
menu = new CheckboxGr oup ( ) ;
opl = new Checkbox ( " Pr i mer a opci n" , menu, f al se) ;
op2 = new Checkbox ( " Segunda opci n" , menu, f al se) ;
op3 = new Checkbox ( " Ter cer a opci n" , menu, f al se) ;
op4 = new Checkbox ( " Cuar t a opci n" , menu, f al se) ;
add( op1) ;
add ( op2) ;
add ( Op3) ;
add( op4) ;
opl . addI t emLi st ener ( t hi s) ;
op2. addI t emLi st ener ( t hi s) ;
op3. addI t emLi st ener ( t hi s) ;
op4. addI t emLi st ener ( t hi s) ;
I
publ i c st at i c voi d mai n( St r i ng ar gs[ ] )
I
Ej CheckboxGr oup vent ana = new Ej CheckboxGr oup ( ) ;
vent ana. set Layout ( new Gr i dLayout ( 3, 2) ) ;
vent ana. set Ti t l e ( " El AWT" ) ;
vent ana. set Si ze( 400, 250 ) ;
ventana.setResizable(fa1se);
ventana.setVisible(true);
/ * Redef i ni r el mt odo get I nset s de l a cl ase Cont ai ner es una
f or ma de consegui r que l os component es que si t uemos en un
cont enedor queden l i ger ament e separ ados del bor de del mi smo.
Los val or es que especi f i quemos en get i nset s l os ut i l i zar n
l os admi ni st r ador es de di seo a l a hor a de col ocar compo-
nent es en el cont enedor */
publ i c i nset s get I nset s ( )
i
1
r et ur n new I nset s( 20, 20, 20, 20) ;
publ i c voi d pai nt ( Gr aphi cs g )
I
i f ( menu. get Sel ect edCheckbox ( ) ! = nul l )
g. dr awst r i ng ( " El ement o sel ecci onado ' I+
menu. get Sel ect edCheckbox ( ) . get Label ( ) , 20, 230) ;
\
Interfaces grficas de usuario 249
publ i c voi d i t emSt at eChanged( 1t emEvent e)
I
1
r epai nt ( ) ;
1
Compilacin
C: \ l i br o\ Tema09>j avac Ej CheckboxGr oup. j ava
Ejecucin
C: \ l i br o\ Tema09>j ava Ej CheckboxGr oup
9.13. LISTAS
La clase L i s t proporciona listas donde se pueden realizar selecciones mltiples. Si
todos los elementos de una lista no caben en el nmero de filas visibles, aparece
automticamente una barra de desplazamiento para que se pueda acceder a los res-
tantes elementos de la lista; sucede, de modo anlogo, si el nmero de caracteres
de alguna de las opciones supera el nmero de columnas visibles.
Enero
1 Febrero
Agosto
Octubre
I Noviembre
Figura 9.17. Lista cuyos elementos no caben en el nmero de filas visibles
y con varias opciones seleccionadas: Marzo, Abril, J ulio.
Los constructores de una lista son:
publ i c Li st ( )
Crea una lista que no permite selecciones mltiples.
publ i c Li st ( i nt pi)
Crea una lista con tantas filas visibles como especifique el parmetro pl y que no admite
selecciones mltiples.
250 Java 2. Manual de programacin
public Li st (int pl, boolean p2)
Crea una lista con tantas filas visibles como indique el parmetro pi y que admitir o no
selecciones mltiples segn sea t r ue o f al se el valor que le pasemos como parmetro p2.
Para aadir nuevas opciones a una lista se emplea:
public void add( j ava. l ang. St r i ng pl)
Otros mtodos tiles son:
public synchronized j ava. l ang. St r i ng get Sel ect edI t em( )
Devuelve una cadena con el nombre del elemento seleccionado, si no se selecciona ningn
elernento o se selecciona ms de uno devuelve nu 11 .
public synchronized int get Sel ect edI ndex0
Devuelve el ndice del elemento seleccionado. AI primer elemento de la lista le corresponde
un cero, al siguiente un uno y as sucesivamente. Si hay ms de un elemento seleccionado o
an no se ha seleccionado ninguno, devuelve - 1.
public synchronized void sel ect (int p l )
Permite especificar la eleccin por defecto.
public synchronized j ava. l ang. St r i ng[ ] get Sel ect edI t ems0
Se emplea para tratar selecciones mltiples, devolviendo un vector de cadenas que contiene
los nombres de los elementos seleccionados.
public synchronized int[] get Sel ect edI ndexes0
Se utiliza para tratar selecciones mltiples, devolviendo un vector de enteros con los ndices
de los elementos seleccionados.
En una lista se han de considerar dos tipos de eventos; si se efecta doble clic
con el ratn sobre un elemento de la lista se produce un Act i onEvent ; si se efec-
ta un nico clic sobre los elementos de la lista, se produce un I t emEvent . Para
tratar el suceso Act i onEvent se necesita enlazar el ,objeto Li st a la interfaz
Act i onLi st ener y sobreescribir act i onper f or med, y para tratar el suceso
I t emEvent es necesario enlazarlo a I t emLi ct ener y sobreescribir
i t emSt at eChanged.
Ejemplo
Este programa permite efectuar selecciones mltiples en una lista con las siguien-
tes caractersticas:
Efectuando clic con el botn izquierdo del ratn sobre elementos no seleccio-
Si efecta clic sobre un elemento seleccionado, lo elimina de la seleccin.
nados, los selecciona.
Interfaces grficas de usuario 251
Seleccin.
Elemento 1
Elemento 4
Figura 9.18. Resultado de la ejecucin del programa ejemplo de listas.
El marcado y desmarcado de los elementos podr efectuarse tantas veces como
se quiera (Fig. 9.18). Para terminar el proceso de seleccin mltiple, deber efec-
tuar doble clic sobre un elemento an no seleccionado de la lista, el cual, con sta
operacin, tambin se aadir a la seleccin. Si efecta doble clic sobre un elemento
previamente seleccionado, tambin terminar el proceso de seleccin, pero este
ltimo elemento no se aadir a la misma.
import j ava. awt . *;
import j ava. awt . event . *;
public class Ej Li st a extends Fr ame implements I t emLi st ener ,
Act i onLi st ener
i
private Li st l i st a;
public Ej Li s t aO
addwi ndowl i st ener (new Ci er r e3 ( ) ) ;
l i st a = new List(5,true);
for (int i = 1; i < 8; i ++)
l i st a. add( " El ement o " +i ) ;
l i st a. addAct i onLi st ener ( t hi s) ;
1i ct a. addI t emLi st ener (this) ;
add( 1i st a) ;
1
public static void mai n ( St r i ng ar gs [ ] )
Ej Li st a vent ana = new Ej Li s t aO;
vent ana. set Layout (new Fl owLayout ( ) ) ;
vent ana. set Ti t l e ( " El AWT" ) ;
vent ana. set Ci ze( 400, 250 ) ;
vent ana. set Vi si bl e( t r ue) ;
252 Java 2. Manual de programacin
public void pai nt ( Gr aphi cs g)
I
St r i ng ar r [ I = 1i st a. get Sel ect edI t er ns ( ) ;
int al t o = g. get Font Met r i cs ( ) . get Hei ght ( ) ;
if ( ar r . l engt h != O)
{ g. dr awSt r i ng ( " Sel ecci n: ' I, 20, 250- al t o*8) ;
for (int i = O; i < ar r . l engt h; i ++)
g. dr awSt r i ng( ar r [ i ] , 20, 250- al t o* ( 7- i ) ) ;
1
1
public void act i onPer f or med( Act i onEvent e)
{
if ( e. get Sour ce0 == l i st a)
r epai nt ( ) ;
1
public void i ternStateChanged(1ternEvent e)
t 1
9.14. CLASE Scrollbar
Las barras de desplazamiento son componentes que recorren valores enteros y pue-
den estar orientadas horizontal o verticalmente (Fig. 9.19).
Figura 9.19. Barra de despl azami ento.
Constructores
public Scr ol l bar ( )
Crea una barra de desplazamiento vertical.
public Scr ol l bar (int pi)
Crea una barra de desplazamiento en la direccin indicada por el parmetro p 1 :
Scr ol l bar . HORI ZONTALoScr ol l bar . VERT1CAL.
Interfaces grficas de usuario 253
public Scr ol l bar (int pl , int p2, int p 3 , int p 4 , int p5)
Crea una barra de desplazamiento en la direccin que se le indique mediante el parmetro
pl , con el valor inicial especificado en p2 (el cuadro de desplazamiento aparecer inicial-
mente en esta posicin), cuyo tamao para el cuadro de desplazamiento es el tercer parme-
tro y con los valores mnimo y mximo que contengan los parmetros p4 y p5. Si el valor
inicial es menor que el mnimo o mayor que el mximo, el valor inicial se har igual al mni-
mo o mximo respectivamente.
Otros mtodos necesarios para trabajar con barras de desplazamiento son:
public synchronized void set val ues (int pl, int p2, int p3, int p4)
Establece los parmetros para una barra de desplazamiento.
public int get Maxi mum( )
Devuelve el valor mximo.
public int get Mi ni mum( )
Devuelve el valor mnimo.
public int get val ue ( )
Obtiene el valor actual de la barra.
public synchronized void set val ue (int pl)
Establece el valor actual.
Ejemplo
Crea una barra de desplazamiento horizontal (Fig. 9.20).
import j ava. awt . *;
import j ava. awt . event . *;
class Ej Bar r a extends Fr ame
{
public Ej Bar r a ( ) '
(
Scr ol l bar bar r a = new Scr ol l bar Scr ol l bar . HORI ZONTAL,
100, o, o, 200) ;
Fr ame v = new Fr ame( " El AWT" ) ;
v. add ( " Nor t h" , bar r a ) ;
v. set Si ze( 200, 200 ) ;
v. set Vi si bl e( true ) ;
v. addWi ndowLi st ener ( new Ci er r e3 (
1
public static void mai n( St r i ng ar gs
(
}
new E] Bar r a ( ) ;
1 '
254 Java 2. Manual de programacin
La salida del programa anterior es la mostrada en la Figura 9.20.
I
Fi gura 9.20. Resultado de la ejecucin del ejemplo.
Cada vez que se mueve el cuadro de desplazamiento se genera un evento del
tipo Adj usment Event , que debe ser recogido por el receptor
Adj ust ment Li st ener , por lo que se enlazar el objeto a la interfaz corres-
pondiente y se sobreescibir el mtodo ad j ust r nent val uechanged.
9.15. MENS
Menucomponent es la superclase de todos los elementos relacionados con los
mens, siendo subclases suyas tanto MenuI t emcomo MenuBar . MenuI tern
contiene los mtodos para crear los elementos de un men. La clase MenuBar con-
tiene el constructor de barras de men. Las barras de men actan como contene-
dores de mens. La clase Menu es una subclase de MenuI t emy proporciona
mtodos para la administraccin de los mens. Los mens contienen elementos de
men y se agregan a barras de men.
Cuando se selecciona un elemento de un men se genera un evento del tipo
Act i onEvent , que se tratar de forma anloga a como se ha explicado en otras
ocasiones.
Los elementos se aaden al men mediante el mtodo add y los mens a la
barra de mens de la misma forma, pero la adicin del men a un marco se efecta con:
public synchronized void set MenuBar ( j ava. awt . MenuBar pl)
Constructores
public MenuBar ( )
Construye la barra de mens.
lnferfaces grficas de usuario 255
public Menu ( J ava. l ang. St r i ng pl)
Construye el men, recibe como parmetro el nombre del men.
Crea un elemento de men, recibe como parmetro el nombre de la opcin
public MenuI t em( j ava. 1ang. St r i ng pl)
Ejemplo
Pasos a seguir para la creacin de un men que responda a eventos:
Figura 9.21. Mens.
// Fr ame con bar r a de men.
import j ava. awt . *;
import j ava. awt . event . *;
public class Ej Menu extends Fr ame implements Act i onLi st ener
i
public E j Menu ( )
t
addWi ndowLi st ener (new Ci er r e3 ( ) ) ;
set Ti t l e ( " Mar co" ) ;
MenuBar mb = new MenuBar ( ) ;
Menu m = new Menu ( " Ar chi vo" ) ;
MenuI t em abr i r = new MenuI t em( " Abr i r ar chi vo" ) ;
MenuI t em cer r ar = new MenuI t em( " Cer r ar ar chi vo" ) ;
abr i r . addAct i onLi st ener ( t hi s) ;
cer r ar . addAct i onLi st ener ( t hi s) ;
m. add( abr i r ) ;
m. add( cer r ar ) ;
mb. add ( m) ;
set MenuBar ( mb) ;
set si ze ( 200, 100) ;
set Vi si bl e( t r ue) ;
1
public void act i onPer f or med( Act i onEvent e)
t
Syst em. out . pr i nt l n( e. get Sour ce( ) ) ;
256 Java 2. Manual de programacin
public static void main ( St r i ng ar gs [ ] )
I
new EjMenu ( ) ;
9.1 6. ADMINISTRADORES DE DISEO
J ava tiene cinco administradores de diseo que controlan la ubicacin de los
componentes aadidos a un contenedor y, cuando el usuario redimensiona el
contenedor, estos administradores intentan reajustar dichos componentes en
la nueva rea. Los ms importantes son: Fl owLayout , Bor der Layout y
Gr i dLayout . Para incorporar un administrador de diseo se utiliza la siguiente
sentencia:
setLayout (new NombreGestor(parmetros) ) ;
y cuando se desee no usar un administrador se pasa null al mtodo set l ayout ;
en este caso habr que colocar y dimensionar los componentes de forma manual,
para lo que se puede utilizar el mtodo
public void setBounds(int p l , int p2, int p 3 , int p4)
en el que los parmetros pl y p2 representan la posicin, en pixels, del extremo
superior izquierdo del componente con respecto a su contenedor, mientras p 3 y p 4
son la anchura y altura del objeto respectivamente.
Cuando se quiere dejar un pequeo borde entre un contenedor y los componen-
tes que situamos en l se puede recurrir a redefinir el mtodo get i nse t s de la
clase Cont ai ner , especificando en l la cantidad de espacio que se desea reser-
var para dicho borde. Estos valores sern tenidos en cuenta por el administrador de
diseo correspondiente cuando vaya a colocar los componentes en el contenedor.
Un ejemplo de get i nset s aparece en el apartado que comenta la clase
Checkbox.
Las caractersticas de los administradores de diseo fundamentales se detallan a
continuacin.
9.16.1. FlowLayout
Utiliza la interfaz Layout Manager y es el administrador de diseo que usan por
omisin los paneles y las applets. Cuando se utiliza Fl owLayout los componentes
se colocan en el contenedor de izquierda a derecha en el orden en el que van siendo
agregados y, cuando no caben ms en una fila, continan colocndose en la siguiente.
lnterfaces grficas de usuario 257
Los constructores son:
publ i c Fl owLayout ( )
public Fl owLayout ( i nt pi)
Construye un Fl owLayout
por defecto, que centra los
componentes, dejando 5 pixeles
de espacio entre cada uno de
ellos.
Construye un Fl owLayout y
mediante el parmetro permite
especificar el alineamiento. Son
valores vlidos para dicho pa-
rmetro.
Fl owLayout . LEFT
Fl owLayout . CENTER
Fl owLayout . RI GTH
publ i c Fl owLayout ( i nt pl, i nt p 2 , i nt p 3 ) Construyeun Fl owLayout de
forma que se pueden especifi-
car tanto el alineamiento como
el espacio horizontal y vertical
a dejar entre los componentes.
El diseo se establece mediante setl ayout. Por ejemplo:
set Layout (new Fl owLayout ( Fl owLayout . LEFT) )
La adicin de componentes se efecta empleando el mtodo add.
9.1 6.2. BorderLayout
Es el administrador de diseos por defecto para los cuadros de dilogo y los mar-
cos y se caracteriza por acomodar a los componentes en cinco areas: North,
South, East, West y Center, especificadas en el orden en el que dichas reas
son dimensionadas.
I South I
Figura 9.22. BorderLayout: reas.
Es posible usar, por tanto, de uno a cinco componentes con BorderL ayout,
uno para cada posicin, y, excepto en el caso de Center, cuando alguna posicin
no es usada la zona correspondiente ser ocupada por los otros componentes.
258 Java 2. Manual de programacin
Si no se usa Nor t h ni sout h, quedara as. Si no se usa Nor t h, ni sout h, ni East .
Figura 9.23. Bor der Layout cuando no se usan algunas posiciones.
Sus constructores son:
public Bor der Layout ( ) Construye un Bor der Layout .
public Bor der Layout (int pl, int p2) Construye un Bor der Layout
separando cada rea horizontal
y verticalmente el nmero de pi-
xeles indicados como argumento.
Establecindose el diseo de la siguiente forma:
set Layout (new Bor der Layout ( ) 1
set Layout (new Bor der Layout ( pi , p2) )
para situar un componente en una determinada posicin se incluye la posicin o
rea en el mtodo add :
public j ava. awt . Component add( j ava. l ang. St r i ng pl,
j ava. awt . Component p2)
el primer parmetro es la posicin, cuyo nombre ( Nor t h, Sout h, East ,
We s t o Cent e r ) debe comenzar siempre por mayscula y, puesto que el rea ha
de especificarse, los componentes podrn agregarse en cualquier orden.
9.1 6.3. GridLayout
Divide el contenedor en una cuadrcula que permite colocar los componentes en filas
y columnas, concediendo el mismo tamao a todos ellos. Dichos componentes se
agregan a la cuadrcula ocupando la primera fila de izquierda a derecha y pasando a
continuacin a ocupar, en el mismo sentido, la fila siguiente y as sucesivamente.
Los constructores de Gr i dLayout son:
public Gr i dLayout ( i nt pi, int p2)
Construye un Gr i dLayout con el nmero de filas especificado como primer parmetro y
el nmero de columnas especificado como segundo parmetro.
public Gr i dLayout (int pl, int p2, int p3, int p4)
Construye un Gr i dLayout con el nmero de filas especificado como primer parmetro y
el nmero de columnas especificado como segundo parmetro y cada componente separado
horizontalmente por p 3 pixeles y verticalmente por p 4.
Interfaces grficas de usuario 259
El diseo se establece mediante:
set Layout (new Gr i dLayout ( pl , p2) )
set Layout (new Gr i dLayout ( pl , p2, p3, p4) )
y la adicin de componentes se realiza con add:
public j ava. awt . Cor nponent add( j ava. awt . Cor nponent p l )
Nota: Redenir cl =todo getinsets de la clase Container sirve para
$es que se cdoquen ea un contenedor queden lige-
i8l misrrns.
jemplo
En este ejemplo se muestra el comportamiento de los administradores de diseo y dis-
tintos componentes del AWT. Pero no incluye la gestin de eventos, excepto la del even-
to de cierre que se produce cuando se hace clic en el icono de salida de la ventana.
Figura 9.24. Ejemplo sobre el comportamiento de los administradores de diseo.
260 Java 2. Manual de programacin
import j ava . awt . * ;
import j ava. awt . event . *;
public cl as s Vent anas extends Fr ame
t
public Vent anas ( )
I
addWi ndowLi st ener (new Ci er r e3 ( ) ) ;
Panel panel Bot ones = new Panel ( ) ;
Panel panel cent r al = new Panel ( ) ;
MenuBar mb = new MenuBar ( ) ;
Menu m = new Menu ( " Men" ) ;
m. add( new MenuI t em( " Opci n 1" ) ) ;
m. add( new MenuI t em( " Opci n 2" ) ) ;
m. add( new MenuI t em( " Opci n 3" ) ) ;
mb. add( m ) ;
set MenuBar ( mb ) ;
panel Bot ones. add ( new Text Fi el d ( " Campo de Text o" ) ) ;
panel Bot ones. add ( new But t on ( " Bot n" ) ) ;
panel Bot ones . add ( new Checkbox ( " Casi l l a Ver i f i caci n" ) ) ;
Choi ce sel ecci n = new Choi ce ( ) ;
sel ecci n. addI t em( " 1" ) ;
sel ecci n . addI t em( " 2" ) ;
sel ecci n. addI t em( " 3" ) ;
panel Bot ones. add( sel ecci n ) ;
/ / Se ut i l i za Gr i dLayout par a di vi di r el cont enedor
panel cent r al . set Layout ( new Gr i dLayout ( 2, l ) ) ;
/ / se col oca el di buj o
Di buj o d = new Di buj o ( ) ;
d. set Backgr ound( Col or . yel 1ow) ;
panel Cent r al . add( d) ;
/ / se col ocan l a et i quet a y el r ea de t ext o
Panel p = new Panel ( ) ;
p. set Layout ( new Bor der Layout ( ) ) ;
p. add ( " Nor t h" , new Label ( " Et i quet a" , Label . CENTER ) ) ;
Text Ar ea Text o= new Text Ar ea ( " Puede escr i bi r aqu +
for ( i nt i =l ; i <=12; i t +)
Text o. append ( i +" \ n" ) ;
p. add ( " Cent er " , Text o ) ;
panel Cent r al . add( p ) ;
" el t ext o que desee\ n" ) ;
Interfaces grficas de usuario 261
/ *se ut i l i za Bor der Layout par a acomodar l os component es en
l as di st i nt as r eas */
set Layout ( new Bor der Layout ( ) ) ;
add ( " Sout h" , panel Bot ones ) ;
add ( " Cent er " , panel cent r al ) ;
Li st l i st a = new Li st ( ) ;
l i st a. add( " Mer cur i o" ) ;
1 i s t a . add ( " Venus " ) ;
l i st a. add ( " Ti er r a" ) ;
l i st a. add ( " Mar t e" ) ;
l i st a. add( " J pi t er " ) ;
l i st a. add ( " Sat ur no" ) ;
l i st a. add ( " Ur ano" ) ;
l i st a. add ( " Nept uno" ) ;
l i st a. add( " Pl ut n" ) ;
add( " East " , l i st a ) ;
1
public s t a t i c voi d mai n( St r i ng ar gs[ ] )
i
Vent anas vent ana = new Vent anas ( ) ;
vent ana. set Ti t l e ( " El AWT" ) ;
vent ana. set Si ze( 400, 250 ) ;
vent ana. set Vi si bl e( t r ue) ;
1
1
/ / Subcl ase de Canvas
cl as s Di buj o extends Canvas
I
public void pai nt ( Gr aphi cs g )
{
i nt ancho = get s i z e0 . wi dt h;
i nt al t o = get s i z e0 . hei ght ;
Font f uent e = g. get Font ( ) ;
i nt t amaol et r a = f uent e. get si ze ( ) ;
g. dr awSt r i ng ( " Los pl anet as" , ( ancho- g. get Font Met r i cs ( ) .
g. dr awOval ( l , l +t amaoLet r a, ancho- 2, al t o- t amaoLet r a- 2 ) ;
g. f i l l 0val ( ancho/ 4, t amaoLet r a+al t o/ 6, ancho/ 2, ( al t o-
st r i ngWi dt h( " Los pl anet as" ) ) / 2, 10 ) ;
t amaol et r a) / 2) ;
1
1
Otros administradores de diseo son: Gr i dBagLayout , parecido a Gr i dLayout
pero admitiendo que los componentes ocupen varias celdas, y Car dLayout , que crea
una organizacin con tarjetas.
262 Java 2. Manual de programacin
j ava . awt .
9.17. swing
Component
j ava. awt . Cont ai ner
El paquete swi ng extiende el awt , aade nuevos componentes e incorpora dos
administradores de diseo ms. La superclase de los componentes swi ng es la
clase J Component , que deriva de la clase estndar Cont ai ner y, por tanto, des-
ciende tambin de la clase Component del awt , de esta jerarqua se deduce que
todos los componentes swi ng son contenedores (Fig. 9.25). Entre las novedades
aportadas por j avax . swi ng destacan las ventanas con pestaas, el hecho de
poder aadir bordes as como asociar un texto de ayuda a cualquier componente.
Adems, los componentes swi ng se ejecutan uniformemente en cualquier plata-
forma. Hay que tener en cuenta que, en muchas ocasiones, los nombres de los com-
ponentes en ambos paquetes casi coinciden, diferencindose nicamente en que los
de swi ng anteponen una J , y la forma de trabajo tambin, facilitndose as el paso
de awt a swi ng.
Figura 9.25. J erarqua de clases: la clase J Component .
-
10
Gestin de eventos
CONTENIDO
10.1. Tipos de eventos.
10.2. Los componentes del AWT como fuente
de eventos.
10.3. Receptores de eventos.
10.4. Procesamiento de eventos.
10.5. Clases adaptadoras.
10.6. Clases receptoras annimas.
10.7. Problemas comunes en el tratamiento de eventos.
263
264 Java 2. Manual de programacin
Los usuarios pueden comunicarse con los programas a travs de
los objetos visuales que ofrecen las Interfaces Grficas de Usuario
(IGU). Cuando se trata del paquete awt la comunicacin se pro-
duce de la siguiente forma, los distintos componentes del AWT son
capaces de detectar eventos de una determinada clase y notificar
esta accin a un objeto receptor. Si el receptor recibe el aviso de
que ha ocurrido determinado suceso, llama a un mtodo, redefini-
do por el programador, que ejecuta las acciones deseadas. Por
otra parte, Swi ng proporciona nuevos tipos de eventos pero el pro-
cesamiento de los mismos es anlogo al comentado anteriormen-
te. En este captulo se comentan los diferentes tipos de eventos
del AWT, as como los problemas que se presentan en el procesa-
miento de los mismos.
10.1. TIPOS DE EVENTOS
La programacin GUI es una programacin dirigida por eventos que implica la
necesidad de procesar los mismos y, por tanto, la utilizacin de las clases propor-
cionadas por el paquete j ava . awt . event que definen los tipos de eventos del
AWT.
J erarqua de clases
Figura 10.1. Clases proporcionadas por el paquete j ava . awt . event
La jerarqua de clases conduce a una divisin de los eventos en dos categoras fun-
damentales, de bajo nivel, subclase de Component Event , y semnticos, colegas de
Gestin de eventos 265
Component Event . No obstante, la programacin de los eventos de ambas cate-
goras es similar y su principal diferencia reside en la naturaleza del objeto evento y
la informacin que es capaz de proporcionar.
Los eventos de bajo nivel ofrecen acceso al componente que ha generado el
evento y, con l, acceso a los mtodos de la clase Component mediante el
mtodo:
public j ava. awt . Component get Component 0
Los eventos semnticos proporcionan diferentes mtodos para obtener una refe-
rencia al objeto que ha generado el evento. Por ejemplo, en Act i onEvent se
puede obtener la etiqueta identificativa del objeto fuente mediante
public j ava. l ang. Ct r i ng get Act i onCommand0
mientras que en I t emEvent debiera utilizarse
public j ava. awt . I t emCel ect abl e get I t emSel ect abl e0
Nota: Si no se desea recordar mtodos especficos es posible recurrir al
mtodo
public java.lang.0bject getsource0
perteneciente a la clase j ava. ut i 1 . Event obj ect , situada muy arriba
en la jerarqua; como consecuencia, este mtodo puede ser utilizado con todo
tipo de eventos,
10.2. LOS COMPONENTES DEL AWT COMO FUENTE
DE EVENTOS
Los distintos componentes del AWT son capaces de actuar como fuente de even-
tos, es decir, como objetos capaces de detectar eventos de una determinada
clase y, para conocer los eventos que pueden ser detectados por cada uno de
ellos, hay que tener en cuenta tanto la siguiente tabla como la jerarqua de cla-
ses del AWT.
266 Java 2. Manual de programacin
Tabla 10.1. Fuentes de eventos
Fuente Clase de evento
Butt on
L l S t
Y e r. u I ten
TextFi el d
Acti onEvent
Acti onEvent
Acti onEvent
Acti onEvent
Scrol l Bar Adj ustrnentEvent
C ornpor.e n t CornponentEvent
Conzai ner Contai nerEvent
Conponent FocucEvent
Checkbox
CheckboxMen~dI tern
Choi ce
L;ct
I ternEvent
I ternEven t
I ternEvent
I ternEvent
Corrponenr K e y0 ver, t
Cunponent MouseEvent
TextArea
T extF i el d
TextEvent
TextEvent
D; al og Wi ndowEvent
Frame Wi ndowEvent
10.3. RECEPTORES DE EVENTOS
Las clases de nivel ms bajo dentro de los distintos subrboles a considerar en
la jerarqua de eventos tienen una interfaz ((oyente)) asociada, excepto Mous eEven t
que tiene dos, con un nico mtodo o bien un conjunto de mtodos declarados en ellas
para tratar los eventos de las mismas y los receptores de eventos son clases que imple-
mentan interfaces oyentes especficas.
Clase de evento Interfaz
I A rti onEvent I Ac t 1 onLi s t ener
~c t i onL i s t e ne r , mtodos:
public abstract void act i onPer f or med( j ava. awt . event . Act i onEvent pl)
Gestin de eventos 267
I t emEvent
Clase de evento Interfaz
I t emLi st ener
1
1 Adj ust ment Event 1 Ad] ust ment l i st ener 1
Ad j us t men t Li s t ener , mtodos:
public abstract void
adj ust ment ~a: ueChanged( ~ava. awt . event . Adj ust me~~t Event pl )
Clase de evento Interfaz
1 Component Event 1 Component Li st ener
Component Li st ener , mtodos:
public abstract void
componentHi dden(~ava.awt.event.ComponentEvent pl)
public abstract void
component Moved( j ava. awt . event . Component Event pl)
public abstract void
componentResi zed(]ava.awt.event.ComponentEVent pi )
public abstract void
component Shown( ] ava. awt . event . Component Event pZ)
Clase de evento Interfaz
Cont ai ner Event 1 Cont ai ner Li st ener
Cont ai ner Li st ener , rne'todos:
public abstract void
cor nponent Added( j ava. awt . event . Cont ai ner Event pl)
public abstract void
component Removed( j ava. awt . event . Cont ai ner Evenc pl)
Clase de evento Interfaz
1 FocusEvent 1 FocusLi st ener I
Focus Li s t ener ,
public abstract void f ocusGai ned( j ava. awt . event . FocdsEve~t pi )
public abstract void f ocusL ost( ~ava. awt. event. Foc; sEvent pl)
mtodos:
I t emLi s t ener , mtodos:
public abstract void i t emCt at eChanged( j ava. awt . event . 1t emEvent pl )
268 Java 2. Manual de programacin
MoxseEvenc
i
Clase de evento Interfaz
MouceLi ct ener
MouceMot i onLi ct ener
1 KeyEvenr . 1 KeyLi st ener I
Text Event
KeyLis t e ne r , mtoclos:
publ i c abstract void keyPr essed( j ava. awt . event . KeyEvent pl)
publ i c abstract void keyRel eased( ; ava. awt . event . KeyEvent pl)
publ i c abstract void keyTyped( j ava. awt . event . KeyEvent pl)
Text Li st ener
~
Mo uceLi c t ener , mtodos:
publ i c abstract void
publ i c abstract void
publ i c abstract void
publ i c abstract void
publ i c abstract void
MoLI s eMo t i o I: L i s t en e r ,
publ i c abstract void
publ i c abstract void
Clase de evento
mouseCl i cked( j ava. awt . event . MouseEvent pl)
mouseEnt er ed( j ava. awt . event . MouseEvent pl)
mouseExi t ed( j ava. awt . event . MouseEvent pl)
mousePr essed( ~ava. awt . event . MouseEvent pl)
mouseRel eased( j ava. awt . event . MouseEvent pl)
mtodos:
mOuSeDr agged ( 1 ava. awt . event . MouseEvent pi)
mouceMoved( j ava. awt . event . MouseEvent pl)
Interfaz
Text Li s t ener ,
public abstract void t ext Val ueChanged( j ava. awt . event . Text Event pl)
Wl t OdOS:
Clase de evento Interfaz
Wi n do w E ve n t
1
I Wi ndowLi st ener
Wi nci owL i s t ener , mtodos:
public abstract void wi ndowAct i vat ed( j ava. awt . event . Wi ndowEvent pl)
public abstract void wi ndowCl osed( j ava. awt . event . Wi ndowEvent pl)
public abstract void wi ndowCl osi ng( j ava. awt . event . Wi ndowEvent pl)
public abstract void wi ndcwDeact i vat ed( j ava. awt . event . Wi ndowEvent p l )
public abstract void wi ndowDei coni f i ed( ~ava. awt . event . Wi ndowEvent pl)
public abstract void wi ndowI coni f i ed( j ava. awt . event . Wi ndowEvent pl)
publ i c abstract void wi ndowCpened( j ava. awt . event . Wi ndowEvent pl)
Gestin de eventos 269
10.4. PROCESAMIENTO DE EVENTOS
Para el procesamiento de eventos, hace falta que un objeto fuente capaz de detectar
eventos de una determinada clase, notifique a un objeto receptor que se ha produ-
cido un evento de la clase que dicho receptor es capaz de interpretar y, para ello,
dicho receptor debe implementar una interfaz oyente, asociada a un determinado
tipo de suceso, sobreescribiendo cada uno de sus mtodos, y registrarse con la fuen-
te. Cuando el receptor recibe el aviso de que ha ocurrido un suceso llama al mto-
do correspondiente al evento particular generado, sobreescrito por el programador,
que ejecuta las acciones deseadas.
Ejemplo
Presentar las coordenadas de la posicin donde se pulse el ratn dentro del rea de
un marco. El programa termina cuando se cierra la ventana.
Pnsicidn del ratdn: 60, 40
Figura 10.2. MousseEvent .
-
import j ava. awt . *;
import j ava. awt . event . *;
public class Mar co extends Fr ame
{ int x = O, y = O;
public static void mai n( St r i ng ar gs[ ] )
t
Mar co f uent e = new Mar co
f uent e. set Ti t l e ( " Mar co" ) ;
f uent e. set Ci ze( 250, l OO) ;
f uent e. set Vi si bl e( t r ue) ;
/ / se i nst anci an y r egi st .
1 ;
i n l os r ecept or es
f uent e. addWi ndowLi st ener ( new Recept or Ci er r eO) ;
f uent e. addMouseLi st ener ( new Recept or Rat on( f uent e) ) ;
public void pai nt ( Gr aphi cs g)
t
g. dr awSt r i ng ( " Posi ci n del r at n: "ixt", " +y, 60, 40) ;
270 Java 2. Manual de programacin
/ * Las cl ases r ecept or as i mpl ement an oyent es y sobr eescr i ben
*/ sus mt odos
class Recept or ci er r e implements Wi ndowLi st ener
public void wi ndowCl osi ng( Wi ndowEvent e)
i
i
1
Syst em. exi t ( O) ;
public void wi ndowAct i vat ed( Wi ndowEvent e)
t i
public void wi ndowCl osed( Wi ndowEvent e)
0
public void wi ndowDeact i vat ed( Wi ndowEvent e)
i 1
public void wi ndowDei coni f i ed( Wi ndowEvent e)
i }
public void wi ndowI coni f i ed( Wi nd0wEvent e)
i 1
public void wi ndowOpened( Wi ndowEvent e)
i }
class Recept or Rat on implements MouseLi st ener
1
Mar co l avent ana;
Recept or Rat on( Mar co f uent e)
i
l avent ana = f uent e;
1
public void mousepr essed ( MouseEvent e)
l avent ana. x = e. get X ( ) ;
l avent ana. y = e. get Y ( ) ;
l avent ana. r epai nt 0;
1
public void rnouseRel eased(MouseEvent e)
o
public void rnouseEntered(M0useEvent e)
i 1
public void mouseExi t ed ( MouseEvent e)
t )
public void mouseCl i cked( MouseEvent e)
i }
1
Gestin de eventos 271
Otra forma de implernentacin podra haber sido:
import j ava. awt . *;
import j ava. awt . event . *;
public class Mar co2 extends Fr ame implements Wi ndowLi st ener ,
MouseLi st ener
{ int x = O, y = O;
Mar co2 ( )
(
set Ti t l e ( " Mar co" ) ;
set si ze ( 250, 100) ;
set vi si bl e (true) ;
/ / se r egi st r a el r ecept or
addWi ndowLi st ener ( t hi s) ;
addMouseLi st ener ( t hi s) ;
1
public static void mai n ( St r i ng ar gs [ I )
i
1
i
1
Mar co2 f uent e = new Mar co2 ( ) ;
public void pai nt ( Gr aphi cs g )
g. dr awCt r i ng ( " Posi ci n del r at n: "tx+", " +y, 60, 40) ;
public void wi ndowCl osi ng ( Wi ndowEvent e)
t
Syst em. exi t ( O) ;
public void wi ndowAct i vat ed ( Wi ndowEvent e)
i l
public void wi ndowCl osed( Wi ndowEvent e)
{ I
public void wi ndowDeact i vat ed( Wi ndowEvent e)
{ I
public void wi ndowDei coni f i ed( Wi ndowEvent e)
{ I
public void wi ndowI coni f i ed( Wi ndowEvent e)
i }
public void wi ndowOpened( Wi ndowEvent e)
i )
public void mousePr essed( MouseEvent e)
i
x = e. get X( ) ;
y = e. get Y( ) ;
r epai nt ( ) ;
I
272 Java 2. Manual de programacin
public void mouseRel eased( MouseEvent e)
public void mouseEnt er ed ( MouseEvent e)
public void mouseExi t ed( MouseEvent e)
public void mouseCl i cked( MouseEvent e)
i }
{ I
i }
1
En cuanto a swi ng, hay que destacar que aunque proporciona nuevos tipos de
eventos el procesamiento de los mismos es anlogo al estudiado. Los programas
que utilicen swi ng debern incorporar las siguientes sentencias:
import j ava. awt . *;
import j ava. awt . event . *;
import j avax. swi ng. *;
import j avax. swi nq. event . *;
En versiones anteriores, swi ng ha usado otros nombres de paquetes:
cor n. sun. j ava. swi ng
j ava. awt . swi ng +
10.5. CLASES ADAPTADORAS
Dado que existen interfaces ((oyentes)) con un gran nmero de mtodos y que un
receptor que implementa una de estas clases se ve obligado a sobreescribir todos
ellos, cuando se requiere una interfaz de este tipo se utilizan clases adaptadoras, que
implementan las interfaces oyentes con mtodos vacos y se definen las clases
receptoras para que extiendan las adaptadoras.
Ejemplo
Implementacin de un programa que presenta las coordenadas de la posicin donde
se pulsa el ratn dentro del rea de un marco usando clases adaptadoras.
import j ava. awt . *;
import j ava. awt . event . *;
public class Mar co3 extends Fr ame
i
int x = 0, y = O;
public static void mai n( St r i ng ar gs[ ] )
i
Gestin de eventos 273
Mar co3 f uent e = new Mar co3 0 ;
f uent e. set Ti t l e ( " Mar co" ) ;
f uent e. set Si ze( 250, l OO) ;
f uent e. set Vi si bl e( t r ue) ;
/ / se i nst anci an y r egi st r an l os r ecept or es
f uent e. addWi ndowLi st ener ( new Recept or Ci er r e20) ;
f uent e. addMouseLi st ener ( new Recept or Rat on2( f uent e) ) ;
1
public void pai nt ( Gr aphi cs g)
i
g. dr awSt r i ng ( " Posi ci n del r at n: "txt", " +y, 60, 4O) ;
/ / Las cl ases r ecept or as ext i enden adapt ador as
class Recept or Ci er r e2 extends Wi ndowAdapt er
public void wi ndowCl osi ng ( Wi ndowEvent e)
t
I
Syst em. exi t ( O) ;
1
class Recept or Rat on2 extends MouseAdapt er
t
Mar co3 l avent ana;
Recept or Rat on2( Mar co3 f uent e)
t
l avent ana = f uent e;
1
public void mousePr essed ( MouseEvent e)
I
l avent ana. x = e. get X ( )
l avent ana. y = e. get Y ( ) ;
l avent ana. r epai nt 0;
I
1
Nota: Las clases adaptadoras hacen innecesario redefinir aquellos mtodos,
declarados en la interfaz, no tiles para el programa que se est diseando.
Las clases adaptadoras disponibles en j ava . awt . event son:
Class Cor nponent Adapt er Class Cont ai ner Adapt er
Class FocucAdapt er Class KeyAdapt er
274 Java 2. Manual de programacin
Cl ass MouseAdapt er Cl ass MouseMot i onAdapt er
Cl ass Wi ndowAdapt er
10.6. CLASES RECEPTORAS ANNIMAS
Una clase annima es aquella que no tiene nombre y, cuando se va a crear un obje-
to de la misma, en lugar del nombre se coloca directamente la definicin. Las cla-
ses receptoras pueden ser definidas como clases annimas.
Ejemplo
Construir un men de opciones con el componente Choi ce, elegir una opcin, pre-
sentarla en pantalla y realizar el cierre de la ventana mediante una clase annima
(Fig. 10.3).
Elemento seleccionado Tercero
Figura 10.3. Ejemplo de Choi ce y clase annima para el cierre de ventana.
i mpor t j ava. awt . *;
i mpor t j ava. awt . event . *;
publ i c cl ass Ej Anoni ma ext ends Fr ame i mpl ement s I t emLi st ener
i
pr i vat e Choi ce sel ecci n;
St r i ng el ement o = "";
publ i c Ej Anoni ma ( )
t
/ *empl eo de una cl ase anni ma par a ef ect uar el ci er r e de l a
*/
addWi ndowLi st ener ( new Wi ndowLi st ener O
vent ana
Gesti n de eventos 275
t
public void wi ndowcl osi ng ( Wi ndowEvent e)
I
I
public void wi ndowAct i vat ed ( Wi ndowEvent e)
t }
public void wi ndowCl osed( Wi ndowEvent e)
t }
public void wi ndowDeact i vat ed( Wi nd0wEvent e)
t l
public void wi ndowDei coni f i ed( Wi ndowEvent e)
t l
public void wi ndowI coni f i ed( Wi ndowEvent e)
I }
public void wi ndowopened ( Wi ndowEvent e)
I I
Syst em. exi t ( O) ;
1 )
sel ecci n = new Choi ce ( ) ;
sel ecci n. addI t em( " Uno" ) ;
sel ecci n. addI t em( "Dos" ) ;
sel ecci n. addI t em( " Ter cer o" ) ;
/ / Opci n pr esel ecci onada
sel ecci n. sel ect ( 1) ;
sel ecci n. addI t emLi st ener ( t h s) ;
add ( sel ecci n) ;
I
public static void mai n( St r i ng ar gs[ ] )
i
Ej Anoni ma vent ana = new Ej Anoni ma ( ) ;
vent ana. set Layout ( new Fl owLayout O ) ;
vent ana. set Ti t l e ( " El AWT" ) ;
vent ana. set Si ze( 400, 250 ) ;
vent ana. set Vi si bl e( t r ue) ;
1
public void pai nt ( Gr aphi cs g)
I
el ement o = sel ecci n. get Sel ect edI t em( ) ;
g. dr awst r i ng ( " El ement o sel ecci onado" +el ement o,
20, 230) ;
I
public void i t emSt at eChanged( 1t emEvent e)
t
I
r epai nt ( ) ;
1
276 Java 2. Manual de programacin
Resulta prctico definir como annimas las clases receptoras que extienden
adaptadoras. Por ejemplo, en el caso anterior se podra definir la siguiente clase
annima:
/ / empl eo de una cl ase anni ma
addWi ndowLi st ener ( new Wi ndowAdapt er
I
publ i c voi d wi ndowCl osi ng
i
Syst em. exi t ( O) ;
)
Wi ndowEvent e)
10.7. PROBLEMAS COMUNES EN EL TRATAMIENTO DE EVENTOS
Un problema frecuente en el tratamiento de eventos se origina por los titubeos del
usuario ante la realizacin de una determinada eleccin y la medida a tomar suele
ser ignorar las selecciones realizadas por el mismo hasta que ste confirme su deci-
sin; para ello se aade un botn de confirmacin y se ignoran los eventos genera-
dos hasta que el usuario pulse dicho botn.
Ejemplo
Crear un CheckboxGr oup que agrupe 4 casillas de verificacin. Slo se acepta
la seleccin de la opcin cuando se pulsa el botn de confirmacin (Fig. 10.4).
i mpor t j ava. awt . *;
i mpor t j ava. awt . event . *;
publ i c cl ass Ej CheckboxGr oup ext ends Fr ame i mpl ement s Act i onLi ct ener
i
pr i vat e Checkbox opl , op2, op3, op4;
pr i vat e CheckboxGr oup menu;
pr i vat e But t on conf i r maci on;
pr i vat e Label 1;
St r i ng el ement o = " El i j a opci n y pul se Acept ar " ;
publ i c Ej CheckboxGr oup( )
i
addWi ndowLi st ener ( new Ci er r e ( ) ) ;
menu = new CheckboxGr oup ( ) ;
opl = new Checkbox ( " Pr i mer a opci n" , menu, f al se
op2 = new Checkbox ( " Segunda opci n" , menu, f al se
op3 = new Checkbox ( " Ter cer a opci n" , menu, f al se
op4 = new Checkbox ( " Cuar t a opci n" , menu, f al se)
Gestin de eventos 277
add( op1) ;
aci d( op2) ;
add( op3) ;
add( op4) ;
Panel p = new Panel ( ) ;
p. set Layout (new Gr i dLayout ( 2, l ) ) ;
1 = new Label ( el ement o) ;
conf i r maci on = new But t on ( " Acept ar " ) ;
p. add( conf i r maci on) ; .
conf i r maci on. addAct i onLi st ener ( t hi s) ;
p. add( 1) ;
add( p) ;
public static void mai n( St r i ng ar gs[ ] )
i
Ej CheckboxGr oup vent ana = new Ej CheckboxGr oup( ) ;
vent ana. set Layout (new Gr i dLayout ( 3, 2) ) ;
vent ana. set Ti t l e ( " El AWT" ) ;
vent ana. set Si ze( 500, 250) ;
vent ana. set Vi si bl e( t r ue) ;
public void pai nt ( Gr aphi cs g)
I
if ( menu. get Sel ect edCheckbox ( ) ! = null)
el ement o = " El ement o sel ecci onado: " t
menu. get Cel ect edCheckbox( ) . get Label ( ) ;
1. set Text ( el ement o) ;
1
public I nset s get I nset s ( )
i
1
return new i nset s ( 20, 20, 20, 20) ;
public void act i onPer f or med( Act i onEvent e)
i
1
r epai nt ( ) ;
1
class Ci er r e extends Wi ndowAdapt er
I
public void wi ndowCl osi ng ( Wi ndowEvent e)
Syst em. exi t ( 0) ;
1
1
278 Java 2. Manual de programacin
~ r Ptimera opcin C Sewnda aotin
r Tercera opcl6n @ Cualta opcldn
, - _ _ _ _ .. _ _ _
Aceptar
L ..--..........<..I ~ .............---,.,.._I_<._ ~ _._._._._,_,..__;
Elemento sel ecci onada: Cuarta opcln
Fi gura 10.4. Confirmacin de la seleccin de una opcin.
Por otra parte, en algunos programas las acciones a realizar ante un determinado
evento deben depender de eventos anteriores y, en estos casos, lo habitual es recu-
rrir a variables booleanas que reflejen lo que ha sucedido antes y programar las
acciones a realizar en relacin con el valor de dichas variables.
Ejercicio
Diseo de una calculadora sencilla (Fig. 10.5).
Fi gura 10.5. Calculadora.
En un programa que efecte la creacin de una calculadora ser preciso en pri-
mer lugar distinguir entre la parte correspondiente al diseo de la pantalla y la de
Gestin de eventos 279
manejo de los sucesos; dentro de esta ltima, es necesario resaltar que las acciones
a realizar ante la pulsacin de un botn van a depender sobre todo de si dicho botn
es un dgito o un operador. Considerando operadores binarios y las operaciones
como series de operando operador operando operador para evaluar segn el orden
de introduccin, cuando el botn pulsado sea un operador marcar el fin de la ope-
racin anterior, pero la actual no se podr realizar hasta que no se introduzca un
segundo operando y se marque su fin con un nuevo operador. Cuando el botn pul-
sado sea un dgito la accin depender de la seleccin anterior y de si esta fue un
dgito, la coma decimal o un operador. Por tanto, la ejecucin de unas acciones u
otras requerir la consulta de los valores de variables booleanas (ot r oNumer o,
esDeci mal ) que informen sobre dicha seleccin anterior.
import j ava. awt . *;
import j ava. awt . event . *;
public class Cal cul ador a ext ends Fr ame
Text Fi el d r esul t ado;
boolean ot r oNumer o = t r ue, esDeci r nal = f al se;
doubl e t ot al =O. O;
char oper ador =' x' ; / / si n oper ador
/ * Di sea l a pant al l a ut i l i zando 2 panel es auxi l i ar es que se
col ocan con Bor der Layout .
Uno de est os panel es auxi l i ar es cont i ene a su vez ot r os dos,
uno de oper andos y ot r o de oper ador es, que se col ocan . , t - l i -
zando Gr i dLayout . Los panel es de oper andos y oper ador es con-
t i enen l os bot ones y vuel ven a hacer uso de Gr i aLayout */
public Cal cul ador a ( j
Bot ones cer o, uno, dos, t r es, cuat r o, ci nco, sei s, s ~et e,
ocho, nueve, coma;
Bot ones suma, r est a, mul t i pl i ca, di vi de, obt i ene, bor r a;
set Font ( new Font ( " Ar i al " , Font . PLAI N, 14) ) ;
set Backgr ound( Col or . 1i ght Gr ay) ;
set Ti t l e ( " Cal cul ador a" j ;
set si ze ( 200, 140) ;
addWi ndowLi st ener ( new Ci er r e0 ) ;
Panel panel oper andos = new Panel ( ) ;
panel Oper andos. set Layout ( new Gr i dLayout ( 3, 4) ) ;
cer o = new Bot ones( " O" , ' x' , ' O' , this);
/ * el segundo par amet r o que se pasa al const r uct or i ndi ca
panel Oper andos. add( cer oj ;
cer o. addAct i onLi st ener ( cer o) ;
que no es un oper ador , el t er cer par met r o es el val or */
280 Java 2. Manual de programacin
c
uno = n e w Bot ones ( " l " , ' x' , ' 1' thi s) ;
panel oper andos. add ( uno) ;
uno. addAct i onLi st ener ( un0) ;
doc = n e w Bot ones ( " 2" , ' x' , ' 2' , thi s ) ;
panel oper andos. add ( dos) ;
dos. addAct i onLi st ener ( dos) ;
t r es = n e w Bot ones ( " 3 " , ' x' , ' 3 ' , thi s) ;
panel @per andos. add( t r es) ;
t r es. addAct i onLi st ener ( t r es) ;
cuat r o = n e w Bot ones ( " 4" , ' x' , ' 4' , thi s) ;
panel Oper andos. add( cuat r o) ;
cuat r o. addAct i onLi st ener ( cuat r o) ;
ci nco = n e w BOtOneS ( "5", ' x' ' ' 5' , thi s) :
panel Oper andos. add( ci nco ) ;
ci nco. addAct i onLi st ener ( ci nco) ;
sei s = n e w Bot ones ( " 6" , ' x' , ' 6' , thi s) ;
panel Oper andos. add( sei s) ;
cei s. addAct i onLi st ener ( sei s) ;
s i er e = n e w Bot ones ( " 7" , ' x' , 'If, thi s) ;
panel Oper andos. add( si et e) ;
ci et e. addAct i onLi ct ener ( si et e) ;
ocho = n e w Bot ones ( " 8" , ' x' , ' 8' , thi s) ;
panel Oper andos. add( ocho ) ;
ocho. addkct i onLi st ener ( ocho) ;
n' J eve = n e w Bot ones ( " 9" , ' x' , ' 9' , thi s) ;
panel Oper andos. add( nueve) ;
nueve. addAct i onLi ct ener ( nueve) ;
coma = n e w Bot ones( " , " , ' x' , '.', thi s ) A
panel Oper andos. add( coma) ;
coma. addAct i onLi st ener ( coma) ;
Panel panel oper ador es = n e w Panel ( ) ;
panel oper ador es . cet Layout ( n e w Gr i dLayout ( 2 , 3 ) ) ;
/ / bor r a pasa como oper ador el espaci o en bl anco
bor r a = n e w Bot ones ( " C" , ' ', ' O ' , thi s ) ;
/ * el segundo par amet r o que se pasa al const r uct or i ndi ca el
oper ador , el t er cer par met r o es el val or y par a l os oper a-
dor es es cer o */
panel @per ador es. add( bor r a) ;
bor r a. addAct i onLi st ener ( bor r a) ;
suma = n e w Bot ones ( ' I + " , ' + r , ' O' , thi s) ;
panel Oper ador es. add( suma) ;
sJ ma. addAct i onLi st ener ( suma) ;
r est a = n e w Bot ones ( " - ' I , I - ' , ' O' , thi s) ;
panel Gper ador es. add( r est a) ;
r ecr a. addA- zi onLi ct ener ( r est a) ;
mul t i pl i ca = n e w Bot cnec ( " * ' I , ' * I , ' O' , thi s) ;
panel Cperadcres .add ( mul t i pl i ca) ;
- . ul t i pl i ca. addAct i onLi st ener ( mul t i pl i ca) ;
di vi Se = n e w Bo:onec ( " / ' I , ' / r , ' O' , thi s) ;
Gesti n de eventos 281
panel Oper ador es. add( di vi de) ;
di vi de. addAct i onLi st ener ( di vi de) ;
obt i ene = new Bot ones ("=", ' = I , ' O' , t hi s ) ;
panel Oper ador es. add( obt i ene) ;
obt i ene. addAct i onLi st ener ( obt i ene) ;
Panel panel cent r al = new Panel ( ) ;
panel cent r al . set Layout ( newGr i dLayout ( 1, 2, 10, 10) ) ;
panel Cent r al . add( panel 0per andos) ;
panel Cent r al . add( panel 0per ador es) ;
Panel panel Resul t ado = new Panel ( ) ;
panel Resul t ado. set Layout ( new Fl owLayout 0) ;
r esul t ado = new Text Fi el d( " O" , 15) ;
r esul t ado. set Edi t abl e( f al se) ;
panel Resul t ado. add( r esul t ad0) ;
add ( " Nor t h" , panel Resul t ado) ;
add ( " cent er " , panel cent r al ) ;
set Vi si bl e( t r ue) ;
1
publ i c st at i c voi d mai n ( St r i ng ar gs [ I )
i
1
new Cal cul ador a ( ) ;
/ / no se t r at a de un oper ador
voi d col oca( char val or )
I
St r i ng . di gi t 0 = "";
i f ( val or == I . ' )
i f ( ! esDeci r nal )
{
I
i f ( ot r oNumer o )
i
r esul t ado. set Text ( " O" ) ;
ot r oNumer o = f al se;
1
esDeci r na1 = t r ue;
di gi t o = " . ";
1
I
el se
i f ( ot r oNur ner o )
di gi t o = " " t val or ;
282 Java 2. Manual de programacin
r esul t ado. set Text ( di gi t o ) ;
if ( val or != ' O' )
ot r oNumer o = false;
else
r epai nt ( ) ;
r esul t ado. set Text ( r esul t ado. get Text ( ) + di gi t o ) ;
/ / es un oper ador
void calcula(char ot r ooper ador )
i
double numer o;
ncmer o = (new Doubl e ( r esul t ado. get Text ( ) ) ) . doubl eval ue ( ) ;
if ( ( ! ot r oNumer o 1 1 oper ador == '=' ) && ot r ooper ador != ' ' 1
t
switch( oper ador )
i
case '+' :
t ot al += numer o;
break;
case I -' :
t ot al -= numer o;
break;
case ' * I :
t ot al *= numer o;
break;
case '/ ' :
t ot al /= numer o;
break;
case ' x' :
case ' ':
t ot al = numer o;
break;
r esul t ado. set Text ( ( new Doubl e ( t ot al ) ) . t ost r i ng ( ) ) ;
1
oper ador = ot r ooper ador ;
ot r oNumer o = true;
esDeci ma1 = false;
if ( ot r ooper ador == ' ' )
t
r esul t ado. set Text ( " O" ) ;
oper ador = ' ';
t ot al = 0. 0;
1
Gestin de eventos 283
cl as s Bot ones extends But t on implements Act i onLi st ener
I
char unoper ador , unval or ;
Cal cul ador a cal c;
Bot ones( Ct r i ng t ext o, char oper , char val or , Cal cul ador a c )
t
super( t ext o ) ;
unoper ador = oper ;
unval or = val or;
cal c = c;
1
public void act i onPer f or med( Act i onEvent e)
i
i f ( unoper ador == ' x' )
/ / no es un oper ador
cal c. col oca ( unval or ) ;
cal c. cal cul a( unoper ador ) ;
else
1
i
cl as s Ci er r e extends Wi ndowAdapt er
i
public void wi ndowcl osi ng ( Wi ndowEvent e)
t
1
Cyst em. exi t ( O) ;
I 11
Applets
CONTENIDO
11.1. Introduccin a HTML.
11.2. Incorporacin de applets a pginas Web.
11.3. Estructura de un applet.
11.4. Transformacin de aplicaciones en applets.
11.5. Incorporacin de sonido.
11.6. Incorporacin de imgenes.
285
286 Java 2. Manual de programacin
~~ ~ ~~ ~ ~~~ ~~ ~
Los applets son pequeos programas J ava que se incluyen en
pginas Web y cuyo cdigo se descarga desde el sevidor para ser
ejecutado localmente por un navegador. Por tanto, para trabajar con
applets es necesario conocer algunas de las caractersticas de las
pginas Web y del lenguaje en que stas estn escritas, y el cap-
tulo comienza exponiendo conocimientos bsicos sobre HTML.
Tambin se explicar la estructura fundamental de un applet. Te-
niendo en cuenta que las applets trabajan con IGU y estn guia-
das por eventos, el captulo se apoya en los conocimientos
aportados por otros anteriores para la creacin de las primeras
applets.
11.1. INTRODUCCIN A HTML
Internet es til para el intercambio de informacin y la comunicacin multiperso-
nal gracias a su organizacin en servidores, que disponen de la informacin y los
recursos, y clientes, que acceden a ellos. Dentro de los servicios proporcionados
por Internet, la Web ocupa un lugar destacado, constituyendo las pginas Web,
archivos guardados en servidores repartidos por todo el mundo y los navegadores
programas cuya misin es conectarse a un servidor Web para recibir sus datos y
presentar las pginas en pantalla. Las paginas Web se escriben en lenguaje HTML
(lenguaje de marcas de hipertexto). En un documento HTML existe texto normal y
marcas encerradas entre llaves angulares que indican al navegador cmo mostrar el
contenido del documento en pantalla.
Existen marcas bsicas que necesitan otra de cierre, como las mostradas en la
Tabla 11.1.
Tabla 11 .I. Marcas bsicas de un documento HTML
~~ ~ __
Marca Significado
<HTML> . . . </ HTML> Comienzo y fin del documento HTML
<HEAD> . . . </HEAD> Comienzo y fin de cabecera
<BODY> . . . </ BODY> Comienzo y fin del cuerpo
Applets 287
Las marcas <HTML> y </ HTML> sealan el principio y fin del documento y
<HEAD> </ HEAD> y <BODY> </BODY > dividen el documento en sus dos par-
tes fundamentales: cabecera y cuerpo.
PARTES EN UN DOCUMENTO HTML
<HTML> - Comienzo del documento
<HEAD>
</HEAD>
<BODY >
</ BODY>
Cabezera
Cuerpo
1
1
...
...
</HTML> - Fin del documento
Otras marcas que necesitan cierre se muestran en la Tabla 11.2.
Tabla 11.2. Marcas en las que se exige cierre
Marca Significado
<TI TL E> ttulo-de-faggina </TI TLE>
<Hn> ... </ Hn>
<UL>
<UL>
<OL>
<OL>
<L I > ... </OL >
<B>... </ B>
<I > ... </ I >
entradas-de-la-l i sta
entradas-de-la-lista
Ir dentro de la cabecera y permitir poner ttulo
al documento.
Cabeceras cuyo nivel viene representado por el
nmero n que las acompaa. El tamao de texto
ms grande es para las de nivel 1
Comienzo y fin de una lista no numerada
Comienzo y fin de una lista numerada
Entrada de la lista
Negrita
Cursiva
Existen tambin en HTML otras marcas que no necesitan cierre (Tabla 1 1.3).
288 Java 2. Manual de programacin
Tabla 11.3. Marcas en las que se requiere cierre
Marca Significado
<BR>
<P>
<HR>
Salto al principio de la siguiente lnea sin introducir una lnea en
blanco para separar el texto anterior.
Nuevo prrafo, introduciendo una lnea en blanco para separar el
siguiente texto del anterior.
Lnea horizontal grfica como separador de bloques de texto.
Es preciso tener presente que la escritura de saltos de lnea en una pgina HTML
As mismo, existe otra clase de marcas que requieren atributos con especifica-
se trata como si fuera una escritura de espacios en blanco.
cin de la informacin adicional necesaria para completar la accin.
Tabla 11.4. Marcas que requieren atributos
Marca Significado
~ ~ ~~~ ~~~ ~ ~
<FONT SIZE=nmero> Cambia el tamao de las fuentes.
<IMG SRC=nombre-imagen> Permite incluir en una pgina
Web la imagen con el nombre
especificado.
La marca para la inclusin de una
imagen se puede complementar
con el atributo ALT que permite
la sustitucin de la imagen por
una descripcin de la misma
cuando dicha pgina se visite con
el navegador en modo texto.
<I MG SRC=nombre-imagen ALT=descripcin>
Los enlaces en las pginas Web se indican a traves de la marca <A>. . . </ A>,
que se denomina ((ancla)) (anchors) y que necesita como atributo la referencia al
documento con el cual se enlaza (URL), de la siguiente forma:
<A H RE F = ref- a 1- doc urn en t o- con- e 1- c u a 1- se- en 1 a z a >
t ex t o- que- s e-rno s t ra ra- en-pa n t a 1 1 a </ A>
Adems de las marcas citadas, existen caracteres que tienen un significado espe-
cial en lenguaje HTML. Estos caracteres especiales sirven para representar en el
dispositivo de salida (pantalla, impresora, ...) a otros caracteres normales de escritu-
ra que no pueden escribirse directamente, dado que tienen un significado especial
en HTML. Es decir, por ejemplo, para representar en pantalla el smbolo es pre-
ciso escribir en el documento HTML el carcter (( & 1 t ; D.
Appl ets 289
Tabla 11.5. Representacin de caracteres especiales
Carcter que se desea presentar
< &I t ;
> &gt ;
11 &quot;
Carcter por el que debe sustituirse
& &amp;
. . . . . .
HTML tambin tiene cdigos especiales para los caracteres que no forman parte
de conjunto ASCII estndar (Tabla 11.6).
Tabla 11.6. Cdigos especiales para representar caracteres no ASCII
Carcter que se desea presentar Carcter por el que debe sustituirse



...
&oacut e;
&nt i l de;
&Nt i l de;
...
11.2. INCORPORACIN DE APPLETS A PGINAS WEB
Los applets permiten vincular cdigo J ava con pginas Web. Esta accin permite
construirpginas Webdinmicas. Adems, hay que tener en cuenta que el cdigo J ava
se ((descarga)) desde el servidor para ser ejecutado en el navegador, de forma que se
aprovecha la potencia del sistema local y se evita la sobrecarga del servidor. Un applet
se incorpora en una pgina Web usando las siguientes rdenes (comandos) html:
<APPL ET
CODEBASE= URL - de- l a- cl ase
CODE =n omb r e- de- 1 a- c 1 a se
NAME=nornbre
WI DTH=nrnero HEI GHT=nmero
ALT= texto
ALI GN=? us ti f i caci n
V SPA CE=espaci o- ver ti cal
<PARAM
HSPA CE =espaci o- hor i zon t a l
>
NAME=n ombre- a rgurnen to VALUE= va 1 or-a r gume n t o>
. . . (parametros, puede haber varios)
(cdigos HTML alternativos para clientes que no soportan J ava)
</ A PPL ET>
290 Java 2. Manual de programacin
Los distintos elementos y su responsabiiicLd se describen a continuacin:
CODEBASE: Necesario cuando el upplet no se encuentra en el mismo lugar que
la pgina Web y representa el directorio, relativo al directorio en donde se
encuentra la pgina Web, que contiene la clase del upplet.
CODE: Obligatorio; nombre del archivo que contiene el cdigo byte de la clase
ya compilada.
NAME: Opcional. Nombre de la instancia del applet. Este nombre permite a los
upplets de una misma pgina encontrarse y comunicarse entre s.
WI DTH y HEI GHT: Obligatorios; representan el tamao del rectngulo que
ocupar el applet en la pgina Web.
ALT: Opcional; sirve para especificar el texto alternativo que presentar un
navegador cuando comprenda la etiqueta APPLET, pero no pueda ejecutar el
applet.
ALI GN: Opcional; establece la alineacin del upplet con respecto a los otros
elementos de la pagina. Como justificacin, se podr indicar LEFT, RI GHT,
TOP, TEXTTOP, MI DDLE, ABSMI DDLE, BASELI NE, BOTTOM y ABSBOT-
TOM.
tal que separar al upplet del texto que le rodea.
VSPACE y HSPACE: Opcionales, permiten fijar el espacio vertical y horizon-
Entre las rdenes APPLET y / APPLET se pueden colocar parmetros para el
upplet con la sintaxis:
<PARAM NA ME=nornbre- argumento V A L UE =val or - ar gumento>
- NAME: Nombre del parametro que se desea pasar al applet. El nom-
bre a r g u me n t o puede escribirse encerrado o no entre comillas y no se
hacedistincin entre maysculas y minsculas.
- VALUE: Valor que se desea enviar al upplet mediante el parametro. El
valor que se enva tambin puede escribirse encerrado o no entre comillas.
Es importante tener presente que los parmetros pasados a un upplet pueden ser
varios, resultando necesario especificar para cada uno de ellos un nombre
( NAME) y un valor (VALUE). Otro factor a considerar es que si se desea que las
applets que trabajan con parmetros puedan ejecutarse siempre, conviene que en las
mismas se proporcionen valores por omisin para dichos parmetros. Por ltimo,
diremos que los parmetros se reciben en el upplet siempre como cadenas median-
te el mtodo get par amet er :
public j ava. l ang. Ct r i ng get Par amet er ( j ava. 1ang. St r i ng pl)
Appl ef s 291
La sentencia necesaria sera, pues:
St r i ng ar gument o=get Par amet er ( "nombre-argumento" ) ;
donde las comillas son obligatorias. Esta sentencia devuelve el valor-argumento
del parmetro cuyo nombre ( NAME) es nombre-argumento; si no lo encuentra,
devuelve nu 1 1.
11.2.1. Edicin de un documento HTML y - ejecucin de applefs
La edicin de una pgina HTML se realiza con un editor de texto. Una vez escrito
el cdigo en el editor, se debe almacenar con la extensin HTML.
La visualizacin de la pgina Web que incorpora un applet se podr efectuar
usando un navegador o el visor de applets, appletviewer; de ambas formas el applet
se carga y ejecuta automticamente.
FORMATO BSICO DE UNA PGINA WEB QUE INCORPORA UN APPLET
<HTML>
<HEAD>
</ HEAD>
<BODY>
<APPLET
CODE= nombr e- de- l a- cl ase
WI DTH= nmer o
hei ght = nmer o >
</ APPLET>
</ BODY>
</ HTML>
Ejemplo
Una pgina HTML que incorpora un applet al que se le pasan parmetros podra ser
la mostrada en la Figura 1 1.1.
292 Java 2. Manual de programacin
<HEAD>
;/HEAD,
<RODY>
<HI .EjernpIo</Hl>
<UL>
~TlTLE>T&iacute,iulocrlTLE>
<Ll> Lino
<LI>Dos </Liz
</UL>
<I-- Colocacion del codiaa HTML aue i nt er ese - - >
4PFLET
CODE =libro Tenia1 1 El4pplet class
WIDTH =220
HEIGHT =ion>
~P ARAM NAME ="Colar" VALJ E ='w5,1nn,inn":
cPARAM NAME ="Nombre" VALUE ="Cadena">
aAPFLET>
</BODY,
:/HTML>
Figura 11.1. Pgina T. ht ml .
Es conveniente observar el cdigo HTML y, sobre todo, cmo se especifica en
CODE el nombre del archivo que contiene el cdigo byte (bytecode) de la clase com-
pilada.
CODE=l i br o. Temal l . Ej Appl et . cl ass
El applet de la Figura 11.2 recibe como cadenas los parmetros Nombre y
Col or. Dicho upplet no adjudica valores por omisin para los parmetros, ya que
el ejemplo pretende ser una demostracin sobre el paso de los mismos y, si se pro-
dujeran errores basta con que stos se visualicen. Es importante destacar trata-
miento del parmetro Col or que en el mencionado upplet se efecta. Es necesario
tener en cuenta que en J ava el color est encapsulado en la clase Col or , que defi-
ne algunas constantes para especificar un conjunto de colores comunes, pero ade-
ms es posible definir colores utilizando constructores de color. De esta forma es
posible especificar cualquier color y despus J ava busca el ms cercano al solici-
tado en funcin de las limitaciones del sistema donde se est ejecutando el pro-
grama o applet. El tratamiento efectuado es debido a que applet exige recibir
cadenas como parmetros y el constructor de color empleado requiere tres nme-
ros enteros.
public Col or (int p l , int p 2 , int p3) Los parmetros son valores del
O al 255 que se corresponden
con la cantidad de colores puros,
rojo, verde y azul, utilizados en
la mezcla para obtener el color
deseado.
Appl et s 293
package libro Tema1 1,
import java awt *,
import J ava applet *,
public class EjApplet extends Applet
String nombre,
String color,
public void init0
i
nom b re =get P a ra m e t e r(1' N om b r e" ),
c o I o t =y et P a ra m et e r("C o I o I"),
int cl =Integer parselnt(co1or substring(0,3)),
int c2 =Integer parselnt(co1or subctring(4,6)),
int c3 =Integer parselnt(co1or substringp,lO)),
setBackground(new Color(c1 ,c2, c3)),
I
1
i
public void paint(Graphics g)
g setFont(new Font("Arial", Font BOLD, 14)),
y drawString(nombre ,20,2O),
Figura 11.2. Applet: Ej Appl et . j ava.
El mtodo i ni t ( ) es proporcionado por la clase Appl et e inicializa el upplet
cada vez que se carga (posteriormente se ampliar el concepto de i ni t). El upplet
puede hacer uso de pai nt debido a que la clase Appl et hereda de Panel , que a
su vez lo hace de Cont ai ner y sta de Component .
Tanto la pgina como el upplet se almacenan en C : \ 1 i br o \ Tema 1 1 .
Una vez creados el applet y la pagina, la nica operacin necesaria ser compi-
lar el upplet, para lo que se utiliza la siguiente instruccin:
C: \ l i br o\ Temal l >j avac Ej Appl et . J ava
Al abrir la pgina, usando por ejemplo Microsoft Internet Explorer, el upplet se
Otra forma de ejecutar un upplet es utilizando uppletviewer; ste simula un
carga y ejecuta automticamente. El resultado se muestra en la Figura 11.3.
navegador elemental y necesita que se le pase como parmetro el nombre del archi-
vo HTML donde se incorpora el upplet. Es decir, ejecutar la orden:
C: \ l i br o\ Temal l >appl et vi ewer T. ht ml
294 Java 2. Manual de programacin
. uti0
m Dos \\
Par met r o: Par met r o:
rn el GI
Nombr e y
l ugar
donde se
encuent r a
l a pgi na
Fi gura 11.3. Resultado de la ejecucin del applet E] Appl et . cl ass.
El uso de uppletviewer requiere aadir al archivo HTML la orden:
CODECASE = . . \. . \
11.3. ESTRUCTURA DE UN APPLET
La clase Appl et extiende la clase Panel del AWT y Panel extiende
Cont ai ner que, a su vez, extiende Component , proporcionndose as a las
upplets todas las herramientas necesarias en la programacin IGU (Znterfuz Grfica
de Usuario) y, al igual que todos los programas que trabajan con IGU, las upplets
estn guiadas por eventos.
Las upplets disponen de cinco mtodos que pueden sobreescribir, aunque no es
obligatorio que lo hagan, pues tienen implementaciones por defecto que se invoca-
rn automticamente durante la ejecucin de la misma. Cuatro de estos mtodos son
proporcionados por la clase App 1 et :
public void i ni t ( ) Inicializa el applet y es invocado por el
Appletviexlev o el navegador cuando se carga el
applet.
Appl ets 295
public void s t a r t ( ) Se ejecuta a continuacin de i ni t y tambin cada
vez que el usuario del navegador regresa a la
pgina HTML donde reside el upplet y debe contener
las tareas que deban llevarse a cabo en estas
ocasiones.
public void st op( ) Se ejecuta cuando el usuario abandona la pgina
HTML en la que reside el applet.
public void dest r oy ( ) Libera todos los recursos que el applet est utilizando
y se ejecuta antes de que el applet se descargue
cuando el usuario sale de la sesin de navegacin.
El quinto mtodo es pai nt perteneciente a la clase Cont ai ner , que se invo-
ca para dibujar en el applet al iniciar su ejecucin, as como cada vez que el mismo
necesita redibujarse. Un ejemplo se presenta cuando el applet se oculta por una ven-
tana y luego esta ventana se mueve o se cierra.
ESTRUCTURA BSICA DE UN APPLET
import j ava. awt . *;
import j ava. appl et . *;
public class Nombr eAppl et extends Appl et
/ / mt odos que se pueden sobr eescr i bi r
public void i ni t ( )
{ / I . . . i
public void st ar t O
{/ / . . . I
public void s t op0
{ / I . . . I
public void dest r oy O
{/ / . . . I
public void pai nt ( Gr aphi cs g)
{/ / . . . I
I
Otros mtodos de inters cuando se trabaja con upplets son:
public void recize(int pl, int p2)
Redimensionar el applet.
296 Java 2. Manual de programacin
public void r epai nt ( )
Repintar el upplet a peticin del programa.
public void updat e( j ava. awt . Gr aphi cs pl)
Es llamado por r epai nt y, como pai nt , se utiliza para dibujar en el upplet, ofreciendo la
posibilidad de efectuar repintados incrementales.
public void showst at us ( j ava. l ang. Ct r i ng pi)
Muestra un mensaje en la barra de estado del navegador o visor de applets.
public j ava. awt . I mage get I mage ( j ava. net . URL pl,
j ava. l ang. St r i ng p 2 ) .
Devuelve un objeto i mage que encapsula la imagen encontrada en la direccin especifica-
da mediante el parmetro p l y cuyo nombre es el especificado como segundo parmetro.
public j ava. appl et . Audi oCl i p get Audi oCl i p ( j ava. net . URL p l ,
j ava. l ang. St r i ng p 2 ) .
Devuelve un objeto Audi ocl i p que encapsula el fragmento de audio encontrado en la
direccin especificada mediante el parmetro pl y cuyo nombre es p2.
public j ava. appl et . App1et Cont ext get Appl et Cont ext 0
Obtiene el contexto del upplet.
public j ava. net . URL get CodeBase0
Obtiene el URL del upplet.
public j ava. net . URL get Document Base0
Devuelve el URL del archivo HTML que inici el upplet.
public abstract void showDocument ( j ava. net . URL pi)
Muestra, desde el contexto de un upplet, el documento especificado mediante el parmetro
pl . Es un mtodo definido en la interfaz
j ava. app1et . Appl et Cont ext
public abstract j ava. ut i l . Enumer at i on get Appl et s ( )
Mtodo que permite obtener las applets que se encuentran en el contexto de la actual.
Definido en la interfaz
j ava. appl et . App1et Cont ext
public abstract j ava. appl et . Appl et get Appl et ( j ava. l ang. St r i ng pl)
Devuelve el upplet de nombre pl , si dicha upplet se encuentra en el contexto actual, en otro
caso devuelve nul l Definido en la interfaz
j ava. appl et . App1et Cont ext
Appl ets 297
Adems de Appl et Cont ext que permite acceder al entorno de ejecucin del
applet, la clase Appl et dispone de otras dos interfaces mas: 1) Appl et St ub,
proporciona mecanismos para la comunicacin entre el applet y el navegador; 2)
Audi ocl i p, reproduce archivos de sonido. La incorporacin de imgenes y soni-
do a un applet se ver ms adelante.
Ejemplo
Applet que calcula el volumen de una esfera y lo muestra en la barra de estado.
package l i br o. Ter nal 1;
import j ava. awt . *;
import j ava. awt . event . *;
import j ava. appl et . *;
public class Esf er avol extends Appl et implements Act i onLi st ener
i
Label mensaj e;
Text Fi el d val or ;
public void i ni t ( )
i
mensaj e =new Label ( "I nt r oduzca el r adi o y pul se <RTM>: ") ;
val or = new Text Fi el d( l 0) ;
add ( mensaj e) ;
add ( val or ) ;
val or . addAct i onLi st ener ( t hi s) ;
public void act i onPer f or med( Act i onEvent e)
i
Coubl e val = new Doubl e ( val or . get Text ( 1 ) ;
double r adi o = val . doubl eval ue ( ) ;
showst at us ( " El vol umen es "
+ Doubl e. t oSt r i ng( vol umenEsf er a( r adi o) ) ) ;
public double vol umenEsf er a( doubl e r adi o)
double vol umen;
vol umen = (double) 4/ 3*Mat h. PI *Mat h. pow ( r adi o, 3) ;
return vol umen;
I
298 Java 2. Manual de programacin
Figura 11.4. Resultado de la ejecucin del applet Esf er avol . cl ass.
Archivo HTML ( Pagi na . HTML)
<HTML>
<HEAC>
</ HEAD>
<BODY>
<APPLET
CODE=l i br o. Temal l . Esf er aVol . cl ass
NAME=Esf er aVol
WI DTH=32 O
HE; GHT=l OO >
</APPET>
</ BODY >
</ HTML>
11.4. TRANSFORMACIN DE APLICACIONES EN APPLETS
Las tcnicas generales a seguir para transformar en upplets las aplicaciones con
IGU desarrolladas en J ava son:
Aadir a las importaciones del programa la del paquete j ava . appl et . *.
Hacer que la clase que define el applet extienda Appl et . La sustitucin de
Fr ame por Appl et obliga a eliminar las posibles llamadas a set Ti t l e y a
cambiar di spose por dest oy.
Reemplazar el constructor de la clase por el mtodo i ni t .
Eliminar el mtodo mai n.
Eliminar las llamadas a Syst em. exi t .
Hacer que la entrada y salida de datos se efecte siempre a travs del AWT.
Appleis 299
Tener en cuenta que el administrador de diseo por defecto para las applets es
Crear un archivo HTML que incorpore el applet.
Fl owLayout .
Se requiere, adems, tener presente las siguientes consideraciones:
Los applets, por razones de seguridad, no pueden efectuar todos los trabajos
que realizan las aplicaciones. Por ejemplo, no pueden ejecutar un programa de
la computadora del usuario, ni listar directorios, ni borrar, ni leer, ni escribir, ni
renombrar archivos en el sistema local.
Cuando se efecta programacin multihilo, deben detenerse los hilos de un
applet cuando se sale de la pgina Web en la que el mismo reside. Para ello, se
sobreescribe el mtodo stop del applet. Los hilos se reinician en el mtodo
st ar t del applet que se invoca automticamente cuando el usuario retorna a
la pgina Web.
Los applets slo pueden crear conexiones por red con la computadora de la que
proceden.
Ejemplo
Transformar en applet la aplicacin de la calculadora vista en el captulo anterior.
package l i br o. Temal 1;
i mpor t j ava. awt . *;
i mpor t j ava. awt . event . *;
/ / se aade l a i mpor t aci n del paquet e appl et
i mpor t j ava. appl et . *;
/ / En l a apl i caci n l a cl ase Cal cul ador a ext end a Fr ame
publ i c class Cal cul ador a ext ends Appl et
i
Text Fi el d r esul t ado;
bool ean ot r oNumer o = true, esDeci ma1 = f al se;
doubl e t ot al = 0. 0;
char oper ador = ' x' ;
/ / i ni t r eempl aza al const r uct or de l a cl ase, Cal cul ador a0
publ i c voi d i ni t 0
t hi s. set Layout ( new Bor der Layout ( ) ) ;
Bot ones cer o, uno, dos, t r es, cuat r o, ci nco, sei s,
si et e, ocho, nueve, coma;
Bot ones suma, r est a, mul t i pl i ca, di vi de, obt i ene, bor r a;
300 Java 2. Manual de programacin
set Font (new Font ( " Ar i al " , Font . PLAI N, 14) ) ;
set Backgr ound( Col or . 1i ght Gr ay) ;
Panel panel oper andos = new Panel ( ) ;
panel oper andos. set Layout (new Gr i dLayout ( 3, 4) ) ;
cer o = new Bot ones ( " O" , ' x' , ' O' , thi s) ;
panel Oper andos. add( cer o) ;
cer o. addAct i onLi st ener ( cer o) ;
uno = new Bot ones ( " l " , ' x' , ' 1' , thi s) ;
panel Oper andos. add( uno) ;
uno. addAct i onLi st ener ( uno) ;
dos = new Bot ones( " 2" , ' x' , ' 2' , thi s ) ;
panel oper andos . add ( dos) ;
dos. addAct i onLi st ener ( dos) ;
t r es = new Bot ones ( " 3 " , ' x' , ' 3 ' , thi s) ;
panel Oper andos. add( t r es) ;
t r es. addAct i onLi st ener ( t r es) ;
cuat r o = new Bot ones ( " 4" , 'x' , ' 4' , thi s) ;
panel Oper andos. add( cuat r o) ;
cuat r o. addAct i onLi st ener ( cuat r o) ;
ci nco = new Bot ones ("5", ' x' , ' 5' , thi s) ;
panel Oper andos. add( ci nco ) ;
ci nco. addAct i onLi st ener ( ci nco) ;
sei s = new Bot ones ( " 6" , ' x' , ' 6' , thi s) ;
panel Oper andos. add( sei s) ;
sei s. addAct i onLi st ener ( sei s) ;
si et e = new Bot ones ("7", ' x' , ' I ! , thi s) ;
panel Oper andos. add( si et e) ;
si et e. addAct i onLi st ener ( si et e) ;
ocho = new Bot ones ( " 8" , ' x' , ' 8' , thi s) ;
panel Oper andos. add( ocho 1 ;
ocho. addAct i onLi st ener ( och0) ;
nueve = new Bot ones ( " 9" , ' x' , ' 9' , thi s
panel Oper andos. add( nueve) ;
nueve. addAct i onLi st ener ( nueve) ;
coma = new Bot ones ( ", ' I , ' x' , ' . ' , thi s
panel Oper andos. add( coma) ;
coma. addAct i onLi st ener ( coma) ;
Panel panel oper ador es = new Panel ( ) ;
panel Oper ador es. set Layout ( new Gr i dLayout ( 2, 3) ) ;
bor r a = new Bot ones( " C" , ' ', ' O' , thi s ) ;
panel Oper ador es. add( bor r a) ;
bor r a. addAct i onLi st ener ( bor r a) ;
suma = new Bot ones ("+", 't' , ' O' , thi s) ;
panel Oper ador es. add( suma) ;
suma. addAct i onLi st ener ( suma) ;
r est a = new Bot ones ( ' I - " , '-' , ' O ' , thi s) ;
panel Oper ador es. add( r est a) ;
r est a. addAct i onLi st ener ( r est a) ;
mul t i pl i ca = new Bot ones ( "*", ' *' , ' O ' , thi s) ;
panel Oper ador es. add( mu1t i pl i ca) ;
nul t i pl i ca. addAct i onLi st ener ( mul t i p1i caj ;
di vi de = new Bot ones ( " / ' I , '/', ' O' , this) ;
panel Oper ador es. add( di vi de) ;
ai vi de. addAct i onLi st ener ( di vi dej ;
obt i ene = new Bot ones ( " = ' I , I =' , ' O' , this j ;
panel Oper ador es. add( obt i ene) ;
obt i ene. addAct i onLi st ener ( obt i enej ;
Appl et s
Panel panel cent r al = new Panel ( ) ;
panel Central . setL ayoUt(new Gr i dLayout ( l , 2, : 0, 13) ) ;
panel Centrai .add(panel Cperandos);
panel Cent r al . add( panel 0per adcr e. s) ;
Panel panel Resul t ado = new Panel ( ) ;
panel Resul t ado. set Layout (new Fl owLayout ( j j ;
r esul t ado = new Text Fi el d( " O" , 15) ;
r esul t ado. set Edi t abl e( f al se) ;
panel Resul t ado. add( r esul t adoj ;
add ( " Nor t h" , panel Resui t adoj ;
add( " Cent er " , panel cent r al ) ;
/ / Desapar ece el mt odo mai n( )
void col oca (char val or )
i
St r i ng di gi t o = " ' I ;
if( val or == ' . ) '
I
if ( ! ecDeci mal )
if ( ot r oNumer o )
i
r esul t ado. set Text ( " O" ) ;
ot r oNumer o = false;
I
esDeci mal = true;
di gi t 0 ' f . I ' l .
I
I
else
if ( ot r oNumer o )
i
di gi to = " " +val or ;
r esul t ado. set Text ( di gi t o 1 ;
if ( val or != ' O' )
ot r oNumer o = false;
1
else
r epai nt ( ) ;
r esul t ado. set Text ( r esul t ado. get Text ( ) + di gi t 0 1;
302 Java 2. Manual de programacin
void cal cul a (char ot r ooper ador )
i
double numer o;
numer o = (new Doubl e ( r esul t ado. get Text ( ) ) ) . doubl eval ue ( ) ;
i f ( ( ! ot r oNumer o 1 1 oper ador == '=' ) && ot r ocper ador != ' ' )
switch( oper ador )
i
case I t ' :
t ot al t= numer o;
break;
case I -' :
t ot al -= numer o;
break;
case ' * I :
t ot al *= numer o;
break ;
case ' / I :
t ot al /= numer o;
break;
case ' x' :
case ' ':
t ot al = numer o;
break:
1
r esul t ado. set Text ( ( new Doubl e ( t ot al ) ) . t ost r i ng( ) ) ;
1
oper ador = Gt r oOper adGr ;
ot r oNumer o = true;
esDeci mal = f al se;
i f ( ot r ocper ador == ' ' 1
i
r esul t ado. set Text ( " 0" ) ;
oper ador = ' ';
t ot al = 0. 0;
1
cl ass Bot ones extends But t on implements Act i onLi st ener
i
char unoper ador ;
char unval or ;
Cal cul ador a cal c;
Bot ones( St r 1ng t ext o, char oper , char val or , Cal cul ador a c )
i
super( t ext o ) ;
unoper ador = oper ;
unval or = val or ;
cal c = c;
I
Appl ets 303
publ i c voi d act i onPer f or med ( Act i onEvent e)
if ( . ; noper ador == x )
else
cai c. col oca ( unval or ) ;
cal c. cal cul a( unoper ado=) ;
/ / No es necesar i a l a cl ase Ci er r e
Archivo HTML ( PagCal c. HFML)
<HTML>
<HEAD>
<TI TTE, Cal cui adora</ TI T=E>
</ HEAC>
<BODY>
<APPL E,
C03Y=l i br o. Tei a; l . Ca~cui ~d~~a. cl as s
NAME=Ca 1 cu i ado r a
WI DTH=2 OC
HEI GHT=14@ >
</ APPLET>
</ B03Y>
</ HTML>
Cuando un programa no trabaja con interfaz grfica de usuario, su transforma-
cin en applet conlleva modificaciones ms profundas, ya que se requiere pasar a
una programacin dirigida por eventos.
Ejemplo
Transformar en applet una aplicacin que rellena un vector con 1 O nmeros enteros
aleatorios, muestra los nmeros generados y la media de los mismos.
/ / Apl i caci n
class LLenaAr r
publ i c stati c voi d mai n ( St r i ng [ j ar gs)
f i nal i nt n5i ems=l G;
i nt ar r [ ] = new i nt[nEl erns] ;
i nt j ;
i nt suma = O ;
for(j = 0; j < nEl ems; j ++)
i
ar r [ j ] = 1 + ( i nt) (Math.randorn() * 10) ;
suma += ar r [ j l ;
304 Java 2. Manual de programacin
doubl e medi a = ( doubl e) ( suma) / nEl ems;
f or ( j = O; 1 < nEl ems; j ++)
Syst em. out . pr i nt l n ( " ' I ) ;
Syst em. out . pr i nt l n ( " La medi a es "+ medi a) ;
syst em. out . pr i nt ( ar r [ j ] + " ' I ) ;
i
Compilacin
C: \ l i br o\ Temal : >] avac LLenaAr r . j ava
Ejecucin y resultado de la misma
C: \ l i br o\ Temal l >] ava LLenaAr r
8 9 3 4 9 10 7 7 3 6
La neci a es 6. 6
/ / applet
i mpor t ] ava. awt . *;
i mpor t ] ava. appl et . *;
publ i c cl ass LLenaAr r 2 ext ends Appl et
f i nal i nt nEl ems = 10;
i nt ar r [ ] = new i nt [ nEl emsl ;
doubl e medi a = 0. 0;
publ i c voi d i ni t ( )
i nt suma = O;
t
f or ( i nt j = O; j < nEl ems; 1 ++)
ar r [ j ] = 1 + ( i nt ) ( Mat h. r andom0 * 10) ;
suma += ar r [ j ] ;
medi a = ( doubl e) ( suma) / nE1ern. s;
publ i c voi d pai nt ( Gr aphi cs g )
i nt x = O;
f or ( i nt j = O; j < nEl ems; j ++)
I
x += 35;
g. dr awSt r i ng( St r i ng. val ueOf ( ar r [ j ] ) , x, 35) ;
Applets 305
g. dr awSt r i ng( " La medi a es "+ medi a, 35, 70) ;
1
Compilacin
C: \ l i br o\ t ema l l >j avac LLenaAr r 2. j ava
Archivo HTML ( Numer os. ht ml )
I HTMLZ
<HEAD>
</ HEAD>
<BODY>
<APPLET
CODE= LLenaAr r 2. cl ass
WI DTH= 400
HEI GHT= l oo>
</APPL ET>
</ BODY>
</ HTML>
Ejecucin
C: \ l i br o\ Temal l >appl et vi ewer numer os. ht m1
El resultado se muestra en la Figura 1 1.5.
7 2 9 6 8 6 1 8 1 3
Lamediaes 51
Figura 11.5. Resultado de la ejecucin del applet LLenaAr r . cl ass
306 Java 2. Manual de programacin
11.5. INCORPORACIN DE SONIDO
Para reproducir sonidos desde un applet, se comienza por cargar el archivo de soni-
do mediante
public j ava. appl et . Audi oC1i p get Audi oCl ; p( ; ava. net . URL pi,
l ava. l ang. St r i ng p2)
y posteriormente se controla la reproduccin mediante los mtodos proporcionados
por Audi ocl i p.
Ejemplo
Audi ocl i p audi ocl ;
audi ocl = get Audi oCl i p ( get CodeBase ( ) , " Soni do. au" ) ;
audi ocl . pl ay ( ) ;
. . .
. . .
De esta forma los datos de audio se cargan cuando se construye el audio clip.
La interfaz Audi ocl i p del paquete j ava . appl et define los siguientes
mtodos:
public abstract void l oop( ) Reproduce el archivo de forma continua.
public abstract void pl ay( ) Reproduce el archivo.
public abstract void st op( ) Detiene la reproduccin.
La versin 1.3 de la Plataforma 2 de J ava incluye una nueva y poderosa
API ( j avax . sound) que permite capturar, procesar y reproducir audio y MIDI.
Este A PI permite una flexible configuracin del audio y del sistema M I D I , inclu-
yendo mtodos para que las aplicaciones puedan preguntar al sistema cules son los
recursos que estn instalados y disponibles. Los archivos de audio pueden ser de los
formatos AI F, AU y WAV y los de msica M I D I Ti po O, M I D I Ti po 1 y RMF.
11.6. INCORPORACIN DE IMGENES
El mtodo a seguir para la incorporacin de imgenes a un applet es similar al anterior-
mente descrito para la incorporacin de sonido. La imagen se carga mediante el mtodo
public j ava. awt . I mage get I mage( j ava. net . URL pi,
j ava. l ang. St r i ng p2)
Appl ets 307
en el que pi representa el lugar de ubicacin de la imagen, mientras que p2 es el
nombre del archivo que la contiene, que puede ser de tipo j pg o gi f , y se puede
mostrar utilizando
publ i c abstract bool ean dr awI mage( j ava. awt . 1mage pl , i nt p2,
i nt p3, j ava. awt . i mage. I mageObser ver p4)
El primer parmetro p l es la imagen, el segundo, p2, y tercero, p3, representan
el lugar donde debe situarse la imagen en el applet (en realidad son las coordena-
das para la esquina superior izquierda de la misma) y el cuarto, p4, es una refe-
rencia a un objeto I mageobser ver , que puede ser cualquiera que implemente la
interfaz I mageobser ver y normalmente es el objeto en el que se muestra la ima-
gen. Tambin se puede utilizar para mostrar la imagen
publ i c abstract bool ean dr awI mage( j ava. awt . 1mage pl , i nt p2,
i nt p3, i nt p4, i nt p 5 , j ava. awt . i mage. I r nage0bser ver p6)
Este segundo mtodo permite establecer una anchura y altura determinadas para
I mageobser ver es una interfaz implementada por la clase Component que
la misma mediante los parmetros p 5 y p 6.
define el mtodo
public abstract bool ean i mageupdat e ( j ava. awt . I mage pl, i nt p2,
i nt p3, i nt p4, i nt p5, i nt p6)
el cual puede redefinirse para cambiar su comportamiento por defecto, que es pin-
tar las imgenes mientras se cargan. El mtodo i mageupdat e devolver
f al se cuando se haya completado la carga de una imagen y t r ue en caso con-
trario.
Ejemplo
Modificacin del ejercicio que calcula el volumen de una esfera y lo presenta en la
barra de estado, para que muestre la imagen de un altavoz y haga sonar un pitido
especial tras la introduccin de los datos.
package l i br o. Ter nal 1;
i mport j ava. awt . *;
i mport j ava. awt . event . * ;
i mport j ava. appl et . *;
308 Java 2. Manual de programacin
public class Esf er aVol 2 extends Appl et implements Act i onLi st ener
l abel mensal e;
Text Fi el d val or ;
Audi ocl i p pi t a;
I mage audi o;
public void i ni t ( )
/ * Se supone qae l os ar chi vos, t ant o de i magen como de
soni do, se encuent r an al macenados en el mi smo l ugar
que el appl et , por eso se obt i ene su di r ecci n con
get CodeBase "/
audi o = get I mage ( get CodeBace ( ) , " Audi o. gi f " ) ;
pi =a = get Audi oCl i p ( get CodeBase ( ) , " Soni do. au" ) ;
mensaj e = new Label ( " 1nt r oduzca el r adi o y pul se <RTM>: " ) ;
val or = new TexLFi el d( l 0) ;
add( mensaj e1 ;
ada ( val or ) ;
val or . addAct i onl i st ener ( t hi s) ;
public void act i onPer f or med( Act i 0nEvent e)
t
Coubl e val = new Doubl e ( val or . get Text ( ) ) ;
double r adi o = val . doubl eval ue ( ) ;
showCt at us ( " El vol umen es " +
pi t a. pl ay( ) ;
Doubl e. t oSt r i ng( vol umenEsf er a( r adi o) ) ) ;
1
public double vol umenFsf er a ( double r adi o)
i
double vol umen;
vol umen = (double) 4/ 3* Mat h. PI * Mat h. pow( r adi o, 3) ;
return vol umen;
public void pai nt ( Gr aphi cs g)
i
i
g. dr awI mage ( audi o, O, O, this) ;
Archivo HTML ( Pagi na2. HTML)
<HTML>
<HEAD>
</ HEAD>
<BODY>
<APPLET
CGDE=i i br o. Temal l . Esf er aVol 2. cl ass
NAME=Esf er aVol 2
WI DTH=320
HEI GHT=100 >
</ APPLES>.
</BODY >
</ HTML>
I I
Figura 11.6. Resultado de la ejecucin de Esf er aVol 2. cl ass.
Si se requiere cargar varias imgenes simultneamente en lugar de la interfaz
I mageobser ver y su mtodo i mageupdat e, es mejor utilizar la clase
Medi aTr acker de j ava. awt , con la cual se puede comprobar el estado de
diversas imgenes en paralelo.
Mtodos
publ i c Medi aTr acker ( j ava. awt . . Component p l )
Permite crear la instancia.
publ i c voi d addI mage ( j ava. awt . I mage pl , i nt p 2 )
Aade una nueva imagen sobre la que controlar el estado de carga. El primer parmetro es la
referencia a la imagen que est siendo cargada y el segundo es un nmero identificativo del
misma.
publ i c bool ean I mage checkI D ( i nt pl)
Verifica el estado de la imagen.
publ i c voi d wai t For I D( i nt pi)
Obliga al programa a esperar hasta que la imagen cuyo identificador se especifica como par-
metro se haya cargado por completo.
publ i c voi d wai t For Al l ( )
Obliga al programa a esperar hasta que todas las imgenes registradas se hayan terminado de
cargar.
A 12
rrogramacion
concurrente:
Hilos de ejecucin
CONTENIDO
12.1. La programacin multihilo en J ava.
12.2. Estados de un hilo.
12.3. Creacin de hilos.
12.4. Planificacin y prioridades.
12.5. Hilos de tipo demonio.
12.6. Grupos de hilos.
12.7. Sincronizacin.
12.8. Animaciones.
12.9. Doble buffer.
31 1
31 2 Java 2. Manual de programacin
J ava permite la creacin de programas con mltiples hilos de eje-
cucin (multithreading); es decir, programas con varias partes,
denominadas hilos, que realizan sus actividades en paralelo. Hay
que tener en cuenta que la mayor parte de las computadoras per-
sonales disponibles hoy da cuentan con un nico procesador, lo
que hace imposible la ejecucin simultnea de los diferentes hilos,
dado Io cual se utiliza un sistema de planificacin que permite
compartir el uso del procesador segn unas prioridades previa-
mente establecidas.
La creacin de programas con varios hilos de ejecucin resul-
ta muy til en algunas ocasiones; por ejemplo, para imprimir un
documento largo mientras el usuario contina con el uso de la
IGU, o para conseguir una eficiente implementacin de las anima-
ciones. No obstante, tambin puede dar origen a multitud de pro-
blemas y, en la mayor parte de los casos, los hilos habr que
coordinarlos, por ejemplo, para impedir que uno lea datos de una
estructura antes de que otro los escriba en ella.
12.1. LA PROGRAMACIN MULTlHlLO EN JAVA
Los hilos de ejecucin en J ava estn implementados en la clase Thread, que forma
parte del paquete j ava . l ang . Cada hilo (thread) tiene un principio, unflujo de
ejecucin y un,fin definidos, pero no es una entidad independiente sino que debe
ejecutarse en el contexto de un programa. La clase Thread implementa el con-
cepto de ejecucin multihilo de una forma independiente de la plataforma donde se
va a producir dicha ejecucin. El intrprete de la mquina virtual especfica donde
se rueda (se ejecuta) el programa es el encargado de conseguir que los hilos se eje-
cuten de forma concurrente, esto es, alternada en el tiempo, dando la apariencia de
una ejecucin simultnea. Por esta razn, la alternancia de cdigo se efecta de
forma muy diferente en distintas computadoras.
Imp~rtante: Los sistemas operativos tienen diferentes formas de planificar la
concreta de la concurrencia de ope-
. Cuando varios hilos con la misma
ede predecirse durante cunto tiempo se
ido en un sistema especfico.
Programacin concurrente: Hilos de ejecucin 31 3
12.2. ESTADOS DE UN HILO
Los objetos hilo de J ava tienen cuatro posibles estados: nuevo, ejecutable, bloqueado,
muerto (Tabla 12.1 ).
Tabla 12.1 Estados de objetos hilo
~~~ ~ ~ ~ ~ ~ ~~ ~~ ~
Nuevo A este estado se accede mediante la llamada a un constructor de la clase hilo, y
durante el mismo el hilo an no tiene asignados recursos.
Ejecutable Se accede con una llamada al mtodo st ar t . ste mtodo asigna los recursos
necesarios para ejecutar el hilo, planifica su ejecucin y realiza una llamada a su
mtodo run, que es el que contiene el cdigo con las acciones que debe realizar
el hilo y habitualmente es un bucle.Como los hilos se alternan, un hilo en estado
ejecutable no tiene por qu ser el que, en un determinado momento, se encuentra
ejecutndose.
Bloqueado Un hilo puede estar bloqueado como consecuencia de:
Una llamada al mtodo sl eep, se tendr as un hilo dormido que, al cabo de
un cierto tiempo, despertar y pasar al estado Ejecutable. El mtodo i nterrupt
consigue que un hilo dormido se despierte inmediatamente, producin-
dose una excepcin.
Esperando la terminacin de una operacin de entradaisalida.
Llamadas a otros mtodos como wai t , yi el d o j oi n.
Muerto A este estado se llega tanto tras completar el mtodo run. El mtodo stop de
versiones anteriores ya no se usa en J ava2, debido a que ocasionaba problemas por
ejemplo por no limpiar, antes de finalizar la ejecucin de un hilo, el estado de los
objetos con los que el mismo se encontraba trabajando.
Es preciso tener en cuenta que un hilo puede pasar fcilmente del estado
Bloqueado al estado Ejecutable, y la forma de paso estar estrechamente relaciona-
da con la causa que provoc la detencin del hilo.
Para obtener informacin sobre el estado de un hilo, se puede recurrir al mto-
do i sAl i ve , que devuelve t r ue siempre que el hilo no se encuentre en los esta-
dos Nuevo, ni Muerto. Otro mtodo que indirectamente proporciona tambin
informacin sobre el estado de un hilo es j oi n, que obliga al hilo llamador a espe-
rar hasta que finalice el hilo al que se llama. El mtodo j oi n permite, adems,
especificar el lmite de tiempo que se esperar a que el otro hilo termine su trabajo.
Un hilo Muerto no puede volver al estado Ejecutable.
Importante: Los mtodos st op, suspended y r esume pertenecen a ver-
siones anteriores y ya no se usan en J ava2.
31 4 Java 2. Manual de programacin
12.3. CREACIN DE HILOS
La creacin de hilos en J ava se puede efectuar de dos formas:
1 . Usando una instancia de una clase que implemente la interfaz Runnabl e.
Esta interfaz slo tiene el mtodo r un, que es el mtodo donde habr que
colocar el cdigo que debe ejecutar el hilo y su implementacin constituye la
mejor eleccin desde una perspectiva orientada a objetos.
2. Creando una subclase de la clase Thread para obtener un objeto que here de
de ella. Hay que tener en cuenta que J ava no admite la herencia mltiple, por
lo que cuando se utiliza este mtodo y se hereda de Thread, dicha subcla-
se ya no podr serlo de ninguna otra.
En ambos casos, para que el hilo comience su ejecucin es necesario: I ) crear el
El siguiente es un ejemplo de creacin de un hilo implementando la interfaz
hilo, 2) llamar al mtodo st ar t .
Run na b 1 e:
public class Pr i nci pal
public static void mai n ( St r i ng[ ] ar gs)
I
Encuent r a bcl = new Encuent r a ( " 0012R" ) ;
1
public class Encuent r a implements Runnabl e
I
Thr ead t ;
St r i ng cl aveb;
public Encuent r a ( St r i ng cl ave)
i
cl aveb = cl ave;
t = new Thr ead (this) ;
t . s t ar t 0;
public void r un ( )
i
Cyst em. out . pr i nt l n( " Est a es l a t ar ea a r eal i zar por el hi l o" ) ;
t=Y
Thr ead. cur r ent Thr ead( ) . cl eep( 2000) ;
1
catch ( I nt er r upt edExcept i on e)
Programacin concurrente: Hilos de ejecucin 31 5
t
I
Syst em. out . pr i nt l n ( " Fi n" ) ;
I
Despus de compilar el programa, ejecute C: \ l i br o\ Temal 2>j ava
Pr i nci pal . En este ejemplo, una clase llamada Encuent r a implementa la
interfaz Runnabl e, lo que obliga a Encuent r a a implementar el mtodo r un.
A continuacin se construye un hilo con el constructor
public Thr ead ( l ava. i ang. Runnabi e PI)
cuyo parmetru es una instancia de la clase que implementa la interfaz Runnabl e,
y despus se llama al mtodo s t ar t , cuyo formato es
public synchronized void st ar t ( )
para que comience la ejecucin del hilo.
El cdigo a ejecutar por el hilo ser el definido en el mtodo r un, aunque ste
3uede llamar a otros mtodos. Para que se pueda observar mejor el funcionamiento
i e r un, se han colocado en l las instrucciones Syst em. out . pr i nt l n y el
mtodo sl eep.
El mtodo sl eep se utiliza cuando se pretende retrasar la ejecucin de un hilo;
-ecibe como parmetro un nmero de milisegundos y hace dormir al hilo dicho
imero de milisegundos como mnimo. Debe colocarse en un bloque
: r y/ cat ch, ya que puede lanzar una excepcin si algn otro hilo intenta inte-
rumpirlo mientras est dormido. Cuando el hilo completa el mtodo r un se con-
iierte en muerto y finaliza. El hilo actual puede obtenerse mediante el mtodo
Chr ead. cur r ent Thr ead ( ) .
La creacin de hilos podra efectuarse tambin de la siguiente forma:
public class Pr i nci pal 2
I
public static void mai n ( Str i ng[ ] ar gc)
t
Encuent r a2 bcl = new Encuent r a2 ( " @@12R" ) ;
bcl . st ar t ( ) ;
1
public class Encuent r a2 extends Thr ead
i
St r i ng cl aveb;
31 6 Java 2. Manual de programacin
public Encuentra2 ( St r i ng cl ave)
I
cl aveb = cl ave;
public void r un ( )
i
Cystem.out . p r i n ~l n ("Esta es l a tarea a r eal i z ar por el hi l o" ) ;
t=Y
{
s; eep( 2000) ;
i
catch ( I nter r uptedE xcepti on e)
System. oi i t . pri nt111 ( " F i n" ) ;
En este caso, el mtodo r un se coloca en una subclase de Thread. Esta clase,
en vez de implementar la interfaz Runabl e, extiende Thread y redefine su
mtodo run. El hilo se crea instanciando la clase Encuentra2 y, como en el caso
anterior, para que comience su ejecucin se recurre tambin a st ar t .
12.4. PLANIFICACIN Y PRIORIDADES
Los sistemas operativos difieren en la forma de planificar la ejecucin de los hilos.
Solaris 7 , por ejemplo, usa multitarea por derecho de prioridad (preemptive) esto
quiere decir que ejecuta un hilo de cierta prioridad hasta completarlo o hasta que
est listo otro hilo de ms alta prioridad que lo desaloja. Windows utiliza reparti-
cin de tiempo por turno circular (round-robin), esto implica la concesin a cada
hilo de una cantidad limitada de tiempo, transcurrida la cual el hilo puede ser desa-
lojado por otro que est listo con su misma prioridad; los hilos con mayor prioridad
siguen ejecutndose los primeros y desalojando, como siempre, a los de menor prio-
ridad. Adems, hay que tener en cuenta que Windows NT es capaz de utilizar
mquinas con ms de una unidad central de proceso (UCP). En un sistema con ml-
tiples UCP los hilos del programa podran ser planificados en UCP separadas.
Como J ava puede rodar en diferentes sistemas, cada uno de los cuales tiene su
propia forma de manejar hilos, no se puede predecir durante cunto tiempo se eje-
cutar un hilo antes de que sea interrumpido en un sistema especfico. Si en un
determinado momento existen varios hilos en estado Ejecutable, se ejecutar pri-
mero el que tenga mayor prioridad y, slo cuando finalice o se detenga dicho hilo,
se iniciar la ejecucin de otro con menor prioridad; por otra parte, si un hilo con
Programacin concurrente: Hilos de ejecucin 31 7
mayor prioridad que el que est en ese momento ejecutndose pasa al estado
Ejecutable, <<arrebatarn la UCP al que se encuentra en ejecucin. El problema
exige tener cuidado con los algoritmos para que resulten independientes de la pla-
taforma y slo se presenta ante hilos de idntica prioridad, y mtodos que pueden
ayudar a resolverlo son sl eep y yi el d.
El mtodo sl eep quita el control de la UCP a un hilo con cualquier prioridad,
ofreciendo oportunidad para que otros se ejecuten. Adems, un hilo puede ceder su
derecho de ejecucin efectuando una llamada al mtodo yi el d, pero slo a hilos
adecuados y disponibles; es decir, a hilos ejecutables con igual prioridad que el
mismo, por lo que ste mtodo no asegura que el hilo actual detenga su ejecucin.
Es redundante en los sistemas con reparticin de tiempo por turno circular. Los
mtodos suspend y r esume pertenecen a versiones anteriores y ya no se usan en
En J ava la prioridad de los hilos por omisin es 5 y, cuando se crea uno nuevo,
hereda la prioridad del que lo cre. La prioridad podr ser modificada mediante el
mtodo
' J ava2.
public final void secpr i cr i t y (int pl)
al que se le pasa como parmetro valores numricos enteros comprendidos entre
M I N PRI ORI TY (constante que vale i ) y MAX PRI ORI TY (constante que vale
I O), definidas en la clase Thr ead. Cuanto mayor sea el valor entero, mayor ser
el nivel de prioridad que indica. Para obtener la prioridad de un hilo se utiliza el
mtodo
public final int get Pr i or i t y( )
12.5. HILOS DE TIPO DEMONIO
Un demonio es un hilo cuyo propsito es ofrecer servicios a otros hilos de ejecu-
cin existentes dentro del mismo proceso. El intrprete de J ava permanece en eje-
cucin hasta que todos los hilos de un programa finalizan su ejecucin, pero no
espera a que terminen cuando stos han sido establecidos como demonios. Para
especificar que un hilo de ejecucin es de tipo demonio, se deber realizar una lla-
mada al mtodo
public final void setDaernon (boolean pl)
pasndole como argumento t r ue. Para determinar si un hilo es de este tipo, se
deber llamar al mtodo
public final boolean isDaernon ( )
31 8 Java 2. Manual de programacin
12.6. GRUPOS DE HILOS
Los hilos en J ava siempre pertenecen a un grupo, lo cual va a permitir que se pue-
dan manipular y gestionar de forma colectiva. Cuando se crea un hilo J ava lo colo-
ca por defecto en el grupo del hilo bajo el cual se crea y para colocarlo en otro hay
que especificarlo en el constructor, no siendo posible cambiar a un hilo de grupo
tras su creacin. Los constructores proporcionados por Thr ead que permiten aso-
ciar un nuevo hilo a un grupo especfico son:
public Thr ead( j ava. 1ang. Thr eadGr oup pl , j ava. l ang. Runnabl e p2)
public Thr ead( j ava. l ang. Thr eadGr oup pl, j ava. l ang. Runnabl e
p2, j ava. l ang. St r i ng p 3 )
El grupo de un hilo actual puede obtenerse medi ant e el mtodo
public final j ava. 1ang. Thr eadGr oup get Thr eadGr oup0
y el del hilo actual lo podra proporcionar la siguiente instruccin:
Thr ead. cur r ent Thr ead0 . get Thr eadGr oup( ) ;
Es necesario tener en cuenta que los grupos no slo pueden contener hilos de eje-
cucin, sino tambin otros grupos. La clase Thr eadGr oup implementa las carac-
tersticas y posibilidades de los grupos de hilos y dentro de ella es posible destacar
los siguientes mtodos:
public Thr eadGr oup ( j ava. l ang. St r i ng pi)
Crea un grupo de hilos, el parmetro pl es el nombre para el grupo.
public Thr eadGr oup j ava. 1ang. Thr eadGr oup pl, j ava. l ang. St r i ng p2)
Crea un grupo hijo del grupo pasado como argumento, el parmetro p2 es el nombre para el
grupo hijo.
public int act i vecount ( )
Nmero de hilos Ejecutahles de un grupo de hilos
public final void dest r oy( )
Destruye un grupo de hilos y sus subgrupos.
public int enumer at e ( j ava. i ang. Thr ead p1[ 1 )
Devuelve en el array una referencia a todos los hilos activos del grupo.
public int enumer aze ( j ava. 1ang. Thr eadGr oup pi[ 1 )
Devuelve en el array una referencia a todos los grupos activos del grupo.
Programacin concurrente: Hilos de ejecucin 31 9
public final int ';'.' ','../ I , ' , ' I
Devuelbe la prioridad mxi ma que puedc tcricr tin hi l o dc un grupo
public final - J - . J . ' , f ,
Devuelve el nombre del grupo
public final j avc. l anq. Thr e, ~J r 2r , &L ~ J C t I 0
Devuelve el grupo padre de un grupo de hilos
public final Boolean i saemon ( )
Indica si el grupo es un demonio.
public final void set Maxpr i or i t y (int pl)
Establece la prioridad mxima para un grupo.
public final void set Daemon (boolean pl)
Establece si el grupo actual es o no un demonio.
12.7. SINCRONIZACI~N
Cuando hay muchos hilos rodando en una mquina virtual de J ava, es posible que
varios de ellos deseen modificar la misma fuente al mismo tiempo; en estas cir-
cunstancias, se hace necesario sincronizarlos de alguna forma y que cada uno de
ellos conozca de algn modo el estado y las actividades de los dems. La forma ms
sencilla de explicar la sincronizacin es recurrir al clsico problema de produc-
tor/consumidor, en el que existe un productor que genera datos y los almacena en
una estructura de tamao limitado, por ejemplo un array, desde donde se extraen por
un consumidor. El productor ser un hilo que aade los datos a la estructura tan
rpido como puede, mientras que el consumidor va a ser otro hilo que extrae esos
mismos datos tambin tan rpido como puede. En esta situacin es evidente que
ser necesario un contador para saber el nmero de elementos almacenados en el
array en un instante determinado e impedir que, de momento, siga trabajando el
productor cuando el array est lleno o el consumidor si se queda vaco, como se
muestra en el siguiente programa.
320 Java 2. Manual de programacin
publ i c cl ass Pr i nci pal s
t
publ i c st at i c voi d mai n ( St r i ng [ ] ar gs)
Dat os d = new Dat os ( ) ;
Pr oduct or p = new Pr oduct or ( d) ;
Consumi dor c = new Consumi dor ( d) ;
I
i
publ i c cl ass Dat os
doubl e[ ! ad;
i nt cont ador = - 1;
publ i c Dat os ( )
ad = new doubl e [ 41 ;
1
publ i c voi d poner ( doub1e d)
whi l e ( cont ador < ad. l engt h - 1)
cont ador ++;
ad[ cont ador ] = d * 1000 + cont ador ;
publ i c voi d qui t ar 0
whi l e ( conEador >= O)
doubl e d = ad[ cont ador ] ;
ad[ cont ador ] = O;
cont ador - - ;
Syst em. out . pr i nt l n ( " Consume " +d) ;
publ i c cl ass Pr oduct or i mpl ement s Runnabl e
Thr ead hi l ol ;
Dat os dt os;
i nt num = 0;
Programacin concurrente: Hilos de ejecucin 321
public Pr oduct or ( Dat os d)
t
dt os = d;
hi l ol = new Thr ead( t h1. s) ;
hi l ol . st ar t ( ) ;
public void r un0
i
for (int i = O ; i < 5; i ++)
dt os . poner ( i ) ;
t=Y
Thr ead. cur r ent Thr ead0 . sl eep( 100) ;
1
catch ( I nt er r upt edExcept i on e)
t }
public class Consumi dor implements Runnabl e
i
Thr ead hi l o2 ;
Dat os dt os;
public Consumi dor ( Dat os d)
dt os = d;
hi 102 = new Thr ead( t hi s) ;
hi l o2. st ar t ( 1 ;
\
public void r un( )
t
for (int i = O; 1 < 5; i ++)
dt os. qui t ar ( ) ;
try
i
Thr ead. cur r ent Thr ead ( ) . sl eep ( 100) ;
322 Java 2. Manual de programacin
El problema que surge ahora es debido a que puede ocurrir que, tras un incre-
mento del contador por parte del hi l ol , y antes de que ste coloque un nuevo
dato en la estructura, el planificador decida dejar de ejecutar el productor y comen-
zar a ejecutar consirmidor y pase a ejecutarse el hi 102, que quita un dato de la
posicin indicada por el contador, donde an no hay un dato vlido, y decrementa
el contador; si ahora vuelve a ejecutarse el hi l ol como ya tena efectuado su
incremento de contador no lo realiza de nuevo y coloca el dato actual sobrescri-
biendo uno anterior. J ava soluciona este tipo de problemas mediante la sincroniza-
cin, usando variables de condicin y monitores.
. Los monitores son objetos especiales asociados a datos que controlan el acceso a
los mismos. Por otra parte, se denominan secciones crticas a aquellos bloques de
cdigo de un programa que acceden a datos compartidos por hilos de ejecucin dis-
tintos y concurrentes. Cuando, en J ava, se marcan secciones crticas con la palabra
reservada synchr oni zed se asocia un nico monitor a los datos contenidos en
ellas; de esta forma, durante el tiempo que un hilo permanece dentro de uno de estos
bloques sincronizado, los dems hilos que quieran acceder ai mismo o a cualquier
otro sincronizado sobre la misma instancia tienen que esperar hasta que el monitor
est libre, pues slo un hilo puede obtener el monitor sobre los datos en un instante
dado y los hilos que no poseen el monitor no pueden tener ningn tipo de acceso a
los datos con l asociados. Para aplicar todo esto al ejemplo anterior bastara marcar
con synchr oni zed los mtodos poner y qui t ar , impidiendo su interrupcin:
public synchronized void poner (double d)
i
while ( cont ador < ad. l enqt h- 1)
{
cont ador ++;
ad[ cont ador ] = d * 1030 + cont ador ;
public synchronized void qu;tar )
I
while ( cont ador >= O)
i
double d = ad[ cont ador ] ;
ad[ cont ador ] = 3;
cont ador - - ;
Cyct em. out . pr i nt l n ( " Consume " +d) ;
Para que la sincronizacin sea efectiva, todos los bloques que acceden a los
recursos compartidos deben estar sincronizados. Tambin hay que tener en cuenta
que, aunque los bloques sincronizados pueden no ser mtodos completos, en gene-
Programacin concurrente: Hilos de ejecucin 323
ral, la mejor opcin es que lo sean. No hay problema en que un hilo llame a un
mtodo que accede a datos para los que ya tiene el monitor.
La sincronizacin es necesaria en programas donde hay varios hilos que de-
sean modificar las mismas fuentes al mismo tiempo; no obstante, puede dar ori-
gen a algunos problemas. Imagine que dos hilos de ejecucin necesitan el mo-
nitor sobre dos estructuras y cada uno coge el monitor para una de ellas, pero
como cada hilo necesita los dos monitores y ninguno puede obtener el que tiene
cogido el otro, ambos se paran. La solucin consiste en que alguno de estos hilos
ceda voluntariamente el monitor al otro, estas cesiones voluntarias se efec-
tan a travs de los mtodos wai t , not i f y y not i f yAl l de la clase
Ob] ect .
En el problema productor/consumidoK citado como ejemplo, si uno de los pro-
cedimientos de monitor descubre que no puede continuar, situacin que correspon-
dera a los casos array lleno para productor y vaco para consumidor, mejor que
dormirse por un cierto periodo de tiempo es que dicho procedimiento se bloquee
( wai t ) hasta que el otro le indique que se debe despertar y volver a competir por
el monitor ( not i f y) .
Mtodos
public final void wai t ( ) Cuando un hilo en ejecucin invoca el mtodo
wai t pasa a una cola asociada al objeto y su
ejecucin se detiene hasta que otro hilo active
el mtodo not i f y de ese mismo objeto.
public final void not i f y( ) Es el mtodo por el que un hilo que est ejecu-
tando un mtodo sincronizado puede despertar
al primero de la cola asociada ai objeto.
public final void not i f yAl l ( ) Convierte en Ejecutables todos los hilos que
esperaban en la cola del objeto, aunque slo
uno de ellos podr obtener el monitor.
Resumen: Se denominan secciones crticas a aquellos bloques de cdigo de un
programa que acceden a datos compartidos por hilos de ejecucin distintos y con-
currentes; si las secciones criticas se marcan con la palabra synchroni zed
se asocia un nico monitor a los datos contenidos en ellas.
Los monitores son objetos especiales asociados a datos que controlan el acce-
so a los mismos, ya que slo un hilo puede obtener el monitor sobre los datos en
un instante dado. Un hilo puede ceder voluntariamente el monitor al otro a tra-
vsdelosmtodos wai t , noti f yynoti f yA l 1 del acl aseObj ect.
324 Java 2. Manual de programacin
Ejemplo
public class Pr i nci pal s2
' L
public static void pai n ( St r i ng [ ] args)
Dat os2 d = new Dat os 20;
Pr oauct or 2 p = new Pr oduct or 2( d) ;
Consumi dor 2 c = new Consumi dor 2 ( d) ;
1
public class Dat os2
double[: ad;
int conzador = - 1;
public Dat os2 ( )
t
ad = new doubl e [ 4; ;
public synchronized void poner ( double d)
while ( cor . t ador >= ad. l engt h- 1)
/ * debe est ar en un bucl e w h i l e, no en un i f ,
por si en l a ci gui enze l l amada se r epi t e el pr obl ema,
por ej expl o a causa de un not i f yAl l ( ) */
W a l t ( ) ;
catch ( I nt er r upt edExcept i on e)
t }
while ( cont ador < aa. 1eng: h- 1)
cont ador +*;
ad[ cont ador l = d*1000 + cont ador ;
i
not i f y ( ) ;
public synchronized void qui t ar ( )
!
while ( cont ador < O)
t
t=Y
t
wai t ( ) ;
Programacin concurrente: Hilos de ejecucin 325
i
cat ch ( I nt er r upt edCxcept i on e)
t i
i
whi l e ( cont aacr >= 3)
doubl e d=ad [ cont ador j ;
cont ador - - ;
Cyst em. o, t . pr i ?, t l n ( Cc ~c - me +d) ;
not i f y ( ) ;
I
publ i c cl ass Pr oduct or 2 i mpl ement s Runnabl e
I
Thr ead hi l ol ;
Dat os2 dt os;
i nt Rum = O;
publ i c Pr oduc ~or 2 ( Dat os2 d)
t
dt os = d;
hi l ol = new Thr ead( t hi s) ;
hi l ol . st ar t ( ) ;
publ i c voi d r un0
t
for ( i nt : = O ; i < 3 ; i t + )
dt cc. poner ( i ) ;
publ i c cl ass Consumi dor 2 i mpl ement s Runnabl e
i
Thr ead hi l o2;
Dat os2 dt cs;
publ i c Consumi dor 2 ( Dat os2 d)
dt os = d;
hi l o2 = new Thr ead( t hi s) ;
hi l o2. star: ( 1 ;
publ i c voi d r un( )
for ( i nt i = O; 1 < 3 ; i ++)
I
326 Java 2. Manual de programacin
ci t os. qui t ar ( ) ;
1
12.8. ANI MAClON ES
Un upplet trabaja con animaciones cuando efecta una presentacin sucesiva de
imgenes, cada una con pequeas diferencias con respecto a la anterior, dando as
la apariencia de movimiento. Estas applets, adems de dibujar las imgenes,
deben poder responder a las acciones del usuario, por lo que las animaciones
deben ejecutarse como hilos independientes que no obstaculicen otras tareas y los
hilos deben detenerse cuando se sale de la pgina Web en la que reside el applet.
Para todas estas tareas:
El upplet implementar la interfaz Runnabl e, que se encargara de reali-
zar las tareas de dibujo. Por ejemplo:
public class Rebot a extends Appl et implements Runnabl e,
MouseLi st ener
public void r un ( )
i
. . .
. . .
r epai nt ( ) ;
. . .
Se sobreescribirn los mtodos start y stop del applet con el cdigo ade-
cuado para convertir en Ejecutables y Muertos los hilos que hayan podido
crearse. Por ejemplo:
public void s t ar t 0
{
if ( hi l o == null)
i
hi l o = new Thr ead( this ) ;
hi l o. st ar t 0;
En stop se asigna nul l al/los hilo/s para que se puedan recolectar sus
recursos cuando se abandone la pgina Web en la que el applet reside.
Programacin concurrente: Hilos de ejecucin 327
Por ejemplo:
public void st op( )
hi l oct op ( ) ;
public void hi l oct op ( )
ej ecut abl e = false;
hi l o = null;
Lgicamente, las animaciones pueden ser efectuadas por cualquier programa
J ava con GUI, no es necesario que se trate de un applet.
Nota: No confunda los mtodos st ar t y st op de los hilos y de las upplets.
El mtodo st op para hilos est obsoleto.
Recuerde: Las animaciones deben ejecutarse como hilos independientes para
que no obstaculicen la simultnea realizacin de otras tareas.
12.9. DOBLE BUFFER
Una tcnica muy empleada en las animaciones con la finalidad de reducir el parpa-
deo es el doble buffer. Esta tcnica permite que, mientras se presenta un imagen en
pantalla (primer bqfler), tambin puede tratarse de texto o grficos, se pueda ir ela-
borando en memoria la imagen siguiente (segundo bqffer). El doble buffer requiere:
La creacin de un objeto Image vaco, que acta como buffer. El mtodo a
emplear pertenece a la clase j ava . awt . Component :
public j ava, awt . I mage cr eat eI mage (int pl, int p2)
donde pi y p2 son la anchura y altura de la misma. Por ejemplo
i magen = cr eat ehage ( ANCH0, ALTO ) ;
Obtener un contexto grfico para dibujar la imagen en segundo plano, con el
siguiente mtodo de la clase j ava . awt . I mage:
public abstract j ava. awt . Gr aphi ce get Gr aphi cs0
328 Java 2. Manual de programacin
Por ejemplo,
cont ext oGr af = i magen. get Gr aphi cc0;
Mostrar el contenido del buffer mediante dr awI mage de j ava . awt . Gr aphi cs
publ i c abstract bool ean dr awI mage( ~ava. awt . I mage p l , i nt p2,
i nt p3, j ava. awt . i mage. I mage0bser ver p4)
en donde el primer parmetro es la imagen a dibujar, los dos siguientes son las
coordenadas para la esquina superior izquierda de la misma y el cuarto es el
observador. Por ejemplo,
g . ar awi mage ( i magen, O, O, thi s ) ;
Pero tenga presente que dr aw I mage tiene otros muchos formatos mediante
los cuales puede ser invocado.
Ejercicio
Pelota que rebota en los bordes de un upplet; su movimiento se puede detener y
reactivar efectuando clics con el ratn sobre en cualquier posicin del mismo
(Fig. 12.1).
/ / Ej empl o de ani maci n y dobl e buf f er .
i mport ; ava. awt . *;
i mport j ava. awt . event . *;
i mport j ava. appi et . *;
publ i c class Rebot a extends Appl et implements Runnabl e,
MouceLi st ener
{
publ i c f i nal i nt ANCHO = 200;
publ i c f i nal i nt ALTO = 100;
f i nal i nt TMI N = 25;
i nt act ual = TMI N;
i nt px = O;
i nt py = O ;
i nt dx = 1;
i nt dy = 1;
boolean e2ecut abl e = true;
Tsr ead hi i o = nul l ;
I mage i magen;
Gr aphi cs cont ext oGr af ;
publ i c voi d i ni t ( )
Programacin concurrente: Hilos de ejecucin 329
I
r esi ze ( ANCH0, ALTO ) ;
/ * La pel ot a sal e de una posi ci n al eat or i a e?. ;a parze
superior del applet */
i nt r ango = ANCHO - TMI N;
px = ( i nt ) ( Mat h. r andom0 * r ango) ;
try
i
i magen = cr eat eI mage ( ANCH0, ALTO ) ;
cont ext oGr af = i magen. get Sr aphi cs0;
I
cat ch ( Except i on e)
t
cont ext oGr af = nul l ;
1
addMouseLi st ener ( t hi s) ;
\
publ i c voi d st ar t ( )
i
i f ( hi l o == nul l )
i
hi l o = new Thr ead( t hi s ) ;
hi l o. st ar t ( ) ;
publ i c voi d st op( )
I
hi l ost op ( ) ;
I
publ i c voi d r un( )
i
whi l e ( hi l o ! = nul l )
I
i f ( ej ecut abl e)
t
i f ( px + act ual > ANCHO I I px < 0)
i f ( py + act ual > ALTO 1 1 py < O)
dx *= - 1;
dy *= - 1;
px = px + dx;
PY = PY + dy;
t =Y
hi l o. sl eep( 10 ) ;
1
cat ch( Except i on e )
i}
330 Java 2. Manual de programacin
r egai nt ( 1 ;
ni i c = null;
public void hi l oct . op ( )
ej ecut abl e = false;
hi l c = null;
public void hi l osuspend( )
el ecut abl e = false;
public void hi l or esume ( )
e J ecur abl e = true;
public void updat e( Gr aghi cs g )
pai r t ( g ) ;
public void pai nt ( Gr aphi cs g )
if ( ccpt ext osr af != null )
t
di buj a ( cont ext cGr af ) ;
g. ci rawI rnage ( i magen, O, O, this ) ;
else
di buj a( g ) ;
public void diCu 1 a ( Gr aphi cs g )
y. set Col or ( Col or . gr ay) ;
g. f i l LRect ( O, O, ANCEG, ALTG ) ;
g. set coi or (Col or. red) ;
y. f i l , Oval ( px, py, acz, al , act ua- ) ;
public void mousePr ecced ( YouseEvent e)
if ( ej ecut abl e )
else
e ~e c u~a bl e = ! ej ecut abl e;
hi l or esume ( ) ;
hi l osl spend ( 1 ;
Programacin concurrente: Hilos de ejecucin 331
1
public void rnouceRel eaced(MouceEvent e)
{ I
public void mouseEnt er ed ( MonseEvent e)
1 1
public void r nouseExi t ed ( MouceEvent e)
t i
public void mousecl i cked ( MouseEvent e)
I }
Unas ltimas aclaraciones: en el ejemplo expuesto, el mtodo r un se encarga de
obtener la posicin donde la pelota ha de ser dibujada, de forma que se consiga su
rebote en los bordes del applet, y manda que se redibuje. Cuando se presiona el
ratn, mousepr essed detiene o activa alternativamente la ejecucin del hilo.
El archivo Rebot a. h t m creado es el siguiente:
Archivo HTML (Rebota.htm)
<HTML>
<HEAD>
</ HEAD>
<BODY >
<appl et
code=Rebot a. cl asc
name=Rebot a
wi dt h=200
hei ght =100 >
</ appl et >
</ BODY>
</ HTML>
Applet started 1 Applet started I Applet started I
~~ ____
Figura 12.1. Applet Viewer muestra Rebot a, cl ass.
Compilacin
C: \ l i br o\ Temal 2>j avac Rebot a. 3 ava
332 Java 2. Manual de programacin
Ejecucion con appietviewer
C: \ i i br o\ Te~a12>appl et vi ewer Rebot a. ht m
Ejercicio
El siguiente applet que muestra el funcionamiento del mtodo de ordenacin deno-
minado mtodo de la burbuja. Este applet presenta dos botones; uno permite la
generacin de un nuevo array aleatorio de nmeros enteros y el otro lanza un hilo
que efecta la ordenacin del mismo (Fig. 12.2). Cada nmero entero contenido en
el array se representa en su correspondiente posicin mediante un grfico de barras,
donde la altura de la barra se corresponde con el valor del nmero. El proceso de
ordenacin aparece paso a paso, pudindose apreciar en cada momento los inter-
cambios que se van efectuando (Figs. 12.3 y 12.4).
Fi gura 12.2. Situacin inicial
El applet diseado es:
import j ava. awt . *;
import l ava. awt . event . *;
import j ava. appl et . *;
import j ava. ut i l . *;
/ * Se ut i l i za l a cl ase Random, per t eneci ent e a j ava. ut i 1, par a
l a gener aci n de nmer os al eat or i os */
/ * Cl ase que per mi t e l a or denaci n gr f i ca de un ar r ay de
ent er os por el mt odo de Bur buj a */
public class Or denaci onGr af i ca extends Appl et implements
Act : on L i s t en e r , RLI n n ab 1 e
Programacin concurrente: Hilos de ejecucin 333
/ / Var i abl es gener al es
private s t at i c i nt nur nel ems = 100; / / No de ent er os
private s t at i c i nt r ango = 160; / / Rango
private i nt [ ] ar r 0r d; / / Ar r ay de or denaci n
private Thr ead t = nul l ; / / Hi l o de or denaci n
private f i nal i nt ANCHO = 640;
private f i nal i nt ALTO = 400;
/ / Var i abl es de pr oceso
pri vate boolean ej ecut abl e = true;
/ / Var i abl es de gr f i co
private static Col or col or deBar r a = Col or . bl ue; / / Col or de bar r a
private st at i c i nt Anchur adeBar r a = 3; / / Anchur a
private st at i c i n t yI ni = 100 t r ango; / / Ordenada i ni ci al
private st at i c i n t xI ni = 20; / / Absci sa i ni ci al
private stati c i n t xSep =Anchur adeBar r a*2; / / Ceparaci n x entre barras
private i mage i magen;
private Gr aphi cs cont ext oGr af ;
/ / Panel es
Panel pl ;
/ / Bot ones
But t on nuevoAr r ;
But t on nueva0r d;
// Const r uct or
public Or denaci onGr af i ca ( )
(
set Layout (new Bor der Layout ( ) ) ;
pl = new Panel ( ) ;
/ / Conf i gur aci n de panel
pl . set Layout (new Fl owLayout ( ) ) ;
nuevoAr r = new But t on ( " Nuevo ar r ay" ) ;
nuevaOr d = new But t on ( " Or denar " ) ;
nuevoAr r . addAct i onLi st ener ( t hi s) ;
nuevaOr d. addAct i onLi st ener ( t hi s) ;
pl . add ( nuevoAr r ) ;
pl . add ( nuevaOr d) ;
add ( " Sout h" , pl ) ;
/ / Gener aci n i ni ci al de ar r ay al eat or i o
ar r Or d = r andomEnt Ar r ay( nume1er ns) ;
public void i ni t ( )
I
r esi ze ( ANCH0, ALTO ) ;
334 Java 2. Manual de programacin
i magen = cr eat eI mage( ANCH0, ALTO ) ;
cont ext oGr af = i magen. get Gr aphi cc( ) ;
cat ch( Except i on e)
cont ex2oGr af = null;
public void st op( )
i
1
hi l ost op ( ) ;
public void pai nt ( Gr aphi cs g )
if( cont ext oGr af != null )
t
di buj a ( cont ext oGr af ) ;
g . dr awI mage ( i magen, O O, this ) ;
else
. di buj a( g ) ;
public void updat e( Gr aphi cs g )
pai nt ( g ) ;
1
public void di buj a ( Gr aphi cs g)
g. set col or ( Col or . gr ay) ;
g. f i l l Rect ( O, O, ANCHG, ALTO ) ;
for (int i = O; 1 < ar r Gr d. l engt h; i t +)
di buj aEnt ( g, ar r Gr d[ i ] , i ) ;
/ * Cont r ol de Event os.
Al pul sar el bot n nuevoAr r se gener a un nuevo ar r ay y se
i nt er r umpe cual qui er or denaci n que se est uvi er a l l evando
a cabo.
Al pul sar el bot n nuevaOr d comi enza el pr oceso de or dena-
ci n t r as l a cr eaci n de un nuevo ar r ay y no ocur r e nada
si el ar r ay ya se est aba or denando.
Una vez empezado el pr oceso de or denaci n o se gener a un
nuevo ar r ay o hay que esper ar a que di cho pr oceso t er mi ne */
public void act i onPer f or med( Act i onEvent e)
i
if ( e. get Cour ce0 == nuevoAr r )
Programacin concurrente: Hilos de ejecucin 335
4,
i f ( t ! = nul l )
t i l ost op ( ) ;
ar r Or d = ranaornEntArray(nuwe1ems);
r epai nt ( 1 ;
1
i f ( e. net sour r e ( ) == ni eva0r d)
i f ( t == nul l )
ej ecut abl e = t r ue;
t . s t ar t 0;
t = new Thr ead( t hi s 1 ;
I
publ i c voi d hi l ost op ( )
ej ecut abl e = f al se;
t = nul l ;
/ / Bi r buj a
publ i c voi d r un ( )
i
whi l e ( t != nul l )
i
f or ( i nt i = 1; i < ar r 0r d. l engt h && ej ecut abl e; i t - )
f or ( i nt j = O; j < ar r 0r d. l engt h- i && ej ecut abl e; J ++)
i f ( ar r Or d[ : +l ] < ar r Or d[ j j & & e<ecut abl e)
i nt tr?p = ar r Or d[ j j ;
ar r 0r d [ j ] = ar r Or d: j +1] ;
ar r 3r d[ J +l ] = =nip;
r epai nt ( ) ;
t*Y
t
t . sl eep ( 100) ;
i
cat ch( Except i on e )
t }
}
t = nul l ;
/ / Mt odo par a :a const r ucci n de un ar r ay al eat or i o de entezcs
publ i c i nt [ ] r andomEnt Ar r ay ( i nt N)
Random gen = new Random() ;
i nt [ ] a = new i nt : N] ;
f or ( i nt 1 = C; i < a. l enqt h; i ++)
a[ i ] =Mat h. abs ( gen. next I nz( ) : r ango) ;
336 Java 2. Manual de programacin
return ( a) ;
I
// Mt odo par a l a r epr esent aci n de un ent er o en su posi ci n i
publ i c voi d di buj aEnt ( Gr aphi cs g, i nt h, i nt i )
i nt x = xI ni + i * xSep;
i nt y = yI ni - h;
i nt w = Anchur adeBar r a;
g. set Col or ( co1or deBar r a) ;
g. f i l l Rect ( x, y, w, h) ;
AOOl et st arf eu I
Figura 12.3. Fase intermedia del proceso de ordenacin, se observa cada intercambio.
Figura 12.4. Array ordenado.
Programacin concurrente: Hilos de ejecucin 337
El archivo Ord . htm tiene el siguiente contenido:
Archivo HTML ( Or d. ht m)
<HTML>
<HEAD>
<TI TLE>Pr oceso de or denaci n en el mt odo de l a Bur buj a</ TI TLE>
</ HEAD>
<BODY>
<appl et
code=Or denaci onGr af i ca. cl ass
name=Or denaci onGr af i ca
wi dt h=640
hei ght =400 >
</ appl e t >
</ BODY>
</ HTML>
I
I
Maneio
de excepciones
CONTENIDO
13.1. Conceptos generales.
13.2. Manejo de excepciones.
13.3. Captura y tratamiento de excepciones.
13.4. Lanzar la excepcin.
13.5. Declarar la excepcin.
13.6. El bloque f i nal l y.
13.7. Creacin de excepciones.
13.8. Mtodos de la clase Thr owabl e.
L 339
340 Java 2. Manual de programacin
Las excepciones son objetos que describen y permiten controlar
errores y problemas inesperados en el funcionamiento de un pro-
grama sin oscurecer el diseo del mismo, y se manejan por un
cdigo especial que no sigue el flujo normal de ejecucin de dicho
programa. El compilador obliga al manejo de algunas excepciones,
mientras que para otras esto ser potestativo del programa. J ava,
adems de proporcionar mltiples clases de excepciones, permite
crear nuevos tipos para que respondan a una anomala en el fun-
cionamiento de un programa sobre la que los usuarios deban ser
informados. En este captulo se explica la captura, tratamiento,
declaracin, creacin y lanzamiento de excepciones y se comen-
tar su importancia e inexcusable uso en algunas ocasiones, por
ejemplo en operaciones con archivos.
13.1. CONCEPTOS GENERALES
Todos los tipos de excepcin son subclases de Thr owabl e y, como se puede
observar en el esquema de la jerarqua de clases (Fig. 13.1), por debajo de
Thr owabl e hay dos clases, Er r or y Except i on, que dividen las excepcio-
nes en dos ramas distintas.
Las excepciones de la clase Er r or abarcan fallos graves de los que los pro-
gramas no pueden recuperarse y, por tanto, no suelen ser capturadas por los
mismos.
La clase Except i on abarca las excepciones que los programas suelen captu-
rar; tiene varias subclases, entre las que destacan Runt i meExcept i on,
I OExcept i on e I nt er r upt edExcept i on.
- Runt i meExcept i on comprende errores en tiempo de ejecucin que se
producen al efectuar operaciones sobre datos que se encuentran en la memo-
ria de la computadora, se subdivide en diversas subclases entre las que
destacan Ar i t hmet i cExcept i on y Nul l Poi nt er Except i on,
ambas pertenecientes al paquete j ava . l ang, como casi todas las
Runt i meExcept i on, y disponibles en todos los programas ya que este
paquete se importa automticamente.
- I OExcept i on comprende los errores de entrada/salida y pertenece al
paquete j ava . i o.
- I nt er r upt edExcept i on, de cuyo tipo son los errores debidos a la
interrupcin de un hilo de ejecucin por otro, pertenece tambin a j ava . l ang.
Manejo de excepci ones 341
Adems de disponer de todas estas clases, es posible extender la clase
Except i on o sus subclases y crear nuevos tipos de excepciones que respondan a
una anomala en el funcionamiento de un programa sobre la cual deben ser infor-
mados los usuarios, aunque hay que tener en cuenta que no es conveniente utilizar
las excepciones como un mtodo alternativo para especificar flujo de control.
Importante: Todos los errores que se pueden originar en un mtodo, excepto los
de tipo Er r or y Runt i meExcept i on, hay que declararlos en una clusula
t hr ows o bien capturarlos y tratarlos dentro de ese mismo mtodo. Los proga-
mas no estn obligados a capturar ni declarar las excepciones del tipo
Runt i meExcept i on.
Throwable
Error
Exception
Interrupted Exception
RuntimeException
ArithmeticException
IlLegalArgumentException
r-- NumberFormatException
1 - ~~ IndexOutOfBoundsException
I
StringlndexOutOfBoundsException ArraylndexOutOfBoundsException
...
NullPointerException
ILegalMonitorStateException
...
-
- IOException
FileNotFoundException
, ...
EOFException
- AWTException
Fi gura 13. I . Excepciones,
342 Java 2. Manual de programacin
Dada la obligatoriedad impuesta por el compilador con respecto a la captura
de algunas excepciones, hace ya tiempo que se viene utilizando cdigo para la gestin
de las mismas y se ha visto ya que para capturar excepciones basta con escribir el cdi-
- go que se quiere controlar en un bloque t r y y especificar la excepcin que se desea
capturar en una clusula cat ch. As, si escribe el siguiente programa, el compilador
le obligar a modificarlo y capturar, de la forma especificada, la excepcin
I OExcept i on que por la operacin de lectura pudiera haber sido generada.
Ejemplo
El programa siguiente pide la introduccin por teclado de un nmero entero, n,
comprendido entre 1 y 2 O; a continuacin, muestra las sucesivas potencias de 2
desde 2 elevado a 1 hasta 2 elevado a n .
import j ava. i o. *;
publ i c cl ass E: empl o
/ / E: enpl o 1.
publ i c stati c void mai n ( St r i ng ar gs [ ] )
I nput St r eamReader i cr = new I nput St r eamReader ( Syst em. i n) ;
Buf f er edReader br = new Buf f er edReader ( 1sr ) ;
St r i ng cadena;
i nt n = O;
Syct em. out . pr i nt ( " Deme un numer o ent er o ent r e 1 y 20 ' I ) ;
cadena = br . r eadLi ne( ) ;
n = I nt eger . par seI nt ( cadena) ;
i nt 1 = 1;
while ( 1 <= n)
Syst em. out . pr i nt l n ( " 2" " +i +" = " +Mat h. pow( 2, i ) ) ;
it+;
Si lo modifica de la siguiente forma, el compilador lo aceptar y funcionar
correctamente cuando introduzca nmeros enteros en el rango indicado, pero dar
una excepcin si teclea una letra en lugar de un nmero o pulsa RETURN (INTRO) sin
introducir nada.
Ejemplo
import 3 ava . I C. * ;
publ i c cl ass Ej empl o2
Manejo de excepciones 343
public static void r ai n ( Cr r Lr g ar gs [ ] )
!
I nput St r eamReader i sr = new I nputStreamReaser(Cys=em.;n);
Buf f er edReader br = new Buf f er edReader ( i cr ) ;
/ * se hace necesar i a l a i ni ci al i zaci n de l a cadena,
debi do a que l as i nst r ucci ones en el CLoque t r y pasr i a?.
no ser ej ecut adas, per o ser i a i gual i n2ci al i zar l a a " I '
*/
St r i ng cadena = " C" ;
int n;
Syst em. out . pr i nt ( " Deme un nmer o ent er o ent r e 1 y 2C " ) ;
t=Y
I
cadena = br . r eadLi ne ( ) ;
1
catch ( I OExcept i on e)
t }
n = 1nt eger . par seI nt ( cadena) ;
int i = 1;
while ( i <= n)
Syst em. out . pr i nt l n ( " 2^" +i +" = " +Mat h. pow ( 2, i ) ) ;
Iff;
I
I
I
importante: No se puede garantizar que las sentencias siguientes a un deter-
minado catch vayan a ser ejecutadas.
13.2. MANEJO DE EXCEPCIONES
Las operaciones que se pueden realizar con excepciones son: captura y tratamiento
(manejo), lanzamiento y declaracin.
13.3. CAPTURA Y TRATAMIENTO DE EXCEPCIONES
Para capturar una excepcin, se escribe el cdigo que se quiere controlar en un blo-
que tr y; se especifica la excepcin que se desea capturar en una clusula catch y
se coloca el tratamiento para la misma en el bloque catch. La clusula catch con-
siste en la palabra reservada catch, seguida por el tipo de excepcin que se desea
capturar y un nombre de parmetro encerrados entre parntesis. El conjunto
t r y/ cat ch no se puede separar con sentencias intermedias.
344 Java 2. Manual de programacin
No se debe colocar una estructura t r y/ cat ch para cada una de las instruccio-
nes de un programa que pueda lanzar una excepcin, sino agrupar las que estn rela-
cionadas en un nico bloque t r y. En estos casos, es decir, cuando las sentencias
encerradas en un bloque t r y pueden producir ms de una excepcin, es posible
poner varias clusulas cat ch consecutivas; permite efectuar un tratamiento distin-
to para cada una de las excepciones. La bsqueda de la excepcin originada se efec-
tuar secuencialmente en cada una de las clasulas cat ch, por tanto no se debe
colocar una clasula cat ch que capture excepciones de una superclase antes de
otra que capture las de una de sus subclases.
Ejemplo
Modificar el ejercicio de las potencias de modo que no se produzca una interrupcin
si se teclea una letra en lugar de un nmero o se pulsa RETURN (I NTRO) sin introdu-
cir nada.
import j ava. i o. *;
public cl ass E j empl o3
public stati c void mai n ( St r i ng ar gs[ ] )
I nput Ct r eamReader i cr = new I nput St r eamReader ( Syst em. i n) ;
Bcf f er edReader br = new Buf f er edReader ( i sr ) ;
i nt n = O ;
Syst em. out . pr i nt ( " Deme un nmer o ent er o ent r e 1 y 20 " ) ;
try
i
St r i ng cadena = br . r eadLi ne ( ) ;
n = I nt eger . par seI nt ( cadena) ;
catch ( I OExcept i on e)
{/ / t r at ami ent o 1
1
catch ( Nur nber For mat Except i on e)
{/ / t r at ami ent o 2
i nt i = 1;
while ( i <= n)
Syst em. out . pr i nt l n ( " 2^" +1+" = " t Mat h. pow ( 2, i ) ) ;
i t +;
Otra posibilidad para resolver este problema de las mltiples excepciones gene-
radas en un bloque t r y, es utilizar una clasula cat ch que capture excepciones de
Manejo de excepciones 345
una superclase que englobe todos los tipos de excepciones que, por las instruccio-
nes incluidas en t r y, pueden ser generadas y utilizar i nst anceof para determi-
nar el tipo de excepcin.
Ejemplo
Dado que la clase Except i on engloba las excepciones a considerar en los ejem-
plos I a 3 ya explicados, para capturar las citadas excepciones I OExcept i on y
Number For mat Except i on podra escribirse el cdigo de la siguiente manera:
import j ava. i o. *;
public cl as s Ej empl o4
t
public s t a t i c void mai n ( St r i ng ar gs [ I )
I nput St r eamReader i sr = new I nput St r eamReader ( Syst em. i n) ;
Buf f er edReader br = new Buf f er edReader ( i sr ) ;
St r i ng cadena;
i nt n = O;
Syst em. out . pr i nt ( " Deme un nmer o ent er o ent r e 1 y 20 " ) ;
t=Y
t
cadena = br . r eadLi ne ( ) ;
n = I nt eger . par seI nt ( cadena) ;
1
catch ( Except i on e)
i
if ( e instanceof I OExcept i on)
else if ( e instanceof Number For mat Except i on)
Syst em. out . pr i nt i n ( " Er r or de ent r ada/ cal i da" ) ;
Syst em. out . pr i nt l n ( " No t ecl e un nmer o ent er o" ) ;
1
i nt i = 1;
while ( i <= n)
i
Syst em. out . pr i nt i n ( " 2^" +i +" = " +Mat h. pow ( 2, i ) ) ;
i ++;
1
13.4. LANZAR LA EXCEPCIN
Una clasula cat ch puede recibir una excepcin y, en lugar de tratarla o despus
de hacerlo, volver a lanzarla mediante una instruccin t hr ow.
346 Java 2. Manual de programacin
Ejemplo
Modificando levemente el ejemplo anterior, puede utilizarse tambin en el presen-
te caso. La modificacin consiste en la creacin de un mtodo de lectura que, des-
pues de su tratamiento, lanza la excepcin Number For mat Except i on.
import j ava. i o. *;
public class Ej empl o5
t
public static int l eer ( )
i
I nput St r eamReader i sr = new I nput St r eamReader ( Syst em. i n) ;
Buf f er edReader br = new Buf f er edReader ( 1sr ) ;
St r i ng cadena = I "';
int n = O;
try
i
cadena = br . r eadLi ne ( ) ;
n = 1nt eger . par seI nt ( cadena) ;
1
catch ( I OExcept i on e)
{ )
cat ch( Number For mat Except i on e)
i
Syst em. out . pr i nt l n ( " 1) Tecl e sol o r et ur n?" ) ;
throw ( e) ;
1
return n;
1
public static void mai n ( St r i ng ar gs [ ] )
i
int n = O;
Syst em. out . pr i nt ( " Deme un nmer o ent er o ent r e 1 y 20 ' I ) ;
try
{
n = l eer ( ) ;
cat ch( Number For mat Except i on e)
Syst em. out . pr i nt l n ( " 2) Tecl e una l et r a o un r eal ?" ) ;
1
int i = 1;
while ( i <= n)
i
Syst em. out . pr i nt l n ( " 2A" +i t " = " +Mat h. pow ( 2, i ) ) ;
i ++;
1
1
1
Manej o de excepciones 347
13.5. DECLARAR LA EXCEPCIN
Las excepciones pueden no ser tratadas (manejadas), posponiendo su tratamiento
para que sea efectuado por el mtodo llamador, pero cuando no pertenecen a la clase
Runt i meExcept i on, es necesario listar los tipos de excepciones que se pasan en
la cabecera del mtodo. En general las excepciones Runt i meExcept i on deben
capturarse en el mtodo donde se han producido; en caso contrario sern tratadas
por el bloque t r y del mtodo invocador ms prximo que capture dicha excepcin
y sin necesidad de ser listadas en la cabecera del mtodo.
Ejemplo
En este caso l eer no efecta ningn tratamiento y, como se puede observar, se
hace necesario listar la I OExcept i on en la cabecera del mtodo.
import j ava. i o. *;
public class Ej empl o6
public static int l eer ( ) throws I OExcept i on
I
I nput St r eamReader i sr = new I nput St r eamReader ( Syst em. i n) ;
Buf f er edReader br = new Buf f er edReader ( i sr ) ;
St r i ng cadena = "";
try
t
cadena = br . r eadLi ne ( ) ;
return I nt eger . par seI nt ( cadena) ;
1
finally
t i
1
public static void mai n ( St r i ng ar gst l )
i
int n = O;
Syst em. out . pr i nt ( " Deme un nmer o ent er o ent r e 1 y 20 ' I ) ;
I
try
n = l eer ( ) ;
1
catch ( I OExcept i on e)
i }
catch ( Number Fo r ma t Excep t i on e)
i
1
int i =l ;
while ( i <= n)
Syst em. out . pr i nt l n ( " Tecl e sol o r et ur n?" ) ;
348 Java 2. Manual de programacin
SySt em. out . pr i nt l n ( " 2" " +i +" = " +Mat h. pow( 2, i ) ) ;
i ++;
Hay que tener en cuenta que el bloque t r y no puede aparecer slo, por lo que,
al no ser necesario ninguna clasula cat ch, se ha de colocar una clusula y bloque
f i nal l y.
f i na l l y
I }
13.6. EL BLOQUE finally
Cuando no se produce ninguna excepcin en un mtodo y tambin cuando se pro-
duce pero es capturada, la ejecucin contina en la sentencia siguiente a cat ch,
excepto si se fuerza a otro tipo de abandono mediante instrucciones como r et ur n,
br eak o cont i nue. Cuando la excepcin no se captura, la bsqueda de la clasu-
la cat ch adecuada para la captura de la excepcin lanzada contina por los restan-
tes mtodos en orden inverso a como fueron efectuadas las llamadas. Por tanto, no
se puede garantizar que las sentencias siguientes a un determinado cat ch vayan a
ser ejecutadas.
Ejemplo
Compare los siguientes cdigos. En el primer caso, las instrucciones Siguientes a los
cat ch se ejecutan nicamente si ocurre una excepcin. En el segundo caso, por las
instrucciones siguientes a los cat ch en el mtodo leer no pasa ni cuando todo es
correcto ni cuando se produce una Number For mat Except i on.
import j ava. i o. *;
publ i c c l as s Ej empl o7
t
publ i c s t a t i c i n t l eer ( )
i
I nput St r eamReader i sr = new I nput Ct r eamReader ( Syst em. i n) ;
Buf f er edReader br = new Buf f er edReader ( 1sr ) ;
St r i ng cadena = " ' I ;
try
cadena = br . r eadLi ne ( ) ;
return I nt eger . par seI nt ( cadena) ;
Manejo de excepciones 349
/ / cuando t odo es cor r ect o sal e
1
catch ( I OExcept i on e)
o
catch ( Number For mat Excep t i on e )
i i
// I nst r ucci n si gui ent e a cat ch
Syst em. out . pr i nt l n ( " Pasa sol o cuando ocur r e excepci n" ) ;
return O;
publ i c s t a t i c voi d mai n ( St r i ng ar gs [ I )
i
i n t n = 0;
Syst em. out . pr i nt ( " Deme un nmer o ent er o ent r e 1 y 20 ' I ) ;
n = l eer ( ) ;
i n t i =l ;
whi l e ( i <= n)
f
Syst em. out . pr i nt l n ( " 2" " +i +" = " +Mat h. pow( 2, i ) ) ;
it+;
1
import j ava. i o. *;
publ i c c l a s s Ej empl o8
t
publ i c s t a t i c i n t l eer ( )
i
I nput St r eamReader i sr = new I nput St r eamReader ( Syst em. i n) ;
Buf f er edReader br = new Buf f er edReader ( i sr ) ;
St r i ng cadena = "";
try
I
cadena = br . r eadLi ne ( ) ;
return I nt eger . par seI nt ( cadena) ;
1
catch ( I OExcept i on e)
I 1
/ / I nst r ucci n si gui ent e a cat ch
Syst em. out . pr i nt l n ( "No pasa cuando no hay er r or ni " +
return O;
"cuando sepr oduceunNumber For mat Except i on" ) ;
publ i c s t a t i c voi d mai n ( St r i ng ar gs[ ] )
I
350 Java 2. Manual de programacin
i nt n = O;
Syst em. out . pr i nt ( " Deme un nmer o ent er o ent r e 1 y 20 " ) ;
t =Y
i
1
cat ch( Number For mat Except i on e)
I }
i nt i = 1;
whi l e ( i <= n)
i
n = l eer ( ) ;
System.out.pri ntl n("2^"+i +" = " +Mat h. pow( 2, i ) ) ;
i ++;
1
1
I
Nota: El bloque finally sirve para colocar en l instrucciones que se desea
se realicen siempre que se sale de un bloque t r y y es opcional, pero pasa a
ser obligatorio cuando un bloque t r y no va seguido por ninguna clasula
catch ya que, como se dijo, el bloque t r y no puede aparecer solo.
El formato general es:
t ry
1
}
cat ch( Ti po- de- excepci on i dent i f i cador )
i
1
/ / ot r os cat ch si l os hubi er a
f i nal l y
{
1
...
. . .
...
Las instrucciones colocadas en el bloque f i nal l y se realizan siempre que se
sale del bloque t r y: tanto si se ha producido una excepcin y se ha capturado,
como si no se ha capturado, como si no se ha producido la excepcin, como si se
ha salido del bloque t r y con r et ur n, br eak o conti nue. No resulta, pues,
adecuado poner en un bloque f i nal l y sentencias que a su vez puedan produ-
cir nuevas excepciones.
Manejo de excepciones 351
Ejemplo
Aunque el tratamiento de archivos se ver en el captulo siguiente, dado que el
tnanejo de excepciones es muy importante en el trabajo con archivos, se muestra a
continuacin el control de excepciones en un programa diseado para comparar dos
archivos especificados mediante la lnea de rdenes. Para comprender la imple-
mentacin efectuada se necesita conocer que los argumentos pasados en la lnea de
rdenes a un programa se reciben por el mtodo main y se almacenan en el array
unidimensional de tipo st r i ng que dicho mtodo especifica siempre como par-
metro.
public static void mai n ( St r i ng ar gs [ I )
Los argumentos escritos a continuacin del nombre del programa se separan
unos de otros por un espacio en blanco y J ava almacenar el primero de ellos en
a r g s [ O ] , el segundo en a r g s [ 1 ] , y as sucesivamente. El programa compara los
archivos, efectuando una lectura secuencia1 de ambos y comprobando la igualdad
entre lo que va leyendo de cada uno de ellos. Se detiene cuando encuentra alguna
diferencia o uno de los archivos termina.
La clasula t r y inicial prueba de forma agrupada diversas excepciones que se
pueden producir en el programa. No obstante, en el caso de que la excepcin sea
generada por no encontrarse el archivo, conviene identificar cul de los dos archi-
vos pasados como parmetros es el que no ha sido encontrado, por tanto se colo-
can dentro del t r y anterior otros dos bloques t r y que permitan identificar cul
de ellos ha sido la causa. La instruccin de cierre de archivo debe aparecer en el
boque f i nal l y para que siempre sea ejecutada y como lanza una I OExcept i on
sta vuelve a ser capturada. La llamada al programa debe efectuarse de la siguien-
te forma:
C: \ l i br o\ Temal 3>j ava CompAr ch a. t xt b. t xt
Una llamada sin parmetros produce la salida siguiente:
C: \ l i br o\ Temal 3>j ava CompAr ch
La l l amada debe ser : j ava CompAr ch ar chi vo1 ar chi vo2
Otros casos considerados son aquellos en los que alguno o ambos archivos no
existen.
import j ava. i o. *;
class CompAr ch
I
352 Java 2. Manual de programacin
public static void mai n ( St r i ng ar gs [ ] )
l
int i = O, j = O;
Fi l eI nput St r eam f l = nuii;
Fi l eI nput Ct r eam f 2 = null;
try
t
/ / Abr e el pr i mer ar chi vo
try
i
/ / Excepci n por aper t ur a del ar chi vo
f l = new Fi l eI nput Ct r eam( ar gs [ O] ) ;
1
catch(Fi 1eNotFoundExcepti on e)
t
1
Cyst em. out . pr i nt l n ( ar gs [ O] + 'I Ar chi vo no encont r ado" ) ;
/ / Abr e el segundo ar chi vo
try
I
f 2 = new Fi l eI nput Ct r eam( ar gc[ 11) ;
cat ch( Fi 1eNot FoundExcept i on e)
I
Syst em. out . pr i nt l n ( ar gs [ l ] + " Ar chi vo no encont r ado" ) ;
i
/ / Compar a l os ar chi vos
do
t
/ *Las excepci ones gener adas en l a l ect ur a se capt ur an
i = f l . r ead0;
j = f 2. r eadO;
if ( i != j ) break;
por el t r y ext er no */
I
while(i != - 1 & & j != - 1) ; / / f i n de ar chi vo
if(i != j )
else
Syst em. out . pr i nt 1n ( " Los ar chi vos son di f er ent es. " ) ;
Syst em. out . pr i nt l n ( " Los ar chi vos son i gual es. ' I ) ;
i
catch ( I OExcept i on e)
t
Syst em. out . pr i nt l n ( " Er r or " ) ;
Manej o de excepciones 353
I
catch(A rrayI ndexOut0f BoundsExcepti on e)
i
Cyst em. out . pr i nt l n ( " La l l amada debe ser : "+
" j ava CompAr ch ar chi vo1 ar chi vo2" ) ;
1
cat ch( Except i on e)
I
}
f i nal l y
i
/ / ] ava. l ang. Nul l Poi nt er Except i on
t ry
i
/ * el ci er r e de archi vo no debe col ocar se en el
ant er i or bl oque t r y pues pudi er a no ej ecut ar se.
La oper aci n de ci er r e l anza una excepci n que hay
que t r at ar */
i f ( f l != nul l )
f l . cl ose 0 ;
cat ch ( I OExcept i on e)
i
1
try
t
i f ( f 2 != nul l )
f 2. cl os eO;
1
cat ch ( I OExcept i on e)
t }
I
Nota: Los argumentos pasados en lnea de comandos a un programa se reci-
ben por el mtodo main y se almacenan en el array unidimensional de tipo
String que dicho mtodo especifica siempre como parmetro. Cuando se
llama al programa sin parmetros, la posterior referencia a los mismos origina
una excepcin del tipo Array I nde xOu t O f Bounds Ex cep t i on.
13.7. CREACIN DE EXCEPCIONES
En J ava es posible definir nuevas excepciones especficas para una determinada situa-
cin, que se usarn para detectar anomalas en el funcionamiento de una aplicacin.
354 Java 2. Manual de programacin
Para crear una excepcin se define una subclase de Except i on que implemente
un constructor con un parmetro de tipo St r i ng y sobreescriba el mtodo
get Mecsage ( ) de la clase Thr owabl e. Hay que tener en cuenta que la clase
Except i on no define ningn mtodo, slo hereda los definidos por Thr owabl e.
Ejemplo
Creacin de una nueva excepcin.
cl as s NuevaExcp extends Except i on
!
St r i ng mensaj e;
public NuevaExcp ( St r i ng causa)
i
I
mensaj e = causa;
public St r i ng get Message ( )
return mensaj e;
Para usar la nueva excepcin la aplicacin crear y lanzar un objeto de ese tipo
cuando se cumpla una determinada condicin. Como en cualquier otro caso, la
excepcin deber ser capturada o declarada escribiendo su tipo en la cabecera del
mtodo que la lanza precedido por la palabra reservada t hr ows. Si se lanza desde
mai n el tratamiento no se podr posponer y habr que capturarla.
Ejemplo
Esta aplicacin que usa la nueva excepcin ( NuevaExcp) . La excepcin se lanza
y captura en mai n. El ejemplo lanza la excepcin siempre, aunque lo normal sera
que sta slo se lanzara cuando ocurriera algn motivo.
public cl as s Ej empl o9
i
public s t at i c void mai n ( St r i ng [ I ar gc)
i
try
i
/ / se l anza si empr e
throw new NuevaExcp( " C1n motivo") ;
I
catch ( NuevaExcp e)
Manej o de excepciones 355
Syst em. out . pr i nt l n( e. get Message0) ;
El programa siguiente solicita la edad y, si no est en el rango adecuado, lanza
una excepcin.
import j ava. i o. *;
publ i c c l a s s Ej empl o10
publ i c s t a t i c voi d mai n ( St r i ng ar gs[ ] )
i
I nput St r eamReader i sr = new I nput St r eamReader ( Syst em. i n) ;
Buf f er edReader br = new Buf f er edReader ( i sr ) ;
St r i ng cadena;
i n t edad = O;
Syst em. out . pr i nt ( " I nt r oduzca l a edad " ) ;
t ry
I
cadena = br . r eadLi ne ( ) ;
edad = I nt eger . par seI nt ( cadena) ;
i f ( edad < 18 1 1 edad > 65)
throw new Fuer aDeRango( " Excepci n: val or f uer a de r ango" ) ;
Syst em. out . pr i nt l n ( " Edad: " + edad) ;
catch ( Except i on e)
i f ( e i nstanceof I OExcept i on)
else i f ( e i nstanceof Number For mat Except i on)
else
Syst em. out . pr i nt l n ( " Er r or de ent r ada/ sal i da" ) ;
Syst em. out . pr i nt l n ( " No t ecl e un nmer o ent er o" ) ;
Syst em. out . pr i nt l n( e. get Message( ) ) ;
c l a s s Fuer aDeRango extends Except i on
I
St r i ng mensaj e;
publ i c Fuer aDeRango ( St r i ng causa)
i
1
publ i c St r i ng get Message ( )
i
I
mensaj e = causa;
return mensaj e;
i
356 Java 2. Manual de programacin
Ejemplo
El problema de las Torres de Hanoi es un problema clsico de recursin. Se tienen tres
torres y un conjunto de discos de diferentes tamaos. Cada disco tiene una perfora-
cin en el centro que le permite ensartarse en cualquiera de las torres. Los discos
han de encontrarse siempre situados en alguna de las torres. Inicialmente todos
estn en la misma torre, ordenados de mayor a menor, como se muestra en el dibu-
jo. Se debe averiguar los movimientos necesarios para pasar todos los discos a otra
torre, utilizando la tercera como auxiliar y cumpliendo las siguientes reglas:
En cada movimiento slo puede intervenir un disco. Origen Destino Auxiliar
2 3
No puede quedar un disco sobre otro de menor tamao.

El problema se puede resolver considerando que para pasar, por ejemplo, tres
discos del pivote origen al destino, han de pasar dos discos al pivote auxiliar, mover
uno al destino y mover dos discos del auxiliar al destino.
Paso 7
1 Orinen Destino Auxiliar
Paso 3
-~
Paso 2
-~ ~
Oriqen Destino AuxGr-T Oriqen Destino Auxiliar
El paso 1, vulnera la primera regla, pero para solucionarlo, podemos recurrir a
la misma mecnica: movemos un disco de origen a destino, movemos el siguiente
al auxiliar y, por ltimo movemos el disco de destino a auxiliar.
Fases del Paso 1
1 Origen Destino Auxiliar 1 Origen Destino Auxiliar ~ Origen Destino Auxiliar
Lo mismo ocurrira con el paso 3 y se solucionara de la misma forma.
Se creara la clase Hanoi para resolver el problema. En esta clase el mtodo
movsTor r e lanza una NuevaExcp si el nmero de discos es negativo. El mtodo
Manejo de excepciones 357
mai n de la clase Pr uebaH captura y trata las excepciones; vuelve a pedir el nme-
ro de discos cuando ste fue negativo y ante cualquier otro tipo de excepcin, como
introducir una letra en lugar de un nmero, el programa termina.
publ i c cl ass Hanoi
pri vate s t a t i c voi d movsTor r e ( i n t ndi scos, i n t or i gen, i n t
dest i no, i n t auxi l i ar ) throws NuevaExcp
i
/ / Cont r ol Excepci ones
i f ( ndi scos < O)
i f ( ndi scos == O)
i f ( ndi scos == 1)
else
throw new NuevaExcp ( " Numer o de di scos i ncor r ect o" ) ;
re turn ;
Syst em. out . pr i nt l n ( " Paso di sco de " +or i gen+" a " t uest i no) ;
movsTor r e( ndi scos- 1, or i gen, auxi l i ar , dest i no) ;
Cyst em. out . pr i nt l n( " Paso di sco de " + or i gen t " a ' I +
dest i no) ;
movsTor r e( ndi scos- 1, auxi l i ar , dest i no, or i gen) ;
publ i c Hanoi ( i n t n) throws NuevaExcp
i
Syst em. out . pr i nt l n( " Bi enveni do a l as t or r es del f i n del munao" ) ;
Cyst em. out . pr i nt l n ( " Movi mi ent os: "+ ( i nt ) ( Mat h. pow ( 2, n) - 1) ) ;
Cyst em. out . pr i nt l n ( " Li st ado: " ) ;
movsTor r e( n, 1, 2, 3) ;
/ / est a cl ase ya ha si do coment ada
c l as s NuevaExcp extends Except i on
i
St r i ng mensaj e;
publ i c NuevaExcp ( St r i ng causa)
I
mensaj e = causa;
i
publ i c St r i ng get Mecsage ( )
I
return mensaj e;
358 Java 2. Manual de programacin
import j ava. i o. *;
public class Pr uebaH
I
public static void mai n ( St r i ng[ ] ar gs)
i
int n = O;
boolean r epet i r = false;
do
t
try
I
r epet i r = false;
Syst em. out . pr i nt l n ( " I nt r oduzca nmer o de di scos: " ) ;
I nput St r eamReader i sr = new
I nput Ct r eamReader ( Syst em. i n) ;
Buf f er edReader br = new Buf f er edReader ( i sr ) ;
n = I nt eger . par seI nt ( br . r eadLi ne ( ) ) ;
Hanoi h = new Hanoi ( n) ;
1
catch ( NuevaExcp el )
t
Syst em. out . pr i nt l n ( " \ t El nmer o de di scos no puede "+
" ser negat i vo" ) ;
r epet i r = true;
1
catch ( I OExcept i on e2)
{
1
catch ( Except i on e3)
i
1
Syst em. er r . pr i nt l n ( " Er r or de l ect ur a" ) ;
Syst em. er r . pr i nt l n ( e3) ;
1
while ( r epet i r ) ;
1
13.8. MTODOS DE LA CLASE Throwable
public j ava. l ang. Thr owabl e f i l l I nCt ackTr ace( )
Devuelve un objeto con los mtodos en ejecucin en el momento de lanzarse la excepcin.
public j ava. l ang. St r i ng get Message0
Devuelve el mensaje descriptivo almacenado en una excepcin.
Manejo de excepciones 359
public void pr i nt Ct ackTr ace( )
Muestra por consola un mensaje con la clase de excepcin, el mensaje descriptivo de la
misma y una lista con los mtodos en ejecucin en el momento de lanzarse la excepcin.
public void pr i nt St ackTr ace( j ava. i o. Pr i nt St r eamp l )
Enva el mensaje anteriormente especificado al flujo que se le especifique como parmetro.
public j ava. l ang. St r i ng t ost r i ng( )
Devuelve una cadena descriptora de la excepcin.
D I i I I i l l 111
I
I
Arch vos
CONTENIDO
14.1. La clase Fi l e.
14.2. Flujos.
14.3. Apertura de archivos.
14.4. Encadenamiento de flujos
14.5. Excepciones en archivos.
14.6. Mtodos de I nput st r eam.
14.7. Mtodos de Out put st r eam.
14.8. Mtodos de Reader .
14.9. Mtodos de Wr i t er .
14.10.
14.1 1.
14.12.
14.13.
14.14.
14.15.
14.16.
14.17.
14.18.
Mtodos de Dat a I nput s t r eam.
Mtodos de Dat aout put st r eam.
Mtodos de RandomAccessFi l e.
Serializacin de objetos.
St r i ngTokeni zer y St r eamTokeni zer .
Operaciones con archivos y mantenimiento
de los mismos.
Archivos secuenciales.
Archivos directos.
Funciones de transformacin de clave
y tratamiento de colisiones.
361
362 Java 2. Manual de programacin
Como estructura de datos, los archivos permiten el almacena-
miento permanente y la manipulacin de un gran nmero de
datos. Los archivos de datos son un conjunto de datos estructura-
dos que se tratan como una unidad y se encuentran almacenados
en un dispositivo de almacenamiento externo. Un archivo se con-
sidera formado por una coleccin de datos lgicamente relaciona-
dos, a los que denominaremos registros, cada registro agrupa
datos tambin con una relacin lgica entre s a los que se deno-
mina campos y es el programador el encargado de estructurar los
archivos de tal forma que se adapten a las necesidades del pro-
grama ya que, en realidad, J ava considera los archivos simple-
mente como flujos secuenciales de bytes.
En los archivos de datos se pueden destacar dos organizaciones
fundamentales: secuencia/ y la directa o aleatoria, siendo posible
trabajar en J ava con ambos tipos de organizaciones. La organi-
zacin secuencia/ implica que los datos se almacenan consecu-
tivamente en el soporte externo, no siendo posible acceder
directamente a un determinado dato si no se recorren todos los
anteriores. La organizacin directa permite el posicionamiento
directo en un determinado lugar de un archivo para leer la informa-
cin all almacenada y no obliga al almacenamiento de la misma en
forma secuencial. Adems, a diferencia de la secuencial, la organi-
zacin directa permite modificar un dato previamente almacenado,
eliminarlo o insertar uno nuevo en cualquier posicin del archivo sin
que sea necesario efectuar una copia de todo el archivo cada vez
que se realiza una de estas operaciones. En el presente captulo, se
explicar el concepto de fhjo y se mostrar cmo estructurar los
datos e implementar en J ava ambos tipos de organizaciones.
14.1. LA CLASE F i l e
Los objetos de la clase Fi l e no especifican cmo se almacena o recupera la infor-
macin en un archivo, slo describen las propiedades del mismo y permiten obte-
ner informacin sobre l.
Nota: Un objeto de la clase File posibilita la obtencin de informacin sobre
las propiedades tanto de un archivo como de un subdirectorio y permite la
modificacin de algunos de sus atributos. Los mtodos del et e y
r enameTo de la clase Fi l e permiten borrar y renombrar archivos.
Los objetos Fi l e se crean mediante los siguientes constructores:
Archivos 363
public Fi l e ( j ava. i o. Fi i e dir, j ava. l ang. Ct r i ng nombre)
Donde el primer parmetro es un objeto Fi l e que referencia un directorio y el segundo el
nombre del archivo.
public Fi l e ( 7 ava . l ang . St r i ng path)
El parmetro es el nombre de un directorio o bien el nombre completo, incluyendo ruta de
acceso, de un archivo.
public Fi i e( j ava. l ang. St r i ng path, j ava. 1ang. Ct r i ng nombre)
Donde el primer parmetro es el nombre del directorio y el segundo el nombre del archivo.
Ejemplos
/ / r ut a r el at i va, el di r ect or i o act ual
Fi l e ar ch = new Fi l e ( " ej empl o. dat " ) ;
/ * r ut a absol ut a, en ei si gui ent e caso especi f i ca el di r ect o-
r i o r ai z en Wi ndows que ut i l i za un separ ador ( \ ) di st i r . -
t o de ni x ( / ) */
Fi l e ar ch = new Fi l e ( " \ \ ' I , " ej empl o. dat " ) ;
/ * es posi bl e ut i l i zar en una ver si n Wi ndows de J ava el ca-
Fi l e ar ch = new Fi l e( " / " , " e] empl o. dat " ) ;
r ct er / como separ ador */
Mtodos y campos a destacar dentro de la clase son:
public static final char separ at or char
public j ava. l ang. St r i ng get Name0
public 1ava. l ang. Ct r i ng get par ent o
public j ava. l ang. St r i ng get Absol ut ePat h( )
public j ava. l ang. St r i ng get pat h( )
public boolean canwr i t e 0
Variable inicializada co'n el
separador indicado en el archi-
vo de propiedades del sistema
que permite especificar rutas
independientes de la plataforma.
Devuelve el nombre del archivo
referenciado por el objeto.
Devuelve el nombre del direc-
torio padre.
Devuelve la ruta absoluta del
archivo.
Devuelve la ruta relativa.
Devuelve t r ue si se puede
escribir en el archivo o directo-
rio.
public boolean canRead( ) Devuelve t r ue si se puede leer
desde el archivo o directorio.
364 Java 2. Manual de Programacin
public boolean i s F i l e ( 1
public boolean : sDi r ector y( )
public ; ava. l ang. St r i ng[ ] l i st ( )
public boolean mkdi r ( )
public boolean del er e ( )
I>e\uclve t r ue si el archivo re-
presentado por el objeto F i l e es
un archivo normal.
Devuelve t r ue si el archibo
representado por el objeto ?i 10
es un directorio.
Devuelve un array con los nom-
bres de los archivos y directo-
rios existentes en el directorio
especificado por el objeto F i l e.
Esta lista no incluye el directo-
rio actual ni el padre del actual.
Crea el directorio especificado
por el objeto F i l e.
Borra el objeto 0 1 ~e cspecifica-
do, cuando se trate de un direc-
torio cste ha de estar vacio
public boolean renar?eTo ( j ava. i o. F i l e dect ) lienombra el archivo especifi-
cado por el objcto F i l e con el
nombre del archivo Fi l e pasado
como parmctro y devuelve
t r ue cuando la operacin se
efecta con xito y f al ce si se
intenta renoinbrar un archivo
cambindolo de directorio.
public boolean ex i s t s ( )
Ejercicio
Mostrar el contenido de un subdirectorio.
De\tielbe t r u e si existe el
ob.jeto F i l e especificado y
f al ce en caso contrario.
Fi gura 14.1. Listado del contenido de un subdirectorio
7
Archivos 365
i mpor t j ava. i o. *;
publ i c cl ass Li st ado
t
publ i c st at i c St r i ng l e e r ( )
I nput St r ear nReader i sr = new I nputCtreamReader(Sy3te- .- n);
Buf f er edReader br = new Euf f er edReader ( 1sr ) ;
try
r et ur n br . r eadLi ne0;
i
cat ch( Except i cn e)
t i
r et ur n I "' ;
1
publ i c st at i c voi d mai n ( St r i n, - [ ] argsj
Syst er n. out . pr i nt l n ( " I ndi que nombr e de cubdi r ecEor i s" ) ;
Syst em. out . pr i nt l n ( " Tr ayect or i a absol ut a, ej : C: \\:.icrcj") ;
St r i ng nomdi r = l eer ( ) ;
Fi l e ar ch = new Fi l e( nor ndi r ) ;
i f ( ar ch. exi ct c ( 1 j
i f ( ar ch. i sni r ect or y ( ) )
{
Syst er n. out . pr i nt l n ( " i ont eni bo de "Tnom5: r) ;
St r i ng ar r [ j = ar c h. l i s t 0;
f or ( i nt J = 3; j < ar r . l engt h; I ++)
I
Fi l e ot r o = new Fi l e( nomdi r + " \ \ " +ar r [ ] ] ) ;
i f ( otr o. i sDi r ect or y ( 1 )
el se
Syst em. out . pr i nt l n ( ar r [ j ] + " <f i R >" j ;
Syst en. out . pr i nt i c( ar r [ j l ) ;
el se
Syst em. out . pr i nt l n ( r ~omdi r A" no es un di r ect or i o" ) ;
el se
Cyst er . . out . pr i nt l n ( " No exi st e" ) ;
1
Ejercicio
i
I
Utilice AWT para efectuar la misma tarea que el ejercicio anterior y defina una clase
annima para el cierre de la ventana.
366 Java 2. Mar ual de Programacin
-i -i
LE kr LE
Fi gura 14.2. Listado del contenido de un subdirectorio. Pantalla inicial.
Contenidci de c \libro A
Temal qCilR5
Tema1 1 <[)IR-
_.
1
Fi gura 14.3. Listado del contenido de un subdirectorio.
import j ava. awt . * ;
import j ava. awt . even: . *;
import j ava. i o. *;
public class Ej Fi l e extends Fr ame implements Act i onLi st ener
Text Fi el d t ext oi ;
Text Ar ea t ext o2;
public Ej Fi l e ( )
cet ayoct (new Bor der Layout ( ) ) ;
/ / empl eo de Ena cl ase anni ma
Archivos 367
aadWi ndow; i st ep. er ( new Wi ndowAdopt er ( )
t
public void wi ndowcl osi ng ( Wi nCc, dEver . t e)
Syst em. exi t ( 3) ;
I
1 ) ;
t ext ol = newText Fi el d ( " I nt r oduzca en esze - , gar "-
t ext ol . sel ect Al l ( 1 ;
add ( " Nor t h" , t ext ol j ;
t ext ol . addAct i onLi st ener ( t hi s) ;
t ext o2 = new Text Ar ea 0 ;
add ( " Cent er " , t ext o2) ;
" el novbre ae un sundi r ect or i o" , 55) ;
public void act i onPer f or med( Act i onEveKt e )
I
Fi l e ar ch = new Fi l e ( t ext ol . get Text ( ) ) ;
if ( ar ch. exi st s ( ) )
if ( ar ch. i sDi r ect or y ( ) )
t ext o2. append ( " Cont eni do de " + ar ch t " \ n" ) ;
St r i ng ar r [ ] = ar ch. l i st ( ) ;
for(int J = O; j < ar r . l engt h; j c+)
i
Fi l e ot r o = new Fi l e, ( ar ch+ "\ \ " f ar r [ j ] j ;
if ( ot r o. 2sDi r ect or y ( ) 1
t ext o2 . append ( ar r [ j 1 + ' I <CI X>" - "\ F. ") ;
el se
t ext o2. append ( ar r [ J ] + " \ n" ) ;
I
I
el se
t ext o2. append ( e. t ost r i ng ( ) - " nc es cc di r ei t sr i 3" ) ;
el se
t ext o2. append ( e. t ost r i ng ( j + " n3 exi st e" ) ;
public static void mai n( St r i ng ar gs[ ] )
Ej Fi l e vt = new Ej Fi l eO;
vt . set Ti t l e ( " Ej empl o FI LS" ) ;
vt . set Si ze( 400, 250 ) ;
vt . set Vi si bi e( t r uej ;
368 Java 2. Manual de Programacin
14.2. FLUJOS
Los programas en J ava realizan las operaciones de entrada/salida a travs de,flu-
j os; as se consigue gestionar de forma similar la entrada/salida sobre dispositi-
vos muy diferentes, como teclado, pantalla, impresora, una conexin a red, un
bz@r en memoria o un archivo en el disco. A diferencia de la pantalla, la impre-
sora no tiene definido en J ava un flujo de salida estndar y para sacar por impre-
sora los resultados de un programa hay que asociar un flujo al puerto ( LPT1, . . . )
donde est conectada. Las diferentes clases de flujos se encuentran agrupadas en
el paquete j ava . i o y en la parte superior de esta jerarqua destacan las clases:
I nput st r eam, Out put st r eam, Reader , Wr i t er y RandomAccessFi l e.
Fi gura 14.4. Clases de flujos que heredan de Obj ect.
i nput st r eames una clase abstracta, superclase de otras concretas que tratan
con flujos de entrada de bytes, mientras que Out put st r eames la clase abstracta
superclase de otras que representan un flujo de salida de bytes. Estas clases definen,
pues, la funcionalidad bsica comn a todas las clases de flujo de bytes. Vea la
Figura 14.5. Wr i t er es una clase abstracta para escribir caracteres en flujos y
Reader la clase abstracta cuyas subclases podrn leerlos (Fig. 14.6.).
Cuando se trabaja con Reader o Wr i t er el flujo se orienta a Unicode (16 bits)
y con St r eama bytes (8 bits). Las clases St r eam, en gran parte, se consideran
obsoletas, ya que J ava usa Unicode y tiene ms sentido usar Reader / Wr i t e r que
trabajar con byres, donde J ava tiene que traducir los bytes en Unicode para impri-
mirlos y de vuelta en Unicode cuando los lee.
Por otra parte, en adicin a St r eam, Reader y Wr i t er , el paquete j ava. i o
define la clase RandomAccessFi l e que permite implementar archivos de acce-
so directo.
Archivos 369
Figura 14.5. I nput st r eamy Out put st r eam, jerarqua de clases.
370 Java 2. Manual de Programacin
Reader
I
Fi gura 14.6. Reader y Writer, jerarqua de clases.
14.3. APERTURA DE ARCHIVOS
Para crear, escribir o leer un archivo se requiere establecer un flujo a/desde l; las
clases capaces de crear un flujo aidesde un archivo requieren una referencia a un
objeto Fi l e o un nombre de archivo como argumento. Estas clases son:
La subclase Fi l eOut put Ct r eamhereda de Out put Ct r eamy permite
crear un flujo de salida para escribir bytes en un archivo. Los constructores
son:
public Fi l eOur put Ct r eam( j ava. l ang. St r i ng nombre).
public Fi l eOct put Ct r eam( j ava. i o. Fi l e file)
/ / f i l e es un obj et o F i l e
public Fi LeCut put Ct r eam( j ava. l ang. Ct r ; ng nombre, boolean
a a d i r ) .
Archivos 371
Los tres constructores lanzan excepcin. Con los dos primeros si el archivo
existe y se abre de esta forma, se destruye. El ltimo constructor permite aa-
dir datos a un archivo existente, cuyo nombre viene especificado por nombr e.
Ejemplo
Fi l eout put st r eam f 1 = n e w Fi l eOut put Ct r eam( " i nf o. t xt " ) ;
o bien
Fi l e ar ch = n e w Fi l e( " ej empl o. da~" j ;
Fi l eout put st r eam f 2 = n e w Fi l eOut put St r eam( ar ch) ;
Un flujo debe cerrarse cuando ya no vaya a utilizarse con las sentencias sufi-
cientes:
f l . cl os e0;
f 2 . cl ose ( j ;
La subclase Fi l eI nput St r eamhereda de I nput st r eamy permite crear
un flujo para lectura de bytes desde un archivo. La lectura comienza desde el
principio del archivo y cuando se leen datos del mismo, para que se puedan
volver a leer los datos del principio es necesario cerrar el flujo y volverlo a
abrir. Los constructores son:
public Fi l eI nput St r eam( ] ava. i c. Fi l e f i l e )
public Fi l eI nput Ct r eam( j ava. l ang. St r i ng nombre)
Ambos constructores lanzan una Fi l eNot FoundExcept i on
Ejemplo
Fi l eI nput St r eam f l = n e w Fi l eI nput St r eam( " not as. t xt " ) ;
o bien
Fi l e ar ch = n e w Fi l e ( "e] empl o. t xt " j ;
Fi l eI nput St r eam f 2 = n e w Fi LeI nput St r eam( ar ch) ;
El flujo se cierra de modo similar al caso anterior.
Fi l ewr i t er hereda de Wr i t er y proporciona l a posibilidad de crear un
flujo para escritura de caracteres en un archivo. Los constructores son:
372 Java 2. Manual de Programacin
public Fi i eWr i t er ( j ava. 1o. F
public Fi l eWr i t er ( ] ava. l ang
public F- l eWr - t er ( 7ava. l ar . g
l e f i l e )
St r i ng nombre)
St r i ng nombre, boolean aadir)
y lanzan una I OExcept i on. Los dos primeros constructores destruyen una
archivo existente; el ltimo permite aadir datos al final del mismo.
Ejemplo
Fl i eWr l t er f e new Fi l eWr i t er ( " i nf o. t xt " ) ;
f e. :lose ( ) ;
. . .
Fi l eReader permite crear un flujo para la lectura de caracteres desde un
archivo. Anlogamente a lo que ocurre con Fi l eI nput St r eam, la lectura
comienza desde el principio del archivo y cuando se leen datos del mismo, para
una nueva lectura desde el principio es necesario cerrar el flujo y volverlo a
abrir. Los constructores son:
public Fi l eReader ( l ava. i o. F i i e f i l e )
public Fi l eReader ( j ava. l ang. St r i ng nombre)
y lanzan una excepcin Fi l eNot FoundExcept i on.
Ejemplo
Fi l eReader f l = new Fi l eReader ( " i nf o. t xt " ) ;
f l . cl ose ( ) ;
. . .
La clase RandomAcces s Fi l e permite el acceso directo (tambin llamado
ucceso aleatorio) a una determinada posicin dentro de un archivo, as como
la lectura y escritura de datos en dicho archivo. Esta clase no deriva de
I nput st r eamni de Out put st r eam, sino que implementa las interfaces
Dat aI nput y Dat aout put que definen los mtodos de entradahalida bsi-
cos. El flujo se crea mediante:
public RandcmAccessFi l e( j ava. i o. Fi l e f i l e , j ava. l ang. Ct r i ng m)
throws Fi l eNot FoundExcept i on
public RandorrSi ccessFi l e(j ava.l ang.Ctri ng nombr e, ] ava. i ang. St r i ng m)
throws I OExcept i on
El parmetro mrepresenta el modo en el que se crear el flujo y en la llamada
se le podr pasar: r (lectura) o r w (lectura/escritura).
Archivos 373
Ejemplo
RanaomAcceccFi l e :l e = new Rai domAcceccFi l e ( " dat os . =a- " , " r w" ) ;
f l e. cl ose ( 1 ;
Nota: En J ava RandomAccessFi l e es la clase que permite el acceso directo
y Fi l eReader,Fi l eI nputStream, Fi l eWr i t er y Fi l eOut put St r eam
ofrecen tratamiento secuencial.
14.4. ENCADENAMIENTO DE FLUJOS
Para conseguir flujos personalizados, que se adapten a los requisitos de transferencia de
datos en J ava se utiliza la composicin de flujos. Este sistema sirve no slo para archi-
vos, si no que se aplica tambin a los flujos de red y de conector (socket). Existen una
serie de flujos que efectan tratamientos especiales de la informacin; son, por ejemplo:
I nput St r eamReader
Out put Ct r eamWr i t er
Buf f er edReader
Buf f er edWr i t er
Buf f er edI nput St r eam
Buf f er edOut put St r eam
Pr i nt st r eam
Pr i zt Wr Lt er
Dat aI nput Ct r eam
Dat aout put Ct r eam
Convierten bytes a caracteres.
Establecen un buffer para caracteres
I
Establecen un buffer para bytes
Escribe valores y objetos en un flujo de bytes.
Escribe valores y objetos en un flujo de caracteres.
Permiten leer y escribir tipos de datos primitivos,
efectuando conversiones desde un flujo de bytes a
dichos tipos de datos primitivos.
Estos flujos pueden asociarse unos con otros y con los de apertura de archivos para
obtener el flujo deseado ai escribir o leer de un archivo. Por ejemplo, la clase
Fi l eOut put St r eamconsidera el flujo como una coleccin de bytes, pero no como
unidades ms grandes; cuando se desea imprimir unidades ms grandes, se le puede
asociar un objeto Pr i nt st r eam. Los objetos Pr i nSt r eamadmiten los mtodos
pr i nt y pr i nt l n para valores y objetos. Cuando se trata de objetos, estos mtodos
374 Java 2. Manual de Programacin
llaman al mtodo t ost r i ng del objeto e imprimen el resultado. Pr i nst r eam
almacena los datos a imprimir en un bufer con la finalidad de trabajar de la forma ms
eficiente posible y disminuir el nmero de operaciones de transferencia, as los datos
slo se escriben cuando se llena el buffer o termina el programa. Esto resulta muy con-
veniente para los archivos, pero no para la pantalla. Sys tern. out es una instancia de
Pr i n S t r e amy por eso pr i nt y pr i nt 1 n son los mtodos que se vienen utilizan-
do para mostrar informacin por pantalla. La clase posee el mtodo
public void f l ush ( )
que se utiliza para asegurar que los buffers de datos se escriben fsicamente en el
flujo de salida.
Ejemplos
1. Syst em. out . pr i nt ( " Deme una cadena " ) ;
Syst em. out . pr i nt l n ( " y a cont i nuaci n pul se RETURN" ) ;
/ * Habi t ual ment e J ava vac a el buf f er cuando, est e se
l l ena, cuando t er mi na el pr ogr ama y cuando se ef ect a
una l ect ur a desde t ecl ado, por l o que l a si gui ent e
i nst r ucci n no suel e ser necesar i a */
Syst em. out . f l ush0 ;
2. Fi l e f = n e w Fi l e ( " t ext o. t xt " ) ;
/ / l a si gui ent e i nst r ucci n abr e el ar chi vo par a escr i t ur a
Fi l eout put st r eam f e = n e w Fi l eOut put St r eam( f ) ;
Pr i nt st r eam sal i da = n e w Pr i nSt r eam ( f e) ;
/ * Despus se ut i l i zar an l os mt odos pr i nt l n o pr i nt de
sal i da. pr i nt l n ( " Los f l uj os pr opor ci onan canal es "+
Pr i nt st r eam */
" de comuni caci n" ) ;
/ * P or l t i mo ser i a conveni ent e cer r ar l os f l uj os con el
mt odo cl ose */
Otro encadenamiento se puede utilizar para leer cadenas desde un archivo abierto
con Fi l eI nput St r eam. El programa que lee llama a un Buf f er Reader que
utiliza un I nput St r eamReader , que a su vez utiliza un Fi l eI nput St r eam
para leer del Fi l e.
Ejemplo
/ / Obj et o Fi l e
Fi l e f = n e w Fi l e ( " t ext o. t xt " ) ;
/ / Aper t ur a del ar chi vo par a l ect ur a. F l ul o de byt es
Fi l eI nput St r eam f l = n e w Fi l eI nput St r eam( f ) ;
Archivos 375
/ / Conver si n a f l uj o de car act er es
I nput Ct r eamReader ent r ada = n e w I nput St r eamReader ( f 1j ;
/ * Buf f er par a car act er es y obj et o que per mi t e l eer una l nea
Buf f er edReader l ect or cad = n e w Buf f er edReader ( ent r ada) ;
/ / Lect ur a
St r i ng cadena = l ect or Cad. r eadLi ne0; / / l anza una I OExcept i on
compl et a */
El mtodo r eadLi ne ( ) de la clase Buf f er edReader permite leer una
secuencia de caracteres de un flujo de entrada y devuelve una cadena; adems, uti-
liza un byffeer para mejorar el rendimiento. Para efectuar lectura desde teclado, se
utiliza syst em. i n, que es una instancia de j ava. i o. I nput st r eam; por esta
razn, las lecturas de una cadena desde teclado se han efectuado con un mtodo
anlogo ai anteriormente expuesto.
Ejemplo
I nput Ct r eamReader ent r ada = n e w I nput Ct r eamReader ( Syst em. i n) ;
Buf f er edReader l ect or cad = n e w Buf f er edReader ( ent r adaj ;
St r i ng cadena = l ect or cad. r eadLi ne ( ) ;
Dat a I npu t S t r eamy Da t aOut put S t r eamse utilizan respectivamente para
leer o escribir en un flujo Fi l eOut put St r eamo Fi l eOut put St r eamdatos
de tipos primitivos y recuperarlos como tales y tambin en este caso se aplica enca-
denamiento.
Ejemplo
Fi l eI nput Ct r eam f e = n e w Fi l eI nput Ct r eam
Dat aI nput Ct r eam de = n e w Dat aI nput St r eam
cad = de. r eadUTF( j ;
de. cl ose ( ) ; / / mt odo her edado de Fi l t er
" dat os . dat " ) ;
f e) ;
nput st r eam
14.5. EXCEPCIONES EN ARCHIVOS
Cuando se trabaja con archivos se pueden producir errores de entrada/salida y J ava
obliga a prever este tipo de errores y recoger las excepciones que pueda lanzar el
sistema. Las excepciones del paquete j ava . i o se muestran en la Figura 14.7.
Cuando el programador disea un mtodo tiene dos opciones con este tipo de
excepciones: listaras en la cabecera del mismo o bien recogerlas y tratarlas. Si est
sobrescribiendo un mtodo del que no puede modificar la interfaz, se ver obligado
a recoger estas excepciones y tratarlas en el propio mtodo.
Las excepciones en el trabajo con archivos pueden ser lanzadas por los mtodos
de escritura y lectura, pero adems hay que tener en cuenta que la apertura de un
376 Java 2. Manual de Programacin
archivo puede producir una excepcin I OExcept i on cuando falla la operacin; por
ejemplo, si se intenta abrir para lectura un archivo que no existe, y el cierre de un
archivo con el mtodo cl ose tambin puede producir una I OExcept i on. Por otra
parte, los archivos en J ava terminan con una marca de fin de archivo y cuando en la
lectura de un archivo se llega a dicha marca se puede lanzar una EOFExcept i on.
Capturar y tratar las excepciones en la apertura y cierre de un archivo.
publ i c cl ass Cont r ol Excepci ones
t
publ i c st at i c voi d mai n ( St r i ng[ ] ar gs)
i
Abr eYCi er r a ar ch = new Abr eYCi er r a ( ) ;
ar ch. l eer ( ) ;
i mpor t j ava. i o. *;
publ i c cl ass Abr eYCi er r a
I
Fi l eI nput St r eam f l = null;
publ i c voi d l eer 0
Fi l e f = new Fi l e( " t ext o. t xt " ) ;
f l = new Fi l eI nput Ct r eam( f ) ;
1
cat ch( I 0Except i on e)
I
Cyst em. out . pr i nt l n ( e) ;
1
f i nal l y
t
try
i
/ * no debe col ocar se en el pr i mer bl oque t r y ya que
i f ( f l != null)
f l . cl os e0;
1
cat ch( I 0Except i on e)
pudi er a no ej ecut ar se */
Cyct er n. o. dt . pr i nt l n ( e) ;
Syst er r . . out . pr i nt l n ( " Fi n" ) ;
:t
1
Archivos 377
Figura 14.7. Excepciones del paquete 1 ava. 10
Nota: Al trabajar con archivos, las excepciones pueden ser lanzadas por los
mtodos de lectura y escritura y tambin por las operaciones de apertura y cie-
rre del archivo. El compilador obliga a tratar dichas excepciones.
378 Java 2. Manual de Programacin
Nota: Cuando se detecta el fin de flujo:
. El mtodo r ead de i nput st r eamdevuelve - 1.
El mtodo r eadLi ne devuelve nul l .
Los mtodos que se exponen en Dat aI nput St r eam generan una
EOFExcept i on.
14.6. MTODOS DE inputstream
public int available ( )
De\uelve el nmero de bytes actualmente disponibles para su lectura en el flujo de entrada.
public void cl ose 0
Cierra el flujo de entrada. Genera una I OExcept i on si se produce un error.
public synchronized void mark(int num)
Coloca una marca en el flujo de entrada, vlida hasta que se lea el nmero de bytes especi-
ficado como parmetro.
public boolean marksupported0
Comprueba si el flujo de entrada soporta los mtodos mark y reset.
public abstract int read0
Devuelve como entero el siguiente byte disponible de la entrada.
public int read(byte b [ I )
Intenta leer desde el flujo de entrada el nmero de bytes necesarios para llenar el array b
pasado como parmetro y devuelve el nmero real ledo.
public int read(byte b[ 1 , int d e s d e , int c u a n t o s )
Intenta leer desde el flujo de entrada el nmero de bytes especificados corno tercer parme-
tro y los introduce en el array b empezando en b [de cde ] .
public synchronized void reset ( )
Coloca el puntero de entrada en la marca establecida con mark.
public long skip(1ong n)
Salta y descarta n bytes del flujo de entrada, devolviendo el nmero real de bytes saltados.
Excepto mark, todos los mtodos restantes lanzan una I OExcept i on.
Archivos 379
14.7. MTODOS DE Outputstream
publ i c voi d cl ose( )
Cierra el flujo de salida. Genera una I OExcept i on si se produce un error
publ i c voi d f l ush( )
Vaca y limpia el buffer.
publ i c voi d wri t - e ( byt e b [ I )
Escribe b. l engt h bytes del array b en el flujo de salida.
publ i c voi d wr i t e( byt e b[ 3 , i nt d e s d e , i nt cuantos)
Escribe b. cuant os bytes del array b en el flujo de salida comenzando desde b [ doczel .
publ i c abst r act voi d wr i t e i nt 5)
Escribe un nico byte en el flujo de salida.
Todos estos mtodos lanzan una excepcin I OExcept i on.
14.8. MTODOS DE Reader
La clase Reader es una clase abstracta, superclase de todos los flujos de entrada
orientados a carcter que proporciona un conjunto de mtodos similar al que la clase
i nput S t r eamproporciona para los flujos de entrada orientados a byte. Todos sus
mtodos lanzan una excepcin I OExcept i on.
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
abst r act voi d cl ose ( )
voi d mar k ( i nt n u m l a r a c t e r e s )
bool ean mar kSuppor t ed( )
i nt r ead( )
i nt r ead ( char c [ ] )
abst r act i nt r ead char c[ I , i nt d e s d e , i nt cuantos)
bool ean r eady ( )
voi d r eset 0
l ong ski p( 1ong n)
14.9. MTODOS DE Writer
La clase Wr i t er es una clase abstracta superclase de todos los flujos de salida
orientados a carcter que proporciona un conjunto de mtodos similar al que la clase
Out put st r eamproporciona para los flujos de entrada orientados a byte. Todos
sus mtodos lanzan una I OExcept i on.
380 Java 2. Manual de Programacin
publ i c abst r act voi d cl ose ( )
publ i c abst r act voi d f l ush ( )
publ i c voi d wr i t e ( char c [ I )
publ i c abst r act voi d wr i t e ( char c[ 1 , i nt d e s d e , i nt
publ i c voi d wr i t e ( i nt c)
publ i c voi d wr i t e ( l ava. l ang. Ct r i ng c a d e n a )
publ i c voi d wr i t e ( j ava. l ang. Ct r i ng c a d e n a , i nt d e s d e , i nt
c u a n tos)
c u a n t o s )
14.10. MTODOS DE DataInputStream
Esta clase acta como filtro envolviendo un flujo de entrada para as permitir la
lectura desde un archivo de datos de tipos primitivos. Mtodos de
Dat a I ri pu t S t r eamson:
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
publ i c
f i nal i nt r ead ( byt e b u f f e r [ ] )
f i nal i nt r ead( byt e b u f f e r [ 1 , i nt d e s d e , i nt c u a n t o s )
f i nal bool ean r eadBool ean0
f i nal byt e r eadByt e ( )
f i nal char r eadchar ( )
f i nal doubl e r eadDoubi e ( )
f i nal f l oat r eadFl oat ( )
f i nal voi d r eadFul l y( byt e b u f f e r [ 1 )
f i nal i nt ski pByt es ( i nt n)
f i nal voi d r eadFul l y( byt e b u f f e r [ 1 , i nt d e s d e , i nt
c u a n tos)
f i nal i nt r eadI nt ( )
f i nal l ong r eadLong ( )
f i nal shor t r eadshor t ( )
f i nal i nt r eadUnsi gnedByt e ( )
f i nal i nt r eadUnsi gnedChor t ( )
f i nal j ava. l ang. Ct r i ng r eadUTF( )
st at i c f i nal j ava. l ang. Ct r i ng r eadUTF( j ava. i o. Dat aI nput
e n t r a d a )
Todos estos mtodos lanzan una I OExcept i on y casi todos ellos estn defini-
dos en la interfaz Dat aI nput implementada por la misma. Los mtodos r eadUTF
devuelven una cadena de caracteres Unicode y generan una excepcin del tipo
UTFDat aFor mat Except i on si los bytes no representan una codificacin UTF-
8 vlida de una cadena Unicode. En el formato UTF-8' los dos primeros bytes indi-
can el nmero de bytes que han de ser ledos a continuacin para formar la cadena.
El nombre de los restantes mtodos realizan las tareas que dicho nombre sugiere.
' Las siglas UTF-8 significan Formato de Transformacin Universal 8; es un formato de transmisin para
Unicode vlido para los archivos de sistemas Unix.
Archivos 381
14.1 1. MTODOS DE DataOutputStream
Esta clase acta como filtro envolviendo un flujo de salida para as permitir la
escritura en un archivo de datos de tipos primitivos. Todos los mtodos de
Dat aOut put St r eam, excepto si ze ( ) lanzan una I OExcept i on. Mtodos
de Dat aOut put St r eamson:
publ i c voi d f l ush( )
publ i c f i nal i nt si ze( )
publ i c synchroni zed voi d wr i t e (byte b u f f e r [ i , i nt de s de , i nt c u a c t s c )
publ i c synchr oni zed voi d wr i t e ( i nt v a l o r )
publ i c f i nal voi d wr i t eBool ean( boo1ean b o o l e a n o )
publ i c f i nal voi d wr i t eByt e ( i nt v a l o r )
publ i c f i nal voi d wr i t eByt ec ( ] ava. l ang. Ct r i ng c a d e n a )
publ i c f i nal voi d wr i t echar ( i nt c a r c t e r )
publ i c f i nal voi d wr i t echar s ( j ava. l ang. St r i ng c a d e n a )
publ i c f i nal voi d wr i t eDoubi e ( doubl e v a l o r )
publ i c f i nal voi d wri teFl oat: ( f l oat v a l o r )
publ i c f i nal voi d wr i t eI nt ( i nt v)
publ i c f i nal voi d wr i t eLong ( l ong v)
publ i c f i nal voi d wr i t eshor t ( i nt v )
publ i c f i nal voi d wr i t eUTF( ] ava. l ang. St r i ng c a d e n a )
El mtodo si z e ( ) devuelve el nmero de bytes escritos y, por su nombre y lo
comentado en otras ocasiones, puede deducirse el significado de los restantes. Casi
todos los mtodos de esta clase estn definidos en la interfaz Dat aout put imple-
mentada por la misma.
Nota: Dat aI nput St r eamy Dat aOut put St r eamse utilizan respec-
tivamente para leer o escribir en un flujo Fi l eOut put Ct r eamo
Fi l eOu t pu t S t r eamdatos de tipos primitivos y recuperarlos como tales
aplicando encadenamiento.
14.12. MTODOS DE RandomAccessFile
Esta clase implementa las interfaces Dat aI nput y Dat aout put y adems de los
mtodos de ambas interfaces ofrece tambin los siguientes:
publ i c l ong get Fi l ePoi nt er ( ) Devuelve, en bytes, la posicin
actual en el archivo.
publ i c l ong l engt h0 Devuelve, expresada en bytes,
la longitud del archivo.
382 Java 2. Manual de Programacin
publice void ceek(1ong pl ) Coloca en una posicin espec-
fica relativa al principio del
archivo, de forma que las ope-
raciones de lectura o escritura
puedan realizarse directamente
en dicha posicin.
14.13. SERIALIZACIN DE OBJETOS
En J ava un registro de un archivo se puede corresponder con una clase y los cam-
pos del registro coincidiran con las variables de instancia; por consiguiente, en
lugar de leer y escribir series de datos agrupadas en los archivos, puede resultar ms
adecuado leer y escribir objetos. La serializacin de objetos es la forma de guardar
objetos en archivos o enviarlos a travs de la red, ya que permite escribir o leer obje-
tos en flujos. El mecanismo de serializacin mantiene el control sobre los tipos de
objetos y las relaciones entre ellos.
Para que se pueda serializar un objeto, basta con establecer que implemen-
te la interfaz Ser i al i zabl e. Esta interfaz no tiene mtodos, por lo que no habr
que aadir implementaciones a la clase, pero obliga a que todos los campos de datos
del objeto sean serializables; como los tipos predefinidos son todos serializables,
en realidad lo nico que habr que considerar es que si desde ese objeto se refe-
rencian otros, estos tambin hayan sido declarados serializables. La clase que
permite escribir los objetos en el flujo de salida es Obj ectOutputStream y
Cbj ectI nputCtream la que permite leerlos.
Obj ectOutputStream implementa la interfaz Obj ectcutput que a su
vez implementa Datacutput que le aade la capacidad de escribir, adems de
objetos, tipos bsicos de datos. Las operaciones con archivos se harn encade-
nando un Obj ectcutputstr eam a un Fi l eCutputCtream y el mtodo
wri teobj ect ( obj eto) es el que se utiliza para escribir objetos en el flujo
abierto hacia el archivo:
public final void wr i t eObj ect ( j ava. i ang. 0bj ect o b j )
Los mtodos f l ush ( ) y cl ose ( ) se emplearn para obligar a volcar el con-
tenido del bgfer y cerrar el flujo respectivamente.
Cbj ectI nputCtream implementa la interfaz Cbj ectI nput que a su vez
implementa DataI nput que le aade la capacidad de leer, adems de objetos, tipos
bsicos de datos. Las operaciones con archivos se harn encadenando un
Cbj ectI nputStreama un Fi l eI nputStreamy el mtodo readobj ect ( ) .
public final j ava. l ang. Obj ect r eadobj ect 0
es el mtodo que se utiliza para leer objetos en el flujo abierto hacia el archivo.
Archivos 383
I I
Nota: La serializacin de objetos permite guardar en archivos objetos que
implementan la interfaz Se r i a 1 i z ab 1 e.
14.14. StringTokenizer Y StreamTokenizer
St r i ngTokeni zer pertenece al paquete j ava. ut i l ; trabaja sobre cadenas y
se puede utilizar como herramienta para efectuar el anlisis de las lneas ledas de
un archivo de texto. La clase St r eamTokeni zer es miembro del paquete
j ava. i o y realiza un trabajo muy similar a St r i ngTokeni zer , permitiendo
dividir un flujo de entrada en fragmentos significativos mediante el empleo de unos
delimitadores. El constructor es:
public St r eamTokeni zer ( j ava. i o. Reader r)
La constante TT EOF indica que se ha ledo el final del flujo; de modo anlogo
TT EOL y TT WORD indican el fin de lnea y el fin de palabra. Para inicializar los
del&itadores,se emplea r eset synt ax ( ) y despus con el mtodo wor dchar s
se puede establecer la serie de caracteres que pueden constituir una palabra. El
mtodo eol I sSi gni f i cant determina que los caracteres de lnea nueva sean
tratados como tokens, de forma que next Token devuelva TT - EOL cuando se lea
el fin de lnea.
14.15. OPERACIONES CON ARCHIVOS Y MANTENIMIENTO
DE LOS MISMOS
Las operaciones con archivos son aquellas que tratan con su propia estructura, tales
como la creacin, apertura o cierre de los mismos y que son proporcionadas por el
lenguaje, en este caso J ava. Adems de utilizar este tipo de operaciones al trabajar
con archivos, ser necesario disear mtodos que efecten tareas de mantenimien-
to. El mantenimiento de un archivo incluye las siguientes operaciones:
9 Actualizacin
Altas. Operacin de incorporar al archivo un nuevo registro.
Bajas. Accin de eliminar un registro de un archivo. Las bajas pueden ser
de dos tipos:
Ldgicu. Se efecta colocando en el registro que se desea borrar una bandera o
indicador que lo marque como borrado. Admite la posterior recuperacin de la
informacin.
384 Java 2. Manual de Programacin
Fkica. implica la desaparicin de esa informacin del archivo de forma que no
pueda ser recuperada por operaciones posteriores. Puede efectuarse mediante la
sobreescritura del registro o bien creando un nuevo archivo que no incluya dicho
registro.
Modificaciones. Proceso de modificar la informacin almacenada en un
determinado registro de un archivo.
Consulta
De un nico registro.
De todos los registros del archivo.
14.1 6. ARCHIVOS SECUENCIALES
En los archivos secuenciales los registros se almacenan unos al lado de otros sobre
el soporte externo y se pueden designar por nmeros enteros consecutivos; sin
embargo, estos nmeros de orden no se pueden utilizar como funciones de acceso
y para realizar el acceso a un registro resulta obligatorio pasar por los que le prece-
den. Adems, este tipo de archivos no pueden abrirse simultneamente para lectura
y escritura y terminan con una marca de final de archivo.
Los archivos secuenciales en J ava se pueden abrir para lectura con
Fi 1 e I nput S t r eamo Fi 1 eReade r ypara escritura con Fi 1 eOu t put S t r eam
o Fi l ewr i t er .
Cuando un archivo secuencial se abre para lectura, un puntero de datos imagi-
nario se coloca al principio del archivo, de forma que la lectura siempre comen-
zar por el principio. Cuando un archivo secuencial se abre para escritura, el
puntero de datos imaginario puede colocarse al principio del archivo, con lo que
si ste exista se perder cualquier informacin almacenada en el mismo, o bien
al final:
public Fi l eOut put Ct r eam( j ava. l ang. St r i ng nombre, boolean a a d i r )
public Fi l ewr i t er ( J ava. l ang. St r i ng nombre, boolean ar adi r )
para as poder aadirle nueva informacin por el final.
Un caso particular de archivos secuenciales son los archivos de texto, que estn
formados por una serie de lneas cada una de las cuales se encuentra constituida por
una serie de caracteres y separadas por una marca de final de lnea.
Ejercicio
Disear nprograma con interfaz grfica que muestre el contenido de los archivos
de texto que se le indiquen a travs de un campo de texto (Fig. 14.8).
Archivos 305
! -
mode con codepage prepate=((850) C iWINDWS\COMMAND\ega I
mode con codepage select=850
keyb sp,,C iWINDOWSiCOMMAND\keyboard SYS
set path=% p ath %, C hi p
Fin
f
Figura 14.8. Ejecucin: muestra el contenido del archivo c : \ aut oexec. bak.
import j ava. i o. *;
import j ava. awt . *;
import j ava. awt . event . *;
public class LeeText o extends Fr ame implements Act i oni i st ener
Text Ar ea cont eni do;
T extF i el d nombr e;
Fi l e ar ch = null;
public LeeText o ( )
cet Layout (new Bor der Layout ( ) ) ;
addWi ndowLi st ener ( new Wi ndowAdapt er ( )
public void wi ndowCl osi ng ( Wi ndowEvent e)
Cyst em. exi t ( O) ;
1
1 ) ;
nombr e = new Text Fi el d( ) ;
nombr e. addAct i onLi ct ener ( t hi s) ;
add ( " Nor t h" , nombr e) ;
cont eni do = new Text Ar ec3 ( ) ;
add ( " Cent er " , cont eni do) ;
1
public void act i onPer f or med ( Act i onEvent e)
nombr e. sel ect Al l ( ) ;
ar ch = new Fi l e ( nombr e. qet Text ( 1 ) ;
Car gar Ar chi vo ( ) ;
386 Java 2. Manual de Programacin
public static void mai n( St r i ng ar gs[ ] )
I
LeeText o ventana = new LeeText o ( ) ;
vent ana. cet Ci ze( 400, 250 ) ;
ventana. cet - i t - e ( " Zl empl o de Lect ur a desde Ar chi vo" ) ;
ver . t ana. cet V- si bl e( t r ue) ;
void Car gar Ar c?. i vo ( 1
i
Fi l e3eader f = null;
Suf f er edReader br = null;
St r i ng cadena = null;
try
f = new Fi i eReader ( ar ch) ;
br = new Suf f er edReader ( f ) ;
do
cadena = br . r eas Li ne0;
if ( r ader , a != null)
cor . t eni do. append( cadena + " \ n" ) ;
i
while ( cadena != null) ;
catch ( Fi l eNozFoundExcept i sn e)
!
cont eni do. apFend( " Ei ar ch; vo no exi st e\ n" ) ;
I
catch ( I OExcept i on e)
ccnt eni do . append ( " Er r or \ n" ) ;
finally
t=Y
t
if ( br != null)
{
Dr . cl ose( ) ; / / bast a con cer r ar el oDj et o nac ext er i or
i
catch ( I OExcept i on e)
!
cont eni do. append ( " Er r or \ n" ) ;
i
coxt eni do. appexd ( "F: n\ n\ n") ;
Archivos 387
Ejercicio
Un ejemplo de serializacin. El programa debe permitir efectuar altas y bajas y con-
sultas de los datos de los empleados de una empresa.
En la implementacin expuesta a continuacin, las operaciones se efectan en
un array en memoria; este array es el campo de datos de un objeto de tipo
Per sonal . El objeto Per sonal se recupera y escribe desdeien un archivo en el
disco empleando serializacin. Como los elementos del array son objetos de tipo
Empl eado, la clase Empl eado tambin ha de ser serializable. El mtodo mai n
de la clase Ej empl o llama a: 1) l eer , mtodo que cuando el archivo existe lee el
objeto, 2) oper aci ones, que a travs de un men de opciones permite elegir la
operacin a realizar, 3) escr i bi r , que escribe el objeto en el archivo cuando
dicho objeto ha sufrido cambios.
La clase Empl eado representa los registros y sus campos son: cdi go,
edad, nombr e, domi ci l i o y t el Sf ono. El cdi go es el campo clave que
identifica al empleado y se supone que no se van a introducir en ningn momento
cdigos repetidos.
Las altas se efectan simplemente aadiendo nuevos elementos al final del array.
El array se crea de nuevo, para aumentar su tamao, en cada adicin y se utiliza otro
array auxiliar copi aDeLi s t a para conservar la informacin anterior. Tras crear
el nuevo array ar r Empl eados, se copian en e1 los elementos del array
copi aDeLi st a y se coloca al final el nuevo empleado ( unEmpl eado) . Esta
forma de trabajar imita el funcionamiento de la clase Vect or del paquete
j ava . ut i l , que inicialmente crea un array de objetos de un tamao determinado
y, si ms adelante se necesita, crea otro de mayor tamao, mueve todos los objetos
al nuevo y borra el antiguo; la clase Vect or proporciona as arrays dinmicos, que
aumentan o disminuyen de tamaiio en tiempo de ejecucin.
La baja de un empleado (mtodo el i Lmi nar de la clase Per sonal ) disminu-
ye el tamao del array.
La consulta pide un cdi go y efecta un recorrido secuencia1 del array hasta
que ste se acaba o encuentra un empleado cuyo cdi go sea igual al introducido
desde teclado. En el caso de que encuentre a dicho empleado, muestra la informa-
cin almacenada sobre dicho empleado.
import j ava. i o. * ;
publ i c cl ass Ej empl o
stati c Per sonal l i st a = nul l ;
/ / si ?a l i st a s- i f r e cambi os se escr i be en el di sco
stati c boolean car cbi os;
388 Java 2. Manual de Programacin
publ i c stati c void mai p( St r i ng[ ] ar gs)
l eer ( ) ;
oper aci ones ( ) ;
escr i bi r ( ) ;
publ i c stati c void l eer ( )
/ * Cr eaci n consi der a dos casos si el ar chi vo exi st e
Li l e f i cher o = new Fi l e( " empr esa. dat " ) ;
i f
i
pr evi ament e o no */
( ! f i cher o. exi st s ( ) )
l i st a = new Per sonal ( 1 ;
Syst em. out . pr i nt l r ! ( " Nuevo ar chi vo" ) ;
el se
oi s = new Obj ect i cput St r eam( new Fi l ei nput st r eam
l i st a = ( Per sonal ) oi s. r eadobl ect 0 ;
Syst em. out . pr i nt i n ( " Ar chi vo exi st ent e" ) ;
( " empr esa. dat " ) ) ;
1
catch ( Cl assNot FoundExcept i sn e)
Syst em. out . pr i nt i r . ( " Er r or : " + e. t ost r i ng ( ) ) ;
catch ( I OExcept i on e)
I
Syst em. out . pr i nt l n ( " Er r or : " + e. t ost r i ng ( ) ) ;
1
f i nal l y
I
i f ( oi s != nul l )
oi s . cl ose ( ) ;
1
catch ( I OExcept i on e)
t j
publ i c stati c void oper aci ones ( )
t
short opci n = O ;
I npuZCt r eamReader i sr = new : nput St r eamReader ( Syst em. i n) ;
Buf f er edReader br = new BLf f er edReader ( 1sr ) ;
Archivos 389
int posi = - 1;
short cdi go = 3;
short edac = O;
Ct r i nq Rornbre, dor ni ci i i o, t el f ono;
boolean el i mi nado = false;
boolean er r or ;
/ / Mant eni mi ent o
try
t
do
Syst er n. out . pr i nt l n ( " MENC" ) ;
Syst er n. out . pr i nt i n( " ?. Al t as" ) ;
Syst er n. oUt . pr i nt l n( " 2. Baj as" ) ;
Syst er n. out . pr i nt l n ( " 3. Consul t as" ) ;
Syst er n. out . pr i nt l n ( " 4. Fi n" ) ;
Syst er n. out . pr i nt i n( ) ;
Syst er n. cGt . pr i nt ( " E l i j a opci n: " ) ;
do
opci n = Shor t . par seShor t (new Buf f er edReacer (new
i nput Ct r ear nReader ( Syst em. i n) ) . r eadLi neO) ;
while ( opcL6n < 1 ' 1 opci n > 4) ;
switch ( opci r . )
/ * Con el f i n de si mpl i f i car el ej empl o, se supone
case 1: / / al t as
que no se i nt i - od~cen cdi gos r epet i dos */
/ * se t r at a l a excepci hn par a que vr el va a pedi r
el dat o en el caso de que se ; nt r oduzca un
val or no n, xi r i co */
do
er r or = false;
try
Syst em. out . pr i nt ( " cdi go: " 1 ;
cdi go = Shor t . par seshor t ( br . r eadLi ne ( ) ) ;
catch ( Numcer For mat Except i on ne)
Syst em. out . pr i nt l n ( " Vai or no vl ; do "+
er r or = true;
"( ha de ser un nmer o) " ) ;
I
while ( er r or ) ;
Syst em. out . pr ini: ( " nombr e :
nombr e = br . r eai Li ne ( ) ;
do
{
" ) ;
390 Java 2. Manual de Programacin
er r or = false;
try
Syst em. out . pr i nt ( " edad: ' I ) ;
edad = Shor t . par seShor t ( br . r eadLl ne0) ;
catch ( Number For mat Except i on ne)
t
Syst em. out . pr i nt l n( " Val or no vi l do "f
er r or = true;
" ( ha de ser UI nmer o) " ) ;
while ( er r or ) ;
System. out . pr i nt ( " domi ci l i o : " ) ;
domi ci l i o = br . r eadLi ne ( ) ;
Syst em. out . pr i nt ( " t el f ono: ' I ) ;
t el f ono = br . r eadLi ne ( ) ;
1i st a. aadi r (new Empl eado ( cdi go, nombr e, edad,
domi ci l l o, t el f ono) ) ;
cambi os = true;
break;
do
case 2: / / baj as
t
er r or = false;
try
t
Syst em. out . pr i nt ( " Cdi go a borra: : : " ) ;
cdi go = Shor t . par seshor t ( br . r eat l Li ne ( ) ) ;
1
i
catch ( Number For mat Except i on ne)
Syst em. out . pr i nt l n( " Vai or no vl i do "f
er r or = true;
" ( ha de ser un nmer o) " ) ;
!
i
while ( er r or ) ;
el i mi nado = l i ct a. el i ml nar ( cdi go) ;
if ( el i mi nado)
S y s t em. out . p r 1 n t 1 n ( " Reg I c t r o e 1 i mi ri ado " ) ;
cambi os = true;
1
else
if ( l i ct a. l ongi t ud( ) != O)
else
break;
Syst em. out . pr i nt l n ( " No est a" ) ;
Syst em. out . pr i nt l n ( " Li st a vac a" ) ;
Archivos 391
case 3: / / consul t as
do
er r or = false;
try
I
Syst em. out . pr i nt ("Cdi go a buscar : " ) ;
cdi go = L hort. parseChort(br. readl i ne0);
catch ( Number For mat Yxcept i on r e)
t
Cyst em. out . pr i ~t l n ( " Val or no vl i do "+
er r or = true;
" ( ha de ser UT. n, hero) " ) ;
while ( er r or ) ;
posi = l i st a. bi i scar ( cdi go) ;
if ( posi == - 1)
if ( l i st a. l o. i gi t ud0 ! = O)
else
Cyst em. out . pr i nt 13 ( " Regi st r o no encoct zado" ) ;
Cyst em. out . pr i nt l n ( " Li st a vaci a" ) ;
else
l i st a. e: ement o( posi ) . most r ar 0;
break ;
case 4:
while ( opci 6n != 4) ;
catch ( I OExcept i on e)
public static void escr i b; r ( )
t
Obj ect Out put St r eam ous =: null;
/ / si hubo cambi os l os i ' : ; cri be en el archi vo
try
if ( cambi os)
t
out = new Obj ect Out put Ct r eam( new
ous. wr i t e0bj ect ( l i st a) ;
Fi l eOnt put Ct zean( " empr esa. dat " ) ) ;
i
l i st a = null;
catch ( I OExcept i on e)
392 Java 2. Manual de Programacin
t
Cyst em. out . pr i nt i n( " Er r or : " + e. t oSt r i ng( ) ) ;
finally
t
if ( ous != null)
ous. cl ose ( ) ;
catch ( I OExcept i on e)
t i
/ * Cl ase Per sonal de l a empr esa. Obj et o que r epr esent a un
ar r ay de Empl eado */
import l ava. i o. *;
public class Per sonal implements Ser i al i zabl e
private Empl eado[ ] ar r Empl eados;
private int nEl ement os;
public Per sonal ( )
/ / Cr ea' el ar r ay
nEl ement os = O;
ar r Empl eados = i ni ci al i zar ( nE1ement os) ;
private Empl eado[ ] inicializar(int nEl ement os)
t
return new Empl eado [ nEl ement os] ;
catch ( Ou t Of Memor yEr r or e )
I
Syst em. out . pr i nt l n( e. t oSt r i ng( ) ) ;
return ar r Empl eados;
public Empl eado el ement o( i nt i )
if (i >= O && i < nEl ement os)
else
return ar r Empl eados [ i 1 ;
I
Archivos 393
Syst em. out . pr i nt l n (' "3 hay el ement os en esa poSi ci 6Z" ) ;
r et ur n nul l ;
I
1
publ i c i nt l ongi t ud( )
i
1
r et ur n ar r Empl eados. l encj t h;
publ i c voi d aadi r ( Empl eado unEmpl eado)
i
Empl eado [ ] copi aDeLi st a;
// el ar r ay cr ece conf or mse l e van aadi endo nuevos ei ement oc
copi aDeLi st a = ar r Empl eados;
nEl ement os = copi aDeLi si a. l engt h;
ar r Empl eados = i ni ci al i zar ( nEl er nent oc t 1) ;
f or ( i nt i = O; i < nEl er nent os; i ++ j
ar r Er npl eados [ i ] = copLaDeLi st a[ i ] ;
ar r Empl eados[ nEl ement os] = unEmpl eado;
nEl ement os++;
publ i c bool ean el i mi nar ( shor t cod)
{
Empl eado[ ] copi aDeLi st a;
i nt posi = buscar ( cod) ;
i f ( posi ! = - 1)
i
/ / el ar r ay di smi nuye cuando se el i mi nan el ement os
ar r Empl eados [ posi l = nul l ;
cop1 a DeL i s t a = a r r Emp: . eado s ;
i f ( copi aDeLi st a. l engLh ! = O)
i
i nt k = O;
nEl ement os = copi aDeLi st a. l engt h;
ar r Empl eadoc = i ni c i al i zar ( nEl ement os - 1 j ;
for ( i nt i = O; i < nEl ement os; I ++)
i f ( copi aDeLi st a [ i ] != nul l )
ar r Empl eados [ k +t ] = copi aDeLi st a [ i ] ;
nEl ement os- - ;
r et ur n t r ue;
1
1
r et ur n f al se;
}
publ i c i nt buscar ( shor t cod)
i
i nt posi = O;
394 Java 2. Manual de Programacin
i f ( pos1 < nEl ement oc)
f or ( i nt 1 = posi ; I < nEl ement os; I ++)
i f ( ar r Empl eadcc [ i ] . devol ver codi go ( ) == cc d)
r et ur n 1;
r et ur n - 1;
/ / Cl ase Empl eado. Obj et o que r epr esent a un r egi st r o.
i mpor t ; ava. _o. *;
publ i c cl ass Enpl eado i mpl ement s Ser l ai i zabl e
pr i vat e shor t codi go;
pr i vat e shor t edad:
pr i vat e St r i r g nombr e, domi ci l i o, t el ef ono;
publ i c Empl eado ( )
publ i c nmpl eado( shor t cod, St r i nq zom, shor t annos, St r i ng
=om, St r i ng t f no)
I
cdi go = cod;
noxbr e = corn;
edad = annos;
domi ci l i o = dcm;
t el f or o = t f no;
publ i c voi d est abl ecer Cdi go( shor t cod)
i
cci go = cod;
i
publ i c shor t devol ver cdi go ( )
r et ur n cdi go;
i
publ i c voi d est abi ecer Nombr e ( St r i ng nom)
I '
nombr e = nori;
publ i c St r i ng devol ver Nombr e0
r et ur n nombr e;
Archivos 395
public void est abl ecer Edad (short annos)
t
I
edad = annos;
public short devol ver Edad ( )
t
return edad;
public void ect abl ecer Domi ci l i o( St r i ng dom)
i
domi ci l i o = dom;
public St r i ng devol ver Domi ci l i o( )
I
return domi ci 1 i o ;
i
public void est abl ecer Tel Sf ono ( St r i ng t f no)
I
t el f ono = t f no;
1
public St r i ng devol ver l el ' i f ono ( )
i
re turn t ei f ono ;
I
public void most r ar ( )
i
Syst em. out . pr i nt l n ( devol ver Codi go ( ) ) ;
Syst em. out . pr i nt l n ( devo Lver Nombr e ( ) ) ;
Cyst em. out . pr i nt l n ( devo. Lver Edad ( ) ) ;
Syst em. out . pr i nt l n ( devo. . ver Domi ci l i o ( ) ) ;
Syst em. out . pr i nt l n ( devo1- ver Tel f ono ( ) ) ;
I
14.17. ARCHIVOS DIRECTOS
Los registros en un archivo de acceso directo han de ser de longitud fija. En un
archivo directo, el orden fsico de los registros no tiene por qu corresponderse con
aquel en el que han sido introducidos, y los registros son accesibles directamente
mediante la especificacin de un nmero que indica la posicin del registro con res-
pecto al origen del archivo. Los archivos directos, tambin denominados aleatorios,
396 Java 2. Manual de Programacin
se abren para lectura y escritura al mismo tiempo. En J ava RandomllccessFile
es la clase que permite la apertura de archivos de acceso directo y ofrece el mtodo
seek (posi ci n) para el posicionamiento sobre un determinado registro del
srchivo.
Nota: A diferencia de los secuenciales:
Los archivos directos se abren para lectura y escritura al mismo tiempo.
Permiten el posicionamiento sobre un determinado registro, sin que sea
necesario recorrer los anteriores.
14.18. FUNCIONES DE TRANSFORMACIN DE CLAVE
Y TRATAMIENTO DE COLISIONES
Aunque la informacin en un archivo directo puede colocarse simplemente de
forma secuencial, normalmente esto no se hace as, dado que la utilidad fundamen-
tal de los archivos directos es proporcionar un rpido acceso a la informacin. Con
esta finalidad los datos deben situarse de tal manera que puedan ser localizados
rpidamente y, como ste tipo de archivos permite el posicionamiento directo en un
determinado lugar del archivo y el acceso a la informacin en los archivos se suele
efectuar utilizando una clave, la solucin consiste en crear una relacin perfecta-
mente definida entre la clave identificativa de cada registro y la posicin donde se
colocan dichos datos. La clave es un campo del propio registro que lo identifica de
modo nico, por ejemplo el nmero de matrcula de un alumno en el caso de un
archivo que almacenara datos de alumnos o el NIF, nmero de identificacin fiscal,
en el caso de querer guardar informacin sobre los clientes de una empresa. Es pre-
ciso tener en cuenta que, aunque en ocasiones la clave ( x) podr ser utilizada para
obtener la posicin empleando simplemente la frmula mostrada en la Tabla 14.1,
otras veces esto no es posible.
Tabla 14.1. Frmula que en algunas ocasiones se puede aplicar
para transformar la clave en una posicin
Frmula Clave Posicin relativa al
comienzo del Archivo
O
5*t amao r egi st r o
Posi ci or. = (long) ( x- 1) * t amao r egi st r o;
Archivos 397
La citada frmula no se puede utilizar cuando el porcentaje de claves a almace-
nar en el archivo es reducido en comparacin al rango en el que pueden oscilar los
valores de las mismas o cuando las claves son alfanumricas. La solucin en estos
casos es aplicar funciones que transformen las claves a nmeros en el rango conve-
niente, a estas funciones se las denomina funciones de conversin (hash), y luego
usar dichos nmeros en la frmula expuesta. El resultado de dicha frmula hay que
convertirlo a un tipo l ong dado que el argumento de seek es de tipo l ong.
Cuando se aplica una funcin de conversin puede ocurrir que dos registros con
claves diferentes produzcan la misma direccin fsica en el soporte. Se dice enton-
ces que se ha producido una colisin y habr que situar ese registro en una posicin
diferente a la indicada por el algoritmo de conversin. Si esto ocurre, el acceso se
hace ms lento, por lo que resulta importante encontrar una funcin de conversin
que produzca pocas colisiones.
Ejemplo
Imagine que las claves identificativas de los registros que desea almacenar oscilan
entre los valores 1 a 1 O O O O O O, pero la cantidad de registros sobre los cuales se va
tener que guardar informacin slo es 5 O. Segn la frmula de la Tabla 14.1, habra
que disponer de un archivo de tamao
( 1000000- 1) * t amaoRegi st r o
para as poder situar en la posicin adecuada cualquier registro que fuera necesario
almacenar. Este archivo sera demasiado grande y estara en su mayor parte deso-
cupado. Puesto que se sabe que no va a ser necesario guardar ms de 50 registros,
se podra aplicar una funcin de conversin como la siguiente:
x = cl ave % 50; / * di vi di r por un nmer o pr i mo da or i gen
a un menor nmer o de col i si ones, es
deci r de r est os r epet i dos */
que convertira cualquier clave entre 1 y 1000000 en nmeros entre O y 49.
Lgicamente con esta funcin a registros con diferentes claves les puede corres-
ponder el mismo x y, por tanto, la misma posicin.
posi ci n = x * t amaoRegi st r o; / * l a f unci n hash apl i cada
hace i nnecesar i o r est ar
l a x */
Existen muchos tipos de funciones de conversin. La eficiencia de la funcin hush
y el mtodo de resolucin de colisiones se mide por el nmero de comparaciones
de claves necesarias para determinar la posicin en la que se encuentra por fin un
398 Java 2. Manual de Programacin
determinado registro. El tratamiento de las colisiones tambin se puede efectuar de
muy diferentes formas:
Creando una zona especial, denominada zona de excedentes, a la cual se lle-
van exclusivamente esos registros. La zona de desbordamiento, excedentes o
sinnimos podra encontrarse a continuacin de la zona de datos o ser incluso
otro archivo.
Buscando una nueva direccin libre en el mismo espacio donde se estn intro-
duciendo todos los registros, zona de datos, para el registro colisionado. Lo que
se puede hacer mediante diferentes tcnicas, por ejemplo, direccionamiento
abierto y encadenamiento.
- El direccionamiento abierto resuelve las colisiones mediante la bsqueda, en
el mismo espacio donde se estn introduciendo todos los registros (zona de
datos) de la primera posicin libre que siga a aquella donde debiera haber
sido colocado el registro y en la que no se pudo situar por encontrarse ya
ocupada. El archivo se considera circular y cuando se busca sitio para un
registro las primeras posiciones siguen a las ltimas.
- El encadenamiento se basa en la utilizacin de tablas hash que permitan
localizar rpidamente por la clave la posicin donde se ha escrito el archivo
en el disco. Los registros se colocan en el archivo de forma secuencia1
excepto cuando se deseen aprovechar los huecos dejados por las operaciones
de baja.
Ejercicio
Presentar un men de opciones que permita efectuar altas, bajas y consultas en un
archivo directo mediante el mtodo de transformacin de claves. El archivo,
ot r osempl eados. dat , almacenar cdi go, nombr e, edad, domi ci -
l i o y t el f ono de los empleados de una empresa. El campo clave es el cdi go.
El mtodo de transformacin de claves consiste en introducir los registros en el
soporte que los va a contener en la direccin que proporciona el algoritmo de con-
versin. Su utilizacin obliga al almacenamiento del cdi go en el propio registro,
ya que ste no se podr deducir de la posicin, y hace conveniente la inclusin en
el registro de un campo auxiliar, ocupado, en que se marque si el registro est ocu-
pado o no. Se requiere tener en cuenta que cdigos distintos, sometidos al algorit-
mo de conversin pueden proporcionar una misma direccin, por lo que se tendr
previsto un espacio en el disco para el almacenamiento de los registros que han
colisionado. Aunque se puede hacer de diferentes maneras, en este caso se reser-
var espacio para las colisiones en el propio archivo a continuacin de la zona de
datos. Se supondr que la direccin ms alta capaz de proporcionar el algoritmo de
Archivos 399
conversin es FI NDATOS y se colocaran las colisiones que se produzcan a partir de
all en posiciones consecutivas del archivo. La zona de colisiones ser la compren-
dida entre FI NDATOS y MAX; siendo MAX una constante establecida por el progra-
mador que determina el tamao total del archivo y cuyo valor, lgicamente, ser
mayor que FI NDATOS.
Creacin. Cuando se abre el archivo por primera vez se debe realizar un reco-
rrido de todo el archivo inicializando el campo ocupado a un valor vaco, por
ejemplo, a espacio en blanco. La inicializacin a espacio en blanco del campo
ocupado se realiza hasta MAX.
Altas. Para introducir un nuevo registro se aplica al campo cdi go de dicho
nuevo registro el algoritmo de conversin, obteniendo as la posicin donde
debe situarse. Se lee la informacin almacenada en el archivo en dicha posi-
cin y si el campo ocupado indica que dicho lugar est libre el nuevo registro
se sita all; cuando la mencionada posicin no esta libre el nuevo registro se sita
en la primera posicin libre existente en la zona de colisiones.
Consultus. Para localizar un registro se aplicar al cdi go a buscar la funcin
de transformacin de claves y, si no se encuentra en la direccin devuelta por
la funcin, se examinar registro a registro la zona de colisiones. Para decidir
que se ha encontrado habr que comprobar que el registro no est de baja y que
su cdi go coincide con el que se est buscando, en cuyo caso se interrumpi-
r la bsqueda y se mostrar el registro por pantalla.
Bajas. La eliminacin de un registro se efectuar mediante baja lgica y con-
sistir en:
- Localizar el registro buscndolo por su cdigo, primero en la zona direc-
ta y, si all no se encuentra, en la zona de colisiones.
- Una vez localizado eliminar la marca existente en su campo ocupado,
asignando a dicho campo el valor que se interpreta como vaco, y escribir
nuevamente la informacin en el archivo en la posicin donde se encontr.
i mport j ava. i o. *;
publ i c class Ej empl o2
i
publ i c stati c f i nal i nt MAX = 100;
/ / Nmer o mxi mo de r egi st r os
publ i c stati c f i nal i nt FI NDATOS = 15;
/ / Fi n de l a zona de dat os
stati c I nput Ct r ear nReader i sr = new I nput Ct r eamReader
stati c Buf f er edReader br = new Buf f er edReader ( i sr ) ;
stati c Per sonal 2 ar chi vo = nul l ;
( Syst em. i n) ;
400 Java 2. Manual de Programacin
public s t at i c void mai n ( St r i ng [ ] ar gs)
i
try
I
abr i r ( ) ;
oper aci ones ( ) ;
1
catch ( I OExcept i on e)
i:
1
f i nal l y
i
t ry
i
ar chi vo. cer r ar ( ) ;
1
catch ( I OExcept i on e)
i }
Syst em. out . pr i nt l n( " Er r or : " t e. t oSt r i ng( ) ) ;
}
public s t a t i c void abr i r ( ) throws I OExcept i on
1
Empl eado2 unEmpl eado = nul l ;
ar chi vo = new Per sonal 2 ( ) ;
i f ( ar chi vo. l ongi t ud( ) == O)
I
Syst em. out . pr i nt l n ( " Oper aci n de i ni ci al i zaci n" ) ;
unEmpl eado = new Empl eado2 ( ) ;
unEmpl eado. est abl ecer Ocupado( ' I ) ;
f or ( i nt i = O; i < MAX; i t +)
ar chi vo. aadi r ( unEmpl eado) ;
1
else
Syst em. out . pr i nt l n ( " Ar chi vo ya exi st e" ) ;
public s t a t i c void oper aci ones( ) throws I OExcept i on
i:
short opci n = O;
boolean er r or ;
do
i
Syst em. out . pr i nt l n ("MEN") ;
Syst em. out . pr i nt l n ( " 1. Al t as" ) ;
Syst em. out . pr i nt l n ( " 2. Baj as" ) ;
Syst em. out . pr i nt l n ( " 3. Consul t as" ) ;
Syst em. out . pr i nt 1n ( " 4. Fin");
Syst em. out . pr i nt l n( ) ;
Syst em. out . pr i nt ( " EL j a opci n: " ) ;
do
{
er r or = f al se;
try
i
opci n = Shor t . par seShor t ( new Buf f er edReader ( new
I nput St r eamReader ( Syst er n. i n) ) . r eadLi ne( ) ) ;
1
cat ch ( Number For mat Except i on ne)
{
Syst em. out . pr i nt l n ( " Val or no vl i do "+
er r or = t r ue;
" ( ha de ser un nmer o) " ) ;
)
)
whi l e ( opci n < 1 1 1 opci n > 4 1 I er r or ) ;
swi t ch ( opci n)
I
case 1: / / al t as
al t as ( ) ;
break ;
baj as ( ) ;
break ;
consul t as ( ) ;
br eak;
case 2: / / baj as
case 3: / / consul t as
case 4:
1
1
whi l e( opci n != 4) ;
)
publ i c st at i c i nt hash( i nt cdi go)
{
}
r et ur n cdi go % FI NDATOS;
publ i c st at i c voi d al t as ( ) t hr ows I OExcept i on
{
Empl eado2 unEmpl eado = nul l ;
i nt posi = - 1;
shor t cdi go = O;
shor t edad = O;
St r i ng nombr e, domi ci l i o, t el f ono;
bool ean er r or , encont r adoHueco;
char ocupado;
402 Java 2. Manual de Programacin
/ * se t r at a l a excepci n par a que vuel va a peci r el dat o
do
i
en caso de er r or */
er r or = false;
try
Syst em. out . pr i nt ( " cdi go: ' I ) ;
cdi go = Shor t . par seshor t ( br . r eadLi ne ( ) ) ;
I
catch ( Number For mat Except i on ne)
i
Syst em. out . pr i nt l n ( " Val or no vl i do "+
er r or = true;
" ( ha de ser un nmer o) " ) ;
1
while ( er r or ) ;
/ * se compr ueba si est l i br e l a posi ci n cor r espondi ent e
posi = hash ( cdi go) ;
unEmpl eado = ar chi vo. el ement o( posi ) ;
encont r adoHueco = false;
/ / si no est l i br e se busca hueco en l a zona dc? col i si ones
if ( unEmpl eado. devol ver Ocupado ( ) == ' * ' )
en l a zona de dat os */
t
posi = FI NDATOS - 1;
while ( posi < MAX- 1 && ! encont r adoHueco)
I
posi = posi + 1;
unEmpl eado = ar chi vo. el ement o ( posi ) ;
if ( unEmpl eado. devol ver Ocupado ( ) ! =
' * ' )
encont r adoHueco = true;
1
i
else
if ( encont r adoHueco)
i
encont r adoHueco = true;
/ / Leer ot r os campos
Syst em. out . pr i nt ( " nombr e: ' I ) ;
nombr e = br . r eadLi ne ( ) ;
do
i
er r or = false;
try
I
Syst em. out . pr i nt ( " edad: ' I ) ;
edad = Shor t . par seShor t ( br . r eadLi ne( ) ) ;
1
Archivos 403
catch ( Number For mzl t Except i on ne)
!
Syst em. out . pr i nt : l n ( " Val or no vl i do "+
er r or = true;
" ( ha de ser un nmer o) " ) ;
1
i
while ( er r or ) ;
Syst em. out . pr i nt ( " domi ci l i o: " ) ;
domi ci l i o = br . r ead1, i ne ( ) ;
Syst em. out . pr i nt ( " t el f ono: " ) ;
t el f ono = br . r eadLi ne0 ;
ocupado = I * ' ; / / s e mar ca como ocupado
/ * se escr i be en l a posi ci n posi que puede per t enecer
ar chi vo . poner el ement o ( posi , new Empl eado2 ( cdi go, nombr e,
edad, domi ci l i o, t el f ono, ocupado) ) ;
a l a zona de dat' 3. s o a l a de col i si ones */
1
1
public static voi d baj as ( ) throws I OExcept i on
Empl eado2 unEmpl eado = null;
int posi = - 1;
short cdi go = O;
boolean er r or , el i mi nado, encont r ado;
do
i
er r or = false;
try
!
Syst em. out . pr i nt ( " Cdi go a bor r ar : " ) ;
cdi go = Shor t . par seshor t ( br . r eadLi ne ( ) ) ;
i
catch ( Number F0r mat E: xcept i on ne)
i
Syst em. out . pr i nt l r i ( " Val or no vl i do "+
er r or = true;
" ( ha de ser un nmer o) " ) ;
1
i
while ( er r or ) ;
/ / se busca en l a zona de dat os
posi = hash ( cdi go) ;
unEmpl eado = ar chi vo. el ement o ( posi ) ;
encont r ado = false;
if ( unEmpl eado. devol ver Ocupado( ) ==' *'
&& unEmpl eado. devol ver Cdi go ( ) == cdi go)
else
i
encont r ado = true;
404 Java 2. Manual de Programacin
/ * si no se encont r en l a zona de dat os se r ecor r e
secuenci al ment e l a de col i si ones par a i nt ent ar
encont r ar l o */
posi = FI NDATOC - 1 ;
while ( posi < MAX- 1 && ! encont r ado)
t
posi = posi + 1;
unEmpl eado = ar chi vo. el ement o ( posi ) ;
if ( unEmpl eado. devol ver Ocupado ( ) == * '
&& unEmpl eado . devol ver Cdi go ( ) == cdi go)
encont r ado = true;
1
1
if ( ! encont r ado)
else
i
Syst em. out . pr i nt l n ( " No est a" ) ;
/ / se mar ca como l i br e
unEmpl eado. est abl ecer Ocupado( ' I ) ;
/ / se escr i be en l a posi ci n adecuada
ar chi vo. poner el ement o( posi , unEmpl eado) ;
1
public static void consul t as ( ) throws I OExcept i on
{
Empl eado2 unEmpl eado = null;
int posi = - 1;
short cdi go = O ;
boolean encont r ado, er r or ;
do
(
er r or = false;
try
(
Cyst em. out . pr i nt ( " I nt r oduzca el cdi go a buscar " ) ;
cdi go = Shor t . par seShor t ( br . r eadLi ne( ) ) ;
}
catch ( Number For mat Except i on ne)
I
Cyst em. out . pr i nt l n ( " Val or no vl i do "t
er r or = true;
" ( ha de ser un nmer o) " ) ;
1
1
while ( er r or ) ;
/ / se busca el cdi go en l a zona de dat os
posi = hash ( cdi go) ;
unEmpl eado = ar chi vo. el ement o ( posi ) ;
encont r ado = false;
Archivos 405
i f ( nEmpl eado. devol ver OcJ pado ( ) == ' * '
& & unEmpl eado. devol ver Codi go ( 1 == codi go)
else
encont r ado = true;
t
/ * si n3 se encuent r i en l a zor Aa ce dat os se r ecor r e
encont r ado = f a l s e ;
whi l e ( POSI < MAX- 1 & & ! encont r ado)
l a de col i si ones par a i nt ept ar 1ocal ; zar l o "/
pos1 = FI NDATOS - 1;
I
posi = posi t I ;
UnEmpl eado = ar chi . i o. ei ement o ( posi ) ;
i f ( unEmpl eado . devol ver Ocupado ( ) == ' * '
&& unEmpl eado. devo. . ver Cdi go ( ) == cdi go)
encont r ado = true;
1
1
i f ( ! encont r ado)
else
Syst em. out . pr i nt l n ( " No est " ) ;
unEmpl eado. most r ar 0;
I
/ / Cl ase Per sonal 2, per sonal de l a empr esa.
import j ava. i o. *;
publ i c c l as s Per sonal 2
i
pri vat e RandomAccessFi l e r af = nul l ;
pri vat e i n t nEl ement os;
pri vat e i n t l ongReg = 102;
/ / r egi st r os de l ongi t ud f i j a, no se per mi t e que excedan l ongReg
publ i c Per sonal 2 ( ) throws I OExcept i on
i
Fi l e ar ch = new Fi l e ( " ct r osempl eados. dat " ) ;
/ / se abr e par a l ect ur a/ escr i t ur a
r af = new RandomAccessFi l e ( ar ch, " r w" ) ;
nEl ement os = t h i s . l ongi t ud ( ) ;
i
publ i c voi d aadi r ( Empl eado2 obj ) throws I OExcept i on
i
/ * se ut i l i za par a i ni ci al i zar el ar chi vo, escr i bi endo un
det er mi nado nmer o de r egi st r os con el campo ocupado a
espaci o en bl anco.
El ar chi vo cr ece cor f or me se l e van aadi endo nuevos
el ement os.
406 Java 2. Manual de Programacin
x /
nZ 1 eme P.t o s t +;
poner e; ement o( nEl ement os, obj ) ;
publ i c voi d poner el ement o ( i nt 1, Empl eado2 unEmp . eado )
throws I CExcept i on
i f ( 1- I >= O & & 1- 1 < nEl ement os)
/ * En el f or mat o UTF- 8 l os dos pr i mer os byt es i ndi can
el numer o de byt es que han de ser l e dos a cont i -
nuar - on par a f or mar l a cadena, como se escr i ben 3
cadenas en est e f or mat o se suman 6 byt es al t amao
de l os campos de dat os de unEmpl eado */
/ / posi ci onami ent o en el l ugar adecuado
r af . seeK( (l ong) ( 1- 1) * l ongReg) ;
r af . wr i t eShor t ( unEmpl eado. devol ver Cdi go( ) ) ;
r af . wr i t eUTF( unEmpl eado. devol ver Nombr e( ) ) ;
r af . wr i t eShor t ( unEmpl eado. devol ver Edad( ) ) ;
r af . wr i t eUTF( unEmpl eado. devol ver Domi ci l i o0 ) ;
r af . wr i t eUTF( j nEmpl eado. devol ver Tel f ono( ) i ;
r af . wr i t eChar ( unEmpl eado. devol ver Ocupado( ) i ;
1
else
Syst em. out . pr i nt l n ( " unEmpl eado demasi ado gr ande" ) ;
Cyst em. out . pr i nt l n ( " No se puede poner en esa posi ci n" ) ;
else
publ i c Empl eado2 el ement o ( i nt i ) throws I OExcept Lon
lL
i f ( i - 1 >= O && i - 1 < nEl ement oc)
t
/ / posi ci onami ent o de nuevo
r af . seek ( (l ong) ( 1- 1) * l ongReg) ;
short codi go = r af . r eadshor t ( ) ;
St r i ng nombr e = r af . r eadUTF0;
shor t edad = r af . r eadShor t ( ) ;
St r i ng domi ci l i o = r af . r eadUTF0;
St r i ng t el f ono = r af . r eadUTF0;
char ocupado = r af . r eadChar 0;
return new Empl eado2 ( codi go, nombr e, edad, domi ci l i o,
t el f ono, ocupado) ;
1
else
i
Syst em. out . pr i nt l n ( " No hay el ement os en esa posi ci n" ) ;
return nul l ;
Archivos 407
publ i c i nt l ongi t ud ( ) throws I OExcept i on
return ( i nt) Mat h. cei l ( (double) r af . l engt h ( ) / 1or gReg) ;
publ i c void cer r ar ( ) throws I OExcept i on
if ( r af ! = nul l )
r af . cl ose ( ) ;
I
i
/ / Cl ase Empl eado2. Obj et o que r epr esent a un r egi st r o
import j ava. i o. *;
publ i c cl ass Empl eado2
i
/ / campo cl ave
pri vate shor t cdi go;
pri vate shor t edad;
pri vate St r i ng nombr e, domi c i 1 i o, t el f ono ;
/ / campo par a ef ect uar b31as l gi cas, por mar ca
pri vate char ocupado;
publ i c Empl eado2 ( )
i
cdi go = O;
edad = O;
nombr e = "";
domi ci l i o = "";
t el f ono = " ' I ;
oc; i pado = ' ' ;
/ / cadena nul a
/ *espaci o en bl anco mar ca e-
r egi st r o como vaci o */
publ i c Empl eado2 (short cod, St r i ng nom, short annos, St r 1r . g
dom, St r i ng t f no, char m3r ca)
I
cdi go = cod;
nombr e = nom;
edad = annos;
domi ci l i o = dom;
t el f ono = t f no;
ocupado = mar ca;
i
publ i c long t amao ( )
i
/ * t amao que ocupan l os campos de dat os. Un shor t ocspa 2
byt es.
Se ut i l i za par a ver si el t amao es per mi t i do y no se
excede l a 1ongReg est abl eci da */
return 2 + nombr e. l engt h( ) * 2 + 2 + domi ci l i o. l engt h( ) *Z
+ t el f ono. l engt k, ( ) * 2 + 2;
1
408 Java 2. Manual de Programacin
publ i c voi d est abl ecer Ocupado ( char mar ca)
ocupado = mar ca;
publ i c char devol ver ocupado ( )
r et ur n ocupado;
publ i c voi d est abl ecer Cdi go( shor t cod)
cdi go = cod;
publ i c shor t devol ver cdi go ( )
r et ur n cdi go;
I
publ i c voi d est abl ecer Nombr e( St r 1ng nom)
nombr e = nom;
1
publ i c St r i ng devol ver Nombr e( )
r et ur n nombr e;
1
publ i c voi d est abl ecer Edad( sh0r t annos)
I
edad = annos;
publ i c shor t devol ver Edad0
r et ur n edad;
publ i c voi d est ab?ecer Domi ci l i o( St r i ng dorn)
1
domi ci l i o = dom;
1
publ i c St r i ng devol ver Domi ci l i o( )
i
r et ur n dorn; ci l l o;
publ i c voi d est abl ecer Tel ef ono( Ct r i ng t f no)
t el kf onc = tf no;
Archivos 409
public St r i ng devol ver Tel ef ono( )
I
return t el f ono;
I
public void most r ar ( )
I
Syst em. out . pr i nt l n( devol ver Cdi go( ) ) ;
Syst em. out . pr i nt l n( devol ver Nombr e( ) ) ;
Syst em. out . pr i nt l n devol ver Edad0) ;
Syst em. out . pr i nt l n devol ver Domi ci l i o( ) ) ;
Syst em. out . pr i nt l n devol ver Tel ef ono( ) ) ;
1
CA 15
Estructuras de datos
definidas por
el programador
CONTENIDO
15.1. Listas.
15.2. Implementacin de una lista.
15.3. Lista ordenada.
15.4. Listas genricas y uso de interfaces.
15.5. Listas doblemente enlazadas.
15.6. Pilas.
15.7. Colas.
15.8. Colas circulares.
rn 41 1
41 2 Java 2. Manual de programacin
J ava, como los restantes lenguajes de programacin, suministra
una serie de tipos de datos bsicos y una serie de operaciones
para su manipulacin. En ocasiones, estos tipos de datos no son
los adecuados para resolver un problema y es necesario crear
nuevos tipos de datos, que ser preciso definir especificando tanto
sus datos componentes como las operaciones que los manipulan.
Estos tipos de datos se definen mediante clases y proporcionan
una de las caractersticas ms importantes de la PO0 (Pro-
gramacin Orientada a Objetos), la reutilizacin de componentes.
Las colecciones de datos organizados y a las que se accede de
forma perfectamente definida constituyen una estructura de datos.
Existe un cierto nmero de estructuras de datos de reconocida uti-
lidad, cuyo uso se repite frecuentemente en los programas, y que
pueden llegar a considerarse como una extensin de los tipos
bsicos del lenguaje; estas estructuras tienen un nombre y unas
caractersticas establecidas y entre ellas destacan: listas, pilas,
colas, rboles y grabs. Las tres primeras son estructuras de datos
lineales, puesto que en ellas cada elemento tiene un nico prede-
cesor y un nico sucesor, mientras que las dos ltimas son estruc-
turas no lineales. En este captulo se describen estructuras de
datos lineales, ya que las estructuras de datos no lineales quedan
fuera de los objetivos de este libro.
Dada la importancia de las estructuras de datos, J ava ofrece
clases que implementan algunas de ellas: j ava. ut i 1 . vect or ,
j ava. ut i l . St ack, j ava. ut i l . Hast abl e, j ava. ut i l . Bi t Set .
15.1. LISTAS
Una lista es una secuencia de elementos del mismo tipo o clase almacenados en me-
moria. Las listas son estructuras lineales, donde cada elemento de la lista, excepto el
primero, tiene un nico predecesor y cada elemento de la lista, excepto el ltimo, tiene
un nico sucesor. El nmero de elementos de una lista se denomina longitud. En una
lista es posible aadir nuevos elementos o suprimirlos en cualquier posicin.
Existen dos tipos de listas: contiguas y enlazadas. En una lista contigua los ele-
mentos son adyacentes en la memoria de la computadora y tienen unos lmites,
izquierdo y derecho, que no pueden ser rebasados cuando se aade un nuevo ele-
mento. Se implementan a travs de arrays. En este tipo de listas la insercin o eli-
minacin de un elemento, excepto en la cabecera o final de la lista necesitar una
traslacin de parte de los elementos de la misma (Fig. 15.1). Una lista enlazada se
caracteriza porque los elementos se almacenan en posiciones de memoria que no
son contiguas (adyacentes), por lo que cada elemento necesita almacenar la refe-
rencia al siguiente elemento de la lista.
Estructuras de datos definidas por el programador 41 3
Las listas enlazadas son mucho ms flexibles y potentes que las listas contiguas
y, en ellas, la insercin o eliminacin (supresin) de un elemento no requiere el des-
plazamiento de otros elementos de la misma.
Las listas enlazadas (Fig. 15.3) se suelen construir vinculando nodos (objetos
que contienen al menos un miembro que es una referencia a otro objeto de su mismo
tipo, Fig. 15.2). Esta forma de organizacin resulta la ms adecuada si el nmero de
elementos a almacenar en un momento dado es impredecible. Si se utiliza un array
para almacenar una serie o coleccin de elementos; en el caso de que el nmero de
elementos exceda el tamao establecido para el citado array en el momento de su
creacin, los nuevos elementos no se podrn almacenar en dicho array y la posible
solucin ser la creacin de un nuevo array de las dimensiones adecuadas y el tras-
paso de la informacin del viejo al nuevo array. Se ha de tener en cuenta que la clase
Vect or de J ava permite crear estructuras de datos de tipo array de objetos redi-
mensionables durante la ejecucin de un programa. En el caso de utilizar nodos vin-
culados para almacenar la informacin, stos se crean y destruyen conforme se
requieran, de esta manera la lista aumenta o disminuye de tamao dinmicamente y
slo se llena cuando se agota la memoria disponible. El acceso a la lista se realiza
mediante una referencia al primer nodo de la misma y, para marcar su fin, se esta-
blece la referencia de enlace del ltimo nodo a nul l .
LLongitud Vacos Lmite
de la lista superior
Lmite
inferior
Figura 15.1. Lista contigua.
public clas Nodo
I
Obj ect i nf o;
Nodo si g;
Nodo ( Obj ect i nf or maci n, Nodo si gui ent e)
(
1
i nf o = i nf or maci n;
si g = si gui ent e;
I
Figura 15.2. Nodo.
41 4 Java 2. Manual de programacin
i nf o si g
I
-+i nf o si g -+
I
Fi gura 15.3. Lista enlazada.
xi
Las listas enlazadas se clasifican a su vez en tres tipos: circulares, doblemente
enlazadas y doblemente enlazadas circulares.
xi
Circulares. El ltimo elemento referencia al primero de la lista (Fig. 15.4).
f i n
Fi gura 15.4. Lista enlazada circular.
Doblemente enlazadas. Su recorrido puede realizarse tanto desde f r ent e a
f i nal como desde f i nal a f r ent e. Cada nodo de dichas listas consta de un
miembro con informacin y otros dos que referencian objetos de su mismo tipo
(ant y si g), uno para referenciar al nodo sucesor y otro al predecesor (Fig. 15.5).
7
~~
t i na1
f r ent e
I I
xrl
Fi gura 15.5. Lista doblemente enlazada.
Listas doblemente enlazadas circulares. En este tipo de listas el miembro ant
del primer nodo de la lista referencia, o apunta, al ltimo nodo y el miembro si g
del ltimo nodo al primero (Fig. 15.6).
Estructuras de datos definidas por el programador 41 5
i ni ci o
Figura 15.6. Lista doblemente enlazada circular.
Resumen: Una lista enlazada se caracteriza porque los elementos se almace-
nan en posiciones de memoria que no son contiguas o adyacentes. Cada ele-
mento necesita almacenar al menos una referencia al siguiente elemento de la
lista. En una lista enlazada la insercin o eliminacin (supresin) de un ele-
mento no requiere el desplazamiento de otros elementos de la misma.
Importante: Una lista enlazada que se implementa vinculando nodos aumen-
ta y disminuye de tamao dinmicamente.
I
15.2. IMPLEMENTACIN DE UNA LISTA
Los mtodos bsicos que necesitara implementar una lista son los especificados en
la clase Li st a:
El constructor Li st a crea una lista vaca asignando el valor nul 1 al miem-
bro privado inicio que contiene la referencia al primer nodo de la lista.
El mtodo vaci a determina si la lista esta vaca comprobando si la referen-
cia al primer nodo de la lista es nul l . Devuelve t r ue cuando la lista est
vaca y f a 1 se en caso contrario.
El mtodo i nser t ar pr i nci pi o crea un nuevo nodo donde almacena una
referencia al objeto que recibe como parmetro y otra al i ni ci o de la lista,
por ltimo asigna a i ni ci o el nuevo nodo y convirtindolo as en el primer
elemento de la lista.
El mtodo bor r ar pr i nci pi o guarda en auxi la referencia al primer nodo
de la lista, y quita ste nodo de la lista, asignando a i ni ci o la referencia al
siguiente nodo de la lista, contenida en i ni ci o. si g; por ltimo, devuelve
la referencia al nodo que se ha quitado (auxi ).
41 6 Java 2. Manual de programacin
public class Li st a
i
private Nodo i ni ci o;
Li st a ( )
i
i ni ci o = null;
public boolean vac a ( )
(
1
return ( i ni ci o == null) ;
public void i nser t ar Pr i nci pi o( 0bj ect el ement o)
Nodo nuevoNodo = new Nodo ( el ement o, i ni ci o) ;
i ni ci o = nuevoNodo;
}
public Nodo bor r ar Pr i nci pi o0
(
if ( vac a ( ) )
t
return null;
1
else
I
Nodo auxi = i ni ci o;
i ni ci o = i ni ci o. si g;
return ( auxi ) ;
I
1
public void most r ar Li st a ( )
i
Nodo act ual = i ni ci o;
while ( act ual != null)
(
act ual . r nost r ar Nodo0;
act ual = act ual . si g;
1
I
public class Nodo
i
public Obj ect i nf o;
public Nodo si g;
Estructuras de datos defi ni das por el programador 41 7
public Nodo ( Obj ect i nf or maci n, Nodo si gui ent e)
I
i nf o = i nf or maci n;
si g = si gui ent e;
1
public void most r ar Nodo ( )
t
1
Syst em. out . pr i nt l n( i nf o) ;
}
public class Pr ueba
I
public static void mai n ( St r i ng[ ] ar gs)
t
Li st a unaLi st a = new Li st a ( ) ;
unaLi st a. i nser t ar Pr i nci pi o( new I nt eger ( 1) ) ;
unaLi st a. i nser t ar Pr i nci pi o( new I nt eger ( 2) ) ;
unaLi st a. most r ar Li st a( ) ;
while ( ! unaLi st a. vac a( ) )
I
Nodo unNodo = unaLi st a. bor r ar Pr i nci pi o0;
unNodo. most r ar Nodo0;
1
unaLi st a. most r ar Li st a( ) ;
1
En la implementacin expuesta, la insercin de un nuevo elemento se efecta
siempre por el principio de la lista y la supresin tambin. En muchas ocasiones
esta situacin no es la deseada, y lo que se desea es buscar o suprimir un ele-
mento determinado. Estas acciones requieren aadir mtodos que permitan la
bsqueda y el borrado de elementos con un determinado valor en un campo de
datos clave.
15.3. LISTA ORDENADA
Una lista est ordenada cuando sus elementos estn organizados, en orden cre-
ciente o decreciente, por el contenido de uno de sus campos de datos. Para que
una lista resulte ordenada es probable que la insercin de nuevos elementos
requiera colocarlos en posiciones intermedias de la misma (Fig. 15.7). Las listas
enlazadas realizan este tipo de inserciones ms eficientemente que las contiguas,
al no ser necesario para insertar un nuevo elemento desplazar ningn otro de la
lista. Tambin resultan ms rpidas las operaciones de supresin de elementos en
posiciones intermedias mediante el empleo de este tipo de listas (Fig. 15.8).
41 8 Java 2. Manual de programacin
i nf o s i g
I
i ni ci o
...... *
........
--c i nf o si g --+ i nf o si g -+
I I
x
I
i nf o si g
i
L .t
........
I I
-+i nf o si g -+i nf o si g --+
I x2 I
xi
I
Xi X3
nul l
I xn I
Fi gura 15.7. Insercin de un nuevo elemento en una posicin intermedia de la lista.
i ni ci o ............................................
Fi gura 15.8. Supresin de un elemento en una posicin intermedia de la lista.
< . ,
l nl Cl O .................. ~
I
- 1 I / I r I
Fi gura 15.9. Supresin del primer elemento de la lista en una lista
con varios elementos.
Estructuras de datos definidas por el programador 41 9
, . .
l nl CI O .........................
Figura 15.10. Supresin del primer elemento de la lista
en una lista con un nico elemento.
La clase Li s t aor denada muestra las operaciones bsicas para necesarias para
trabajar con una lista encadenada ordenada construida mediante vinculacin de
nodos. Estas operaciones san:
El constructor Li st aor denada crea una lista vaca, asignando el valor
nul l al miembro privado i ni ci o que contiene la referencia al primer
nodo de la lista.
El mtodo vaci a comprueba el valor de i ni ci o y devuelve t r ue cuando
la lista est vaca, es decir, cuando la referencia al primer nodo es nul l . y
f al se en caso contrario.
El mtodo i nser t ar crea un nuevo nodo de la clase Nodo2, capaz de alma-
cenar un entero, una cadena y la referencia a otro objeto de su misma clase, y
almacena en dicho nodo la cl ave y el nombre a i nser t ar . El mtodo utili-
za una variable de la clase Nodo2 para recorrer la lista hasta que esta se acabe
o encontrar un elemento con cl ave menor o igual al que se desea insertar. En
otra variable, ant er i or , de la clase Nodo2 guarda en todo momento la refe-
rencia al elemento anterior al que en ese momento est siendo visitado. Cuando
termina el recorrido inserta el nuevo nodo a contiuacin del ant er i or . Si el
ant er i or es nul l , puede significar que la lista est vaca o que la clave del
primer elemento de la misma es menor o igual a la del nuevo y, en ambos casos,
dicho nuevo elemento ha de situarse al comienzo de la lista.
El mtodo bor r ar intenta suprimir de la lista un elemento cuyo campo
cl ave almacena un determinado valor. Para ello, recorre la lista buscando el
elemento, de forma anloga a la indicada para la i nser ci n, empleando
tambin las variables act ual y ant er i or . Si encuentra el elemento y es el
primero, hace que i ni ci o referencie al siguiente nodo de la lista, mientras
que si lo encuentra en cualquier otra posicin, lo que hace es que el campo
si g del elemento ant er i or referencie al elemento siguiente ( act ual . ci g).
El mtodo most r ar Li st a utiliza la variable act ual para efectuar un recorri-
do de la lista y presentar la informacin almacenada en cada uno de sus nodos.
420 Java 2. Manual de programacin
/ / l i st a or denada descendent ement e
public class Li st aor denada
i
private Nodo2 i ni ci o;
Li st aor denada ( )
i
1
i ni ci o = null;
public boolean vac a ( )
return ( i ni ci o == null) ;
1
public void i nser t ar (int cl ave, St r i ng nombr e)
i
Nodo2 nuevoNodo = new Nodo2 ( cl ave, nombr e) ;
Nodo2 ant er i or = null;
Nodo2 act ual = i ni ci o;
boolean pasado = false;
/* r ecor r e l a l i st a hast a encont r ar un el ement o con cl ave menor
while ( act ual != null && ! pasado)
i
o i gual al que se desea i nser t ar */
if ( cl ave < act ual . cl ave)
i
ant er i or = act ual ;
act ual = act ual . si g;
1
else
pasado = true;
I
/ * i nser t a el nuevo el ement o a cont i nuaci n de ant er i or ,
si el ant er i or er a nul l si gni f i ca que ha de i nser t ar se
al comi enzo de l a l i st a */
if ( ant er i or == null)
i ni ci o = nuevoNodo;
else
ant er i or . si g = nuevoNodo;
nuevoNodo. si g = act ual ;
i
public Nodo2 bor r ar (int cl ave)
i
Nodo2 ant er i or = null;
Nodo2 act ual = i ni ci o;
boolean encont r ado = false;
/ / se r ecor r e l a l i st a buscando el el ement o
while ( act ual != null && ! encont r ado)
i
Estructuras de datos definidas por el programador 421
if ( cl ave == act ual . cl ave)
else
encont r ado = true;
I
ant er i or = act ual ;
act ual = act ual . si g;
I
1
/ / si se encuent r a se bor r a
if ( encont r ado)
/ * si es el pr i mer o se hace que i ni ci o r ef er enci e al
si gui ent e el ement o de l a l i st a, si no l o que se
hace es que el campo si g del el ement o ant er i or
r ef er enci e al el ement o si gui ent e */
if ( ant er i or == null)
else
return ( act ual ) ;
i ni ci o = act ual . si g;
ant er i or . si g = act ual . si g;
i
return null;
public void buscar (int cl ave)
1
Nodo2 ant er i or = null;
Nodo2 act ual = i ni ci o;
boolean er . cont r ado = false;
/ / se r ecor r e l a
while ( act ual !
i
if ( cl ave ==
encont r ado
else
!
ant er i or =
l i st a buscando el el ement o con di cha cl ave
= nuii && ! encont r ado)
act ual . cl ave)
= true;
act ual ;
act ual = act ual . si g;
1
/ / si se encuent r a se muest r a
if ( encont r ado)
else
act ual . most r ar Nodo0 ;
Syst em. out . pr i nt l n ( No est a) ;
1
public void most r ar l i st a 0
i
Nodo2 act ual = i ni Ci 0;
while ( act ual != null)
422 Java 2. Manual de programacin
act ual . most r ar Noao( ) ;
act ual = act ual . si g;
public class Nodo2
public int cl ave;
public St r i ng noml sr e;
public n'odo2 sig;
public Nodo2(int cl , St r i ng n)
cl ave = cl ;
nombr e = n;
sl g = null;
public void most r ar Nodo ( )
Cyst er . out . pr i nt l n ( " Cl ave: "- cl ave+" Nombr e " +nombr e) ;
I
public class Pr ~eba2
i
public static void mai n ( Ct r i nq I ] ar gs)
Li st aor denada unai i sta = new Li s t aOr denadaO;
ur . aLi st a. i nser t ar ( 4, " Pedr o" ) ;
unaUi ct a. i nser t ar ( 1, " Lui s" ) ;
unaLi st a. i nser t ar ( 8, " Tomas" ) ;
; naLi st a. most r ar Li st a( ) ;
/ / . * .
15.4. LISTAS GENRICAS Y USO DE INTERFACES
A diferencia de la clase Li st a, la clase Li st aor denada creada en el apartado
anterior es demasiado especfica, ya que slo puede almacenar un tipo entero y una
cadena. Para arreglar situaciones como sta y que una lista pueda almacenar datos
de cualquier clase, los mtodos de la lista debern trabajar con la superclase
Ob] ec t . Esta estructura permitir, siempre que se efecten las conversiones ade-
cuadas, utilizar la lista para almacenar objetos de distinta clase. Se ha de tener pre-
Estructuras de datos definidas por el programador 423
sente que J ava convierte implcitamente una referencia a un objeto de una subclase
en una referencia a su superclase y tambin que es conveniente que en un objeto
listu slo se almacenen datos homogneos, de una misma clase.
En la clase L i s t aor denada, se requiere en ocasiones efectuar comparaciones;
por ejemplo, para encontrar un determinado elemento en una lista, dado que las lis-
tas genricas pueden almacenar toda clase de objetos, debe dejarse a los tipos de
datos la iinpleinentacin de los mtodos de comparacin. Como ya se ha comenta-
do en ocasiones anteriores, esta caracterstica se consigue definiendo una interfaz,
Compar abl e y declarando la informacin almacenada en el nodo, en lugar de per-
teneciente a la clase Obj ect , como perteneciente a la interfaz Compar abl e. As,
para construir una L i s t aOdenadaGener i ca y utilizarla para almacenar en ella
una serie de libros ordenados por el ISBN se requiere:
Definir la interfaz de comparacin; en este caso, concebida para admitir varios
criterios de ordenacin.
interface ComFar abLe
{
boolean mencr que ( Co- , par abl e c, int cr: t eri c) throws Except i un;
Declarar Compar abl e el campo de datos del nodo, i nf .
/ / Ncdo compar abl e
public class Nodo3
private Compar abl e i nf ;
private Ku'ado3 si g;
Nodo3 ( compar abl e i nf or maci n, Ncdo3 si gu- ent e)
i nf = i nf or maci cn;
ci g = si gui ent e;
. . .
1
Disear la lista de forma que sus intodoc trabajen con Compar abl e.
/ / Li st a enl azada or denada est andar par a Coppar abl es
public class L- st aCdeoadaSener i ca
I
private int cri teri o;
424 Java 2. Manual de programacin
private Nod03 pr i mer o;
Li st aOdenadaGener i ca( i nt cr i t er i o)
i
pr i mer o = null;
t hi s. cr i t er i o = cr i t er i o;
i
/ / . . .
public void i nser t ar ( Compar ab1e el ement o) throws Except i on
i
1
/ / . . .
public Compar abl e obt ener ( Compar ab1e el ement o) throws Except i on
t
/ / . . .
1
//. . .
Hacer que los tipos de datos a colocar en la lista implementen los mtodos de
comparacin. As, para construir una lista de libros ordenada por ISBN, la
clase Li br o debe implementar el mtodo menor que.
class Li br o implements Compar abl e
i
private St r i ng aut or ;
private St r i ng t i t ul o;
private long I SBN;
public Li br o( St r i ng a, St r i ng t , long i )
t
aut or = a;
t i t ul o = t ;
I SBN = i ;
1
public booiean menor que( Compar ab1e c, int cr i t er i o) t hrows Except i on
{
Estructuras de datos definidas por el programador 425
if ( ! ( c instanceof Libro) )
t
throw new Exception ("Error de comparacin") ;
i
return( ( (Libro) c) .ISBN < ISBN) ;
1
public String devolverAutor ( )
t
return (autor) ;
I
public String devolverTitulo ( 1
(
return(titu1o) ;
i
public long devolverISBN ( )
I
1
return (ISBN) ;
jercicio
Disear una clase ListadeLibros, que permita efectuar la gestin de una
biblioteca.
La clase Lis tadeLibros representa un array unidimensional cuyos elemen-
tos son listas enlazadas ordenadas de la clase ListaOrdenadaGenerica y ten-
dr mtodos para efectuar el almacenamiento, recuperacin y eliminacin de los
libros. Los libros se almacenan por inicial de ttulo e ISBN. La inicial del ttulo
( a - z ) determina la posicin en el array unidimensional donde ser colocado
el libro. Como cada elemento del array es una ListaOrdenadaGenerica, los
libros que comiencen por la misma inicial sern situados en la correspondiente lista
enlazada ordenados por ISBN.
426 Java 2. Manual de programacin
z
Figura 15.11. La clase Li st a enl azada.
Los aspectos ms importantes en cuanto a genericidad de la clase
Li st aOrdenadaGeneri ca acaban de ser comentados, ya que esta clase ha sido
puesta como ejemplo para exponer las caractersticas de las listas genricas. Por otra
parte, Li st aOr denadaGener i ca es una lista ordenada y los mtodos
est al i aci a, i nser t ar y el i mi na funcionan de manera similar a los ya expli-
cados ( vaci a, i nser t ar y bor r ar ) de la clase Li st aor denada, excepto por
el empleo del mtodo menor que, en lugar de un operador relacional, para efectuar
las comparaciones entre los elementos de la lista y el elemento a insertar o eliminar.
Otros detalles se especifican en el cdigo como comentarios.
Como Li st adeLi br os representa un array cuyos elementos pertenecen a la
clase Li st aOr denadaGener i ca, su constructor crea e inicializa el array, cre-
ando cada uno de sus objetos, de la clase Li st aOr denadaGener i ca. El mto-
do guar dar : 1) llama al mtodo 1 i s t a y le pasa como parmetro el ttulo del
libro, para que lista determine por la inicial del ttulo la posicin en el array de la
lista donde el libro debe ser insertado; 2) invoca al mtodo i nser t ar de
Li s t aOr denadaGener i ca para que efecte la insercin. Los mtodos r ecuper ar
y el i mi nar tambin recurren a l i st a para determinar la posicin en el array de
la lista donde el libro a consultar o suprimir debe encontrarse situado; la diferen-
cia entre ambos es que r ecuper ar una vez localizada la lista llama a obt ener para
que encuentre el elemento dentro de la misma, mientras el i mi nar llama a el i -
mi na para que suprima dicho elemento de la lista.
Estructuras de datos definidas por el programador 427
Otras clases e interfaces implementadas son:
NOd03. Clase de los nodos de la Li st aOr denadaGener i ca.
Li br o. Clase que implementa la interfaz Compar abl e.
Compar abl e. Interfaz de comparacin.
NoEst a. Excepcin general de bsqueda.
Pr uebaL. Clase de prueba para comprobar el buen funcionamiento del
ejercicio.
publ i c class Li st adeLi br os
i
/ / Tamao del ar r ay de i ndexaci n
f i nal stati c i nt 1 = ' z' - ' a' +l ;
/ / Decl ar aci n del ar r ay de I ndexaci n
publ i c Li st aOr denadaGener i ca[ ] l i br os;
/ * Const r uct or : I ni ci al i zaci n del ar r ay de i ndexaci n asi
como de sus el ement os l i st a.
La or denaci n en cada una de l as l i st as se ef ect a
ascendent ement e por el I SBN y car ece de val or el
par met r o pasado a Li st aOr denadaGener i ca */
publ i c Li st adeLi br os ( )
I
l i br os = new Li st aOr denadaGener i ca[ l ] ;
f or ( i nt i =O; i <l i br os. l engt h; i t +)
l i br os [ i ] = new Li st aOr denadaGener i ca ( O ) ;
1
/ / Si mpl e conver si n de cl ave Ti t ul o- - >no de l i st a
i nt l i st a ( St r i ng t i t ul o)
i
return( ( t i t ul o. t oLower Case ( ) ) . char At ( O) - ' a' ) ;
/ / No de l i br os
i nt nl i br os ( )
!
i nt c = O ;
f or ( i nt i = 0; i < 1i br os. l engt h; i++)
420 Java 2. Manual de programacin
c += l i br os [ i ] . nel ems ( ) ;
r et ur n( c) ;
1
/ / Mt odo par a el al macenami ent o
publ i c voi d guar dar ( Li br o l i br o)
{
try
I
1
cat ch( Except i on e) { )
l i br os[ l i st a( l i br o. devol ver Ti t ul o( ) ) ] . i nser t ar ( l i br o) ;
/ / Se i nt er cept a l a posi bl e excepci n de i nser t ar
// Mt odo par a l a r ecuper aci n ( vea cl ass NoEst a)
publ i c Li br o r ecuper ar ( St r i ng t i t ul o, l ong I SBN) throws NoEst a
{
Li br o nuevo = nul l ;
t ry
{
nuevo = ( Li br o) l i br os [ l i st a( t i t ul o) ] . obt ener ( new
Li br o ( "", t i t ul o, I SBN) ) ;
}
cat ch ( Except i on e) { )
/ * Nt ese l a necesi dad de ' downcast i ng' Dado que l a l i st a
es est ndar par a obj et os ' compar abl es' ( vea i nt er f ace
Compar abl e) hay que r eal i zar una i nevi t abl e conver si n
a Li br o.
Nt ese t ambi n que puest o que en est e mt odo se conoce
l a i nt egr i dad de l a l i st a que se manej a( t odos sus obj e-
t os son Li br ono se r eal i za compr obaci n de segur i dad
par a est e downcast i ng ( al cont r ar i o que en l a cl ase
Li br o) */
if ( nuevo == nul l )
r et ur n( nuev0) ;
t hr ow new NoEst a ( ) ;
\
/ / Met odo par a l a el i r ni naci n( vea cl ass NoEst a)
publ i c voi d el i mi nar ( St r i ng t i t ul o, l ong I SBN
(
try
{
1
l i br os [ l i st a ( t i t ul o) ] . el i mi na ( newLi br o ( "" t i t ul o, I SBN) ) ;
Estructuras de datos definidas por el programador 429
cat ch( Except i on e) { }
pr i vat e i nt cr i t er i o;
pr i vat e Nodo3 pr i mer o;
Li st aOr denadaGener i ca( i nt cr i t er i o)
t
pr i r , er o = nul l ;
t hi s. cr i t er i o = cr i t er i o;
1
/ / I nf or ma sobr e si l a l i st a est o no vaci a
publ i c bool ean est avaci a ( )
t
r et ur n ( pr i mer o == nul l ) ;
/ / No de el ement cs
publ i c i nt nel emc ( )
i nt n = C;
~o d o 3 aux = pr i mer o;
whi l e ( aux ! = nul l )
I
aux = aux. devol ver si gui ent e ( ) ;
ni +;
r et ur n ( n) ;
/ * Mt odo par a i nser ci n. Ei hecho de que se per mi t a ar r oj ar
una excepci n es debi do a que se puede Lnt ent ar i ncrod>J c: r
compar abl es de mt odos menor que i ncompat i bl es l o qi ; e dar i a
un pr i mer avi so aqu */
publ i c voi d i nser t ar ( Compar ab1e el er nent c) t hr ows Except Lon
Nodo3 nuevo = new Nodo3( el eme~t o, nul l ) ;
Nodo3 a7J xl = nul l ;
Nodo3 aux2 = pr i mer o;
whi l e ( aux2 != nul l && aux2 . ?~enor q~. e ( nuevo, cr: t eri o) )
430 Java 2. Manual de programacin
acxl = aux2;
a. Gx2 = aux2. devol ver si gui ent e ( ) ;
/ * Obsr vese l a i mpor t anci a del & & en cor t oci r cui t o que
evi za pr obl emas dado el post er i or acceso al mt odo menor que.
Obsrvese t ambi n l a pecul i ar si mpl i f i caci n de l a
si r t axi s i 2pl ement ando un mt odo menor que en Nodo3
(vea - ; ass Nodo3) */
n. ~ev3. asi gnar Ci gi ent e( aux2) ;
if ( aLxl == null)
else
pr i ; - . er o = ~. uevo;
auxl . asi gnar si gci ent e ( nuevo) ;
/ / Dl et odo par a BIuscpeda ( ver coment ar i o sobre t hr ows en i nser t ar j
public Cor par abl e obt ener ( Compar ab1e el ement o) throws Except i on
//* ; Compar anos nodo con nodo o val or con val or ? A pr ct i ca
i ql i al dad s- st emt i ca se opt a por l o mas f ci l */
Nodc3 nuevc = new Nodo3( el er nent o, null);
Ncao3 dux = pr i mer o;
while(aJx != null && aux. menor que ( nuevo, cr i t er i o) j
if ( aux != null & & ! nuevo. menor que ( aux, cr i t er i o) )
aux = acx. devol ver si gui ent e ( ) ;
r et ur n( aux. devol ver Val or ( ) ) ;
1 " Si el uno no es menor que el ot r o y el ot r o r.o es
/ * Obsf r vese zambi r . l a i mpor t anci a del & & en cor t oci r -
menor que el uno: son i gual es: ( a<b & a>b) <=>b=a */
c ~i t o dado el post er i or uso del mt odo menor que
(vea Li br o. menor que) que l anzar l a una excepci j r . */
else
return (null) ;
* Yet odo par a el i - i naci on ( ver coment ar i o sobr e t hr ows er.
i r ser t ar ) */
public void el i i i na( Compar ab1e el ement o) throws Except i on
Nom? ael i i i nar = new Rod03 ( el ement o, null) ;
?&ceo3 auxl = null;
Nodo3 ai x2 = pr i mer o;
Estructuras de datos definidas por el programador 431
whi l e (aux2 != nul l & & aux2. menor que ( ael i mi nar , cr i t er : ~) )
auxl = aux2;
acx2 = aux2. devol ver Si gui ent e( ) ;
i f ( aux2 != nul l & & ! ael i mi nar . menor que( aux2, cr i t er i o) )
i f (aux1 == nul l )
else
pr i mer o = nul l ;
auxl . asi gnar si gui ent e (aux2. devol ver si gui ent e ( 1 ) ;
1
/ * Nodo3 compar abl e que i mpl ement a l a f aci l i dad adi ci ci al
de del ar ce compar ar por el mi smo si n- pl i f , r andc l a si nt axi s */
publ i c class Nodo3
pri vate Compar abLe i nf ;
pri vate nodo3 ci g;
Nodo3 ( Compar abl e i nf or maci n, Nodo3 si g, ; i ent e)
i
:nf = i nf or maci n;
si g = si gi i ent e;
I
publ i c Compar abl e devol ver val or ( )
i
return ( i nf ) ;
publ i c Nodo3 devol ver Ci gai ent e ( 1
return ( ci g) ;
1
publ i c voi d asi gnar val or ( Compar abl e i r . f or maci o~. )
i nf = i nf or naci n;
publ i c voi d asi gnar Si gui ent e( Nodo3 si gui ent e)
i
s;g = ci gui er t e;
432 Java 2. Manual de programacin
boolean menor que ( Nodo3 c, int cr i t er i o) throws Except i on
t
r et ur n( i nf . menor que( c. i nf , O) ) ;
/ / Obj et o compar abl e Li br o
class Li br o implements Compar abl e
private St r i ng aut or ;
private St r i ng t i t ul o;
private long I SBN;
public Li br o( Ct r i ng a, St r i ng t , long i )
I
aut or = a;
t i t ul o = t ;
I SBN = i ;
public St r i ng devol ver Aut or ( )
return ( aut or ) ;
public St r i ng devol ver Ti t ul o ( )
I
return(titu1o) ;
1
public long devol ver I CBN ( )
t
return ( I SBN) ;
/ * Mt odo obl i gado par a compar abl es, como se i ndi ca en l a
i nt er f az el campo cr i t er i o no ser a ut i l i zado en est e caso */
public boolean menor que( Compar ab1e c, int cr i t er i o) throws
Except i on
if ( ! ( c i nst anceof Li br o) )
return ( ( ( Li br o) c) . I SBN<I SBN) ;
throw new Except i on ( " Er r or de compar aci n" ) ;
1
Estructuras de datos definidas por el programador 433
/ * I nt er f az bsi co est ndar de compar aci n. Es l a base sobr e l a
que se i mpl ement a cual qui er or denaci n o bsqJ eda. Arnque en
pr i nci pi o est concebi do par a admi t i r var i os cr ; t er i cs de
or denaci n en est e caso el campo cr i t er i o no ser usado */
i nterface Compar abl e
boolean menor que( Compar ab1e c, i nt cr i t er i o) throws Excepzi on;
1
/ / Excepci n est ndar gener al de bj squeda
cl as s NoEst a extends Except i on
i
public NoEst a ( )
super ( " No se encuent r a el l i br o" ) ;
/ / Una pr ueba si mpl e par a l a bi bl i ot eca Li st adeLi br os
public cl as s Pr uebaL
i
public s t a t i c voi d mai n ( St r i ng [ ] ar gs)
i
/ / I ni ci al i za un obj et o Li st adeLi br os
Li st adeLi br os 1 = new Li st adeLi br os 0 ;
/ / Cr ea dos obj et os Li br o ai macenndol os despus
Li br o l i br ol = new Li br o ( " Chest er t on" ,
" El padr e Br own" , 471193089) ;
Li br o l i br o2 = new Li br o ( " Fr oi d" ,
" Di e Tr aumdeut ung" , 1571 6 90 95 6) ;
1. guar dar ( l i br ol ) ;
1. guar dar ( l i br o2) ;
/ / ?rr; i eba su r ecuper aci n
t = Y
!
Li br o nuevo: = i . r ecuper ar ( " Si padr e Rrcw: : ", 6711333E9) ;
Li br c r.uevo2 = 1 . r ecuper ar ( " Di e : r aundeut ~~y" , 15?1CYV93%) ;
434 Java 2. Manual de programacin
........................
...... ant i nf si g ......................
Sycr er r . out . pr i nt ( " En St ock: " ) ;
Sycr em. out . pr i nt l r ( 1. nl i br osO ) ;
Sys: em. out . pr i nt l n( nuevol . devol ver Ti t ul o( ) +
" : " +nuevol . devol ver Aut or ( ) ) ;
Syst em. ouz. pr Lnt l n( nuevo2. devol ver Ti t ul o( ) +
" : " +nuevo2. devol ver Aut or ( ) ) ;
Cycr em. i n. r ead ( ) ;
ant i nf si g
I
catch ( Except i on e) { 1
/ / 3orra ; no de l os l i br as
1. el i ai nar ( " El padr e Br own" , 471193089) ;
Syst em. ol i t . pr i nt ( " En St ock: " ) ;
Syst er n. c; l t . pr i nt l n ( 1 . nl i br os ( ) ) ;
catch ( Except i on e) { I
15.5. LISTAS DOBLEMENTE ENLAZADAS
Se caracterizan porque su recorrido puede realizarse tanto desde f r ent e a f i nal
como desde f r ent e a f i nal . Este tipo de listas se suele construir vinculando
nodos. Cada nodo de dichas listas consta de un campo con informacin y otros dos
campos ( ant y si g) que referencian el nodo antecesor y el sucesor respectiva-
mente. Adems en una lista doblemente enlazada, cada nodo, excepto el primero y
el ltimo, se encuentra referenciado por otros dos, su sucesor y su antecesor.
Fi gura 15.12. Insercin de un nuevo elemento al principio de una lista doblemente
enlazada.
Estructuras de datos definidas por el programador 435
En la operacin de insercin ser necesario tener en cuenta si se trata del primer
elemento de la lista; en caso contrario, el nuevo elemento ha de colocarse por delan-
te del primero, en una posicin intermedia o al final. La supresin debe contemplar
si se desea eliminar un elemento al principio de la lista, en el medio o ai final, y ade-
ms la posibilidad de que la lista conste de un nico elemento y quede vaca tras su
eliminacin.
15.6. PILAS
Una pila es una lista que tiene establecidas ciertas restricciones en cuanto a la forma
de extraer o colocar en ella nuevos elementos. La pila se utiliza siempre que se
desea recuperar una serie de elementos en orden inverso a como se introdujeron. La
extraccin de un elemento de una pila se realiza por la parte superior, de igual forma
que la insercin. Esta propiedad implica que el nico elemento accesible de una pila
es el ltimo. Estas estructuras se denominan LIFO (Last Input First Output),
((ltimo elemento que se pone en la pila es el primero que se puede extraer)).
Las pilas se pueden implementar vinculando nodoc y tambin mediante arrays,
utilizando una variable auxiliar, ci ma, que apunte al ltimo elemento de la pi l a.
En realidad, en J ava no es necesario definir la clase Pi l a, ya que en el paquete
j ava. ut i 1 viene la clase St ack (pila). La clase St ack hereda de Vect or , ya
que una pila se puede implementar con eficiencia mediante una tabla que no tiene
tamao fijo. Los mtodos proporcionados por St ack son:
public boolean empt y ( )
Comprueba si la pila est vaca
public synchronized j ava. l ang. Cbj ect peek( )
Consulta el elemento situado en la cima de la pila, sin quitarlo de sta. Si la pila est vaca,
devuelve una excepcin Empt ySt ackExcept i on.
public synchronized j ava. l ang. Obj ect pop ( )
Quita el objeto situado en la cima de la pila y lo devuelve como resultado de la funcin. Si
la pila est vaca, devuelve la excepcin anteriormente mencionada.
public j ava. l ang. Obj ect push( j ava. l ang. 0bj ect obj)
Coloca un nuevo elemento en la cima de la pila.
public synchronized int sear ch( j ava. l ang. 0bj ect obj)
Devuelve la distancia existente desde la cima de la pila hasta la posicin donde el objeto,
obj , se encuentra situado o -1 si el objeto no est en la pila.
public St ack ( )
Constructor.
436 Java 2. Manual de programacin
vaca se coloca un elemento se coloca otro elemento se quita un elemento
ci ma =2.
ci ma =1
...
...
...
3
2
1
Fi gura 15.13. Pila implementada con vector
La implementacin de una pila utilizando nodos vinculados requiere el diseo
de los mtodos:
.
.
Se
Pi l a, el constructor. Crea una pila vaca asignando nul l al miembro pri-
vado ci ma que contiene la referencia a la cima (tope) de la pila.
vaci a. Determina si la pila est o no vaca comprobando el valor de ci ma;
devuelve t r ue cuando el valor de ci ma es nul l y f al se en caso contra-
rio.
api l ar . Aade un nuevo elemento en la cima de la pila, es decir, crea un
nuevo nodo cuyo campo si g referencia la ci ma de la pila y a continuacitn
asigna a ci ma el nuevo nodo.
de sapi l ar . Comprueba que la pila no est vaca, suprime el nodo de la cima
haciendo que ci ma pase a referenciar al siguiente nodo, o a nul l si la pila se
ha quedado vaca, y devuelve el objeto perteneciente al nodo eliminado.
obt ener ci ma. Devuelve el objeto almacenado en la cima de la pila.
podra efectuar de la siguiente forma:
public class Pi l a
private Nodo4 ci ma;
P i l a ( )
I
ci ma = null;
1
public boolean vac a ( )
return ( ci ma == null) ;
I
Estructuras de datos definidas por el programador 437
public void api l ar ( 0bj ect el ement o)
{
ci ma = new Nodo4( el ement o, ci ma) ;
public Obj ect desapi l ar ( ) throws Except i on
{
i f ( vac a ( ) )
Obj ect aux = ci ma. i nf ;
ci ma = ci ma. si g;
return aux) ;
throw new Except i on ( " Pi l a Vaci a" ) ;
1
public OLj ect obt ener ci ma ( ) throws Except i on
i
i f ( vac a ( ) )
return ( ci ma. i nf ) ;
throw new Except i on ( " Pi l a Vaci a" ) ;
1
public cl as s Nodo4
i
Obj ect i nf ;
Nod04 si g;
Nodo4 ( Obj ect i nf or maci n, Nod04 si gui ent e)
i
i nf = i nf or maci n;
si g = si gui ent e;
1
/ / La i nf or maci n se muest r a en or den i nver so al de i nt r oducci n
import j ava. i o. *;
public cl ass Pr uebaP
I
public s t a t i c void mai n ( St r i ng ar gs [ ] )
i
St r i ng cadenai , cadenaf ;
Pi l a p = new Pi l a( ) ;
Syst em. out . pr i nt l n ( " Pr ueba" ) ;
Syst em. out . pr i nt l n ( " Escr i ba una pal abr a: " ) ;
try
I
I nput St r eamReader i s = new I nput St r eamReader ( Syst em. i n) ;
Buf f er edReader bf = new Buf f er edReader ( i s) ;
cadenai = bf . r eadLi ne ( ) ;
438 Java 2. Manual de programacin
for ( i nt i = O; i < cadenai . l engt h( ) ; i +t )
cadenaf = "";
for ( i nt i = O; i cadenai . l engt h 0 ; i t +)
p. api l ar (new Char act er ( cadenai . char At ( i ) ) ) ;
cadenaf = cadenaf + ( ( Char act er ) p. desapi l ar ( ) ) .
char val ue ( ) ;
Syst em. out . pr i nt l n ( cadenaf ) ;
1
cat ch( Except i on e) i 1
Cuando un programa llama a un subprograma, se utilizan internamente pilas
para guardar el lugar desde donde se hizo la llamada y el estado de las variables en
ese momento.
Entre las aplicaciones de las pilas destacan: 1) Su uso en la transformacin de
expresiones aritmticas de notacin injija a postfija' y en la posterior evaluacin de
la expresin. 2) Su utilizacin para la transformacin de algoritmos recursivos en
iterativos.
15.7. COLAS
Una cola es una estructura de datos lineal en donde las eliminaciones se realizan por
uno de sus extremos, denominadofrente, y las inserciones por el otro, denominado
final. Se las conoce como estructuras FIFO (First Input First Output). La cola de un
autobs o de un cine son ejemplos de colas que aparecen en la vida diaria. La cola
se podr implementar mediante un array unidimensional, usando la clase Vect or
o utilizando nodos vinculados.
Cuando se implementa con un array (Fig. 15.14) se utilizan dos variables nu-
mricas, pr i mer o y l t i mo, para marcar el principio yf i nal de la cola; como
los elementos se aaden por el final y se quitan por el principio, puede ocurrir que
la variable l t i mo llegue al valor mximo del array, aun cuando queden posi-
ciones libres a la izquierda de la posicin pr i mer o (Fig. 15.15). Existen diver-
sas soluciones:
' Una de las tareas que realiza un compilador es la evaluacin de expresiones aritmticas. En la mayo-
ra de los lenguajes de programacin las expresiones aritmticas se escriben en notacin infiju, que son aque-
llas en las cuales el smbolo de cada operacin binaria se sita entre los operandos: 4 * (3+5). Muchos
compiladores transforman estas expresiones irzfijas en notacin po. s?f i j ~~, en la cual el operador sigue a los
operandos (o prefija, en la cual el operador procede a los operandos) y a continuacin generan instrucciones
mquina para evaluar esta expresin postfija: 4 3 5 +*. Nunca se necesitan parntesis para escribir expre-
siones en las notaciones posfija y prefija.
Estructuras de datos definidas por el programador 439
Retroceso
Consiste en mantener fijo a 1 el valor de primero, realizando un
desplazamiento de una posicin para todas las componentes ocu-
padas cada vez que se efecta una supresin.
Reestructuracin Cuando ltimo llega al mximo de elementos se desplazan las
componentes ocupadas hacia atrs las posiciones necesarias para
que el principio coincida con el principio de la tabla.
Un array circular es aquel en el que se considera que la compo-
nente primera sigue a la componente ltima.
Mediante un array circular
pr i mer o l t i mo MAX
Fi gura 15.14. Cola implementada con array.
pr i mer o l t i mo I
MAX
Fi gura 15.15. Cola implementada con un array tras una serie de operaciones
de adicin y sustraccin de elementos.
La clase Vect or de J ava, as como la creacin de una cola utilizando nodos
vinculados evitan los problemas originados por MAX en las implementaciones con
arrays.
Las operaciones tpicas en una cola son: crear la cola, comprobar si la cola est
o no vaca, poner elementos en la cola por el,final, quitar elementos por elfrente y
obtener el objeto situado en e1,frente de la misma. En la implementacin de una
cola utilizando nodos vinculados que se efecta a continuacin los mtodos que
realizan las mencionadas tareas se denominan respectivamente: Col a, vac a,
poner , qui t ar y obt ener pr i mer o. Los miembros privados pr i mer o y
l t i mo guardan la informacin sobre elfrente yJ inal de la cola; inicialmente, el
constructor asigna nul l a ambos.
440 Java 2. Manual de programacin
El mtodo vaci a comprueba si queda algn elemento que se pueda extraer de
la cola consultando pr i mer o y si el valor de pr i mer o es nul l devuelve
t r ue para indicar que la cola est vaca, en caso contrario devuelve f al se.
El mtodo poner se encarga de aadir nuevos elementos a la cola por el
final; para ello, comienza por comprobar si la cola est vaca, si esto ocurre,
ser necesario que pr i mer o referencie al nuevo elemento, en caso contra-
rio ser el elemento referenciado por u1 t i mo, a travs de su campo s i g,
quien establezca un vnculo con el nuevo elemento, el mtodo poner termi-
na asignando a u 1 t i mo el nuevo elemento.
El mtodo qui t ar , si la cola no est vaca, asigna a una variable aux el
objeto alamacenado en el campo i n f del primer elemento, despus hace que
pr i mer o referencie al nodo referenciado por el campo s i g de dicho primer
elemento, si la cola se ha quedado vaca y pr i mer o es nul l asigna tam-
bin nul l a ul t i mo, en cualquier caso, cuando la cola no est vaca,
devuelve aux.
El mtodo obt ener pr i mer o devuelve el objeto referenciado por el campo
i nf o del elemento referenciado por pr i mer o.
public cl ass Col a
t
private Nodo4 pr i mer o;
private Nodo4 ul t i mo;
Col a ( )
{
pr i mer o = nul l ;
ul t i mo = nul l ;
1
public boolean vac a ( )
{
\
return ( pr i mer o == nul l ) ;
public void poner ( Obj ect el ement o)
t
Nod04 aux = new NOdO4( el ement o, nul l ) ;
i f ( vac a ( ) )
else
ul t i mo = aux;
pr i mer o = aux;
u1t i mo. si . g = aux;
1
public Obj ect qui t ar ( ) throws Except i on
{
i f ( vac a ( ) )
Obj ect aux = pr i mer o. i nf ;
throw new Except i on ( " Col a vac a" ) ;
Estructuras de datos definidas por el programador 441
pr i mer o = pr i mer o. si g;
if ( pr i mer o == nul l )
ul t i mo = nul l ;
return ( dux) ;
)
public Obj ect obt ener pr i mer o0 throws Except i on
I
if ( vaci a ( ) )
return ( pr i mer o. i nf ) ;
throw new Except i on ( " Col a vac a" ) ;
1
public class Nodo4
i
Obj ect i nf ;
Nodo4 si g;
Nodo4 ( Obj ect i nf or maci n, Nodo4 si gui ent e)
i
i nf = i nf or maci n;
si g = si gui ent e;
1
1
Una aplicacin de las colas es una cola de impresin. En un sistema de tiempo
compartido suele haber un procesador central y una serie de perifricos comparti-
dos: discos, impresoras, etc. Los recursos se comparten por los diferentes usuarios
y se utiliza una cola para almacenar los programas o peticiones de los diferentes
usuarios que esperan su turno de ejecucin. El procesador central atiende, normal-
mente, por riguroso orden de llamada del usuario; por tanto, todas las llamadas se
almacenan en una cola. Existe otra aplicacin de las colas muy utilizada, la cola de
prioridad; en ella el procesador central no atiende por riguroso orden de llamada,
sino por las prioridades asignadas por el sistema o bien por el usuario, y slo den-
tro de las peticiones de igual prioridad se producir una cola.
Resumen: En realidad las pilas y las colas son listas que tienen establecidas
ciertas restricciones en cuanto a la forma de extraer o colocar en ellas nuevos
elementos:
La extraccin de un elemento de una pila se reaIiza por la parte superior, lo
mismo que la insercin. Estructura LIFO.
En una cola las eliminaciones se realizan siempre por uno de sus extre-
mos, denominado frente, y las inserciones por el otro, denominado final.
442 Java 2. Manual de programacin
15.8. COLAS CIRCULARES
Una cola circular es una variante de las listas circulares. Una cola necesita dos refe-
rencias, una al primer elemento y otra al ltimo; por consiguiente, una cola circular
se toma como referencia de acceso la del ltimo nodo, de esta forma se tiene impl-
citamente la del primero puesto que en una cola circular el primer elemento sigue
al ltimo (Fig. 15.16).
ltimo
I 1
L
i
pr i mer o
Figura 15.16. Cola circular.
Teniendo en cuenta las consideraciones anteriores y utilizando nodos vincula-
dos, los mtodos a implementar tendrn las siguientes caractersticas:
El constructor, Col aci r cul ar . Crea la cola, asignando nul l al miembro
privado ui t i mo.
vaci a. Devuelve t rue si la cola est vaca ( ul t i mo es nul l ) y f al se en
caso contrario.
poner . Crea un nuevo nodo y comprueba si la cola est vaca; si est vaca,
al campo si g del nuevo nodo le asigna el nuevo nodo; si no est vaca, asig-
na al campo sig del nuevo nodo el primero ( ul t i mo. si g) y a ul t i mo. si g
el nuevo. Al terminar, en ambos casos, asigna a u1 t i mo el nuevo.
qui t ar . Tras verificar que la lista no est vaca, el mtodo considera dos
casos: 1) que la lista tenga un nico elemento ( ul t i mo. si g ser igual a
ul t i mo) , por lo que, al quitarlo, ultimo debe pasar a tomar el valor nul l ;
2) que la lista tenga ms de un elemento y, para eliminar el primero, este
primero (que es ui t i mo. si g) deber pasar a referenciar a su siguiente
( ul t i mo. si g. si g).
obt ener pr i mer o devuelve el objeto referenciado por el campo i nf o del
primer elemento.
Estructuras de datos definidas por el programador 443
La implementacin de la cola circular es:
public class Col aci r cul ar
i
private Nodo4 ul t i mo;
Col aci r cul ar ( )
i
ul t i mo = null;
public boolean vac a ( )
i
return(u1timo == null) ;
1
public void poner ( Obj ect el ement o)
I
Nodo4 aux = new Nodo4(el ernento, null);
if ( vaci a ( ) )
else
i
aux. si g = aux;
aux. si g = ul t i mo
ul t i mo. si g = aux
1
ul t i mo = aux;
1
public Obj ect qui t ar
i
if ( vaci a ( ) )
si g;
) throws Except i on
throw new Except i on ( " Col a vac a" ) ;
Obj ect aux = ul t i mo. si g. i nf ;
if ( ul t i mo. si g == ul t i mo)
else
return ( aux) ;
ul t i mo = null;
ul t i mo. si g = ul t i mo. si g. si g;
public Obj ect obt ener pr i mer o ( ) throws Except i on
if ( vac a ( ) )
return ( u1 t i mo. s ig . i n f ) ;
throw new Except i on ( " Col a vac a" ) ;
1
/ / La cl ase Nodo no cambi a
public class Nodo4
444 Java 2. Manual de programacin
Obj ect i nf ;
Nodo4 si g;
Nodo4 ( Obl ect i nf or maci n, Nodo4 si gui ent e)
I
i nf = i nf or maci n;
si g = si gui ent e;
/ * C na pr ueba si mi l ar a l a que se ef ect u con l a pi l a se puede
ut i l i zar ahor a par a ver el f unci onami ent o de l a col a
ci r cul ar . La i nf or maci n se muest r a en el mi smo or den en el
que f ue i nt r oduci da */
i mpor t j ava. i o. *;
publ i c cl ass Pr uebaCC
publ i c st at i c voi d mai n ( St r i ng ar gs [ ] )
t
St r i ng cadenai , cadenaf ;
Col aci r cul ar cc = new Col aci r cul ar ( ) ;
Syst em. out . pr i nt l n ( " Pr ueba" ) ;
Syst em. out . pr i nt l n ( " Escr i ba una pal abr a: " ) ;
t ry
I nput Ct r eamReader i s = new I nput St r eamReader ( Syst er n. i n) ;
Buf f er edReader bf = new Buf f er edReader ( i s) ;
cadenai = bf . r eadLi ne ( ) ;
for ( i nt i = O; i < cadenai . l engt h( ) ; it+)
cadenaf = "";
whi l e ( ! cc. vac a ( ) )
Syst em. out . pr i nt l n( cadenaf ) ;
cc. poner ( new Char act er ( cadenai . char At ( i ) ) ) ;
cadenaf = cadenaf t ( ( Char act er ) cc. qui t ar ( ) ) . char val ue ( ) ;
!
cat ch( Except i on e) { }
1
A A
Palabras
reservadas J ava
m 445
446 Java 2. Manual de programacin
Las siguientes palabras no se pueden utilizar como identificadores:
aDst r act
bool eai
br eak
byt e
case
cat ch
char
cl ass
const
cont i r ue
def au- t
aoubl e
e- se
exter.ds
f al ce
f i nal
13
f i nal l y
f l oat
f or
got o
l f
i mpl ement s
i mpor t
i nst anceof
in:
i nt er f ace
l ong
r.a t I T, e
r ew
n, l l
package
pr i vat e
pr ot ect ed
publ i c
r et ur n
shor t
szat i c
super
s w i t c h
synchr oni zed
t hi s
throw
z n r ows
t r ar. s i en t
t r ue
t r y
voi d
vol at i i e
*. . i l e
..h '
Las siguientes palabras reservadas pueden no tener significado en algunas ver-
siones actuales, pero estn reservadas para uso futuro:
byval ue
cast
C0.T s t
f u t u r e
ge ne r i c
got0
i n n e r
opera t o r
outer
r e s t
va r
APENDI CE B
Prioridad
de operadores
447
448 Java 2. Manual de programacin
B.1. PRIORIDAD DE OPERACIONES
Los operadores se muestran en orden decreciente de prioridad de arriba a abajo. Los
operadores del mismo grupo tienen la misma prioridad (precedencia) y se ejecutan
de izquierda a derecha (asociatividad).
Operador Tipo Asociatividad
o Par nt esi s
o Ll amada a f unci n
[ I Sub ndi ce
Acceso a mi embr os de un obj et o
Dcha- I zda
Dcha- I zda
Dcha- I zda
Dcha- I zda
++
_ -
Pr ef i j o i ncr emect o
Pr ef i j o aecr emer . t o
Dcha- I zda
Dcha- I zda
Ms uni t ar i o
Mei . os uni t ar i o
Ke ga c i on 1 g i c a un 1 t ar 1 a
Compl ement o bi t a bi t Lni t ar i o
( t i po) Model o uni t ar i o
new Cr eacci on de obl et os
Dcha- I zda
Dcha- I zda
Dcha- I zda
Dcha- I zda
Dcha- I zda
Dcha- I zda
+
-
Pr oduct o
Di vi si on
Rest o ent er o
S urna
Rest a
I zda- Dcha
I zda- Dcha
I zda- Dcha
I zda- Dcha
I zda- Dcha
<< Despl azami ent o bi t a bi t a l a i zqui er da Dcha- I zda
>> Despl azami ent o bi t a bi t a l a der echa
>>> Despl azami ent o bi t a bi t a l a der echa
con ext ensi n de si gno Dcha- I zda
r el l enando con cer os Dcha- I zda
< Menor que I zda- Dcha
> Mayor que I zda- Dcha
<= Menor o i g; i al qUe I zda- Dcha
>= Mayor o i gi i al que I zda- Dcha
i nst anceof Ver i f i caci n t i po de obj et o I zda- Dcha
I zda- Dcha I 9.J a 1 dad
-_ _ _
I = Desi gual dad I zda- Dcha
& AND bi t a bi t I zda- Dcha
OR excl csi ve Si t a bi z I ZCa- DCha
OR i ncl Ls; ve bi t a bi r I zda- Dcha
Prioridad de operadores 449
Operador Tipo Asociatividad
~
&& AND l gi co I zda- Dcha
~~~ ~~
I 1 OR l gi co I zda- 3cha
? : Condi ci ona: t er nar i o 3cka- I zda
-
-
+=
-=
*=
/=
~, -
c -
&=
- -
I =
<<=
>>=
>>>=
Asi gnaci n
Asi gnaci n
Asi gnaci n
Asi gnaci n
Asi gnaci n
Asi gnaci n
Asi gnac- n
Asi gnaci n
Asi gnaci n
Asi gnaci n
de suma
de r est a
de pr oduct o
de di vi si n
de mdul o
AND bi t a bi t
OR excl usi ve bi t a bi t
OR i ncl usi ve bi t a bi c
de despl azami ent o
3 c k. a - I z da
Echa- I zda
Dcha- I zda
Dcna- I zda
Echa- I zda
Dcna- I zda
Dcha- I zsa
Dcha- : zda
Ccha- I zci o
a i zqui er da bi t a bi t Echa- I zaa
Despl azami ent o der echo bi t a bi t con
asi gnaci n de ext ensi r . de si gno Echa- I zda
Despl azami ent o der echo bi t a bi t con
asi gnaci n de ext ensi n a cer o Dcha- I zda
Gua de sintaxis
45 1
452 Java 2. Manual de programacin
Este apndice describe las reglas bsicas de sintaxis de J ava que cumplen las dife-
rentes versiones existentes en la fecha de publicacin de este libro: J DKl .1, 1.2 y 1.3,
con el compilador J ava 2.0. Gran parte de la sintaxis de J ava se basa en C y/o C++.
C.1. ESTRUCTURA DE PROGRAMAS JAVA
Un programa J ava consta de una coleccin de archivos o unidades de compilacin.
Cada archivo puede contener un nombre opcional de paquete, una serie de declara-
ciones i mport y por ltimo una secuencia de declaraciones de interfaces o clases.
Una unidad de compilacin puede identificar sus paquetes, importar cualquier
nmero de otros paquetes, clases o interfaces y declarar cualquier nmero de clases
e interfaces.
C.1.1. Declaracin de i mportaci ones
Una declaracin de importacin ( i mpor t ) nombra un elemento de otro paquete
que se utilizar en las declaraciones posteriores de interfaces o clases. Se puede uti-
lizar un asterisco para incluir todos los elementos de un paquete.
i mpor t nombr ePaquece. * ;
i mpor t nombr ePaquet e. Nor r Dr eC- 2se;
i mpor t nonbr ePaquet e. Nambr eI ?t er f az;
As, i mpor t j ava . i o. * ; indica al compilador que importe cualquier clase
del paquete j ava . i o proporcionado por J ava a medida que se necesite. Es una
buena idea incluir esta lnea al principio de cualquier archivo j ava que realice
operaciones de entradaisalida. Otros ejemplos:
i mpor t j ava. ut ; l . Dat e;
i mpor t . ] ava. net . *;
C.1.2. Definicin de cl ases
Una definicin de una clase consta de una declaracin y un cuerpo. El cuerpo con-
tiene campos de datos y declaraciones de mtodos. La declaracin de una clase cons-
ta de palabras reservadas e identificadores: una secuencia opcional (en el modelo
sintctico para indicar que es opcional se encierra entre [ ] ) de modificadores, la
palabra reservada cl ass, el nombre de la clase, un nombre opcional de la clase
padre, una secuencia opcional de interfaces y el cuerpo de la clase con sus miembros.
Gua de sintaxis 453
[modificadoresDeClase] class Nombre [extends Pa d r e ]
[implements In te r f a z I
[, I n t e r f a z 2 [, . . . I : ]
{
I
//cuerpo de l a cl ase ( mi embr os)
Los modi f i cador esDeCl ase pueden ser: abst r act , f i nal , publ i c.
Una clase abstracta es aquella que tiene uno o ms mtodos abstractos y de la
que el programador no piensa instanciar objetos. Su fin es servir como supercla-
se de la que otras puedan heredar. Las clases que heredan de una clase abstracta
deben implementar los mtodos abstractos de su superclase o seguirn siendo abs-
tractas. Una clase f i nal no puede ser superclase y todos sus mtodos son impl-
citamente f i nal . Una clase pblica debe estar en su propio archivo, denominado
Nombre. j ava. Los miembros de una clase pueden ser mtodos y variables de ins-
tancia (pertenecientes a un tipo base o una clase).
// For mat o ms si mpl e de una def i ni ci n de cl ase
class Cl aseno
I
} I / Cl aseno
// campos de dat os y decl ar aci ones de mt odos
// Una cl ase que ext i ende ot r a cl ase
publ i c class Cl aseDos extends Ot r acl ase
I
// campos de dat os y decl ar aci ones de mt odos
} / / Cl aseDos
/ / Cl ase compl ej a
publ i c abstract class Mi obj et o extends Ot r acl ase
iniplaments I nt er f azUno, I nt er f azDos
t
} // Mi Obj et o
// campos de dat os y decl ar aci ones de mt odos
Ejemplos
1. public class Pr i mer pr ogr ama
publ i c s t a t i c void mai n ( St r i ng[ ] ar gs)
I
1
Syst em. out . pr i nt l n( " Si er r aMagi na- Car chel ej o" ) ;
454 Java 2. Manual de programacin
2. publ i c abstract cl ass Numer o
t
. . .
1
C.1.3. Declaracin de variables
En J ava, las variables se pueden declarar: 1) como campos de datos de una clase, 2)
como argumentos de un mtodo, o 3) como variables locales dentro de un bloque.
C.1.4. Declaraciones de campos de datos y variables de mtodos
Una variable se declara proporcionando su tipo y su identificador. El tipo puede ser
uno de los tipos primitivos o puede ser una clase. Las declaraciones de las variables
locales y campos de datos pueden incluir la asignacin de un valor inicial. Los argu-
mentos obtienen su valor inicial cuando se llama al mtodo.
/ / El empi os de decl ar aci ones de var i abl es de mt odo o campos de dat os
i nt z; // i dent i f i cador z es de t i po i nt
char i n; ci al Nonbr e =' M' ; / / i ni ci al Nombr e es de t i po char
/ / y de val or i ni ci al ' M'
St r i r , g sal udo = "Hol aMackoy"; // sal udo es de t i po St r i ng
/ / y de val or i ni ci al "Hol aMackoy"
boolean i nt er r upt or = fal se; / / i nt er r upt or es de t i po bool ean
// y val or i ni ci al f al se
Una declaracin de variables de instancia o campos de datos tiene una parte
de modificador opcional, un tipo, un nombre de variable y una inicializacin
opcional.
[ modi f i cador esDeVar i abl e] t i po nombr e [= val or ] ;
Los modi f i cador esDeVar i abl e pueden ser: publ i c, pr ot ect ed,
st at i c, f i nal .
Ejemplos
1. public cl ass
protected
protected
protected
/ / . . .
i
Fi gur a
Rect angul o posi t i on;
double dx, dy;
Col or col or ;
Gua de sintaxis 455
2. c l as s Empl eado extends Per sona
i
protected St r i ng nombr e = "";
protected i n t edad;
protected Empi eado unEmpl eado;
11.. .
C.1.5. Visibilidad de campos de datos
Los campos de datos son accesibles desde cualquier mtodo dentro de la clase.
Dependiendo de la visibilidad declarada, otros objetos pueden acceder tambin a los
campos de datos. A los campos de datos que no se les proporciona un valor inicial
explcito se les asigna un valor por defecto.
C.1.6. Declaracin de constantes de clase
Las constantes de una clase se decaran como variables, siendo necesario comenzar
su declaracin con las palabras reservadas f i nal y stati c y se les asigna un
valor en la declaracin. Este valor ya no se podw modificar.
Ejemplo
c l as s Empl eado extends Per sona
t
publ i c s t a t i c f i nal cant i daa = 50;
/ / decl ar aci n de var i abi es
/ / decl ar aci ones de mt odos
C.l .7. Conversin explcita de tipos
(nombre- t i p o ) expresibn
C.1.8. Creacin de objetos
Una instanciacin (creacin) de objetos crea una instancia de una clase y declara
una variable de ese tipo. Los objetos se crean a partir de una clase utilizando el ope-
rador new. La sintaxis adecuada es:
456 Java 2. Manual de programacin
[ tipo] nombrevariable = new tipo ( [parmetrol [, parmetroZ[, . . . I I ] ) ;
Repuesto unapi eza = new Repuest o ( ) ;
Aut omovi l mi car r o = new Aut omovi l ( 5, " Gol f " ) ;
La creacin de una instancia (un objeto):
Le asigna memoria dinmicamente.
Crea un objeto con el nombre nombr evar i abl e.
inicializa sus variables de instancia a los valores por defecto: nul 1 para los
objetos, f al se para variables booleanas, O para los otros tipos base.
Llama al constructor con los parmetros especificados.
Por ltimo, devuelve una referencia al objeto creado, es decir, la direccin de
memoria donde se encuentra dicho objeto.
C.1.9. Declaracin de mtodos
Las declaraciones de mtodos simples, denominadas tambin signuturus, constan
de un tipo de retorno, un identificador, y una lista de argumentos (parmetros). El
tipo de retorno puede ser cualquier tipo vlido (incluyendo una clase) o el tipo
voi d si no se devuelve nada. La lista de argumentos consta de declaraciones de
tipo (sin valores iniciales) separados por comas. La lista de argumentos puede estar
vaca. Los mtodos pueden tambin tener una visibilidad explcita.
[ mo d i f i ca doresDeMe t odos ] t ipoDeRes u1 t a do n ombreM t odo
([ tipoparmetrol parmetrol
[,tipoParmetroZ parmetroZ[, ... I ] ] )
[throws Excepci n 1 [ , Excepci n2 [ , . . . I I I
t
/ / cuer po del mtodo
i
Los modi f i cador esDeMet odos pueden ser: publ i c, pr ot ect ed, pr i vat e,
abst r act , f i nal , st at i c, synchr oni zed. Como t i poDeResul t ado se espe-
cificar voi d cuando el mtodo no devuelva resultados. En la implementacin del
mtodo, cuando ste no haya sido declarado voi d, se utilizar la instruccin
r et ur n para devolver un valor al punto de llamada del mtodo. Es decir, en cuan-
to que se ejecuta r et ur n, el mtodo termina devolviendo un nico valor como
resultado. Para devolver mltiples valores mediante una funcin en J ava deben com-
binarse todos los ellos en un objeto y devolver la referencia al objeto. A continua-
cin del nombre del mtodo y entre parntesis se especificar la lista de parmetros,
que constar de cero o ms parmetros formales cada uno de ellos precedido por su
tipo y separados por comas.
Gua de sintaxis 457
Cuando se llama a un mtodo, os parmetros actuales se asignan a los parme-
tros formales correspondientes. Entre los parmetros actuales, los de la llamada, y
los formales, los de la declaracin, debe existir concordancia en cuanto a nmero,
tipo y orden.
La palabra reservada t hr ows permite listar tipos de excepciones lanzadas por el
mtodo cuyo tratamiento se pospone para que sea efectuado por el mtodo llamador.
Los mtodos de una clase estn asociados con una instancia especfica de la
misma, excepto si son estticos.
publ i c cl ass Ej empl oi {
/ / campos de dat os decl ar ados, ni nguno
/ * Decl ar aci n si mpl e: no se devuel ve nada, no se pasa ni ngn
pr i vat e voi d cal cul ar I mpuest os( ) {
1
ar gument o */
/ / cuer po del mt odo
/ * Un mt odo con un ar gument o de t i po doubl e que devuel ve us
publ i c i nt Cal CUl ar Tot al (double x) [
ent er o */
/ / cuer po del mt odo
1
/ * Un mt odo que devuel ve un obj et o de t i po Mi obj et o con un
pr ot ect ed Mi Obj et o conver t i r ( i nt z, St r i ng s) {
}
ent er o y una cadena de ent r ada */
// cuer po del mt odo
1 / / cl ase Ej empl o1
C. l . I O. Llamadas de mtodos
Cuando se llama a un mtodo, se deben proporcionar los argumentos del tipo ade-
cuado:
/ / i nt er i or de un mt odo
i
cal cul ar Z ( ) ;
i nt z = cal cul ar Z ( 16, 25) ;
Mi obj et o ob] = conver t i r ( 25, " Hol a Mackoy" ) ;
C.l . I 1. El mtodo main
Cada aplicacin J ava (no los appkts) debe tener un mtodo mai n que es donde
comienza la ejecucin de la misma. Es decir, para ejecutar un programa el intrprete
de J ava comienza llamando al mtodo mai n ( ) . Este mtodo se llama antes de la
458 Java 2. Manual de programacin
creacin de un objeto y ha de declararse como st at i c para que se pueda llamar
sin tener que referirse a una instancia particular de la clase. Como adems es Ila-
mado por cdigo fuera de su clase, tambin tiene que ser declarado como pub1 i c,
que es la forma de permitir que un miembro de una clase pueda ser utilizado por
cdigo que est fuera de la misma. La palabra reservada voi d indica que mai n no
devuelve nada.
public s t at i c void ma;?. ( St r i ng [ I ar gs)
St r i ng [ ] ar gs es la declaracin de un array de St r i ng, mediante el cual
la clase podra tomar un nmero variable de parmetros en la lnea de rdenes;
aunque no se use, es necesario incluir este parmetro cuando se define el mtodo
mai n().
C.1.12. Extensi n de cl ases
[acceso] [ f i n a l : cl as s Nombreclase extends Supercl ase
/ / cLer po de l a cl ase ampl i aaa
Constructor de la subclase
2Tbr eCl ase ( ar ql l , . . . )
. . . ) ;
public
i
super
. . .
1
C.1 .I 3. Constructores
La sintaxis de un constructor es similar a la de un mtodo, sin t i poDeResul t ado
y cuyo nombre debe coincidir con el de la clase. El constructor se invoca automti-
camente cuando se crea una instancia de la clase.
~ n o d i i i e a c o r e ~ De Co n s ~ r t i c t o r ] nombreConst ruct or
( [ tipoParnetrol parmetrol
[, t i poParmet ro2 parmetro2 [, . . . I 1 1 )
/ / cuer po ael const r uct or
1
Gua de si ntaxi s 459
Los modi f i cador esDeConst r uct or siguen las mismas reglas que en los
Un constructor debe ser invocado con el operador new.
Una clase puede tener mltiples mtodos constructores, siempre que stos se
diferencien unos de otros en el nmero y/o tipo de parmetros.
mtodos normales, pero un constructor abstracto esttico final no est permitido.
cl as s Per sona
protected Ct r i r g nombr e = "";
protected i nt edad = O;
public Per sona ( St r i ng nom, i nt aos)
t
nombr e = nom;
edad = aos;
public s t a t i c void mai n ( St r i ng ar gs [ 3 )
Per sona p = new Per sona ( " Lui si t o Mackoy" , 13) ;
Syst em. out . pr i nt l n( " Nombr e: 'I + p. nombr e + " " + " Eaad: "
t p. edad) ;
1
\
C.1.14. Los constructores en la extensin de clases
El cuerpo de un constructor comienza con una llamada heredada al constructor de
la superclase de la clase. Esta llamada debe ser la primera sentencia del cuerpo de
un constructor y no puede aparecer en ningn otro lugar. En J ava super ( . . . )
es usado en vez del nombre del constructor de la superclase. Si no se usa super
entonces se supone implcitamente que el cuerpo del constructor comienza con la
llamada super ( ) sin parmetros. El resto del cuerpo es como un mtodo normal.
cl as s Empl eado extends Per sona
protected St r i ng cat egor i a = "'I;
protected i nt sal ar i o = O;
public Empl eado ( St r i ng nom, i nt aos, Ct r i zg n:vel, i nt suel do)
super ( nom, aos) ;
cat egor i a = ni vel ;
sal ar i o = suel do;
public s t a t i c void mai n ( St r i nq ar gs [ ] )
460 Java 2. Manual de programacin
Empl eado e = new Empi eado ( " Ar zur i t o Mackoy" , 13, " medi o" ,
Syst em. out . pr i nt l n( " Nombr e: " + e. nombr e + " '' + " Eaad: I'
+ e. edad) ;
Syst em. out . pr i nt l n( " Ni ve1: " t e. cat egor i a + " "
+ " Sal ar i o: " + e. sal ar i o) ;
200000) ;
C.1.15. Definicin e implementacin de interfaces
Definicin de una interfaz
public interface Nornbrein t e r f a z
t
public abstract t i poDeResu1 tado nombreMtodo () ;
/ / ot r as decl ar aci ones de mt odos vaci os.
Se ha de tener en cuenta que:
Todos los miembros de una interfaz son pblicos automticamente.
Todos los mtodos son abstractos automticamente.
Todos los campos deben ser declarados st at i c y f i nal .
La clase que implementa la interfaz debe implementar todos los mtodos decla-
rados en ella.
public class Irnplementa [extends Padr e] implements Nombr eI nt er f az
public t i poDeResEl t ado nombr eKt odo0
t
/ / . . .
/ / s e i npl ement an t odos l os mt odos de l a i nt er f az Nombr eI nt er f az
1
Es posible que una clase implemente ms de una interfaz.
[ modi f i cador es DeCl as e] class Nombre [extends Padre]
[implements I n t e r f a c e ]
i, I n t e r f a c e 2 [, . . . 111
/ / I mpl ement aci n de t odos l os mt odos de l as di st i nt as i nt er f aces
Gua de sintaxis 461
Es posible definir clases que tengan objetos del tipo Nombr eI nt er f az, como
si la interfaz fiera una clase, pudiendo as usarse en ellas, las diversas implementa-
ciones de sta. La clase E j empl o puede usar, entre otras que hubiera definidas, la
que ofrece la clase I mpl ement a.
public class Ejemplo
{
public Ejemplo ( )
(
1
public tipoDeResul t a d o unMetodo (NombreInterfaz elemento)
{
/ / . . .
/ / . . .
C. l . I 6. Clases annimas
Una clase annima es aquella que no tiene nombre y, cuando se va a crear un obje-
to de la misma, en lugar del nombre se coloca directamente la definicin.
n e w SuperNombreO { cuerpo clase ]
Por ejemplo, considerando declarada una clase I mpl ement a que implementa
Nombr e I nt er f a z, la siguiente instruccin
e. unMet odo ( n e w I mpl ement a ( ) ) ;
pasa a e. unMet odo una nueva instancia de dicha clase I mpl ement a como par-
metro. Si se quisiera emplear una clase annima no se efectuara la declaracin de
i mpl ement a y la instruccin anterior se sustituira por:
e. unMt odo ( n e w Nombr eI nt er f az ( )
I
public t i poDeResul t ado nombr eMt odo( )
(
/ / . . .
1
/* se i mpl ement an t odos l os mt odos de l a i nt er f az
Nombr eI nt er f az */
1
) ;
462 Java 2. Manual de programacin
C.2. SENTENCIAS
C.2.1. Sentencias de declaracin
t ipo n omb r e Va r i ab 1 e ;
Ejemplos
int l ongi t ud;
double e;
Ci r cul o ci r cul o;
C.2.2. Sentencias de asignacin
Una sentencia se asignacin asigna el valor de la expresin en el lado derecho a la
variable del lado izquierdo.
nombre = expresinlegal;
Ejemplos
l ongi t ud = 5 + I ;
i += 5;
C.2.3. Sentencias re turn
Las sentencias r et ur n proporcionan una salida de un mtodo con un valor de
retorno no voi d. Las sentencias de retorno pueden no aparecer en un mtodo con
un tipo de retorno voi d. Las sentencias r et ur n pueden aparecer en cualquier
parte de una estructura de control; producen un retorno inmediato del mtodo. El
valor de la expresin a continuacin del retorno debe coincidir con el tipo de retor-
no del mtodo.
Ejemplo
public int calcularResta(int x, int y) {
I
return x-y;
Gua de sintaxis 463
C.2.4. Sentencias compuestas
Las sentencias compuestas se encierran entre llaves {} y se ejecutan secuencial-
mente dentro del bloque.
Ejemplo
i
i nt m = 25;
i nt n = 30;
i nt p = m + n;
/ / asi gna el val or 25 a m
/ / asi gna el val or 30 a n
/ / asi gna el val or 55 ( m+ n) a p
C.2.5. Sentencia if
Las sentencias de seleccin proporcionan control sobre dos alternativas basadas en
el valor lgico de una expresin.
i f ( expr es i nl gi ca)
bl oqueCen t e nc i as l
/ / si son var i as sent enci as se enci er r an ent r e { }
bloqueCen t enci as21
[else i f ( expr es i nl gi ca)
[else
bl oqueSen tenciashr]
Ejemplo
i f ( i < O )
else
t
Syst em. out . pr i nt l n ( " Nmer o negat i vo" ) ;
Syst em. out . pr i nt ( " Nmer o vl i do, ' I ) ;
Syst em. out . pr i nt l n ( " es posi t i vo" ) ;
1
C.2.6. Sentencia swi t ch
La sentencia swi t ch es la bifurcacin mltiple.
swi tch ( expr es i on- i nt )
f
464 Java 2. Manual de programacin
case constante-expl:
sentenciasl;
ent r e l l aves */
[break; ]
sen t encias2;
[break; ] ]
/ *si se t r at a de ml t i pl es acci ones no es necesar i o encer r ar l as
[case cons tan te-exp2 :
[case constante-expN:
sent en ci a sN;
[break; ] ]
sen tenciasX;
[break; ] ]
[default
Ejemplos
1. switch ( y / 50)
{
case 2: el ement o = new Demo2 ( O, O) ; break;
case 3: el ement o = new Demo3( 0, O, 100) ; break;
case 4: el ement o = new Demo4( 0, O, 200) ; break;
case 5: el ement o = new Demo5( O, O) ; break;
1
2. switch ( n)
case 1:
case 2:
i
vi sual i zar Resul t ado
break;
case 3:
case 4:
case 5:
case 6:
vi sual i zar Resul t ado
vi sual i zar Resul t ado
break;
default:
vi sual i zar Resul t ado
} / / f i n de swi t ch
C.2.7. Etiquetas
nombreE ti que ta :
break [nombreEtiquetal ;
continue [nombreEtiqueta] ;
" 1, 2, Si er r a de Cazor l a" ) ;
" 3, 4, Si er r a Magi na" ) ;
" 3, 6, Si er r a de J aen" ) ;
n + " f uer a de r ango" ) ;
Gua de si nt axi s 465
sal i r :
i
for ( i = O; i < 10; i ++)
{
for ( j = O; j < 20; j ++)
I
if ( i == 1) break sal i r ;
Syst em. out . pr i nt ( j + " " ) ;
Syst em. out . pr i nt l n0;
1
} / / f i n del bl oque con l a et i quet a
C.2.8. Sentencia while
La sentencia whi l e se utiliza para crear repeticiones de sentencias en el flujo del
programa.
while (expresinlgica)
bl oqueSen tencias
/ / el bl oquesent enci as puede ej ecut ar se de O a n veces
Ejemplo
while ( cuent a <= numer o)
{
Syst em. out . pr i nt ( cuent a + ' I , ") ;
cuent a++;
1
C.2.9. Sentencia do-while
La sentencia do- whi l e se utiliza para repetir la ejecucin de sentencias y se eje-
cuta al menos una vez.
do
while (expresinLgica) ;
bloquesentencias / / el bl oquesent enci as se ej ecut a al menos una vez
466 Java 2. Manual de programacin
Ejemplo
do
System.out . pr i nt ( cuenta + ' I , ' I ) ;
cuenta++;
I
while ( cuenta <= numero)
C.2.1 O. Sentencia for
La sentencia f or se usa para repetir un nmero fijo de veces la ejecucin de una
serie de sentencias.
f or ( [ i ni ci aci n] ; [condi ci nDeTest] ; [ actual i zaci n] )
sentenci as
Ejemplo
f or ( i nt i = O; i < 10; it+)
a[ i ] = 5 * i;
C.2.11. Mtodo e xi t y sentencia break
La sentencia brea k se puede utilizar en una sentencia s w i t c h o en cualquier tipo
de sentencia de bucles. Cuando se ejecuta break el bucle que lo contiene o la sen-
tencia swi t ch terminan y el resto del cuerpo del bucle no se ejecuta. Una invoca-
cin al mtodo exi t termina una aplicacin. El formato normal de una invocacin
al mtodo exi t es
System. exi t ( O ) ;
La captura de excepciones se realiza mediante bloques try- catch. La/s senten-
ciais de un bloque se colocarn siempre entre llaves.
try
bl oqueAI ntentar //aunque sea una ni ca sentenci a sta i r entre { }
boqueCen t en ci a s 1
catch (ti poExcepci on1 i denti f i cador l )
Gua de si nt axi s 467
[catch ( t i poExcepci on2 i dent i f i cadoz- 2)
boqueSen t en ci a s2]
. . .
[ f i nal l y
boqueSen t enci ashr ]
o bien
try
f i nal l y
bl oqueAi n t en t a r
boquesen t enci asN
ya que el bloque t r y no puede aparecer slo.
import j ava. i o. *;
public class Ret ur nTr yEj
{
public s t a t i c i nt l eer ( )
i
I nput St r eamReader i sr = new I nput St r eamReader ( Syst em. i n) ;
Buf f er edReader br = new Buf f er edReader ( i sr ) ;
St r i ng cadena = ' I " ;
try
{
cadena = br . r eadLi ne ( ) ;
return I nt eger . par seI nt ( cadena) ;
1
catch ( Except i on e)
{
i f ( e instanceof I OExcept i on)
else i f ( e instanceof Number For mat Except i on)
Syst em. out . pr i nt 111 ( " Er r or de ent r ada/ sal i da" ) ;
Syst em. out . pr i nt l n ( " No t ecl e un nmer o ent er o" ) ;
1
/ / I nst r ucci n si gui ent e a cat ch
Syst em. out . pr i nt 111 ( " Se devuel ve O" ) ;
return O;
public s t a t i c void mai n ( St r i ng ar gs [ ] )
t
i nt n;
do
{
468 Java 2. Manual de programacin
Syst em. out . pr i nt ( " Deme un nmer o ent er o ent r e 1 y 20 ' I ) ;
n = l eer ( ) ;
1
while ( ( n <= O) I 1 ( n > 20) ) ;
Syst em. out . pr i nt l n( " 2A' ' + n + " = " + Mat h. pow( 2, n) ) ;
1
C.2.13. Sentencia throw
Una sentencia t hr ow lanza una excepcin, que puede ser una excepcin recibida
o bien una nueva excepcin. Una clusula cat ch puede recibir una excepcin y, en
lugar de tratarla o despus de hacerlo, volver a lanzarla mediante una instruccin
t hr ow.
try
bl oque AI nt e nt ar
catch ( NumberForma t Excep t ion i d e n t i f i cador )
{
//. . .
throw ( i d e n t i f i c a d o r ) ;
1
Para lanzar una nueva excepcin, se crea un objeto de una subclase de
Except i on que implemente un constructor y se lanza con t hr ow cuando ocurra
el hecho que debe provocar la excepcin:
if ( e x p r e s i n l g i c a )
throw new ConstuctorSublclaseException ( [ par met r oi [, parmet ro2
[, . . . I l l ) ;
Ejemplo
if ( edad < 18 I I edad > 65)
throw new Fuer aDeRango ( " Excepci n: val or f uer a de r ango" ) ;
cl ass Fuer aDeRango extends Except i on
{
St r i ng mensaj e;
public Fuer aDeRango ( St r i ng causa)
i
mensaj e = causa;
Gua de sintaxis 469
publ i c St r i ng get Message ( )
i
1
return mensaj e;
C.2.14. Sentencia throws
Lista las excepciones no tratadas y pertenecientes a clases distintas de
Runt i meExcept i on. As, su tratamiento ser pospuesto y deber ser efectuado
por el mtodo llamador o tendrn que volver a ser listadas en la cabecera de ste con
otra clusula t hr ows.
[ rnodi fi cadoresDeM todos] t i poDeResul t ado nombr eMt odo
( [ t i p o p a r me trol parme t r o l
[, t i poParrnet ro2 parrnet ro2[, . . . I , ' ] )
[throws Excepcin1 [,
Excepci n2 [, . . . I I I
/ / cuer po del mt odo que no t r at a l a excepci n
C.2.15. Sentencia package
Cada clase pblica definida en J ava debe ser almacenada en un archivo separado
y si hay varias relacionadas todas ellas se almacenan en el mismo subdirectorio.
Un conjunto de clases relacionadas definidas en un subdirectorio comn puede
constituir un paquete J ava. Los archivos del paquete deben comenzar con la
siguiente sentencia:
package nombrepaquete;
donde el nombre del paquete refleja el subdirectorio que contiene dichas clases. Se
utiliza el carcter punto ( . ) como separador entre nombres de directorios, cuando
es necesario especificar varios para referenciar al que contiene las clases.
Ejemplo
package l i br o. Tema03;
470 Java 2. Manual de programacin
Se puede usar una clase definida en otro paquete especificando, para referirse
a ella, la estructura de directorios del otro paquete seguida por el nombre de la
clase que se desea usar y empleando el carcter punto como separador.
Referenciar clases de esta forma puede resultar molesto y la solucin consiste en
utilizar i mport, que permite incluir clases externas o paquetes enteros en el
archivo actual.
c.3. MISCELNEA
C.3.1. Referencia a mi embros de una cl ase
r: arnkre0bj e t o. i? omOreComponen te
Si es st at i c no es necesario referirse a una instancia en particular de la clase
y puede referenciarse como
nombreClase. nombreComponente
Los miembros de una clase estn asociados con una instancia especfica de la
misma, excepto si son estticos.
C.3.2. Conversin expl ci ta de ti pos
Existen dos tipos fundamentales de conversiones de tipos que pueden ser realizados
en J ava, con respecto a tipos numricos y con respecto a objetos. El formato a apli-
car para efectuar una conversin explcita de tipos es:
(t j poA' ombre) expresin;
Ejemplo
double r esul t aao = (double) ( 4/ 8) ; / / asi gna 0. 0 al r esul t ado
double r esul t ado = (double)4/(double)8; / / asi gna 0. 5 al r esul t ado
double r esl J l t ado = (double) 4/ 8; / / asi gna O. 5 al r esul t ado
double r esi i l t aao = 4/ 5; / *conver si n i mpl ci t a, asi gna 0. 0 al
r esul t ado */
A1cmr.o unAl umno = ( Al uyno) KnaPer sona;
Gua de sintaxis 471
C.4. ARRAYS
Un array es un objeto que contiene un nmero de posiciones de memoria consecu-
tivas, celdas de memoria, cada una de las cuales contiene datos del mismo tipo. Los
arrays en J ava pueden se unidimensionales o multidimensionales
C.4.1. Decl araci n de un array
int ar r Ent ] ; / / ar r ay uni di mensi onal capaz ae al nace- ar ent er os
float [ ] ar r Fl oat ; / / ar r ay uni di mensi onal capaz de al macenar floa:
double[] ; j ar r Codbl e; / / ar r ay bi di mensi onal par a al macenar datos cioLble
int a [ ] [ I ; / / ar r ay bi di mens- ona- capaz de al rracenar ent er os
C.4.2. Creaci n de un array
ar r Ent = new int[100]; / *necesar i a su pr evi a dec1ar az: n:
i nt ar r Ent [ ] ; */
Es posible crear arrays en los que cada fila contiene un nmero diferente de
columnas:
a = new int[3] [ I ; / / asi gna f i l as ( supuest a l a pr evi a aecl ar aci n)
a [ O ] = new int[7]; / / asi gna 7 col umnas a l a f ; i a O
a[i] = new int[5]; / / asi gna 5 col umnas a l a f i l a 1
a[ 2] = new int[9]; / / asi gna 9 col umnas a l a f i l a 2
C.4.3. Combi nar decl araci n y creaci n
La declaracin y la creacin se pueden combinar.
int[] ar r Ent = new intiloo];
double[] [ I ar r Doubl e = new doubie[8j [ l o] ;
Pel ot a [ ] ar r ayPel ot as = new Pel ot a; l C] ;
C.4.4. Com binar decl araci n creaci n e i ni ci al i zaci n
int[] ar r Ent = 119, 2, 3 , 5, 7, 6, 8, 15, 9, 12) ;
472 Java 2. Manual de programacin
C.4.5. Recorrido de l os el ementos de un array
Se suele efectuar con ayuda de estructuras repetitivas.
for (int i = O; i < ar r ayPel ot as. 1engt h; i ++)
ar r ayPel ot as [ i ] = new Pel ot a ( ) ;
C.4.6. Acceso a un el emento de un array
Se accede a un elemento de un array mediante un ndice que debe ser un valor ente-
ro mayor o igual que cero y menor que el nmero de elementos del array (almace-
nado en la variable de instancia l engt h) y que especifica la posicin del elemento
en el array
ar r ayPel ot as [ 5] . mover A( 24, 15) ;
a[O] [ 5] = 2 + a[Ol [ 4] ;
C.5. CADENAS
Una cadena (string) es una secuencia de caracteres. J ava proporciona una clase
incorporada St r i ng para manejar cadenas de caracteres:
St r i ng msg = " Si er r a de Cazor l a" ;
Si cadl y cad2 son variables de tipo cadena
cadl == cad2
comprueba si las dos variables se refieren al mismo objeto. Mientras que
cadl . compar eTo( cad2)
devuelve positivo, cero o negativo segn cadl sea mayor, igual o menor que cad2.
C.5.1. Concatenaci n de cadenas
El operador +en J ava tiene un significado especial de concatenacin de cadenas
y se puede utilizar con objetos de la clase St r i ng, que pertenece al paquete
Gua de si ntaxi s 473
j ava . l ang. Al contrario que C++, J ava no soporta sobrecarga de operadores, el
caso del operador + para concatenacin de cadenas es una excepcin a esta regla de
J ava. En cuanto uno de los operandos que intervienen en una expresin es de cade-
na, el operador + convierte a cadena los valores de otros tipos que intervienen en la
expresin y efecta concatenacin:
a + b / / al menos a o b han de ser una cadena
Ejemplos
Syst em. out . pr i nt l n ( 5+1) ; / / Sal i da 6
Syst em. out . pr i nt l n (""t5ii) ; / / Sal i da 51
g. dr awSt r i ng( 5+1, 100, 100) ; / / Er r or de si nt axi s
g. dr awCt r i ng ( " 5 + 1 = " +5+1, 100, 100) ; / / Sal i da 5 + 1 = 51
St r i ng h = new St r i ng ( " Fel i ci dades" ) ;
St r i ng pm = new St r i ng( " par a Mackoy" ) ;
St r i ng t i t ul o = h + " " + pm;
/ / i mpr i me Fel i ci dades par a Mackoy;
Cyst em. out . pr i nt l n( t i t u1o) ;
C.6. APPLETS
Los applets son pequeos programas J ava que se incluyen en pginas Web y cuyo
cdigo se descarga desde el servidor para ser ejecutado localmente por un navega-
dor. Todas las applets disponen de cinco mtodos que pueden sobreescribir, aunque
no resulta obligatorio que lo hagan, pues tienen implementaciones por defecto, y
que se invocarn automticamente durante la ejecucin de la misma. Cuatro de ellos
son proporcionados por la clase Appl et y el otro es pai nt perteneciente a la
clase Cont ai ner .
import j ava. awt . *;
import j ava. appl et . *;
public class Nombr eAppl et extends Appl et
t
public void i ni t ( )
t
/ * I ni ci al i za el appl et y es i nvocado por el Appl et vi ewer o el
navegador cuando se car ga el appl et */
1
public void st ar t ( )
I
474 Java 2. Manual de programacin
/ * Se ej ecct a a cont i nuaci on de i ni t y t ambi en cada vez que e ;
usuar i o ael navegador r egr esa a l a pagi na HI M donde
r esi de el appl et . Debe cont ener l as t ar eas a Ll evar a cabo
en est as ocasi ones */
public void st op( )
/ x Se e; ecLt a cuando el usuar i o abandona l a pagi na HTML er, l a que
r esi de el appl e: */
public void dest r oy( )
I
/ * Li ber a t odos l o s r ecur sos que el appl et est 2 Lt i l i zaxdo y se
ej ecut a axt es de q'e l a appl et se descar gue cuando e l usuar i o
sal e de l a sesi n de navegaci n */
public void pai n= ( Gr aphi cs g)
I
/ * D- bul a en el appl et al comenzar est a a ej ecut ar se y t amb; en
cada vez qLe l a mi sma necesi t a r edi buj ar se */