Introduccion a Ciencias de la

Computacion I
(con Java)

Elisa Viso G.
Canek Pelaez V.
Facultad de Ciencias, UNAM
Indice general

1. Introduccion 1
1.1. Conceptos generales . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2. Historia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3. Sistemas numericos . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.4. La Arquitectura de Von Neumann . . . . . . . . . . . . . . . . . . 13
1.5. Ejecucion de programas . . . . . . . . . . . . . . . . . . . . . . . 25
1.5.1. Filosofas de programacion . . . . . . . . . . . . . . . . . . 26
1.6. Caractersticas de Java . . . . . . . . . . . . . . . . . . . . . . . . 27

2. El Proceso del Software 29

2.1. Que es la programacion? . . . . . . . . . . . . . . . . . . . . . . 29
2.1.1. Conceptos en la orientacion a objetos . . . . . . . . . . . . 36
2.2. Diseno orientado a objetos . . . . . . . . . . . . . . . . . . . . . . 42
2.2.1. Tarjetas de responsabilidades . . . . . . . . . . . . . . . . 45
2.3. Diseno Estructurado . . . . . . . . . . . . . . . . . . . . . . . . . 46

3. Clases y Objetos 55
3.1. Tarjetas de responsabilidades . . . . . . . . . . . . . . . . . . . . 55
3.2. Programacion en Java . . . . . . . . . . . . . . . . . . . . . . . . 62
3.2.1. Declaraciones en Java . . . . . . . . . . . . . . . . . . . . 63
3.2.2. Alcance de los identificadores . . . . . . . . . . . . . . . . 81
3.2.3. Implementacion de metodos en Java . . . . . . . . . . . . 83
3.3. Expresiones en Java . . . . . . . . . . . . . . . . . . . . . . . . . . 91
3.3.1. Declaracion y definicion simultaneas . . . . . . . . . . . . 98

4. Manejo de cadenas y expresiones 101

4.1. Manejo de cadenas en Java . . . . . . . . . . . . . . . . . . . . . . 101
4.2. Implementacion de una Base de Datos . . . . . . . . . . . . . . . 106
4.3. Una clase Menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
4.3.1. Salir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
INDICE GENERAL ii

4.3.2. Agrega estudiante . . . . . . . . . . . . . . . . . . . . . . . 139

4.3.3. Quita estudiante . . . . . . . . . . . . . . . . . . . . . . . 140
4.3.4. Busca estudiante . . . . . . . . . . . . . . . . . . . . . . . 141
4.3.5. Lista todo el curso . . . . . . . . . . . . . . . . . . . . . . 141
4.3.6. Lista los que cumplan con algun criterio . . . . . . . . . . 141
4.3.7. Valor por omision . . . . . . . . . . . . . . . . . . . . . . . 141
4.3.8. Metodo principal de MenuCurso . . . . . . . . . . . . . . . 141

5. Datos estructurados 145

5.1. La clase para cada registro . . . . . . . . . . . . . . . . . . . . . . 146
5.2. La lista de registros . . . . . . . . . . . . . . . . . . . . . . . . . . 151
5.2.1. Paso por valor y por referencia . . . . . . . . . . . . . . . 162
5.2.2. Eliminado de registros . . . . . . . . . . . . . . . . . . . . 163
5.2.3. La clase MenuLista . . . . . . . . . . . . . . . . . . . . . . 166

6. Herencia 171
6.1. Extension de clases . . . . . . . . . . . . . . . . . . . . . . . . . . 171
6.2. Arreglos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
6.2.1. Arreglos de una dimension . . . . . . . . . . . . . . . . . . 175
6.2.2. Iteracion enumerativa . . . . . . . . . . . . . . . . . . . . . 183
6.2.3. Arreglos de mas de una dimension . . . . . . . . . . . . . . 187
6.2.4. Los arreglos como parametros y valor de regreso . . . . . . 190
6.3. Aspectos principales de la herencia . . . . . . . . . . . . . . . . . 193
6.3.1. Super y subclases . . . . . . . . . . . . . . . . . . . . . . . 193
6.4. Polimorfismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
6.5. Clases abstractas . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
6.6. Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200

7. Administracion de la memoria durante ejecucion 203

7.1. El stack y el heap . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
7.2. Recursividad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
7.2.1. Las torres de Hanoi . . . . . . . . . . . . . . . . . . . . . . 237

8. Ordenamientos usando estructuras de datos 245

8.1. Base de datos en un arreglo . . . . . . . . . . . . . . . . . . . . . 245
8.2. Manteniendo el orden con listas ligadas . . . . . . . . . . . . . . . 264
8.2.1. Revisita de la clase ListaCurso . . . . . . . . . . . . . . . . 267
8.3. *Ordenamiento usando arboles . . . . . . . . . . . . . . . . . . . . 271
8.3.1. Construccion de arboles binarios para ordenamientos . . . 274
8.3.2. La clase ArbolOrden . . . . . . . . . . . . . . . . . . . . . . 276
iii INDICE GENERAL

8.3.3. Insercion . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

8.3.4. Listar toda la base de datos . . . . . . . . . . . . . . . . . 279
8.3.5. Conservacion de la aleatoriedad de la entrada . . . . . . . 281
8.3.6. Busquedas . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
8.3.7. Listado condicionado de registros . . . . . . . . . . . . . . 285
8.3.8. Eliminacion de nodos . . . . . . . . . . . . . . . . . . . . . 287
8.3.9. La clase MenuOrden . . . . . . . . . . . . . . . . . . . . . . 293

9. Manejo de errores en ejecucion 295

9.1. Tipos de errores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
9.1.1. Excepciones en tiempo de ejecucion (RuntimeException) . . 296
9.2. La clase Exception . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
9.3. Como detectar y cachar una excepcion . . . . . . . . . . . . . . . 302
9.4. Las clases que extienden a Exception . . . . . . . . . . . . . . . . 311
9.4.1. Relanzamiento de excepciones . . . . . . . . . . . . . . . . 317
9.5. El enunciado finally . . . . . . . . . . . . . . . . . . . . . . . . . . 317
9.6. Restricciones para las excepciones . . . . . . . . . . . . . . . . . . 322
9.6.1. Apareamiento de excepciones . . . . . . . . . . . . . . . . 324
9.7. Recomendaciones generales . . . . . . . . . . . . . . . . . . . . . . 325

10.Entrada y salida 327

10.1. Conceptos generales . . . . . . . . . . . . . . . . . . . . . . . . . . 327
10.2. Jerarqua de clases . . . . . . . . . . . . . . . . . . . . . . . . . . 330
10.3. Entrada y salida de bytes . . . . . . . . . . . . . . . . . . . . . . 330
10.4. Entrada y salida de caracteres . . . . . . . . . . . . . . . . . . . . 335
10.4.1. Entrada y salida estandar . . . . . . . . . . . . . . . . . . 337
10.5. El manejo del menu de la aplicacion . . . . . . . . . . . . . . . . . 339
10.5.1. La clase OutputStream . . . . . . . . . . . . . . . . . . . 339
10.5.2. Lectura desde teclado . . . . . . . . . . . . . . . . . . . . . 348
10.6. Redireccionamiento de in, out y err . . . . . . . . . . . . . . . . . 358
10.7. Persistencia de la base de datos . . . . . . . . . . . . . . . . . . . 359
10.7.1. Como guardar datos en un archivo en disco . . . . . . . . 365
10.7.2. Como leer registros de un archivo de disco . . . . . . . . . 368
10.7.3. Como agregar a un archivo ya creado . . . . . . . . . . . . 371
10.8. Escritura y lectura de campos que no son cadenas . . . . . . . . . 373
10.8.1. Escritura en archivos binarios . . . . . . . . . . . . . . . . 381
10.8.2. Lectura de archivos binarios . . . . . . . . . . . . . . . . . 382
10.8.3. Acceso semi directo a archivos binarios . . . . . . . . . . . 387
10.8.4. Lectura directa de registros . . . . . . . . . . . . . . . . . 390
10.8.5. Escritura directa de registros . . . . . . . . . . . . . . . . . 397
INDICE GENERAL iv

10.9. Lectura y escritura de objetos . . . . . . . . . . . . . . . . . . . . 401

10.10.Colofon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416

11.Hilos de ejecucion 417

11.1. Que es un hilo de ejecucion? . . . . . . . . . . . . . . . . . . . . 417
11.2. La clase Thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
11.3. La interfaz Runnable . . . . . . . . . . . . . . . . . . . . . . . . . 421
11.3.1. Constructores de la clase Thread . . . . . . . . . . . . . . 423
11.4. Sincronizacion de hilos de ejecucion . . . . . . . . . . . . . . . . . 424
11.4.1. Metodos sincronizados . . . . . . . . . . . . . . . . . . . . 424
11.4.2. Sincronizacion de metodos y la herencia . . . . . . . . . . 426
11.4.3. Metodos estaticos sincronizados . . . . . . . . . . . . . . . 427
11.4.4. Enunciados sincronizados . . . . . . . . . . . . . . . . . . . 427
11.4.5. Modelos de sincronizacion . . . . . . . . . . . . . . . . . . 430
11.5. Comunicacion entre hilos de ejecucion . . . . . . . . . . . . . . . . 430
11.5.1. Ejemplo: un servidor de impresora . . . . . . . . . . . . . 432
11.5.2. Mas detalles sobre la espera y la notificacion . . . . . . . . 435
11.6. Alternativas para la programacion de procesos . . . . . . . . . . . 438
11.6.1. Desalojo voluntario . . . . . . . . . . . . . . . . . . . . . . 439
11.7. Abrazo mortal (deadlock ) . . . . . . . . . . . . . . . . . . . . . . 441
11.8. Como se termina la ejecucion de un proceso . . . . . . . . . . . . 445
11.8.1. Cancelacion de un proceso . . . . . . . . . . . . . . . . . . 446
11.8.2. Terminacion de la ejecucion de un proceso . . . . . . . . . 450
11.9. Terminacion de la aplicacion . . . . . . . . . . . . . . . . . . . . . 452
11.10.Depuracion en hilos de ejecucion . . . . . . . . . . . . . . . . . . . 455
11.11.Otros temas relacionados con hilos de ejecucion . . . . . . . . . . 457
Indice de Figuras

1.1. Arquitectura de von Neumann . . . . . . . . . . . . . . . . . . . . 14

1.2. Proceso para ejecutar un programa escrito en ensamblador . . . . 15
1.3. Codificacion en ensamblador de formulas matematicas. . . . . . . 17
1.4. Enteros en signo y magnitud. . . . . . . . . . . . . . . . . . . . . 19
1.5. Numeros en complemento a 2 . . . . . . . . . . . . . . . . . . . . 21
1.6. Suma de dos numeros con complemento a 2 . . . . . . . . . . . . 21
1.7. Sumando 1 al maximo entero positivo . . . . . . . . . . . . . . . . 22
1.8. Notacion de punto fijo. . . . . . . . . . . . . . . . . . . . . . . . . 23

2.1. Proceso del software. . . . . . . . . . . . . . . . . . . . . . . . . . 30

2.2. Arbol de herencia en clases. . . . . . . . . . . . . . . . . . . . . . 40
2.3. Uso de llaves para denotar composicion. . . . . . . . . . . . . . . 48
2.4. Iteracion en diagramas de Warnier-Orr. . . . . . . . . . . . . . . . 49
2.5. Seleccion en diagramas de Warnier-Orr. . . . . . . . . . . . . . . . 49
2.6. Diagramas de Warnier-Orr para secuencia. . . . . . . . . . . . . . 50
2.7. Diagramas de Warnier-Orr para iteracion. . . . . . . . . . . . . . 50
2.8. Diagrama de Warnier-Orr para seleccion. . . . . . . . . . . . . . . 50
2.9. Estado inicial de todo diagrama de Warnier-Orr. . . . . . . . . . . 51
2.10. Diagrama inicial para encontrar factores primos. . . . . . . . . . . 51
2.11. Diagrama de Warnier-Orr para procesar cada k. . . . . . . . . . . 52
2.12. Diagrama para determinar si k es primo. . . . . . . . . . . . . . . 53
2.13. Diagrama de Warnier-Orr para obtener factores primos de un entero. 54

3.1. Tarjetas de clasificacion y acceso. . . . . . . . . . . . . . . . . . . 58

3.2. Tarjeta de responsabilidades de la clase Reloj . . . . . . . . . . . 58
3.3. Tarjeta de responsabilidades para la clase Manecilla. . . . . . . . 59
3.4. Tarjeta de colaboraciones de la clase Manecilla. . . . . . . . . . 60
3.5. Tarjeta de colaboraciones de la clase Reloj. . . . . . . . . . . . . 61
3.6. Encabezado de una interfaz. . . . . . . . . . . . . . . . . . . . . . 64
3.7. Sintaxis para el xaccesoy. . . . . . . . . . . . . . . . . . . . . . . . 64
3.8. Reglas para la formacion de un xidentificadory. . . . . . . . . . . . 65
INDICE DE FIGURAS vi

3.9. Encabezado de una clase. . . . . . . . . . . . . . . . . . . . . . . . 67

3.10. Encabezado para los metodos de acceso. . . . . . . . . . . . . . . 69
3.11. Especificacion de parametros. . . . . . . . . . . . . . . . . . . . . 71
3.12. Encabezado de un constructor. . . . . . . . . . . . . . . . . . . . 76
3.13. Declaracion de un atributo . . . . . . . . . . . . . . . . . . . . . . 79
3.14. Acceso a atributos o metodos de objetos . . . . . . . . . . . . . . 81
3.15. Sintaxis para la implementacion de un metodo. . . . . . . . . . . 83
3.16. Declaracion de variables locales. . . . . . . . . . . . . . . . . . . . 84
3.17. El enunciado de asignacion. . . . . . . . . . . . . . . . . . . . . . 88
3.18. Construccion de objetos. . . . . . . . . . . . . . . . . . . . . . . . 89
3.19. Invocacion de metodo. . . . . . . . . . . . . . . . . . . . . . . . . 89

4.1. Tarjeta de responsabilidades para Curso. . . . . . . . . . . . . . . 107

4.2. Tarjeta de responsabilidades para Curso. . . . . . . . . . . . . . . 113
4.3. Diagrama de Warnier-Orr para los constructores. . . . . . . . . . 114
4.4. Diagrama de Warnier-Orr para regresar el contenido de un campo. 116
4.5. Encontrar el numero de registro al que pertenece una subcadena. . 118
4.6. Edicion del i-esimo registro, si es que existe. . . . . . . . . . . . . 119
4.7. Algoritmos para listar el curso. . . . . . . . . . . . . . . . . . . . 120
4.8. Enunciado compuesto while. . . . . . . . . . . . . . . . . . . . . . 121
4.9. Encontrar el lmite de 21n , dado . . . . . . . . . . . . . . . . . . 122
4.10. Sumar numero mientras no me den un
1 . . . . . . . . . . . . . 123
4.11. Enunciado compuesto do . . . while . . . . . . . . . . . . . . . . . 123
4.12. Algoritmo para agregar un estudiante. . . . . . . . . . . . . . . . 126
4.13. Posibles situaciones para eliminar a un registro. . . . . . . . . . . 127
4.14. Algoritmo para eliminar a un estudiante de la lista. . . . . . . . . 128
4.15. Enunciado compuesto condicional . . . . . . . . . . . . . . . . . . 129
4.16. Metodo que encuentra TODOS los que contienen a una subcadena. 130
4.17. Menu para uso de la clase Curso. . . . . . . . . . . . . . . . . . . 132
4.18. Enunciado switch. . . . . . . . . . . . . . . . . . . . . . . . . . . 133
4.19. Enunciado break. . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

5.1. Ilustracion de una lista. . . . . . . . . . . . . . . . . . . . . . . . . 146

5.2. Contando los registros de una lista. . . . . . . . . . . . . . . . . . 154
5.3. Procesando los registros de una lista. . . . . . . . . . . . . . . . . 155
5.4. Agregando al principio de la lista. . . . . . . . . . . . . . . . . . . . 156
5.5. Esquema del agregado un registro al principio de la lista. . . . . . . . 156
5.6. Agregando al final de la lista. . . . . . . . . . . . . . . . . . . . . 157
5.7. Agregando al final de la lista. . . . . . . . . . . . . . . . . . . . . 158
5.8. Imprimiendo todos los registros. . . . . . . . . . . . . . . . . . . . 159
vii INDICE DE FIGURAS

5.9. Imprimiendo registros seleccionados. . . . . . . . . . . . . . . . . 160

5.10. Patron de busqueda de un registro que cumpla con . . . . . . . . . 161
5.11. Eliminando a un estudiante. . . . . . . . . . . . . . . . . . . . . . 163
5.12. Eliminado de un registro en una lista. . . . . . . . . . . . . . . . . 164

6.1. intr s primos = {2,3,5,7,11}; . . . . . . . . . . . . . . . . . . . . . 178

6.2. float [ ] vector = { 3.14, 8.7, 19.0}; . . . . . . . . . . . . . . . . . 178
6.3. String [ ] cadenas = { S, No}; . . . . . . . . . . . . . . . . . 178
6.4. Declaracion del contenido de un arreglo de objetos . . . . . . . . . 179
6.5. int r s primos = new intr5s; . . . . . . . . . . . . . . . . . . . . . 180
6.6. EstudianteBasicor s estudiantes = . . . . . . . . . . . . . . . . . . . 181
6.7. floatr s vector = floatr3s; . . . . . . . . . . . . . . . . . . . . . . 181
6.8. Stringr s cadenas = new Stringr2s; . . . . . . . . . . . . . . . . . . 181
6.9. Reasignacion de arreglos. . . . . . . . . . . . . . . . . . . . . . . . 183
6.10. Acomodo en memoria de un arreglo de dos dimensiones. . . . . . 188
6.11. Ejecucion de la clase Arreglos. . . . . . . . . . . . . . . . . . . . . 192
6.12. Jerarqua de clases. . . . . . . . . . . . . . . . . . . . . . . . . . . 198

7.1. Estructura de bloques de un programa. . . . . . . . . . . . . . . . 204

7.2. Diagrama de anidamiento dinamico. . . . . . . . . . . . . . . . . . 208
7.3. Secuencia de llamadas en el listado 7.1. . . . . . . . . . . . . . . . 208
7.4. Esquema de una stack o pila. . . . . . . . . . . . . . . . . . . . . 210
7.5. Algoritmo para ejecutar un programa. . . . . . . . . . . . . . . . 211
7.6. Estado del stack al iniciarse la ejecucion de una clase. . . . . . . . 214
7.7. El stack al iniciarse la llamada a main. . . . . . . . . . . . . . . . 214
7.8. Registro de activacion para main. . . . . . . . . . . . . . . . . . . 215
7.9. El stack listo para iniciar la ejecucion de main. . . . . . . . . . . . 215
7.10. El stack durante la ejecucion de main. . . . . . . . . . . . . . . . . 216
7.11. El stack durante la ejecucion de A. . . . . . . . . . . . . . . . . . 217
7.12. El stack antes de empezar a ejecutar B. . . . . . . . . . . . . . . . 218
7.13. El stack antes de empezar a ejecutar C desde la lnea #16:. . . . . 219
7.14. El stack al terminar de ejecutarse C(). . . . . . . . . . . . . . . . 220
7.15. El stack al terminar la ejecucion de B(10,3). . . . . . . . . . . . . 220
7.16. El stack al terminar la ejecucion de A(10). . . . . . . . . . . . . . 221
7.17. El stack antes de la ejecucion de B(3,2). . . . . . . . . . . . . . . 222
7.18. El stack antes de la ejecucion de C(). . . . . . . . . . . . . . . . . 223
7.19. El stack al terminar la ejecucion deC(). . . . . . . . . . . . . . . . 224
7.20. El stack al terminar la ejecucion de B(3,2). . . . . . . . . . . . . . 224
7.21. El stack antes de empezar la ejecucion de C(). . . . . . . . . . . . 225
7.22. El stack listo para iniciar la ejecucion de main. . . . . . . . . . . . 226
INDICE DE FIGURAS viii

7.23. Estado del stack al iniciarse la ejecucion de una clase. . . . . . . . 229

7.24. Estado del stack al iniciarse la llamada de factorial desde main. . . 230
7.25. Estado del stack al iniciarse la llamada de factorial desde factorial. 231
7.26. Estado del stack al iniciarse la llamada de factorial desde factorial. 232
7.27. Estado del stack al iniciarse la llamada de factorial desde factorial. 233
7.28. Estado del stack al terminarse la llamada de factorial(1). . . . . . 234
7.29. Estado del stack al terminarse la llamada de factorial(2). . . . . . 235
7.30. Estado del stack al terminarse la llamada de factorial(3). . . . . . 236
7.31. Estado del stack al terminarse la llamada de factorial desde main. . 236
7.32. Juego de las torres de Hanoi . . . . . . . . . . . . . . . . . . . . . 238
7.33. Estrategia recursiva para las torres de Hanoi . . . . . . . . . . . . 238
7.34. Secuencia de llamadas en la torres de Hanoi . . . . . . . . . . . . 240
7.35. Situacion de las fichas antes de la llamada . . . . . . . . . . . . . 241
7.36. Movimientos /* 1 */ al /* 3 */ . . . . . . . . . . . . . . . . . . . 241
7.37. Movimiento /* 4 */ . . . . . . . . . . . . . . . . . . . . . . . . . . 241
7.38. Movimientos /* 5 */ al /* 7 */ . . . . . . . . . . . . . . . . . . . 242
7.39. Movimiento /* 8 */ . . . . . . . . . . . . . . . . . . . . . . . . . . 242
7.40. Movimientos /* 9 */ al /* 11 */ . . . . . . . . . . . . . . . . . . . 242
7.41. Movimiento /* 12 */ . . . . . . . . . . . . . . . . . . . . . . . . . 243
7.42. Movimientos /* 13 */ al /* 15 */ . . . . . . . . . . . . . . . . . . 243

8.1. Algoritmo para eliminar a un estudiante . . . . . . . . . . . . . . 261

8.2. Agregando al principio de la lista . . . . . . . . . . . . . . . . . . 268
8.3. Agregando en medio de la lista. . . . . . . . . . . . . . . . . . . . 269
8.4. Agregando un registro en orden. . . . . . . . . . . . . . . . . . . . 270
8.5. Definicion recursiva de un arbol. . . . . . . . . . . . . . . . . . . . 272
8.6. Arbol binario bien organizado. . . . . . . . . . . . . . . . . . . . . 273
8.7. Arbol que se forma si los registros vienen ordenados. . . . . . . . 275
8.8. Agregar un registro manteniendo el orden. . . . . . . . . . . . . . 277
8.9. Ejemplo simple para recorridos de arboles. . . . . . . . . . . . . . 279
8.10. Recorrido simetrico de un arbol . . . . . . . . . . . . . . . . . . . 280
8.11. Recorrido en preorden de un arbol . . . . . . . . . . . . . . . . . . 282
8.12. Busqueda en un arbol ordenado . . . . . . . . . . . . . . . . . . . 283
8.13. Busqueda de una subcadena . . . . . . . . . . . . . . . . . . . . . . 284
8.14. Seleccion de registros que cumplen una condicion . . . . . . . . . 286
8.15. Algoritmo para encontrar el menor de un subarbol . . . . . . . . . 289
8.16. Eliminacion de un nodo en un arbol . . . . . . . . . . . . . . . . . 290

9.1. Ejecucion de AritmExc. . . . . . . . . . . . . . . . . . . . . . . . . 297

9.2. Ejecucion de ArraySE. . . . . . . . . . . . . . . . . . . . . . . . . . 297
ix INDICE DE FIGURAS

9.3. Ejecucion del programa ClassCE. . . . . . . . . . . . . . . . . . . . 298

9.4. Deteccion y manejo de excepciones. . . . . . . . . . . . . . . . . . 302
9.5. Excepciones de tiempo de ejecucion cachadas con una superclase. 304
9.6. Ejecucion con relanzamiento de la excepcion. . . . . . . . . . . . . 306
9.7. Ejecucion de CaracteristicasExtra. . . . . . . . . . . . . . . . . . . 316
9.8. Ejecucion de FinallyTrabaja. . . . . . . . . . . . . . . . . . . . . . 318
9.9. Ejecucion de SiempreFinally. . . . . . . . . . . . . . . . . . . . . . 321

10.1. Algoritmo para el uso de flujos de entrada . . . . . . . . . . . . . 328

10.2. Algoritmo para el uso de flujos de salida . . . . . . . . . . . . . . 329
10.3. Funcionamiento de flujo de entrada . . . . . . . . . . . . . . . . . 329
10.4. Funcionamiento de flujo de salida . . . . . . . . . . . . . . . . . . 329
10.5. Jerarqua de clases para InputStream. . . . . . . . . . . . . . . . . 331
10.6. Jerarqua de clases para OutputStream. . . . . . . . . . . . . . . . 334
10.7. Jerarqua de clases para Writer. . . . . . . . . . . . . . . . . . . . 335
10.8. Jerarqua de clases para Reader. . . . . . . . . . . . . . . . . . . . 336
10.9. Entrada/Salida con proceso intermedio (filtros) . . . . . . . . . . 336
10.10.Algoritmo para guardar la base de datos en disco . . . . . . . . . 366
10.11.Algoritmo para leer registros desde disco . . . . . . . . . . . . . . 369
10.12.Formato de un archivo binario autodescrito . . . . . . . . . . . . . 374
10.13.Algoritmo para escribir archivo binario . . . . . . . . . . . . . . . 381
10.14.Algoritmo para leer de archivo binario . . . . . . . . . . . . . . . 383
10.15.Algoritmo para agregar registros desde archivo de acceso directo . 391
10.16.Algoritmo para sobrescribir registros en archivo de acceso directo 398
10.17.Algoritmo para la lectura de objetos . . . . . . . . . . . . . . . . 412
10.18.Escritura a un flujo de objetos . . . . . . . . . . . . . . . . . . . . 412

11.1. Salida de PingPong. . . . . . . . . . . . . . . . . . . . . . . . . . . 419

11.2. Salida con asignacion de nombres. . . . . . . . . . . . . . . . . . . 421
11.3. Salida de RunPingPong. . . . . . . . . . . . . . . . . . . . . . . . . 423
11.4. Salida que produce el servidor de impresion. . . . . . . . . . . . . 436
11.5. Ejecucion con desalojo voluntario. . . . . . . . . . . . . . . . . . . 441
11.6. Ejecucion con la posibilidad de abrazo mortal. . . . . . . . . . . . 442
11.7. Ejecucion de Apapachosa2 con abrazo mortal . . . . . . . . . . . . 444
11.8. Implementacion de destroy en la maquina virtual de Java. . . . . 446
11.9. Interrupcion de un hilo de ejecucion desde el programa principal. . 449
11.10.Terminacion de procesos que son demonios . . . . . . . . . . . . . 455
11.11.Terminacion de procesos . . . . . . . . . . . . . . . . . . . . . . . 456
Indice de Algoritmos y Listados

1.1. Algoritmo para pasar de base 10 a base h. . . . . . . . . . . . . . . 10

1.2. Sumando dos numeros representados con signo y magnitud. . . . . . 20
3.1. Encabezado de la interfaz para Reloj (ServiciosReloj) . . . 66
3.2. Encabezado de la interfaz para Manecilla (ServiciosManecilla) . 66
3.3. Metodo de acceso para los atributos privados de Manecilla (Servi-
ciosManecilla) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
3.4. Metodos de implementacion de la interfaz ServiciosManecilla . . . 72
3.5. Metodos de implementacion de la interfaz ServiciosReloj . . . . . . 72
3.6. Metodos de manipulacion para la interfaz ServiciosManecilla . . . . 73
3.7. Metodos de Manipulacion para la interfaz ServiciosReloj . . . . . . 73
3.8. Encabezados para la implementacion de Reloj y Manecilla . . . . . 74
3.9. Constructores para la clase Reloj. . . . . . . . . . . . . . . . . . . . 76
3.10. Constructores para la clase Manecilla . . . . . . . . . . . . . . . . . 77
3.11. Metodos con la misma firma. . . . . . . . . . . . . . . . . . . . . . 78
3.12. Declaracion de atributos de las clases. . . . . . . . . . . . . . . . . . 80
3.13. Encabezado para el metodo main. . . . . . . . . . . . . . . . . . . 80
3.14. Acceso a atributos de los objetos. . . . . . . . . . . . . . . . . . . . 82
3.15. Bloqueo de nombres de atributos. . . . . . . . . . . . . . . . . . . . 83
3.16. Declaraciones locales en el metodo muestra de Reloj. . . . . . . . . 85
3.17. Version final del encabezado y declaraciones de muestra(). . . . . . 86
3.18. Implementacion de los metodos de acceso de la clase Manecilla. . . 87
3.19. Constructores de la clase Reloj. . . . . . . . . . . . . . . . . . . . . 90
3.20. Constructores de la clase Manecillas. . . . . . . . . . . . . . . . . . 90
3.21. Implementacion de constructores de la clase Manecilla . . . . . . . 95
3.22. Implementacion de constructores de la clase Reloj . . . . . . . . . . 95
3.23. Metodos de acceso de la clase Manecilla. . . . . . . . . . . . . . . 96
3.24. Metodos de manipulacion de la clase Reloj 1/2 . . . . . 96
3.24. Metodos de manipulacion de la clase Reloj 2/2 . . . . . 97
3.25. Metodos de manipulacion de la clase Manecilla . . . . . . . . . . . 97
3.26. Metodos de implementacion de la clase Reloj. . . . . . . . . . . . . 97
INDICE DE ALGORITMOS Y LISTADOS xii

3.27. Clase usuaria de la clase Reloj . . . . . . . . . . . . . . . . . . . . 98

4.1. Interfaz para el manejo de una base de datos 1/3 . . . . . 107
4.1. Interfaz para el manejo de una base de datos 2/3 . . . . . 108
4.1. Interfaz para el manejo de una base de datos 3/3 . . . . . 109
4.2. Encontrar la posicion de un registro que contenga una subcadena(Con-
sultas) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
4.3. Encontrar la posicion de un registro a partir de otra posicion (Consultas) 110
4.4. Clase que maneja listas de cursos. (Curso) 1/2 . . . . . . 113
4.4. Clase que maneja listas de cursos. (Curso) 2/2 . . . . . . 114
4.5. Constructores para la clase Curso. (Curso) . . . . . . . 115
4.6. Metodo que regresa toda la lista. (Curso) . . . . . . . 115
4.7. Calculo de la posicion donde empieza el i-esimo registro. (Curso) . 116
4.8. Metodos que regresan el contenido de un campo. (Curso) . . . 117
4.9. Metodo que da el primer registro en el que esta una subcadena. (Curso) 118
4.10. Metodo que da el siguiente registro en el que esta una subcadena.(Curso)119
4.11. Edicion de un registro individual. (Curso) . . . . . . . 120
4.12. Calculo del lmite de una sucesion . . . . . . . . . . . . . . . . . . 122
4.13. Suma de numeros ledos . . . . . . . . . . . . . . . . . . . . . . . 124
4.14. Metodo que lista todo el curso. (Curso) . . . . . . . . 125
4.15. Metodo que agrega un estudiante a la lista. (Curso) . . . . 127
4.16. Metodo que elimina al registro i. (Curso)1/2 . . . . . . 129
4.16. Metodo que elimina al registro i. (Curso)2/2 . . . . . . 130
4.17. Metodo que lista a los que cazan con . . . (Curso) . . . . . 131
4.18. Ejemplo de identificacion del estado civil de un individuo. . . . . . . 135
4.19. Encabezado de la clase Menu y el metodo daMenu (MenuCurso)1/2 136
4.19. Encabezado de la clase Menu y el metodo daMenu (MenuCurso) 2/2 137
4.20. Metodos para agregar un estudiante a la base de datos. (MenuCurso)1/2 139
4.20. Metodos para agregar un estudiante a la base de datos. (MenuCurso)2/2 140
4.21. Metodo que reporta estudiante inexistente. (MenuCurso) . . . 140
4.22. Metodo principal de la clase MenuCurso. (MenuCurso) . . . . 142
5.1. Atributos de la clase Estudiante. . . . . . . . . . . . . . . . . . . . . 147
5.2. Constructores para la clase Estudiante. 1/2 . . . . . . 147
5.3. Constructores para la clase Estudiante. 2/2 . . . . . . 148
5.4. Metodos de acceso y actualizacion de la clase Estudiante 1/2 . . 148
5.4. Metodos de acceso y actualizacion de la clase Estudiante 2/2 . . 149
5.5. Metodos que arman y actualizan un registro completo. . . . . . . . . 150
5.6. Metodos que arman y actualizan un registro completo. . . . . . . . . 151
5.7. Atributos de la clase ListaCurso. . . . . . . . . . . . . . . . . . . . . 152
5.8. Constructores para la clase ListaCurso. . . . . . . . . . . . . . . . . 153
5.9. Metodos que dan valores de los atributos. (ListaCurso) . . . . 153
xiii INDICE DE ALGORITMOS Y LISTADOS

5.10. Recorrido de una lista para contar sus registros. (ListaCurso) . . 154
5.11. Modifica el numero de grupo. (ListaCurso) . . . . . . . 155
5.12. Agregar un registro al principio de la lista. (ListaCurso) . . . 157
5.13. Agregar un registro al final de la lista. (ListaCurso) . . . . . 158
5.14. Imprimiendo toda la lista. (ListaCurso) . . . . . . . . 159
5.15. Imprimiendo registros seleccionados. (ListaCurso) . . . . . 160
5.16. Metodo que busca un registro. (ListaCurso) . . . . . . . 162
5.17. Eliminacion de un registro en una lista. (ListaCurso) . . . . 165
5.18. Menu para el manejo de la lista. (MenuLista) 1/5 . . . 166
5.18. Menu para el manejo de la lista. (MenuLista) 2/5 . . . . . 167
5.18. Menu para el manejo de la lista. (MenuLista) 3/5 . . . . . 168
5.18. Menu para el manejo de la lista. (MenuLista) 4/5 . . . . . 169
5.18. Menu para el manejo de la lista. (MenuLista) 5/5 . . . . . 170
6.1. Superclase EstudianteBasico. 1/2 . . . . . . . . . 172
6.1. Superclase EstudianteBasico. 2/2 . . . . . . . . . 173
6.2. Encabezado para la subclase EstudianteCurso . . . . . . . . . . . . . 174
6.3. Calculo de n! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
6.4. Codificacion de iteracion for con while . . . . . . . . . . . . . . . 186
6.5. Construccion de un triangulo de numeros . . . . . . . . . . . . . . 187
6.6. Arreglos como parametros y valor de regreso de una funcion 1/2 191
6.6. Arreglos como parametros y valor de regreso de una funcion 2/2 192
6.7. Campos y constructor de EstudianteCurso . . . . . . . . . . . . . 193
6.8. Metodos nuevos para la subclase EstudianteCurso . . . . . . . . . 194
6.9. Redefinicion del metodo getRegistro() . . . . . . . . . . . . . . . . . 195
6.10. Registros en un arreglo. . . . . . . . . . . . . . . . . . . . . . . . . 196
6.11. Otra version del metodo getRegistro . . . . . . . . . . . . . . . . . 197
6.12. Clases abstractas y concretas . . . . . . . . . . . . . . . . . . . . . 199
6.13. Interfaz para manejar una lista. . . . . . . . . . . . . . . . . . . . . 201
6.14. Herencia con una interfaz. . . . . . . . . . . . . . . . . . . . . . . . 201
7.1. Clase que ilustra el anidamiento dinamico . . . . . . . . . . . . . . . 206
7.2. La funcion factorial. . . . . . . . . . . . . . . . . . . . . . . . . . . 229
7.3. Factorial calculado iterativamente . . . . . . . . . . . . . . . . . . 237
7.4. Metodos para las torres de Hanoi . . . . . . . . . . . . . . . . . . 239
8.1. Superclase con la informacion basica de los estudiantes(InfoEstudian-
te)1/3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
8.1. Superclase con la informacion basica de los estudiantes. (InfoEstu-
diante)2/3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
8.1. Superclase con la informacion basica de los estudiantes. (InfoEstu-
diante)3/3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
8.2. Extendiendo la clase InfoEstudiante. (EstudianteLista) . . . 249
INDICE DE ALGORITMOS Y LISTADOS xiv

8.3. Extendiendo la clase InfoEstudiante con calificaciones.(EstudianteCa-

lifs) 1/3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
8.3. Extendiendo la clase InfoEstudiante con calificaciones.(EstudianteCa-
lifs)2/3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
8.3. Extendiendo la clase InfoEstudiante con calificaciones.(EstudianteCa-
lifs)3/3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
8.4. Base de datos implementada en un arreglo (CursoEnVector)1/2 . 254
8.4. Base de datos implementada en un arreglo (CursoEnVector)2/2 . 255
8.5. Metodo para recorrer registros hacia la derecha e izquierda (CursoEn-
Vector) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
8.6. Metodos de acceso y manipulacion (CursoEnVector) . . . . 257
8.7. Metodo de acceso al numero de registros. (CursoEnVector) . . 257
8.8. Agregando registros a la base de datos (CursoEnVector)1/2 . . 258
8.8. Agregando registros a la base de datos (CursoEnVector)2/2 . . 259
8.9. Quitando a un estudiante de la base de datos. (CursoEnVector) . 260
8.10. Busqueda de una subcadena en algun campo del arreglo.(CursoEnVector)262
8.11. Listar todos los registros de la base de datos. (CursoEnVector) . 263
8.12. Listando los que cumplan con algun criterio. (CursoEnVector) . 264
8.13. Definicion de la clase Estudiante para los registros. (Estudiante) 1/3 265
8.13. Definicion de la clase Estudiante para los registros. (Estudiante) 2/3 266
8.13. Definicion de la clase Estudiante para los registros (Estudiante) 3/3 267
8.14. Agregar un registro manteniendo el orden (ListaCurso)1/2 . . 269
8.14. Agregar un registro manteniendo el orden (ListaCurso)2/2 . . 270
8.15. Clase ArbolEstudiante para cada registro o nodo. (ArbolEstudiante) 274
8.16. Agregar un registro en un arbol binario ordenado. (ArbolOrden) . 278
8.17. Listado de la base de datos completa. (ArbolOrden) . . . . 281
8.18. Recorrido simetrico del arbol. (ArbolOrden) . . . . . . 281
8.19. Busqueda del registro con el nombre dado. (ArbolOrden) . . . 283
8.20. Busqueda de subcadena en determinado campo (ArbolOrden)1/2 . 284
8.21. Busqueda de subcadena en determinado campo (ArbolOrden) 2/2 285
8.22. Listado de registros que contienen a una subcadena (ArbolOrden) 1/2 286
8.22. Listado de registros que contienen a una subcadena (ArbolOrden) 2/2 287
8.23. Localizacion del padre de un nodo. (ArbolOrden) . . . . . 288
8.24. Localiza al menor del subarbol derecho. (ArbolOrden) . . . . 289
8.25. Eliminacion de un nodo en el arbol (ArbolOrden) 1/3 . . . . 291
8.25. Eliminacion de un nodo en el arbol. (ArbolOrden)2/3 . . . . 292
8.25. Eliminacion de un nodo en el arbol. (ArbolOrden) 3/3 . . . 293
9.1. Ejemplo de una excepcion aritmetica. . . . . . . . . . . . . . . . . . 296
9.2. Ejemplo de una excepcion de la subclase ArrayStoreException. . . . . 297
9.3. Programa que lanza una excepcion ClassCastException. . . . . . . . 298
xv INDICE DE ALGORITMOS Y LISTADOS

9.4. Manejo de una excepcion a traves de la superclase. (CatchExc)1/2 303

9.4. Manejo de una excepcion a traves de la superclase. (CatchExc)2/2 304
9.5. La excepcion es cachada y relanzada. . . . . . . . . . . . . . . . . . 305
9.6. Creacion de excepciones propias. . . . . . . . . . . . . . . . . . . . 306
9.7. Deteccion de excepciones propias (DivPorCeroUso)1/2 . . . 306
9.7. Deteccion de excepciones propias (DivPorCeroUso)2/2 . . . 307
9.8. Declaracion de excepcion propia. . . . . . . . . . . . . . . . . . . . 308
9.9. Clase que usa la excepcion creada. . . . . . . . . . . . . . . . . . . 308
9.10. Excepciones del programador (I) . . . . . . . . . . . . . . . . . . . . 309
9.11. Uso de excepciones del programador (I) . . . . . . . . . . . . . . . . 309
9.12. Excepciones del programador y su uso (II) (BaseDeDatos)1/2 . 310
9.12. Excepciones del programador y su uso (II) (BaseDeDatos)2/2 . 311
9.13. Definicion de Excepciones propias (RegNoEncontradoException)1/2 312
9.13. Definicion de Excepciones propias (RegNoEncontradoException)2/2 313
9.14. Definicion de excepciones propias (ejemplo) (Ejemplo) . . . 313
9.15. Excepciones creadas por el programador (MiExcepcion2) . . . 314
9.16. Uso de excepciones creadas por el programador (CaracteristicasExtra) 315
9.17. Ejemplo con la clausula finally (Excepcion). . . . . . . . . . . . . . . 317
9.18. Ejemplo con la clausula finally (uso). . . . . . . . . . . . . . . . . . 318
9.19. Otro ejemplo con la clausula finally (Switch) . . . . . . 319
9.20. Otro ejemplo con la clausula finally (OnOffException1) . . . 319
9.21. Otro ejemplo con la clausula finally (OnOffException2) . . . 319
9.22. Otro ejemplo con la clausula finally (OnOffSwitch) . . . . 320
9.23. Otro ejemplo con la clausula finally (ConFinally) . . . . . 320
9.24. Anidamiento de bloques try (CuatroException) . . . . . 320
9.25. Anidamiento de bloques try (SiempreFinally) . . . . . . 321
9.26. Manejo de excepciones con herencia. 1/3 . . . . . . . 322
9.26. Manejo de excepciones con herencia. (StormyInning)2/3 . . . 323
9.26. Manejo de excepciones con herencia. (StormyInning)3/3 . . . 324
10.1. Metodo que solicita al usuario nombre de archivo (MenuListaIO) . 366
10.2. Codigo para guardar la base de datos (MenuListaIO) . . . . 367
10.3. Opcion para leer registros desde disco (MenuListaIO) 1/2 . . . 369
10.3. Opcion para leer registros desde disco (MenuListaIO) 2/2 . . . 370
10.4. Opcion de agregar registros a un archivo en disco (MenuListaIO) 1/2 371
10.4. Opcion de agregar registros a un archivo en disco (MenuListaIO) 2/2 372
10.5. Declaraciones de flujos binarios (MenuListaIO) . . . . . 377
10.6. Opciones de leer y escribir a archivo binario (MenuListaIOReg) 1/3 378
10.6. Opciones de leer y escribir a archivo binario (MenuListaIOReg) 2/3 379
10.6. Opciones de leer y escribir a archivo binario (MenuListaIOReg) 3/3 380
10.7. Salto de bytes en lectura secuencial (MenuListaIOReg)1/3 . . 385
INDICE DE ALGORITMOS Y LISTADOS xvi

10.7. Salto de bytes en lectura secuencial (MenuListaIOReg)2/3 . . 386

10.7. Salto de bytes en lectura secuencial (MenuListaIOReg)3/3 . . 387
10.8. Lectura del nombre del archivo y apertura del mismo (case
LEERDIRECTO) 1/2 . . . . . . . . . . . . . . . . . . . . . . . . . 392
10.8. Lectura del nombre del archivo y apertura del mismo (case
LEERDIRECTO) 2/2 . . . . . . . . . . . . . . . . . . . . . . . . . 393
10.9. Calculo del tamano del registro (case LEERDIRECTO) . . . 393
10.10.Peticion del numero de registro al usuario (case LEERDIRECTO) . 394
10.11.Posicionamiento del apuntador del archivo y lectura (case
LEERDIRECTO) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
10.12.Opcion de modificar registros (case GUARDARDIRECTO)1/2 . 399
10.12.Opcion de modificar registros (case GUARDARDISCO)2/2 . . 400
10.13.Cambios a InfoEstudiante (InfoEstudianteSerial) 1/2 . . . . 408
10.13.Cambios a InfoEstudiante (InfoEstudianteSerial) 2/2 . . . . 409
10.14.Modificaciones a la clase Estudiante (EstudianteSerial) 1/2 . . 409
10.14.Modificaciones a la clase Estudiante (EstudianteSerial) 2/2 . . 410
10.15.Conversion de Estudiante a EstudianteSerial y viceversa(Estudian-
teSerial) 1/2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
10.15.Conversion de Estudiante a EstudianteSerial y viceversa(Estudian-
teSerial) 2/2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
10.16.Solicitud de nombre de archivo para un flujo de objetos MenuLis-
taIOObj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
10.17.Declaracion de flujo de objetos MenuListaIOObj . . . . 412
10.18.Caso de lectura de objetos (declaraciones) MenuListaIOObj . . 413
10.19.Caso de lectura de objetos MenuListaIOObj 1/3 . . . . . 413
10.19.Caso de lectura de objetos MenuListaIOObj 2/3 . . . . . 414
10.20.Caso de lectura de objetos MenuListaIOObj 3/3 . . . . . 415
11.1. Objeto que lanza dos hilos de ejecucion 1/2 . . . . . . 418
11.1. Objeto que lanza dos hilos de ejecucion 2/2 . . . . . . 419
11.2. Asignacion de nombres a los hilos de ejecucion . . . . . . . . . . . . 420
11.3. Hilos de ejecucion con la interfaz Runnable . . . . . . . . . . . . . . 422
11.4. Manejo sincronizado de una cuenta de cheques 1/2 . . . . 425
11.4. Manejo sincronizado de una cuenta de cheques 2/2 . . . . 426
11.5. Sincronizacion selectiva sobre objetos . . . . . . . . . . . . . . . . . 428
11.6. Sincronizacion de variables primitivas en enunciados 1/2 . . . 428
11.6. Sincronizacion de variables primitivas en enunciados 2/2 . . . 429
11.7. Cola generica con operaciones sincronizadas 1/2 . . . . . 432
11.7. Cola generica con operaciones sincronizadas . . . . . . . . . . . . . 433
11.8. Definicion de elementos de la cola. 1/2 . . . . . . . . 433
11.9. PrintJob: trabajo de impresion . . . . . . . . . . . . . . . . . . . . . 434
xvii INDICE DE ALGORITMOS Y LISTADOS

11.10.Servidor de impresion que corre en un hilo propio de ejecucion . . . . 434

11.11.Entorno en el que funciona un servidor de impresion . . . . . . . . . 435
11.12.Para verificar tiempo transcurrido. . . . . . . . . . . . . . . . . . . . 438
11.13.Desalojo voluntario . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
11.14.Posibilidad de abrazo mortal 1/2 . . . . . . . . . 441
11.14.Posibilidad de abrazo mortal 2/2 . . . . . . . . . 442
11.15.Abrazo mortal entre hilos de ejecucion 1/2 . . . . . . . 443
11.15.Abrazo mortal entre hilos de ejecucion 2/2 . . . . . . . 444
11.16.Uso de destroy para terminar un hilo de ejecucion . . . . . . . . . . 446
11.17.Interrupcion de procesos. 1/2 . . . . . . . . . . 447
11.17.Interrupcion de procesos. 2/2 . . . . . . . . . . 448
11.18.Significado de la interrupcion en un proceso . . . . . . . . . . . . . . 449
11.19.Espera para la terminacion de un coproceso . . . . . . . . . . . . . . 450
11.20.Programa principal para ejemplificar la espera . . . . . . . . . . . . . 451
11.21.Verificacion de terminacion con isAlive() . . . . . . . . . . . . . . . 452
11.22.Diferencia entre procesos normales y demonios 1/2 . . . . 453
11.22.Diferencia entre procesos normales y demonios 2/2 . . . . 454
 Introduccion
1
La disciplina de la computacion es el estudio sistematico de proce-
sos algortmicos que describen y transforman informacion: su teora,
analisis, diseno, eficiencia, implementacion y aplicacion. La pregunta
fundamental subyacente en toda la computacion es, Que puede ser
(eficientemente) automatizado?
Peter Denning, 2005.

Hay mucha confusion respecto a terminos que, aparentemente describen a la

misma disciplina. Usaremos a lo largo de estas notas los terminos computacion y
ciencias de la computacion casi indistintamente. Es necesario recalcar que estamos
usando el termino computacion como abreviatura para ciencias de la computacion,
con el significado particular que le estamos dando a este ultimo en nuestro con-
texto. El error mas comun es el de confundir la programacion con la computacion.
La diferencia que existe entre estos dos terminos es tal vez la misma que existe
entre saber la formula para resolver una ecuacion de segundo grado y conocer la
teora de ecuaciones. Si bien la programacion es una parte de la computacion,
la computacion contempla muchsimos otros aspectos que no forzosamente tienen
que ver con la programacion o llevarse a cabo con una computadora. Tambien se
utilizan los terminos de ingeniera y ciencias de la computacion y, excepto por el
enfoque que se pudiera dar en uno u otro caso, estaramos hablando del mismo
cuerpo de conocimientos.
Otro termino que se utiliza frecuentemente (sobre todo en nuestro medio) es
el de informatica. Si bien en muchos casos, se utiliza este termino para referirse
1.1 Conceptos generales 2

a todo lo que tiene que ver con computacion, nosotros lo entendemos mas bien
como refiriendose a aquellos aspectos de la computacion que tienen que ver con la
administracion de la informacion (sistemas de informacion, bases de datos, etc.).
Al igual que la programacion, la informatica la podemos considerar contenida
propiamente en la computacion.
El termino cibernetica es un termino forjado por los sovieticos en los anos
cincuenta. Sus races vienen de combinar aspectos biologicos de los seres vivos
con ingeniera mecanica, como es el caso de los robots, la percepcion remota, la
simulacion de funciones del cuerpo, etc. A pesar de que se utiliza muchas veces en
un sentido mas general, no lo haremos as en estas notas.

1.1 Conceptos generales

El objeto fundamental de estudio de las ciencias de la computacion son los

algoritmos y, en su caso, su implementacion. Veamos antes que nada la definicion
de algoritmo:

Definicion 1.1 Un algoritmo es un metodo de solucion para un problema que cumple con:
1. Trabaja a partir de 0 o mas datos (entrada).
2. Produce al menos un resultado (salida).
3. Esta especificado mediante un numero finito de pasos (finitud).
4. Cada paso es susceptible de ser realizado por una persona con papel y lapiz
(definicion).
5. El seguir el algoritmo (la ejecucion del algoritmo) lleva un tiempo finito
(terminacion).
Estamos entonces preocupados en ciencias de la computacion por resolver pro-
blemas; pero no cualquier problema, sino unicamente aquellos para los que po-
damos proporcionar un metodo de solucion que sea un algoritmo mas adelante
en la carrera demostraran ustedes que hay mas problemas que soluciones, ya no
digamos soluciones algortmicas.
La segunda parte importante de nuestra disciplina es la implementacion de
algoritmos. Con esto queremos decir el poder llevar a cabo un algoritmo dado (o
disenado) de manera automatica, en la medida de lo posible.
3 Introduccion

En la seccion que sigue exploraremos la historia de estos dos conceptos y

la manera en que se distinguieron para conformar lo que hoy conocemos como
ciencias de la computacion.

1.2 Breve historia del concepto de algoritmo

La computacion es una disciplina mucho muy antigua. Tiene dos races fun-
damentales:

La busqueda de una sistematizacion del pensamiento, que dicho en nuestro

terreno se interpreta como la busqueda de algoritmos para resolver proble-
mas, algunas veces generales y otras concretos.

La busqueda para desarrollar implementos o medios que permitan realizar

calculos de manera precisa y eficiente.

En esta segunda raz podemos reconocer los implementos de computo como

el abaco chino y el abaco japones, las tablillas de los egipcios para llevar la con-
tabilidad de las parcelas cultivadas y, en general, todos aquellos mecanismos que
permitan de manera mas expedita, conocer un cierto valor o llevar a cabo un
calculo.
Respecto a la busqueda de la sistematizacion del pensamiento, en la Antigua
Grecia se hizo una contribucion enorme en este direccion con el desarrollo del
metodo axiomatico en matematicas y el desarrollo de la geometra como un siste-
ma logico deductivo, en el que juegan un papel mucho muy importante el modus
ponens (pA B ^ Aq B) y el modus tollens (pA B ^ B q A).
Lo que se pretende con estos mecanismos es, a partir de un conjunto de hechos
aceptados (axiomas) y mediante un cierto conjunto de reglas del juego (reglas
de inferencia o de transformacion) lograr determinar la validez de nuevos hechos.
En el fondo lo que se buscaba era un algoritmo que describiera o automatizara
la manera en que los seres humanos llegamos a conclusiones. Estos patrones de
razonamiento se utilizan no solo en matematicas, sino en la vida diaria y han
dado origen a una disciplina muy extensa y rigurosa que es la logica matematica.
No creemos necesario remarcar el gran avance que ha tenido esta disciplina en
la ultima mitad del siglo XX. Sin embargo, es importante notar que el desarro-
llo ha estado siempre presente, no unicamente en este ultimo perodo. Para ello
presentamos en la siguiente pagina una tabla con aquellos eventos historicos que
1.2 Historia 4

consideramos mas relevantes en el desarrollo de la computacion, con una pequena

anotacion de cual fue la aportacion en cada una de las instancias.

Cuadro 1.1 Resumen de la historia de Ciencias de la computacion

2000 AC Babilonios y egipciosTablas para calculos aritmeticos, como
races cuadradas, interes compuesto, area
de un crculo (8/9*1/2=3.1604...)
Siglo IV AC Aristoteles (384-322 Logica formal con Modus Ponens y Mo-
AC) dus Tollens
825 Abu Jafar Mohammed Libro sobre recetas o metodos para
ibn Musa hacer aritmetica con los numeros
al-Khowarizm arabigos
1580 Francois Viete Uso de letras para las incognitas: surgi-
(1540-1603) miento del algebra
1614 John Napier Huesos de Napier para la multiplicacion.
(1550-1617) El concepto de logaritmo
1620 Edmund Gunter Primer antecesor de la regla de calculo
(1581-1626)
Siglos XVI Galileo (1564-1642) Formulacion matematica de la Fsica
y XVII
Siglo XVI y Descartes (1596-1650) Descubre la geometra analtica, posibili-
XVII tando la aplicacion del algebra a proble-
mas geometricos, y por lo tanto a proble-
mas que tenan que ver con movimiento
fsico
1623 Wilhelm Schickard Primera calculadora digital: sumaba, res-
taba automaticamente; multiplicaba y
divida semiautomatico
1642-1644 Blaise Pascal Calculadora que sobrevivio. Solo sumaba
(1623-1662) y restaba automaticamente
Siglo XVII Gottfried Wilhelm Coinventor del calculo con Newton.
y XVIII Leibniz (1646-1717) Primer investigador occidental de la
aritmetica binaria. Inventor de la rue-
da de Leibniz, que haca las 4 operacio-
nes aritmeticas. Fundamentos de la logi-
ca simbolica
5 Introduccion

Cuadro 1.1 (cont.) Resumen de la historia de Ciencias de la computacion

Siglo XIX Charles Babbage Maquina diferencial y maquina analtica
(1791-1871)
1800 Ada Lovelace Primer programador de la maquina
analtica de Babbage
1854 Pehr George Scheutz Construyo un modelo de la maquina di-
ferencial de Babbage
1854 George Boole Establecio los fundamentos para el estu-
(1815-1864) dio moderno de la Logica Formal
1890 Herman Hollerith Uso de equipo tabulador (de registro
unitario)
1893 Leonardo Torres y Maquina electromecanica basada en la de
Quevedo (1852-1936) Babbage
1900 David Hilbert Propone a los matematicas el encontrar
(1862-1943) un sistema de axiomas logico matemati-
co unico para todas las areas de la ma-
tematica
1928 Hollerith Elaboracion de tablas de posicion de la
luna utilizando su maquina de registro
unitario: uso cientfico de herramientas
pensadas para procesamiento de datos
1936 Kurt Godel (1906-1978) Demuestra que lo que propone Hilbert
no es posible, i.e. que hay problemas ma-
tematicos inherentemente insolubles
1936 Alan Turing Ataco el problema de cuando se puede
(1912-1954) decir que se tiene un metodo de solucion,
que el problema no tiene solucion, etc.
Disena la Maquina de Turing
1939-1945 Wallace J. Eckert con Extension de la maquina tabuladora de
John W. Mauchly IBM para propositos cientficos. Diseno
y construccion de la ENIAC, prime-
ra gran computadora digital totalmente
electronica
1937-1942 Claude Shannon El uso del algebra booleana para el anali-
sis de circuitos electronicos. Liga entre la
teora y el diseno
1.3 Sistemas numericos 6

Cuadro 1.1 (cont.) Resumen de la historia de Ciencias de la computacion

1940 John V. Atanasoff Solucion de ecuaciones lineales si-
(1903-) multaneas. Computadora ABC
1937-1944 Howard T. Aiken Construccion de la MARK I que tena:
(1900-1937) Posibilidad de manejar numeros
positivos y negativos
Posibilidad de utilizar diversas fun-
ciones matematicas
Totalmente automatica
Posibilidad de ejecutar operaciones
largas en su orden natural
1943-1945 John W. Mauchly ENIAC. Primera computadora totalmen-
te electronica
1944 John von Neumann Notacion para describir la circuitera de
la computadora. Conjunto de instruccio-
nes para la EDVAC. El concepto de pro-
grama almacenado - la nocion de que los
datos y los programas pueden compartir
el almacenaje. El concepto de operacion
serial Aritmetica binaria como mecanis-
mo en las computadoras

1.3 Sistemas numericos

A lo largo de esta historia se han transformado notablemente los smbolos que

se usaron para denotar a los objetos de los calculos, a los algoritmos, y a los
resultados mismos. Podemos pensar, por ejemplo, en que una sumadora de las
de Shickard usaba engranes como smbolos para realizar las cuentas. El hombre
primitivo usaba notacion unaria para contar: pona tantos smbolos como obje-
tos deseaba contar. Una primera abreviatura a estos metodos se dio con sistemas
que agrupaban smbolos. As por ejemplo, el sistema de numeros romanos com-
bina smbolos para abreviar, y en lugar de escribir 100 rayas verticales utiliza el
smbolo C.
Un concepto importante es el del numero cero. Su origen es mucho muy an-
7 Introduccion

tiguo. Tambien los mayas tenan un smbolo asociado al cero. Este concepto es
muy importante para poder utilizar notacion posicional. La notacion posicional
es lo que usamos hoy en da, y consiste en que cada smbolo tiene dos valores
asociados: el peso y la posicion. Por ejemplo, el numero 327.15 se puede presentar
de la siguiente manera:

EJEMPLO 1.3.2

327,15  3  102 2  101 7  100 1  10
1 5  10
2

Decimos que la notacion es posicional, porque dependiendo de la posicion que

tenga un dgito con respecto al resto de los dgitos en un numero, ese es el valor
(o peso) que tiene. El sistema que usamos es el decimal posicional, porque es un
sistema posicional que usa al numero 10 como base. El peso que se le asigna a cada
dgito depende del dgito y de su posicion. Cada posicion lleva un peso de alguna
potencia de 10 (decimal) asignadas, alrededor del punto decimal, de la siguiente
forma:

... 104 103 102 101 100 | 10
1 10
2 10
3 . . .

10000 1000 100 10 1 | ,1 ,01 ,001
4513,6  4 5 1 3 |. 6
30100  3 0 1 0 0 |. 0 0 0
,075  |. 0 7 5

Hay varias reglas que observamos respecto a la notacion posicional:

i. En cada posicion se coloca un solo dgito.

ii. Los ceros antes del primer dgito distinto de cero, desde la izquierda, no apor-
tan nada al numero.

iii. Los ceros a la derecha del punto decimal y antes de un dgito distinto de cero
s cuentan. No es lo mismo .75 que .00075.

iv. Los ceros a la derecha del ultimo dgito distinto de cero despues del punto
decimal no cuentan.
1.3 Sistemas numericos 8

v. Los dgitos que podemos utilizar son del 0 al 9.

vi. Cada dgito aporta su valor especfico multiplicado por el peso de la posicion
que ocupa.

Sabemos todos trabajar en otras bases para la notacion posicional. Por ejem-
plo, base 8 (mejor conocida como octal ) sera de la siguiente manera:

EJEMPLO 1.3.3

... 84 83 82 81 80 | 8
1 8
2 8
3 ...

4096 512 64 8 1 | ,125 ,15625 ,001953125
476,18 4 7 6 |. 1  318,12510
413708 4 1 3 7 |.  214310
Tambien podemos pensar en base 16 (hexadecimal ), para lo que requerimos de
16 smbolos distintos. Los dgitos del 0 al 9 nos proporcionan 10 de ellos. Tenemos
el problema de que con la restriccion de que cada posicion debe ser ocupada por un
unico dgito, tenemos que inventar smbolos (o dgitos) para 6 valores que nos
faltan, y que seran del 10 al 15 inclusive. La tradicion es utilizar las letras A, B,
C, D, E y F para los valores consecutivos 10, 11, 12, 13, 14 y 15 respectivamente.
Siguiendo la notacion posicional, pero en base 16, tenemos los siguientes ejemplos:

... 164 163 162 161 160 | 16
1 16
2 ...

65536 4096 256 16 1 | ,0625 ,00390625
476,116 4 7 6 |. 1  1142,062510
BA7C16 11 10 7 12 |.  4774010
Pasamos ahora a la base 2, que es la mas importante hoy en da en compu-
tacion. Los primeros implementos de computo que usaban notacion posicional (los
abacos, huesos de Napier, calculadoras) usaban base 10 (los abacos, en realidad,
usaban una especie de base 5. Por que?). Mientras las calculadoras se construan
con partes fsicas (engranes, cuentas) la base 10 no era muy distinta de cualquier
otra base. Pero al intentar construir calculadoras (o computadoras) electronicas,
la base 10 presentaba problemas de implementacion: como distinguir entre el 4
y el 5, cuando se estaba midiendo en terminos de niveles, analogicamente? Por lo
tanto se opto, aunque no desde el principio, por usar base 2, que tiene un mapeo a
9 Introduccion

la electronica bastante simple. Para base 2 requerimos de dos smbolos, y utiliza-

mos el 0 y el 1. El 0 se puede interpretar como ausencia y el 1 como presencia, por
lo que mas alla de cierto nivel se asume presencia. Esto es mucho mas sencillo que
ver si tenemos uno de 10 (u 8) niveles distintos. La tabla que sigue corresponde a
la notacion posicional en base 2:

... 27 26 25 24 23 22 21 20 | 2
1 2
2 2
3 . . .

128 64 32 16 8 4 2 1 | ,5 ,25 ,125
11001101,112 1 1 0 0 1 1 0 1 |. 1 1 1  205,7510
1010002 1 0 1 0 0 0 |.  4010
Como se puede ver, tratandose de numeros enteros, es facil pasar de una base
cualquiera a base 10, simplemente mediante la formula

num10
0
 d b i
i


i n

donde di se refiere al dgito correspondiente en la i-esima posicion, con la posicion

0 en el extremo derecho, y bi se refiere a la base elevada a la potencia de la posicion

d 2
correspondiente.
0
1010002  i
i


i 5
1  25 0  24 1  23 0  22 0  21 0  20
 32 0 8 0 0 0
 4010
Para pasar de base 10 a cualquier otra base, se utiliza el algoritmo 1.1.
Hay que notar que en la lnea 7 se esta concatenando un smbolo, por lo que
si la base es mayor a 10, se tendran que utilizar smbolos para los dgitos mayores
que 9. As, para pasar de base 10 a base 16 el numero 857510 el algoritmo se
ejecutara de la siguiente manera:

dividendo10 cociente10 residuo10 Smbolo residuo16 Numero16

8575 535 15 F F
535 33 7 7 7F
33 2 1 1 17F
2 0 2 2 217F
1.3 Sistemas numericos 10

Algoritmo 1.1 Algoritmo para pasar de base 10 a base h.

1: dividendo = num10 ;
2: divisor = h;
3: residuo = 0;
4: numero = ;
5: repeat
6: residuo = dividendo % divisor;
7: numero = pegar(residuo,numero);
8: dividendo = dividendo  divisor;
9: until (dividendo = 0);

Para que nos convenzamos que, en efecto 857510  217F16 , procedemos a

descomponer 217F en potencias de 16:

217F16  2  163 1  162 7  161 15  160

 2  4096 1  256 7  16 15
 8192 256 112 15
 8575
En general, para pasar de una base a otra, todo lo que se tiene que hacer es la
division en la base en la que se encuentra el numero que queremos convertir. Por
ejemplo, si deseamos pasar un numero base 8 a base 6, lo haramos de la siguiente
manera:
i. Consideremos que para base 8 contamos con los dgitos del 0 al 7, mientras
que para base 6 unicamente los dgitos del 0 al 5.
ii. Seguimos el algoritmo 1.1, pero haciendo la division y la resta en base 8. El
resultado se muestra a continuacion:

dividendo8 cociente8 residuo8 Smbolo residuo6 Numero6

7535 1217 3 3 3
1217 155 1 1 13
155 22 1 1 113
22 3 0 0 0113
3 0 3 3 30113
11 Introduccion

Trabajemos con los dos numeros en base 10 para corroborar que el algoritmo
trabajo bien:

75358  7  83 5  82 3  81 5  80
 7  512 5  64 3  8 5  1
 3584 320 24 5
 393310
301136  3  64 0  63 1  62 1  61 3  60
 3  1296 0  216 1  36 1  6 3  1
 3888 0 36 6 3
 393310

En general, para pasar de una base B a otra base b, lo que tenemos que hacer
es expresar b en base B, y despues llevar a cabo el algoritmo en base B. Cada vez
que tengamos un residuo, lo vamos a tener en base B y hay que pasarlo a base b.
Esto ultimo es sencillo, pues el residuo es, forzosamente, un numero entre 0 y b.
Cuando una de las bases es potencia de la otra, el pasar de una base a la otra es
todava mas sencillo. Por ejemplo, si queremos pasar de base 8 a base 2 (binario),
observamos que 8  23 . Esto nos indica que cada posicion octal se convertira a
exactamente a tres posiciones binarias. Lo unico que tenemos que hacer es, cada
dgito octal, pasarlo a su representacion binaria:

75358 7 5 3 5
111 101 011 101 1111010111012

Algo similar se hace para pasar de base 16 a base 2, aunque tomando para
cada dgito base 16 cuatro dgitos base 2.
El proceso inverso, para pasar de base 2, por ejemplo, a base 16, como 16  24
deberemos tomar 4 dgitos binarios por cada dgito hexadecimal:

1111010111012 11112 01012 11012

1510 510 1310
F16 516 D16 F 5D

Las computadoras actuales son, en su inmensa mayora, digitales, esto es, que
representan su informacion de manera discreta, con dgitos. Operan en base 2
1.3 Sistemas numericos 12

(binario) ya que la electronica es mas sencilla en estos terminos. Sin embargo,

hay procesos que no son discretos, como las ondas de luz o sonoras. Pero hoy en
da se pueden alcanzar excelentes aproximaciones de procesos continuos mediante
dgitos binarios. Para ello se cuenta con componentes analogicos/digitales que
transforman senales analogicas (continuas) en senales digitales (discretas). Hubo
una epoca en que se tena mucha fe en las computadoras analogicas, aquellas que
funcionaban con dispositivos continuos, pero practicamente han desaparecido del
mercado, excepto por algunas de proposito muy especfico, o las que convierten
senales analogicas en senales digitales, o viceversa.
La siguiente pregunta que debemos hacernos es:

Cuales son los distintos elementos que requerimos para poder implementar un
algoritmo en una computadora digital?
Como se representan en binario esos distintos elementos?

Pensemos, por ejemplo, en las maquinas de escribir. La orden para que se

escriba una letra determinada se lleva a cabo oprimiendo una cierta tecla. Esto es
porque hay una conexion mecanica (fsica) entre la tecla del teclado y el dado que
imprime la tecla. La primera computadora, la ENIAC, funcionaba de manera muy
similar. Cada vez que se deseaba que resolviera algun problema, se alambraban
los paneles de la computadora para que hubiera conexiones fsicas entre lo que
se reciba en el teletipo y las operaciones que se ejecutaban. De manera similar,
las calculadoras mecanicas, al darle vuelta a una manivela, se consegua que los
engranes seleccionados efectuaran una determinada operacion.
En las computadoras modernas, de proposito general, vienen alambradas para
reconocer ciertos patrones, de forma similar a como lo haca el telar de Jackard o la
maquina del censo de Hollerith. Cada patron indica una operacion a realizarse. Los
patrones son numeros binarios con un numero fijo de posiciones (binary digits). A
cada conjunto de posiciones de un cierto tamano se le llama una palabra. El tamano
de palabra es, en general, una potencia de 2: 8, 16, 32, 64, 128. A los grupos de 8
bits se les llama byte. Al conjunto de patrones distintos es a lo que se conoce como
lenguaje de maquina, que por supuesto es personal de cada modelo o tipo de
computadora. Originalmente se distingua entre micro, mini y computadoras por el
tamano en bits de sus palabras. El tamano de la palabra va unido al podero de la
maquina: si tengo mas bits por palabra tengo mas patrones posibles, y por lo tanto
un lenguaje de maquina mas extenso y posibilidad de representar numeros mas
grandes o con mas precision1 Las primeras microcomputadores tenan palabras de
8 bits, mientras que las grandes computadoras tenan palabras de 64 bits. Las
1
En breve veremos la representacion de datos en la computadora.
13 Introduccion

supercomputadoras, que surgieron alrededor de 1985, tenan palabras de 128 bits

y posibilidades de proceso en paralelo.
El tamano de la palabra tambien le da velocidad a una computadora, pues
indica el numero de bits que participan electronicamente en cada operacion.

1.4 La Arquitectura de Von Neumann

Se le llama arquitectura de una computadora a la organizacion que tiene en sus

componentes electronicos, y la manera como estos estan integrados para funcionar.
Lo que se conoce como arquitectura de von Neumann es una organizacion muy
parecida a la de Babbage: tenemos un procesador central el molino de Babbage
en el que se ejecutan las operaciones aritmeticas y de comparacion (logicas); una
memoria central que se utiliza para almacenar datos, resultados intermedios y el
programa a ejecutarse; tenemos unidades de entrada y salida (input/output) que
sirven para darle a la computadora el programa y los datos y recibir los resultados;
por ultimo, tenemos memoria externa o auxiliar, como discos, diskettes, cintas
magneticas, que nos sirven para almacenar, ya sean datos o programas, de una
ejecucion a otra, sin tener que volver a realizar el proceso, o sin que tengamos que
volverlos a proporcionar. Un esquema de una computadora con arquitectura de
von Neumann se muestra en la figura 1.1.
Las flechas que van de un componente a otro pueden tener distintas formas
de funcionar y muy diversas capacidades. Una de las formas en que funciona es
lo que se conoce como un bus. Por ejemplo, si la capacidad de la lnea que va de
memoria al procesador es de menos de 1 palabra, aunque la computadora tenga
palabras muy grandes, la velocidad de la maquina se va a ver afectada.
La memoria esta cuadriculada, o dividida en celdas. Cada celda ocupa una
posicion dentro de la memoria, aunque en principio cada una es igual a cualquier
otra: tiene el mismo numero de bits y las mismas conexiones. Se puede ver como un
vector de celdas, cuyo primer elemento tiene el ndice cero. Se habla de posiciones
altas y posiciones bajas refiriendose a aquellas que tienen ndices grandes o
pequenos respectivamente. En cada celda de memoria se puede colocar (escribir,
copiar) una instruccion, un numero, una cadena de caracteres, etc.
El proceso mediante el que se ejecuta un programa es el siguiente:

i. Se coloca el programa en la memoria de la computadora (se carga, load ).

1.4 La Arquitectura de Von Neumann 14

ii. La unidad de control en el procesador se encarga de ver cual es la siguiente

instruccion. Esta aparece, simplemente, como un patron de bits (un codigo
de maquina).
iii. La Unidad de Control se encarga de ejecutar la instruccion, valiendose para
ello de cualquiera de los componentes de la maquina.

Figura 1.1 Arquitectura de von Neumann

Memoria Memoria Central

auxiliar
Discos

Procesador
central
Unidad de control
Unidad aritmetica
Unidad logica
Cache

Dispositivos de entrada Dispositivos de salida

Teclado, scanner, usb Monitor, impresora, usb,
bocinas

El tipo de instrucciones que tiene una computadora incluyen instrucciones pa-

ra sumar, restar, multiplicar, dividir, copiar, borrar, recorrer el patron de bits,
15 Introduccion

comparar y decidir si un numero es mayor que otro, etc. En realidad son instruc-
ciones que hacen muy pocas cosas y relativamente sencillas. Recuerdese que se
hace todo en sistema binario.

Lenguajes de programacion

Un lenguaje de programacion es aquel que nos permite expresar un problema

de tal manera que podamos instalarlo (cargarlo) en la computadora y se ejecute.
Hasta ahora solo hemos visto el lenguaje de maquina, y este era el unico disponible
con las primeras computadoras de proposito general.

Figura 1.2 Proceso para ejecutar un programa escrito en ensamblador

(4)
Programa
objeto
(binario)
(3)
Unidad
Datos para de control
el programa (5)
Programa a
ejecutar Resultados
Programa (2) MEMORIA (6)
ensamblador
(binario) (1)
1.4 La Arquitectura de Von Neumann 16

Programar en binario es, en el mejor de los casos, sumamente tedioso y com-

plicado. El programador (que es quien escribe los programas) tiene que tener un
conocimiento muy profundo de la computadora para la que esta programando.
Ademas de eso, tiene que ejercer un cuidado extremo para no escribir ningun 1
por 0, o para no equivocarse de direccion. Lo primero que se hizo fue escribir en
octal, ya que era un poco mas claro que binario. El siguiente paso fue asociar
nemonicos a las instrucciones, asociando a cada patron de bits un nombre o
identificador: add, sub, mul, div, etc. A esto se le llamo lenguaje ensamblador. Se
construyo un programa, llamado ensamblador, que se encargaba de traducir los
nemonicos de este estilo y las direcciones escritas en octal a binario. Este programa
no es algo complicado de hacer. Tanto el programa ensamblador como el progra-
ma a traducir se alimentaban, cargados en tarjetas perforadas ver figura 1.2. El
primer paquete era el programa ensamblador, escrito en binario; a continuacion
se presentaba el programa que se deseaba traducir, como datos del primero. La
computadora contaba con un tablero, en el que se le indicaba que empezara a
cargar el programa ensamblador, y una vez cargado (1), empieza a ejecutarlo. El
programa ensamblador indicaba que tena que traducir las siguientes tarjetas (o
cinta perforada), conforme las fuera leyendo (2), y producir tarjetas con el pro-
grama en binario (3) o, mas adelante, cargar el programa binario a memoria para
ser ejecutado (4); al ejecutarse el programa en binario, se lean los datos (5) y se
produca el resultado (6).
El siguiente paso en lenguajes de programacion fue el de los macroensamblado-
res, que asignaban etiquetas a las posiciones de memoria que se estaban utilizando
para acomodar los datos y resultados intermedios, y las posiciones donde iba a
quedar el codigo. El proceso de traduccion era sencillo, ya que se agregaban a
las tablas de traduccion del codigo los equivalentes en octal. Tambien se permita
construir secuencias pequenas de codigo, a las que nuevamente se les asociaba un
nombre o identificador, y que podan presentar parametros. A estas secuencias se
les llamaba macros y de ah el nombre de macroensamblador.
Las computadoras se estaban utilizando tanto con fines cientficos como comer-
ciales. En el uso cientfico era muy comun expresar formulas matematicas, que
tenan que despedazarse en operaciones basicas para poderse llevar a cabo ver
figura 1.3.
El siguiente paso importante fue el de permitirle a un programador que es-
pecificara su formula como se muestra en la parte izquierda de la figura 1.3. El
primer lenguaje de uso generalizado orientado a esto fue FORTRAN For mula
Translator, alrededor de 1956. Pocos anos despues se desarrollo un lenguaje para
usos comerciales, donde lo que se deseaba es poder manejar datos a distintos nive-
les de agregacion. Este lenguaje se llamaba COBOL COmon B ussiness Oriented
Language. Ambos lenguajes, o versiones modernizadas, sobreviven hasta nuestros
17 Introduccion

Figura 1.3 Codificacion en ensamblador de formulas matematicas.

Formula Programa simplificado

?2 def x1 100 mul b2 b b

x1 
b b
2a

4ac def a 102 mul ac a c
def b 104 mul ac 4 ac
def c 106 mul a2 2 a
def ac 108 add rad ac b2
def a2 110 sqrt rad rad
def b2 112 sub x1 rad b
def rad 114 div x1 x1 a2

das.
Estos lenguajes tenan un formato tambien mas o menos estricto, en el sentido
de que las columnas de las tarjetas perforadas estaban perfectamente asignadas,
y cada elemento del lenguaje tena una posicion, como en lenguaje ensamblador.
El proceso por el que tiene que pasar un programa en alguno de estos lenguajes
de programacion para ser ejecutado, es muy similar al de un programa escrito
en lenguaje ensamblador, donde cada enunciado en lenguaje de alto nivel se
traduce a varios enunciados en lenguaje de maquina (por eso el calificativo de
alto nivel, alto nivel de informacion por enunciado), que es el unico que puede
ser ejecutado por la computadora.
Hacia finales de los anos 50 se diseno un lenguaje, ALGOL ALGorithmic
Oriented Language que resulto ser el modelo de desarrollo de practicamente
todos los lenguajes orientados a algoritmos de hoy en da, como Pascal, C, C++,
Java y muchos mas. No se pretende ser exhaustivo en la lista de lenguajes, bas-
te mencionar que tambien en los anos 50 surgio el lenguaje LISP, orientado a
inteligencia artificial; en los anos 60 surgio BASIC, orientado a hacer mas facil
el acercamiento a las computadoras de personas no forzosamente con anteceden-
tes cientficos. En los anos 60 surgio el primer lenguaje que se puede considerar
orientado a objetos, SIMULA, que era una extension de ALGOL. En los aproxi-
madamente 50 anos que tienen en uso las computadoras, se han disenado y usado
mas de 1,000 lenguajes de programacion, por lo que pretender mencionar siquiera
a los mas importantes es una tarea titanica, y no el objetivo de estas notas.
1.4 La Arquitectura de Von Neumann 18

Representacion de la informacion

Acabamos de ver que la representacion de los programas debe ser, eventual-

mente en lenguaje de maquina, o sea, en binario. Tambien tenemos restricciones
similares para el resto de la informacion, como son los datos, los resultados inter-
medios y los resultados finales. Al igual que con los lenguajes de programacion,
si bien la computadora solo tiene la posibilidad de representar enteros positivos
en binario, debemos encontrar la manera de poder representar letras, numeros de
varios tipos, como enteros negativos, reales, racionales, etc. Para ello se sigue una
logica similar a la del lenguaje de maquina.

Caracteres

Supongamos que tenemos un tamano de palabra de 16 bits y queremos repre-

sentar letras o caracteres. Simplemente hacemos lo que hacamos en la primaria
cuando queramos mandar mensajes secretos: nos ponemos de acuerdo en algun
codigo.
El primer codigo que se utilizo fue el BCD, que utilizaba 6 bits por caracter.
Con esto se podan representar 64 caracteres distintos (en 6 bits hay 64 posibles
enteros, del 0 al 63). Con este codigo alcanzaba para las mayusculas, los dgitos y
algunos caracteres importantes como los signos de operacion y de puntuacion.
Con el perfeccionamiento de las computadoras se requirieron cada vez mas
caracteres, por lo que se extendio el codigo a 7 y 8 bits, con el codigo ASCII, que
se uso mucho para transmitir informacion, y el codigo EBCDIC que se uso como
codigo nativo de muchas computadoras, respectivamente. El lenguaje Java utiliza
Unicode, que ocupa 16 bits, para representar a cada caracter. Con esto tiene la
posibilidad de utilizar casi cualquier conjunto de caracteres de muchsimos de los
idiomas en uso actualmente.
Se requiere de programas que transformen a un caracter en su codigo de maqui-
na y viceversa. Estos son programas sencillos que simplemente observan patro-
nes de bits y los interpretan, o bien, observan caracteres y mediante una tabla,
los convierten al patron de bits en el codigo que utilice la computadora.
Practicamente todo manual de programacion trae una tabla de los distintos
codigos que corresponden a los caracteres. Estas tablas vienen con varias columnas;
en la primera de ellas vendra el caracter, y en columnas subsecuentes su codigo
en octal hexadecimal, binario, y utilizando alguno de estos esquemas para dar
19 Introduccion

el codigo que le corresponde en ASCII, EBCDIC o Unicode. Por supuesto que

requerimos de 32,768 para mostrar la codificacion de Unicode, por lo que no
lo haremos, mas que en la medida en que tengamos que conocer el de algunos
caracteres especficos.

Numeros enteros

Ya vimos la manera en que se representan numeros enteros en la computadora:

simplemente tomamos una palabra y usamos notacion posicional binaria para ver
el valor de un entero.
Hoy en da las computadoras vienen, en su gran mayora, con palabras de al
menos 32 bits. Eso quiere decir que podemos representar enteros positivos que
van desde el 0 (32 bits apagados) hasta 232
1 (todos los bits prendidos). Pero,
como le hacemos para representar enteros negativos? Tenemos dos opciones. La
primera de ellas es la mas intuitiva: utilizamos un bit, el de la extrema izquierda,
como signo. A esta notacion se le llama de signo y magnitud. Si este es el caso,
tenemos ahora 31 bits para la magnitud y 1 bit para el signo ver figura 1.4 con
palabras de 16 bits.

Figura 1.4 Enteros en signo y magnitud.

s 214 213 212 211 210 29 28 27 26 25 24 23 22 21 20

0 0 0 0 1 0 1 1 0 1 1 1 0 0 1 1 1467
1 0 0 0 1 0 1 1 0 1 1 1 0 0 1 1
1467
La representacion se signo y magnitud es muy costosa. Por ejemplo, cuando
se suman dos cantidades que tienen signos opuestos, hay que ver cual es la que
tiene mayor magnitud, pues la suma se puede convertir en resta de magnitudes.
Veamos el algoritmo 1.2 en la siguiente pagina.
Como se puede ver, los circuitos que se requieren para sumar dos numeros en
notacion de signo y magnitud son muy complicados, y por lo tanto muy caros.
El otro modo de codificar enteros positivos y negativos es lo que se conoce
como complemento a 2. En este metodo, al igual que con signo y magnitud, se
parte al dominio en 2 partes, los que tienen al bit de potencia mas alta en 0, y los
que lo tienen en 1; los que tienen el bit mas alto en cero son los enteros positivos,
y los que lo tienen en 1 son los enteros negativos. Para saber la magnitud del
numero, en el caso de los positivos se calcula igual que con signo y magnitud, pero
1.4 La Arquitectura de Von Neumann 20

Algoritmo 1.2 Sumando dos numeros representados con signo y magnitud.

1: Sean a y b los enteros a sumar.
2: Sa  signo de a; Ma  magnitud de a.
3: Sb  signo de b; Mb  magnitud de b.
4: if Sa  Sb
5: Ssuma  Sa .
6: Msuma  Ma Mb .
7: else
8: if Ma Mb
9: Ssuma  Sa .
10: Msuma  Ma
Mb .
11: else
12: Ssuma  Sb .
13: Msuma  Mb
Ma .

en el caso de los negativos, la magnitud es la que resulta de restar la palabra de

una con una posicion mas, y donde todas las posiciones originales de la palabra
tienen 0, con un 1 en la posicion extra. Veamos algunos ejemplos en la figura 1.5
en la pagina opuesta.
Como vemos en la figura 1.5, el bit 15 (el que corresponde a 215 ) tambien
nos indica de cierta forma, como en la notacion de signo y magnitud, cuando
tenemos un entero negativo. En el caso de 16 bits, los enteros positivos son del 0 al
215
1  32, 767 que corresponde a una palabra de 16 bits con todos menos el bit 15
prendidos ver figura 1.5, lnea (1). A partir del numero 215  32, 768 y hasta 216

1  65, 535, que corresponde a todos los bits en una palabra de 16 bits prendidos,
estamos representando a numeros negativos ver en la figura 1.5, lnea (3). En
estos ultimos, el bit 15 esta siempre prendido, y por eso reconocemos el signo
del numero. La magnitud (o el valor absoluto) del numero que estamos viendo se
obtiene sacando el complemento a 2 de la palabra en cuestion. El complemento a
2 se obtiene de dos maneras posibles:
i. Se resta en binario de un numero de 17 bits en la figura 1.5, lnea (2) con
ceros en todos los bits, menos el bit 16, que tiene 1.
ii. Se complementan cada uno de los bits de la palabra de 16 bits (se cambian
los 1s por 0s y los 0s por 1s) y despues se le suma 1 a lo que se obtuvo.
Ambas maneras de obtener la magnitud (el complemento a 2) se observa en la
lnea (4) de la figura 1.5.
La gran ventaja de la notacion en complemento a 2 es que es sumamente facil
hacer operaciones aritmeticas como la suma y la resta. En complemento a 2, todo lo
que tenemos que hacer es sumar (o restar) utilizando los 16 bits. Pudiera suceder,
21 Introduccion

sin embargo, que el resultado no sea valido. Por ejemplo, si sumamos dos numeros
positivos y el resultado es mayor que la capacidad, tendremos acarreo sobre el
bit 15, dando aparentemente un numero negativo. Sabemos que el resultado es
invalido porque si en los dos sumandos el bit 15 estaba apagado, tiene que estar
apagado en el resultado. Algo similar sucede si se suman dos numeros negativos
y el resultado ya no cabe en 16 bits ver figura 1.6.

Figura 1.5 Numeros en complemento a 2

215 214 213 212 211 210 29 28 27 26 25 24 23 22 21 20

Un entero positivo en complemento a 2:
0 0 0 0 1 1 1 0 0 0 0 0 1 0 0 0 3, 592 p1q
La palabra con el complemento a 2: 216 
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 65, 536 p2q
Un entero negativo en complemento a 2:
1 0 0 0 1 1 1 0 0 0 0 0 1 0 0 0 36, 360 p3q
La magnitud del entero original:
0 0 1 1 1 0 0 0 1 1 1 1 1 1 0 0 0 29, 176 p4q

Figura 1.6 Suma de dos numeros con complemento a 2

215 214 213 212 211 210 29 28 27 26 25 24 23 22 21 20
0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 1 207
+ 0 0 0 1 0 0 0 1 1 1 0 0 0 0 1 1 4547
0 0 0 1 0 0 1 0 1 0 0 1 0 0 1 0 4754

0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 25
+ 1 1 1 1 1 1 0 0 0 1 0 1 0 1 0 1
939
1 1 1 1 1 1 0 0 0 1 1 0 1 1 1 0
914
1.4 La Arquitectura de Von Neumann 22

Pueden verificar, sumando las potencias de 2 donde hay un 1, que las sumas
en la figura 1.5 se hicieron directamente y que el resultado es el correcto.
La desventaja del complemento a 2 es que se pueden presentar errores sin que
nos demos cuenta de ello. Por ejemplo, si le sumamos 1 al maximo entero positivo
(una palabra con 0 en el bit 15 y 1s en el resto de los bits) el resultado resulta
ser un numero negativo, aquel que tiene 1s en todas las posiciones de la palabra
ver figura 1.7.

Figura 1.7 Sumando 1 al maximo entero positivo

215 214 213 212 211 210 29 28 27 26 25 24 23 22 21 20
0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 32767
+ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
32768
En algunos lenguajes de programacion este tipo de errores se detectan en
ejecucion, pero en la mayora no. Hay que tener presente que la representacion
interna es con complemento a 2, para manejar de manera adecuada este tipo de
posibles errores.
Muchas veces el tamano de la palabra de una computadora no es suficiente
para los numeros que deseamos representar. Entonces, el lenguaje de programacion
puede usar mas de una palabra para representar enteros, simplemente utilizando
notacion posicional base 216 , de manera similar a como se maneja la base 2. Se
dice entonces que la aritmetica se hace por software.

Numeros reales

Para representar a los numero reales tenemos realmente dos opciones:

Punto fijo: Como su nombre lo indica, el fabricante (o el lenguaje de programa-

cion) elige una posicion entre dos bits, y lo que se encuentra a la derecha de
esa posicion es la parte fraccionaria y lo que se encuentra a la izquierda es
la parte entera, ambos vistos como enteros en notacion posicional binaria
ver figura 1.8.
Como se puede ver en la figura 1.8, se mantiene la notacion de complemento
a 2, el bit mas alto indicandonos que el numero es negativo.
23 Introduccion

Figura 1.8 Notacion de punto fijo.

27 26 25 24 23 22 21 20  27 26 25 24 23 22 21 20
0 1 0 0 1 1 0 1 0 1 0 0 0 0 1 1 77,67
1 0 0 1 1 0 1 1 0 1 0 1 0 1 1 0
100,162

Una de las ventajas de este tipo de notacion es que es muy sencillo hacer
operaciones aritmeticas, pues se usa a toda la palabra como si fuera un entero
y el proceso de colocar el punto decimal se hace al final. Sin embargo, tiene
una gran desventaja que es la poca flexibilidad para representar numeros
que tengan muchos dgitos en la fraccion, o muy pocos.

Punto flotante: El punto flotante es otra manera de representar numeros reales.

Basicamente como se logra es dividiendo a la palabra en dos partes, una
para la mantisa y la otra para el exponente, utilizando lo que se conoce
como notacion cientfica. Veamos los siguientes ejemplos:

1,32456  106 1324560

1,32456  10
6 ,00000132456

1,32456  103 
1324,56
Como podemos ver del ejemplo anterior, nos ponemos de acuerdo en cuantos
dgitos van a estar a la izquierda del punto decimal, y todos los numeros
reales los representamos con ese numero de enteros. A continuacion, damos
una potencia de 10 por la que hay que multiplicar el numero, para obtener
el numero que deseamos.
Una abreviatura de esta notacion sera escribiendo los dos numeros anterio-
res de la siguiente forma:

1,32456E6 1324560
1,32456E
6 ,00000132456

1,32456E3 
1324,56
1.4 La Arquitectura de Von Neumann 24

Esta representacion es muchsimo mas versatil que la de punto fijo, y de

hecho es la que se usa generalmente. Al momento de representar los numeros,
se hace en binario. Si damos mucho espacio para los exponentes tenemos la
posibilidad de representar numeros muy grandes o muy pequenos (con el
exponente negativo). Si en cambio le damos mucho espacio a la mantisa,
vamos a tener numeros con mucha precision (muchas cifras significativas).
Es conveniente encontrar un balance entre la magnitud y la precision. Por
ejemplo, la IEEE tiene sus estandares.
Las operaciones con este tipo de numeros son un poco mas complejas que con
punto fijo. Por ejemplo, si deseamos sumar dos numeros, tenemos primero
que llevarlos a que tengan el mismo exponente, y una vez hecho esto se puede
llevar a cabo la suma. En cambio, multiplicar dos numeros es sumamente
facil. Por que?

Al igual que en los numeros enteros, ademas de lo que nos proporcione el

hardware de la computadora como tamano de palabra, por software se pueden
usar tantas palabras como uno quiera para representar a un entero o a un real.
Cada lenguaje de programacion proporciona un conjunto de enteros y reales de
diversos tamanos.
La inmensa mayora de las computadoras utilizan complemento a 2 y mantisa
y exponente para representar numeros.

Limitaciones en la representacion interna

Vimos ya que en la computadora no podemos representar a todos y cualquier

entero: tenemos un numero finito de enteros distintos que podemos representar,
no importa que tan grande sea la palabra de una computadora dada, ya que
tenemos un numero finito de combinaciones de 0s y 1s en cualquier tamano dado
de palabra.
Algo similar ocurre con los numeros reales. No solo no tenemos la posibilidad
de representar a un numero infinito de numeros reales, sino que ademas tampoco
tenemos la densidad de los numeros reales. Como estamos usando binario para
representar a numeros que nosotros manejamos y pensamos como numeros en
base 10, habra numeros que no tengan un representacion exacta al convertirlos
a base 2 (por supuesto que estamos hablando de numeros fraccionarios). Adicio-
nalmente, al agregarle 1 a una mantisa, no obtenemos el siguiente numero real,
ya que estamos sumando, posiblemente, en la parte fraccionaria. Por ello, no es
posible tener una representacion para todos y cada uno de los numeros reales en
25 Introduccion

un intervalo dado: nuevamente, este es un numero infinito y lo que tenemos es un

numero finito de combinaciones.

1.5 Ejecucion de programas

Mencionamos arriba que lo unico que puede ejecutar una computadora de

hardware es un programa escrito en su lenguaje de maquina. Por lo que para que
nuestros programas escritos en Java puedan ser ejecutados, deberan estar escritos
en lenguaje de maquina.
Recuerdan lo que hacamos para obtener un programa escrito en lenguaje de
maquina a partir de uno escrito en ensamblador? Se lo dabamos como datos a un
programa que traduca de enunciados en ensamblador a enunciados en lenguaje
de maquina. Algo similar hacemos cuando estamos trabajando en un lenguaje de
alto nivel.
En general, tenemos dos maneras de conseguir ejecutar un programa escrito
en un lenguaje de alto nivel. La primera de ellas es mediante un interprete, y la
segunda mediante un compilador. Veamos que queremos decir con cada uno de
estos terminos.

Definicion 1.4 Un interprete es un programa que una vez cargado en la memoria de una
computadora, y al ejecutarse, procede como sigue:

Toma un enunciado del programa en lenguaje de alto nivel, llamado el codigo

fuente.

Traduce ese enunciado y lo ejecuta.

Repite estas dos acciones hasta que alguna instruccion le indique que pare,
o bien tenga un error fatal en la ejecucion.

Definicion 1.5 Un compilador es un programa, una vez que reside en memoria y al

ejecutarse, toma un programa fuente y lo traduce completo a un programa en otro
lenguaje de programacion, que generalmente es lenguaje de maquina, equivalente.
Mientras que un interprete va traduciendo y ejecutando, el compilador no
se encarga de ejecutar, sino simplemente de producir un programa equivalente,
susceptible de ser cargado a la memoria de la maquina y ejecutado.
1.5 Ejecucion de programas 26

A los interpretes se les conoce tambien como maquinas virtuales, porque una
vez que estan cargados en una maquina, se comportan como si fueran otra compu-
tadora, aquella cuyo lenguaje de maquina es el que se esta traduciendo y ejecu-
tando.

1.5.1. Filosofas de programacion

Dependiendo del tipo de problema que queramos resolver numerico, admi-

nistrativo, de proposito general, inteligencia artificial, logico tenemos distintos
lenguajes de programacion que permiten representar de mejor manera los forma-
tos de los datos y los recursos que requerimos para resolver el problema. As,
para procesos numericos se requiere de bibliotecas muy extensas con funciones
matematicas, un manejo sencillo de matrices y, en general, de espacios de varias
dimensiones, etc. El lenguaje que fue disenado para este tipo de problemas fue
FORTRAN, y recientemente se usa C. Si lo que queremos es resolver problemas
administrativos tenemos a COBOL, que se rehusa a morir, o Visual Basic que
provee una fabricacion rapida de interfaces con el usuario2 . Como representantes
de lenguajes de proposito general tenemos Pascal, C, Algol. Para problemas que
involucran cambios de estado en los datos, o situaciones que suceden no forzosa-
mente una despues de la otra se cuenta con lenguajes orientados a objetos como
C++, SmallTalk y Java. Para resolver problemas que involucran manejo simbolico
de datos, como lo que se requiere para Inteligencia Artificial, se tienen lenguajes
como LISP y Scheme. Para problemas de tipo logico se tiene ProLog. En fin, casi
cualquier tipo de aplicacion que se nos ocurra, se puede disenar un lenguaje de
programacion para el cual el lenguaje que se utilice en el algoritmo sea mucho muy
cercano al lenguaje de programacion: este es el objetivo que se persigue cuando
se disenan nuevos lenguajes de programacion. Este curso se enfocara a resolver
problemas que se expresan facilmente con orientacion a objetos, y el lenguaje que
utilizaremos es Java.
Es importante darse cuenta que, finalmente, cualquier problema se puede resol-
ver utilizando cualquier lenguaje: finalmente, todo programa tiene que traducirse
a lenguaje de maquina, por lo que no importa en que lenguaje hayamos programa-
do, terminaremos con un programa equivalente escrito en lenguaje de maquina.
El meollo del asunto es, simplemente, que tanto trabajo nos cuesta pensar en el
problema en un lenguaje pensado para resolver otro tipo de problemas. Buscamos
que el lenguaje de programacion se ajuste de manera sencilla a nuestro modo de
2
Una interfaz con el usuario es aquel programa que permite una comunicacion mejor entre
el usuario y el programa en la computadora. Se usa para referirse a las intefaces graficas.
27 Introduccion

pensar respecto al problema que deseamos resolver.

1.6 Caractersticas de Java

Java es un lenguaje orientado a objetos, cuyo principal objetivo de diseno es

que fuera portatil. Una manera de hacer programas escritos en Java es mediante
el siguiente truco:

Se traduce el programa escrito en Java a un lenguaje de bajo nivel, tipo

lenguaje de maquina, pero que no sea el de una maquina en especfico.

Se construye (programa) un interprete de este lenguaje de maquina, y

entonces se ejecuta el programa en lenguaje de maquina en la maquina
virtual de Java.

Esto resulta relativamente sencillo. El lenguaje de maquina de Java se llama

bytecode. Es mas facil construir una maquina virtual que entienda el bytecode que
construir un compilador para cada posible lenguaje de maquina. Ademas, una vez
que esta definida la maquina virtual, se le pueden agregar capacidades al lenguaje,
simplemente dando su transformacion a bytecode.
Por todo esto, para ejecutar un programa escrito en Java necesitamos:

a. Tener un compilador de Java que traduzca de programas escritos en Java a

bytecode (javac).

b. Tener un interprete de bytecode (o maquina virtual de Java) a la que se le da

como datos el programa en bytecode y los datos pertinentes al programa.
 El proceso del
software 2

2.1 Que es la programacion?

Como ya platicamos al hablar de lenguajes de programacion, la programa-

cion consiste en elaborar un algoritmo, escrito en un lenguaje susceptible de ser
ejecutado por una computadora, para resolver una clase de problemas.
Podemos pensar en un algoritmo como la definicion de una funcion. Una vez
definida esta, se procede a aplicar la funcion a distintos conjuntos de argumentos
(datos) para obtener el resultado.
El proceso que nos lleva finalmente a aplicar un programa a datos determinados
conlleva varias etapas, algunas de ellas repetitivas. En el estado inicial de este
proceso tendremos un enunciado del problema que deseamos resolver, junto con
la forma que van a tomar los datos (cuantos datos, de que tipo). En el estado
final deberemos contar con un programa correcto que se puede instalar en una
computadora para ser ejecutado con cualquier conjunto de datos que cumpla las
especificaciones planteadas. Por ello deberemos observar los siguientes pasos (ver
figura 2.1 en la siguiente pagina para el proceso del Software.1 )
1
El diagrama que presentamos es lo que corresponde a un proceso de software en espiral, ya
que se regresa una y otra vez a etapas anteriores, hasta que se pueda llegar al final del diagrama.
2.1 Que es la programacion? 30

Figura 2.1 Proceso del software.

Especificacion

Analisis y Diseno

Implementacion

Validacion

Mantenimiento

Refinamiento y extension

Especificacion del problema: Se nos presenta el enunciado del problema y de-

beremos determinar de manera precisa las especificaciones: de donde par-
timos (con que entradas contamos) y a donde queremos llegar (cual es el
resultado que deseamos obtener). Como producto de esta etapa deberemos
producir tres incisos:
a. Enunciado preciso del problema.
b. Entradas.
c. Salidas.
31 El proceso del software

Analisis y diseno del algoritmo: Planteamos la manera en que vamos a trans-

formar los datos de entrada para obtener el resultado que buscamos, y pro-
cedemos a elaborar un modelo de la solucion. Muchas veces este modelo
involucra varios pasos intermedios (estados de los datos), o mas que un re-
sultado concreto, buscamos un cierto comportamiento, como en el caso de
un juego o una simulacion como la de un reloj. En estos ultimos casos
deberemos pensar en procesos sucesivos que nos lleven de un estado de co-
sas (estado de los datos) al estado inmediato sucesor fotos instantaneas
y cual o cuales son las transformaciones de los datos que nos producen el
siguiente estado.
Dependiendo del ambiente (dominio) de nuestro problema, las soluciones
que disenemos deberan tener distintas caractersticas. La primera de ellas,
que comparten todos los dominios es:

a) La solucion debe ser correcta, eficiente y efectiva.

La unica excepcion posible a esta reglas se presenta si estamos haciendo

un programa para ayudarnos a calcular algo, o para sacarnos de un brete
momentaneo o coyuntural, el programa se va a utilizar pocas veces en un
lapso corto de tiempo; tal vez hasta podemos eliminar la caracterstica de
que sea eficiente (haga el trabajo en un tiempo razonable, utilizando una
cantidad razonable de recursos como la memoria). En los primeros anos de
las computadoras, casi todos los programas eran de este tipo: la gente los
haca para s mismos, o para un grupo reducido que estaba muy al tanto de
lo que estaba pasando.
Hoy en da, en que las computadoras estan en todo, la mayora de la gente
involucrada haciendo programas los hace para otros. Ademas, el tamano
de los sistemas ha crecido tanto, que ya casi nadie es el dueno de sus
programas, sino que se trabaja en el contexto de proyectos grandes, con
mucha gente involucrada. En este tipo de situaciones, que hoy en da son
mas la regla que la excepcion, se requiere ademas que los programas:

b) Sean modulares. Se puedan trazar claramente las fronteras entre pedazos

del programa (o sistema), para que la tarea se pueda repartir.
c) Tengan un bajo nivel de acoplamiento. Esta propiedad se refiere a que
utilicen lo menos posible del mundo exterior y entreguen lo mnimo po-
sible: que haya poco trafico entre los modulos, de tal manera que haya la
posibilidad de reutilizarlos.
2.1 Que es la programacion? 32

d) Alta cohesion, que se refiere al hecho de que todo lo que este relacionado
(funciones, datos) se encuentren juntos, para que sean faciles de localizar,
entender y modificar.

Implementacion o construccion del modelo: En esta etapa deberemos tra-

ducir nuestro algoritmo al lenguaje de programacion que hayamos elegido.
A esta etapa se le conoce tambien como de codificacion. Esta no es una labor
muy difcil, si es que tenemos un diseno que siga la filosofa2 del lenguaje de
programacion.

Asegurar la documentacion del programa: Esto no es o no debera ser

una etapa separada del proceso, ya que lo ideal es que, conforme se va
progresando se vaya documentando el programa. Hoy en da existen muchos
paquetes que ayudan a llevar a cabo el diseno y que ayudan con la documen-
tacion, por lo que Actualmente es imperdonable que falte documentacion en
los programas. En el presente, en que los programas se hacen en un 90 % de
los casos para otros, es muy importante que el programa lo pueda entender
cualquier lector humano; esto se logra, la mayora de las veces, mediante la
documentacion.

Prueba y validacion: Debemos tener la seguridad de que nuestro programa ha-

ce lo que se supone debe de hacer. Para esto hay pruebas informales, que
consisten en presentarle al programa distintos conjuntos de datos y verificar
que el programa hace lo que tiene que hacer. Estas pruebas deben incluir
conjuntos de datos erroneos, para verificar que el programa sabe defender-
se en situaciones anomalas.
La validacion de los programas conlleva demostraciones matematicas de que
los enunciados cambian el estado de los datos de la manera que se busca.

Mantenimiento: La actividad que mayor costo representa hoy en da es la del

mantenimiento de los sistemas. Tenemos dos tipos de mantenimiento: correc-
tivo y extensivo. El correctivo tiene que ver con situaciones que el programa
o sistema no esta resolviendo de manera adecuada. El mantenimiento exten-
sivo tiene que ver con extender las capacidades del programa o sistema para
que enfrente conjuntos nuevos de datos o entregue resultados adicionales.
Sin una documentacion adecuada, estas labores no se pueden llevar a cabo.
Sin un diseno correcto, es practicamente imposible extender un sistema.
2
Con esto nos referimos a la manera como el lenguaje de programacion interpreta el mundo:
por procedimientos, orientado a objetos, funcional, logico. A esto le llamamos paradigmas de
programacion.
33 El proceso del software

Refinamiento y Extension: Esta etapa generalmente la llevan a cabo personas

distintas a las que disenaron el sistema. Se busca que cuando se extiende
un sistema, no se tape un hoyo haciendo otro. La modularidad ayuda, pues
se entiende mejor el funcionamiento del programa si se ataca por modulos.
Pero esta propiedad debe tener, ademas, la propiedad de encapsulamiento,
que consiste en que cada modulo tiene perfectamente delimitado su campo
de accion, la comunicacion entre modulos es mucho muy controlada y una
implementacion interna (modo de funcionar) que pueda ser cambiada sin
que altere su comportamiento y sin que haya que cambiar nada mas.

Estas etapas, como ya mencionamos en algunas de ellas, no se presentan for-

zosamente en ese orden. Mas aun, muchas veces se da por terminada una de ellas,
pero al proceder a la siguiente surgen problemas que obligan a regresar a etapas
anteriores a modificar el producto o, de plano, rehacerlo. Queremos insistir en
la importancia de tener un buen analisis y un buen diseno, no importa cuanto
tiempo nos lleve: esta es la llave para que en etapas posteriores no tengamos que
regresar a rehacer, o nos veamos en la necesidad de tirar trabajo ya hecho.
Pasemos a detallar un poco mas algunas de las etapas de las que hablamos.

Especificacion
Una buena especificacion, sea formal o no, hace hincapie, antes que nada, en
cual es el resultado que se desea obtener. Este resultado puede tomar muy distintas
formas. Digamos que el computo corresponde a un modelo (la instrumentacion o
implementacion del modelo).
Podemos entonces hablar de los estados por los que pasa ese modelo, donde
un estado corresponde a los valores posibles que toman las variables. Por ejemplo,
si tenemos las variables x, y, z, un posible estado sera:

t x5 y 7 z 9 u
Si tenemos la especificacion de un programa (rutina) que intercambie los va-
lores de dos variables x, y, podemos pensarlo as:

t x  K1 y  K2 u
es el estado inicial (con los valores que empieza el proceso), mientras que

t x  K2 y  K1 u
corresponde al estado final deseado. Podemos adelantar que una manera de lograr
que nuestro modelo pase del estado inicial al estado final es si a x le damos el
2.1 Que es la programacion? 34

valor de K2 (el valor que tiene y al empezar) y a y le damos el valor que tena x.
Podemos representar este proceso de la siguiente manera:

t x K1 y K2 u // estado inicial

A x ponle K2
A y ponle K1
t x K2 y K1 u // estado final

y podemos garantizar que nuestras operaciones cumplen con llevar al modelo al

estado final. Sin embargo, las operaciones que estamos llevando a cabo estan con-
siderando a K1 y K2 valores constantes. Un proceso mas general sera el siguiente:

t x K1 y K2 u // estado inicial

En t copia el valor de x
En x copia el valor de y
// En estos momentos x y y valen lo mismo!
En y copia el valor de t
t x K2 y K1 u // estado final

y este proceso funciona no importando que valores dimos para x y y.

Resumiendo, un estado de un proceso, computo o modelo es una lista de va-
riables, cada una de ellas con un cierto valor.
Una especificacion de un problema es la descripcion del problema, que como
mnimo debe tener el estado final del computo. El estado inicial puede ser fijado
a partir del estado final (determinando que se requiere para poder alcanzar ese
estado), o bien puede darse tambien como parte de la especificacion.

Analisis y diseno
Podemos decir, sin temor a equivocarnos, que la etapa de diseno es la mas
importante del proceso. Si esta se lleva a cabo adecuadamente, las otras etapas
se simplifican notoriamente. La parte difcil en la elaboracion de un programa
de computadora es el analisis del problema (definir exactamente que se desea) y
el diseno de la solucion (plantear como vamos a obtener lo que deseamos). Para
esta actividad se requiere de creatividad, inteligencia y paciencia. La experiencia
juega un papel muy importante en el analisis y diseno. Dado que la experiencia
se debe adquirir, es conveniente contar con una metodologa que nos permita ir
construyendo esa experiencia.
35 El proceso del software

As como hay diversidad en los seres humanos, as hay maneras distintas de

analizar y resolver un problema. En esa busqueda por automatizar o matemati-
zar el proceso de razonamiento, se buscan metodos o metodologas que nos lleven
desde la especificacion de un problema hasta su mantenimiento, de la mejor ma-
nera posible. El principio fundamental que se sigue para analizar y disenar una
solucion es el de divide y venceras, reconociendo que si un problema resulta de-
masiado complejo para que lo ataquemos, debemos partirlo en varios problemas
de menor magnitud. Podemos reconocer dos vertientes importantes en cuanto a
las maneras de dividir:

a) Programacion o analisis estructurado, que impulsa la descomposicion del pro-

blema en terminos de acciones, convergiendo todas ellas en un conjunto de
datos, presentes todo el tiempo. La division se hace en terminos del proceso,
reconociendo distintas etapas en el mismo. Dado que el enfasis es en el proceso,
cada modulo del sistema corresponde a un paso o etapa del proceso. Cuando
usamos este enfoque perdemos la posibilidad de encapsular, pues los datos se
encuentran disponibles para todo mundo, y cada quien pasa y les mete mano.
Ademas, hay problemas que son difciles de analizar en terminos de etapas.
Por ejemplo, los juegos de computadora estilo aventura, las simulaciones de
sistemas biologicos, el sistema de control de un dispositivo qumico, un sistema
operativo. Sin embargo, esta metodologa es muy adecuada para disenar, como
lo acabamos de mencionar, un cierto proceso que se lleva a cabo de manera
secuencial.

b) Analisis y diseno orientado a objetos. El analisis orientado a objetos pretende

otro enfoque, partiendo al problema de acuerdo a los objetos presentes. De-
termina cuales son las responsabilidades de cada objeto y que le toca hacer a
cada quien.

Implementacion del modelo

Para la programacion, como ya mencionamos, utilizaremos Java y aprovecha-
remos la herramienta JavaDoc para que la documentacion se vaya haciendo, como
es deseable, durante la codificacion.

Mantenimiento
Porque se trata de un curso, no nos veremos expuestos a darle mantenimien-
to a nuestros programas. En las sesiones de laboratorio, sin embargo, tendran
que trabajar con programas ya hechos y extenderlos, lo que tiene que ver con el
mantenimiento.
2.1 Que es la programacion? 36

2.1.1. Conceptos en la orientacion a objetos

Al hacer el analisis de nuestro problema, como ya mencionamos, trataremos

de dividir a la solucion en tantas partes como sea posible, de tal manera que cada
parte sea facil de entender y disenar. La manera de dividir al problema sera en
terminos de actores y sus respectivas responsabilidades (o facultades): que puede
y debe hacer cada actor para contribuir a la solucion. Cada uno de estos actores
corresponde a un objeto. Agrupamos y abstraemos a los objetos presentes en clases.
Cada clase cumple con:

Tiene ciertas caractersticas.

Funciona de determinada manera.

Quedan agrupados en una misma clase aquellos objetos que presentan las
mismas caractersticas y funcionan de la misma manera.
En el diseno orientado a objetos, entonces, lo primero que tenemos que hacer
es clasificar nuestro problema: encontrar las distintas clases involucradas en el
mismo.
Las clases nos proporcionan un patron de comportamiento: nos dicen que y
como se vale hacer con los datos de la clase. Es como el guion de una obra de teatro,
ya que la obra no se nos presenta hasta en tanto no haya actores. Los actores son
los objetos, que son ejemplares o instancias de las clases (representantes de las
clases).
Al analizar un problema deberemos tratar de identificar a los objetos invo-
lucrados. Una vez que tengamos una lista de los objetos (agrupando datos que
tienen propositos similares, por ejemplo), deberemos abstraer, encontrando carac-
tersticas comunes, para definir las clases que requerimos.
Distinguimos a un objeto de otro de la misma clase por su nombre identidad
o identificador. Nos interesa de un objeto dado:

i. Su estado: cual es el valor de sus atributos.

ii. Su conducta:
Que cosas sabe hacer.
Como va a reaccionar cuando se le hagan solicitudes.

Lo correspondiente a i. esta determinado por cada objeto, ya que cada objeto

es capaz de almacenar su propia informacion. Lo correspondiente a ii. esta dado
por la definicion de la clase, que nos da un patron de conducta.
37 El proceso del software

Tratando de aclarar un poco, pensemos en lo que se conoce como sistema

cliente/servidor. Cliente es aquel que pide, compra, solicita algo: un servicio, un
valor, un trabajo. Servidor es aquel que provee lo que se le esta pidiendo. Esta
relacion de cliente/servidor, sin embargo, no es estatica. El servidor puede tomar
el papel de cliente y viceversa.
Lo que le interesa al cliente es que el servidor le proporcione aquello que el
cliente esta pidiendo. No le importa como se las arregla el servidor para hacerlo.
Si el cliente le pide al servidor algo que el servidor no sabe hacer, que no reconoce,
simplemente lo ignora, o le contesta que eso no lo sabe hacer.
El analisis orientado a objetos pretende reconocer a los posibles clientes y servi-
dores del modelo, y las responsabilidades de cada quien. Divide la responsabilidad
global del proceso entre distintos objetos.
Un concepto muy importante en la orientacion a objetos es el encapsulamiento
de la informacion. Esto quiere decir que cada objeto es dueno de sus datos y sus
funciones, y puede o no permitir que objetos de otras clases ajenas vean o utilicen
sus recursos.
Un objeto entonces tiene la propiedad de que encapsula tanto a los procesos
(funciones) como a los datos. Esto es, conoce cierta informacion y sabe como llevar
a cabo determinadas operaciones. La ventaja del encapsulamiento es que en el
momento de disenar nos va a permitir trazar una lnea alrededor de operaciones y
datos relacionados y tratarlos como una capsula, sin preocuparnos en ese momento
de como funciona, sino unicamente de que es capaz de hacer.
En el caso de los objetos, la capsula alrededor del mismo oculta al exterior
la manera en que el objeto trabaja, el como. Cada objeto tiene una interfase
publica y una representacion privada. Esto nos permite poder hacer abstracciones
mas facil y modelos mas sencillos, pues lo que tomamos en cuenta del objeto es
exclusivamente su interfase; posponemos la preocupacion por su representacion
privada.
Publicamente un objeto anuncia sus habilidades: puedo hacer estas cosas,
puedo decir estas cosas; pero no dice como es que las puede hacer o como es que
sabe las cosas. Los objetos actuan como un buen jefe cuando le solicitan a otro
objeto que haga algo: simplemente le hacen la solicitud y lo dejan en paz para que
haga lo que tiene que hacer; no se queda ah mirando sobre su hombro mientras
lo hace.
El encapsulamiento y el ocultamiento de la informacion colaboran para aislar
a una parte del sistema de otras, permitiendo de esta manera la modificacion y
extension del mismo sin el riesgo de introducir efectos colaterales no deseados.
Para determinar cuales son los objetos presentes en un sistema, se procede de la
siguiente manera:
2.1 Que es la programacion? 38

1. Se determina que funcionalidades e informacion estan relacionadas y deben

permanecer juntas, y se encapsulan en un objeto.

2. Entonces se decide que funcionalidades e informacion se le van a solicitar a

este objeto (que servicios va a prestar). Estos se mantienen publicos, mien-
tras que el resto se esconde en el interior del objeto.

Esto se logra mediante reglas de acceso, que pueden ser de alguno de los tipos
que siguen:

Publico: Se permite el acceso a objetos de cualquier otra clase.

Privado: Solo se permite el acceso a objetos de la misma clase.

En algunos lenguajes de programacion se permiten otros tipos de acceso. Por

ejemplo, en Java tambien tenemos los siguientes, pero que no pretendemos dejar
claros por el momento:

Paquete: Se permite el acceso a objetos que estan agrupados en el mismo paquete

(generalmente un sistema).

Protegido: Se permite el acceso a objetos de clases que hereden de esta clase.

Veamos la terminologa involucrada en el diseno orientado a objetos:

Mensajes (messages)

Un objeto le pide un servicio a otro mandandole un mensaje. A esta accion le

llamamos el envo de un mensaje y es la unica manera en que un objeto se puede
comunicar con otro.
Un mensaje consiste del nombre de una operacion y los argumentos que la
operacion requiere. La solicitud no especifica como debe ser satisfecha.

Comportamiento o conducta (behaviour )

El conjunto de mensajes a los que un objeto puede responder es a lo que se

conoce como la conducta o el comportamiento del objeto.
Al nombre de la operacion en el mensaje le llamamos el nombre del mensaje.
39 El proceso del software

Metodos (methods)

Cuando un objeto recibe un mensaje, ejecuta la operacion que se le solicita,

mediante la ejecucion de un metodo. Un metodo es un algoritmo paso a paso
que se ejecuta como respuesta a un mensaje cuyo nombre es el mismo que el del
metodo. Para que un metodo pueda ser invocado desde un objeto de otra clase,
debe ser publico. En el caso de algunos lenguajes de programacion, a los metodos
se les llama funciones miembro (member functions), porque son miembros de
la clase u objeto.

Clases (classes)

Si dos objetos presentan el mismo comportamiento, decimos que pertenecen a

la misma clase. Una clase es una especificacion generica para un numero arbitrario
de objetos similares. Las clases permiten construir una taxonoma de los objetos
en un nivel abstracto, conceptual. Nos permiten describir a un grupo de objetos.
Por ejemplo, cuando describimos a los seres humanos damos las caractersticas
que les son comunes. Cada ser humano es un objeto que pertenece a esa clase. Hay
que insistir en que las clases corresponden unicamente a descripciones de objetos,
no tienen existencia en s mismas.

Ejemplares (instances)

Las instancias corresponden, de alguna manera, a los ejemplares que pode-

mos exhibir de una clase dada. Por ejemplo, describimos a los seres humanos y
decimos que Fulanito es un ejemplar de la clase de seres humanos: existe, tiene
vida propia, le podemos pedir a Fulanito que haga cosas. Fulanito es un objeto
de la clase de seres humanos. Fulanito es el nombre (identificador, identidad) del
ejemplar u objeto. Su comportamiento es el descrito por los metodos de su clase.
Esta en un cierto estado, donde el estado es el conjunto de datos (caractersticas)
junto con valores particulares.
Un mismo objeto puede pasar por distintos estados. Por ejemplo, podemos
definir que las caractersticas de un ser humano incluyen: estado de conciencia,
estado de animo, posicion. Fulanito puede estar dormido o despierto, contento o
triste, parado o sentado, correspondiendo esto a cada una de las caractersticas (o
2.1 Que es la programacion? 40

variables). Sin embargo, hay variables entre las que corresponden a un objeto, que
si bien cambian de un objeto a otro (de una instancia a otra), una vez definidas
en el objeto particular ya no cambian, son invariantes. Por ejemplo, el color de
los ojos, el sexo, la forma de la nariz.

Figura 2.2 Arbol de herencia en clases.

Elementos geometricos

punto lnea Volumen

recta curva cubo cilindro esfera piramide

Superficie

cuadrado rectangulo crculo elipse

Herencia (inheritance)

Es frecuente encontrar una familia de objetos (o clases) que tienen un nucleo

en comun, pero que difieren cada uno de ellos por algun atributo, una o mas fun-
ciones. Cuando esto sucede, deberemos reconocer al nucleo original, identificando
a una clase abstracta a partir de la cual cada uno de las clases de la familia son
una extension. A esta caracterstica es a lo que se le conoce como herencia: las
clases en la familia de la que hablamos, heredan de la clase abstracta o clase base,
remedando un arbol como el que se muestra en la figura 2.2. En esta figura las
clases abstractas o base se presentan encuadradas con lneas intermitentes, mien-
tras que las subclases se presentan encuadradas con lnea continua. A este tipo de
esquema le llamamos de jerarqua de clases.
41 El proceso del software

Polimorfismo (polymorphism)

Dado que tenemos la posibilidad de agrupar a las clases por familias, que-
remos la posibilidad de que, dependiendo de cual de los herederos se trate, una
funcion determinada se lleve a cabo de manera personal a la clase. Por ejemplo,
si tuvieramos una familia, la funcion de arreglarse se debera llevar a cabo de
distinta manera para la abuela que para la nieta. Pero la funcion se llama igual:
arreglarse. De la misma manera, en orientacion a objetos, conforme definimos he-
rencia podemos modificar el comportamiento de un cierto metodo, para que tome
en consideracion los atributos adicionales de la clase que hereda. A esto, el que
el mismo nombre de metodo pueda tener un significado distinto dependiendo de
la clase a la que pertenece el objeto particular que lo invoca, es a lo que se llama
polimorfismo tomar varias formas.

En resumen, presentados ante un problema, estos son los pasos que deberemos
realizar:
1. Escribir de manera clara los requisitos y las especificaciones del problema.
2. Identificar las distintas clases que colaboran en la solucion del problema y la
relacion entre ellas; asignar a cada clase las responsabilidades correspondien-
tes en cuanto a informacion y proceso (atributos y metodos respectivamen-
te); identificar las interacciones necesarias entre los objetos de las distintas
clases (diseno).
3. Codificar el diseno en un lenguaje de programacion, en este caso Java.
4. Compilar y depurar el programa.
5. Probarlo con distintos juegos de datos.
De lo que hemos visto, la parte mas importante del proceso va a ser el analisis
y el diseno, as que vamos a hablar de el con mas detalle.

2.2 Diseno orientado a objetos

El diseno orientado a objetos es el proceso mediante el cual se transforman las

especificaciones (o requerimientos) de un sistema en una especificacion detallada
2.2 Diseno orientado a objetos 42

de objetos. Esta ultima especificacion debe incluir una descripcion completa de

los papeles y responsabilidades de cada objeto y la manera en que los objetos se
comunican entre s.
Al principio, el proceso de diseno orientado a objetos es exploratorio. El di-
senador busca clases, agrupando de distintas maneras para encontrar la manera
mas natural y razonable de abstraer (modelar) el sistema. Inicialmente consiste
de los siguientes pasos:

1. Determina (encuentra) las clases en tu sistema.

2. Determina que operaciones son responsabilidad de cada clase, y que cono-

cimientos la clase debe mantener o tener presentes para poder cumplir con
sus responsabilidades.

3. Determina las formas en las que los objetos colaboran con otros objetos para
delegar sus responsabilidades.

Estos pasos producen:

una lista de clases dentro de tu aplicacion,

una descripcion del conocimiento y operaciones que son responsabilidad de

cada clase, y

una descripcion de la colaboracion entre clases.

Una vez que se tiene este esquema, conviene tratar de establecer una jerarqua
entre las clases que definimos. Esta jerarqua establece las relaciones de herencia
entre las clases. Dependiendo de la complejidad del diseno, podemos tener anida-
dos varios niveles de encapsulamiento. Si nos encontramos con varias clases a las
que conceptualizamos muy relacionadas, podemos hablar entonces de subsiste-
mas. Un subsistema, desde el exterior, es visto de la misma manera que una clase.
Desde adentro, es un programa en miniatura, que presenta su propia clasificacion
y estructura. Las clases proporcionan mecanismos para estructurar la aplicacion
de tal manera que sea reutilizable.
Si bien suena sencillo eso de determina las clases en tu aplicacion, en la vida
real este es un proceso no tan directo como pudiera parecer. Veamos con un poco
de mas detalle estos subprocesos:

1. Determina las clases en tu sistema (encuentra los objetos).

Para poder determinar cuales son los objetos en tu sistema, debes tener
muy claro cual es el objetivo del mismo. Que debe lograr el sistema? Cual
43 El proceso del software

es la conducta que esta claramente fuera del sistema? La primera pregunta

se responde dando una especificacion completa del problema. En un prin-
cipio daremos descripciones narrativas del problema y nuestro primer paso
debera consistir en dividir el problema en subproblemas, identificando las
clases.
En esta descripcion narrativa, existe una relacion entre los sustantivos o
nombres y los objetos (o clases). Una primera aproximacion puede ser, en-
tonces, hacer una lista de todos los sustantivos que aparezcan en la especifi-
cacion narrativa. Una vez que se tiene esta lista, debemos intentar reconocer
similitudes, herencia, interrelaciones. Debemos clasificar a nuestros objetos
para determinar cuales son las clases que vamos a necesitar.
Las probabilidades de exito en el diseno del sistema son directamente pro-
porcionales a la exactitud y precision con que hagamos esta parte del diseno.
Si este primer paso no esta bien dado, el modelo que obtengamos a partir de
el no va a ser util y vamos a tener que regresar posteriormente a parcharlo.
2. Determina sus responsabilidades (metodos y estructuras de datos).
Determinar las responsabilidades de un objeto involucra dos preguntas:

Que es lo que el objeto tiene que saber de tal manera que pueda
realizar las tareas que tiene encomendadas?
Cuales son los pasos, en la direccion del objetivo final del sistema, en
los que participa el objeto?

Respondemos a esta pregunta en terminos de responsabilidades. Posponemos

lo mas posible la definicion de como cumple un objeto con sus responsabili-
dades. En esta etapa del diseno nos interesa que acciones se tienen que llevar
a cabo y quien es el responsable de hacerlo.
De la misma manera que existe una cierta relacion entre los sustantivos de
la especificacion y las clases, podemos asociar los verbos de la especificacion
a los metodos o responsabilidades. Si hacemos una lista de las responsabili-
dades y las asociamos a los objetos, tenemos ya un buen punto de partida
para nuestro modelo.
Un objeto tiene cinco tipos de funciones:

funciones constructoras, que son las encargadas de la creacion de los

objetos, as como de su inicializacion (establecer el estado inicial);
funciones de implementacion, que son aquellas que representan a los
servicios que puede dar un objeto de esa clase;
2.2 Diseno orientado a objetos 44

funciones de acceso que proporcionan informacion respecto al estado

del objeto;
funciones auxiliares que requiere el objeto para poder dar sus servicios,
pero que no interactuan con otros objetos o clases; y
funciones de actualizacion y manipuladoras, que modifican el estado
del objeto.

3. Determina su colaboracion (mensajes). En esta subdivision nos interesa res-

ponder las siguientes preguntas respecto a cada una de las clases definidas:

Con que otros objetos tiene que colaborar para poder cumplir con sus
responsabilidades (a quien le puede delegar)?
Que objetos en el sistema poseen informacion que necesita o sabe como
llevar a cabo alguna operacion que requiere?
En que consiste exactamente la colaboracion entre objetos?

Es importante tener varios objetos que colaboran entre s. De otra manera,

el programa (o sistema) va a consistir de un objeto enorme que hace todo.
En este paso, aunque no lo hemos mencionado, tenemos que involucrarnos ya
con el como cumple cada objeto con su responsabilidad, aunque no todava a
mucho nivel de detalle. Un aspecto muy importante es el determinar donde
es que se inician las acciones. En el esquema de cliente/servidor del que
hemos estado hablando, en este punto se toman las decisiones de si el objeto
subcontrata parte de su proceso, si es subcontratado por otro objeto, etc.
Es importante recalcar que mientras en la vida real algunos de los objetos
tienen habilidad para iniciar por s mismos su trabajo, en el mundo de la
programacion orientada a objetos esto no es as: se requiere de un agente
que inicie la accion, que ponga en movimiento al sistema.
Es muy importante en esta etapa describir con mucha precision cuales son
las entradas (input) y salidas (output) de cada objeto y la manera que cada
objeto va a tener de reaccionar frente a una solicitud. En teora, un objeto
siempre da una respuesta cuando se le solicita un servicio. Esta respuesta
puede ser

No se hacerlo, no lo reconozco.
Un valor o dato que posee.
La realizacion de un proceso
45 El proceso del software

La manera como estas respuestas se manifiestan van a cambiar de sistema

a sistema.

4. Determina la accesibilidad de las funciones y datos. Una vez que se tiene

clasificado al sistema, es importante perseguir el principio de ocultamiento
de la informacion. Esto consiste en decidir, para cada clase, cuales de sus
funciones y sus datos van a estar disponibles, publicos, y cuales van a estar
ocultos dentro de los objetos de la clase. Es claro que los metodos o funciones
forman parte de la seccion publica, pues van a ser solicitados por otros
objetos. Tambien es claro que los datos deben permanecer ocultos, pues
queremos que el objeto mismo sea el unico que puede manipular su propio
estado. No queremos que otra clase u objeto tenga acceso a los valores del
objeto.

Sin embargo, a veces requerimos de funciones que solo el objeto necesita o

usa. En estos casos, estas funciones las vamos a colocar tambien en el espacio
privado de la clase, buscando que el acoplamiento entre clases sea mnimo:
si nadie requiere de ese servicio, mas que el mismo objeto, para que ponerlo
disponible?

Si bien tratamos de dar una metodologa para el diseno orientado a objetos, es

imposible hacerlo de manera completa en unas cuantas paginas (hay cursos que
se dedican unicamente a este tema). Lo que se menciona arriba son unicamente
indicaciones generales de como abordar el problema, aprovechando la intuicion
natural que todos poseemos. Conforme avancemos en el material, iremos exten-
diendo tambien la metodologa.

2.2.1. Tarjetas de responsabilidades

Como resultado de este analisis elaboraremos, para cada clase definida, lo

que se conoce como una tarjeta de responsabilidades. Esta tarjeta registrara los
atributos, responsabilidades y colaboracion que lleva a cabo esa clase, y una breve
descripcion del objetivo de cada atributo y de cada metodo.
2.3 Diseno Estructurado 46

2.3 Diseno Estructurado

Como ya mencionamos antes, para disenar cada uno de los metodos o funciones
propias de un sistema debemos recurrir a otro tipo de analisis que el orientado
a objetos. Esto se debe fundamentalmente a que dentro de un metodo debemos
llevar a cabo un algoritmo que nos lleve desde un estado inicial a otro final, pero
donde no existe colaboracion o responsabilidades, sino simplemente una serie de
tareas a ejecutar en un cierto orden.
Tenemos cuatro maneras de organizar a los enunciados o lneas de un algoritmo:

Secuencial, donde la ejecucion prosigue, en orden, con cada lnea, una despues
de la otra y siguiendo la organizacion fsica. Por ejemplo:
1: pone 1 en x
2: suma 2 a x
3: copia x a y

se ejecutara exactamente en el orden en que estan listadas.

Iteracion, que marca a un cierto conjunto de enunciados secuenciales e indica la
manera en que se van a repetir. Por ejemplo:
1: pone 1 en x
2: Repite 10 veces desde el enunciado 3 hasta el 5:
3: suma 2 a x
4: copia x a y
5: Escribe el valor de x
En este caso, podemos decir que el estado inicial de las variables al llegar a
la iteracion es con x valiendo 1 y con y con un valor indeterminado. Cual
es el estado final, al salir de la iteracion?
La manera como indicamos el grupo de enunciados a repetirse es dando una
sangra mayor a este grupo; siguiendo esta convencion, el enunciado de la
lnea 2 podra simplemente ser

2: Repite 10 veces:

y el solo hecho de que los enunciados 3, 4 y 5 aparecen con mayor sangra

da la pauta para que esos sean los enunciados a repetirse.
Ejecucion condicional, que se refiere a elegir una de dos o mas opciones de
grupos de enunciados. Por ejemplo:
47 El proceso del software

1: poner un valor arbitrario a y, entre 0 y 9999

2: Si x es mayor que 1:
3: Divide a y entre x y coloca el resultado en z
4: Multiplica a z por 13
5: escribe el valor de z
6: Si x no es mayor que 1:
7: multiplica a y por 16
8: escribe el valor de y
En este caso planteamos dos opciones, una para cuando el estado inicial
antes de entrar a la ejecucion condicional sea con x teniendo un valor mayor
que 1, y la otra para cuando x tenga un valor menor que 1 (que pudiera ser
0).

Recursividad, que es cuando un enunciado esta escrito en terminos de s mismo,

como es el caso de la definicion del factorial de un numero:
$
&n  pn
1q! para n 1
'
n! 
'
% 1 para n  1

Toda solucion algortmica que demos, sobre todo si seguimos un diseno es-
tructurado, debera estar dado en terminos de estas estructuras de control. El
problema central en diseno consiste en decidir cuales de estas estructuras utili-
zar, como agrupar enunciados y como organizar, en general los enunciados del
programa.
Una parte importante de todo tipo de diseno es la notacion que se utiliza
para expresar los resultados o modelos. Al describir las estructuras de control
utilizamos lo que se conoce como pseudocodigo, pues escribimos en un lenguaje
parecido al espanol las acciones a realizar. Esta notacion, si bien es clara, resulta
facil una vez que tenemos definidas ya nuestras estructuras de control, pero no
nos ayuda realmente a disenar. Para disenar utilizaremos lo que se conoce como
la metodologa de Warnier-Orr, cuya caracterstica principal es que es un diseno
controlado por los datos, i.e. que las estructuras de control estan dadas por las
estructuras que guardan los datos. Ademas, el diseno parte siempre desde el estado
final del problema (que es lo que queremos obtener) y va definiendo pequenos pasos
que van transformando a los datos hacia el estado inicial del problema (que es lo
que sabemos antes de empezar a ejecutar el proceso).
Empecemos por ver la notacion que utiliza el metodo de Warnier-Orr, y dado
que es un metodo dirigido por los datos, veamos la notacion para representar
2.3 Diseno Estructurado 48

grupos de datos, que al igual que los enunciados, tienen las mismas 4 formas
de organizarse: secuencial, iterativa, condicional o recursiva . Por supuesto que
tambien debemos denotar la jerarqua de la informacion, donde este concepto se
refiere a la relacion que guarda la informacion entre s. Representa a los datos
con una notacion muy parecida a la de teora de conjuntos, utilizando llaves para
denotar a los conjuntos de datos (o enunciados). Sin embargo, cada conjunto puede
ser refinado con una ampliacion de su descripcion, que se encuentra siempre
a la derecha de la llave. Otro aspecto muy importante es que en el caso de los
conjuntos de Warnier-Orr el orden es muy importante. La manera en que el
metodo de Warnier-Orr representa estos conceptos se explica a continuacion:

Jerarqua
Abre llaves. El nombre de la llave es el objeto de mayor jerarqua e identifica
al subconjunto de datos que se encuentran a la derecha de la llave. Decimos
entonces que lo que se encuentra a la derecha de la llave refina (explica con
mayor detalle) al nombre de la llave. Veamos la figura 2.3.

Jerarqua: en la figura figura 2.3, nombre agrupa a descr1 , descr2 ,. . . ,descrn ;

decimos entonces que las descripciones son un refinamiento de nombre, y
que nombre es de mayor jerarqua que las descripciones.

Figura 2.3 Uso de llaves para denotar composicion.

$
'
'
' descr1
'
'
'
'
'
'
'
'
&descr2
nombre
'
'
'
'
'
'
...
'
'
'
'
'
%descr3

Secuencia: el orden (la secuencia) se denota verticalmente: descr1 se ejecuta

antes que descr2 , y as sucesivamente, en el orden vertical en el que aparecen.

Iteracion: la repeticion se representa con un parentesis abajo del nombre

donde se indican las reglas de repeticion:
49 El proceso del software

Figura 2.4 Iteracion en diagramas de Warnier-Orr.

$
'
'
'
descr1
nombre
& descr2
pMientras te diganq '
'
' ...
%
descrn

En el la figura 2.4, la condicion de repeticion es mientras te digan. Eso

querra decir que se ejecutan en orden, descr1 hasta descrn . Al terminar, se
checa si todava me dicen. Si es as, se regresa a ejecutar completo desde
descr1 hasta descrn , y as sucesivamente hasta que ya no me digan, en
cuyo caso sigo adelante.

Por ultimo, para denotar seleccion se utiliza el smbolo del o

Condicional:
exclusivo , que aparece entre una pareja de opciones ver figura 2.5.

Figura 2.5 Seleccion en diagramas de Warnier-Orr.

$ #
'
' digito  12
...
'
'
'
'
'
'
...
'
'
'
'
' #
'
'
'
'
&digito  2 . . .
' 2 2 ...

nombre
'
'
'
'
'
'
' ...
'
'
'
'
'
' #
'
'
'
'
%digito 2 92
' ...
...

Veamos como quedaran representados los pequenos procesos que dimos arriba
en terminos de la notacion de Warnier-Orr en las figuras 2.6 y 2.7, donde el smbolo
significa obten el valor de lo que esta a la derecha y coloca ese valor en la
variable que esta a la izquierda.
2.3 Diseno Estructurado 50

Figura 2.6 Diagramas de Warnier-Orr para secuencia.

$
&x 1
'
secuencial x x 2
'
% y x

Figura 2.7 Diagramas de Warnier-Orr para iteracion.

$ $
&x x 2
& Repite '
'
iteracion yx
% p10q '
' %escribe el valor de x

Por ultimo, el bloque de pseudocodigo que tenemos para la ejecucion condi-

cional podra quedar como se ve en la figura 2.8.

Figura 2.8 Diagrama de Warnier-Orr para seleccion.

$
'
' y randomp10000q
'
' $
'
'
'
' &z y{x
'
'
'
' x 1 z z {3
'
'
& '
%escribe el valor de z
seleccion
'
'
'
'
'
'
'
'
' #
'
'
' y y {6
%x 1 escribe el valor de y
'

Por supuesto que el metodo de Warnier-Orr nos proporciona herramientas para

llegar a estos esquemas, que se basan, como dijimos antes, en dejar que los datos
nos indiquen las estructuras a traves de la jerarqua que guardan entre ellos.
Ademas, utilizando el principio de divide y venceras, decimos que cualquier
problema puede ser dividido en al menos tres partes: prepararse, ejecutarlo y
51 El proceso del software

completar o cerrar. Veamos en un ejemplo, el de obtener los factores primos de un

entero n, cuales son los pasos a seguir. Por lo que acabamos de mencionar, todo
diagrama de Warnier-Orr empieza con el formato de la figura 2.9.

Figura 2.9 Estado inicial de todo diagrama de Warnier-Orr.

$ #
'
'
' Inicializar
'
'
'
.P rincipio
'
'
' $Obtener datos
'
'
& '
&. . .
N ombre del
P roceso
P roblema '
'
' '
%. . .
'
'
' #
'
'
'
'
'
%.F inal
Entregar resultados
Atar cabos sueltos

Siguiendo el principio de ir de lo general a lo particular indica que intentamos

ver el problema desde un punto de vista general, particularizando unicamente
cuando ya no es posible avanzar sin hacerlo. En este momento, en el problema que
estamos atacando, debemos empezar ya a refinar el proceso. Por ultimo, cuando
decimos que vamos desde los resultados hacia los datos, decimos que el problema lo
vamos resolviendo preocupandonos por cual es el resultado que debemos producir
y cual es el paso inmediato anterior para que lo podamos producir.

Figura 2.10 Diagrama inicial para encontrar factores primos.

$ !
'
'
' .Principio Obtener n
'
' $
'
'
' '
' ...
'
' '
'
'
'
'
' Verifica si k es factor '
&
'
'
'
&
?
primo de n
pk  2 . . . nq
'
'
'
...
F actores primos
' '
'
'
'
'
' %
'
'
' $. . .
'
'
' '
'
' & Da la lista de
'
'
' .Final factores primos
'
% '
% de n
2.3 Diseno Estructurado 52

Para el caso que nos ocupa, determinar los factores primos de un entero, el
diagrama con el que empezamos lo podemos ver en la figura 2.10 en la pagina
anterior. En el primer momento, todo lo que sabemos es que es lo que tenemos de
datos (n) y que esperamos de resultado (una lista con todos los valores de k para
los cuales k es primo y k divide a n). Para el principio y final de nuestros procesos
podemos observar que lo ultimo que vamos a hacer es proporcionar o escribir la
lista de factores primos del numero n. Esto corresponde al final de nuestro proceso.
Sabemos, porque algo de?matematicas manejamos, que deberemos verificar todos
los enteros k entre 2 y n, y que durante este proceso es cuando se debe cons-
truir la lista de primos divisores de n. Tambien sabemos, porque corresponde a
nuestros datos, que al principio de nuestro proceso deberemos obtener n. Con esta
informacion, podemos producir el diagrama inicial que, como ya mencionamos, se
encuentra en la figura 2.10 en la pagina anterior.

Figura 2.11 Diagrama de Warnier-Orr para procesar cada k.

$ !
'
'
' .P rincipio
'
'
' $

#
'
'
' '
'
' esP rimo
'
'
' '
' .P rincipio
'
' '
'
' true
'
' '
' $
'
'
' '
' '
&.P rincipio
' '
'
'
'
' '
'
' ?
V erif ica si i divide a k
'
'
'
'
'
'
'
'
pi  2, . . . , k q ' ...
%.F inal
'
'
' '
& #
'
'
' k es factor de n esP rimo  true Agrega k a
'
' '
Verifica si k es factor '
& '
'
' la lista
primo de ? '
'
'
n '
pk  2, . . . , nq ' '
'
'
'
'
'
'
'
'
'
'
' '
' !
'
' '
'
' esP rimo  true
'
'
' '
' !

'
' '
'
%.F inal
'
'
'
'
'
'
'
'
'
'
'
'
'
'
' !
'
'
' k es factor de n
' !

'
'
%.F inal
53 El proceso del software

Progresamos de atras hacia adelante. Para poder escribir la lista de factores

primos, debemos construirla. Esto lo hacemos en el bloque inmediato anterior al
del final, que es el que procesa a cada k y decide, primero, si k es un divisor de n,
y despues, si lo es, si k es primo o no. Si k es primo, se le agrega a la lista. Esta
etapa la podemos observar en el diagrama de la figura 2.11 en la pagina opuesta,
que muestra unicamente lo relativo al bloque que maneja a cada k.
Nos falta desarrollar el bloque que corresponde a determinar si k es primo.
Esto se hace de manera sencilla, dividiendo a k entre cada i. Si para alguna de
estas is, el residuo es 0, sabemos ya que k no es primo y no vale la pena seguir
verificando. Si, en cambio, para ninguna de las i con las que se prueba, la i divide
a k, entonces sabemos que k es primo. El diagrama correspondiente a este bloque
lo mostramos en la figura 2.12.

Figura 2.12 Diagrama para determinar si k es primo.

$ !
'
'
' .P rincipio
'
'
' $
!
'
'
' '
'
'
' '
'
'
.P rincipio
'
'
' & esP rimo f also
'
'
' k es factor de n
'
'
& '
'
' in !
?
V erif ica si i divide a k '
'
%.F inal
pi  2, . . . , kq '
'
'

'
'
'
'
'
'
'
'
' !
'
'
'
'
'
'
k es factor de n
!

'
%.F inal

El diagrama completo se puede observar en la figura 2.13 en la siguiente pagina

(para ahorrar espacio, y dado que no contribuyen, eliminamos todos los principios
y finales que no hacen nada).
Cuando alguno de los procesos no tiene que hacer nada, simplemente le pone-
mos un signo de conjunto vaco (). Varios de los procesos de P rincipio y F inal
no tienen encomendada ninguna tarea, por lo que aparecen vacos.
Una vez completo el diagrama de Warnier de un problema, el programa esta da-
do realmente por los enunciados en la jerarqua menor (estos son realmente los
enunciados ejecutables), respetando las estructuras de control de repeticion y con-
dicionales. Conforme vayamos avanzando en el curso, trataremos de adquirir expe-
2.3 Diseno Estructurado 54

riencia en el diseno estructurado. No hay que ignorar el hecho de que la intuicion

y la experiencia juegan un papel importante en esta etapa. Haciendo el smil con
arquitectura, una clase corresponde a los planos de una casa mientras que cada
casa que se construye de acuerdo a esos planos corresponde a una instancia u ob-
jeto de esa clase. Para poder determinar cada una de estas funciones (no siempre
tenemos presentes a todos los tipos) deberemos recurrir al diseno estructurado.
Hablaremos mas de este tema mas adelante en el curso El metodo de Warnier-
Orr no proporciona mecanismos para analizar problemas de naturaleza recursiva.
Este tipo de soluciones estara dado por las formulas mismas, o la descripcion de
la solucion.

Figura 2.13 Diagrama de Warnier-Orr para obtener factores primos de un entero.

$ !
'
' .P rincipio n el numero a f actorizar
'
'
' $ $ !
'
$ esP rimo #true
'
' '
' '
'
' .P rincipio
'
'
' '
'
' '
'
'
' '
' '
'
' '
' i es factor esP rimo f also
'
'
' '
'
' '
' '
'
'
' '
' '
' '
'
' in
'
' '
' '
'
'
V erif ica si '
'
de k

'
'
' '
'
' '
' &
'
' '
' '
'
'
i divide a k
'
'
' '
'
' & pi  2, '
'
' '
' k es factor ? '
'
' #
'
'
' V erif ica si k '
'
' ' q '
'
'
' '
' de n '
'
. . . , k '
'
'
i es factor
'
& divide a '
& '
'
' %
'
'
' ! de k
OF P
' n
' '
'
' esP rimo  true Agrega k a la lista
'
'
' pk ? 2 . . . '
'
' '
'
'
' '
' '
'
'
' . . . nq '
' '
'
' !
'
'
' '
'
' '
%
'
' '
' esP rimo  true
'
'
' '
'
'
'
'
' '
'
'
'
'
' '
'
'
'
'
' '
'
'
'
'
' '
'
'
'
' '
' !
k es factor
'
'
' % de n
'
'
' !
%.F inal escribe lista construida

Con esto queda terminado el algoritmo (y los diagramas correspondientes)

para obtener factores primos de un entero. Procedemos ahora a incursionar en
otros problemas, donde utilizaremos la metodologa que acabamos de describir.
 Clases y objetos
3
3.1 Tarjetas de responsabilidades

Para ilustrar de mejor manera el proceso de analisis y diseno procederemos a

trabajar con un ejemplo concreto: el diseno de un reloj analogico. Este ejemplo,
aunque sencillo, nos va a permitir seguirlo hasta su implementacion. Los pasos
para ello son, como lo mencionamos en secciones anteriores, hacer diagramas o
esquemas para cada una de las etapas de definicion, que volvemos a listar:

Accion A partir de: Produce:

1. Encontrar las Una descripcion o Una lista de objetos y un esquema para
clases y los especificacion del cada clase
objetos problema
2. Determinar las La lista de objetos. Esquema de clases con lista de funcio-
responsabilida- La especificacion nes miembro o metodos, clasificados en
des del programa publicos y privados, y con un breve des-
cripcion de que se supone que hace cada
una
3. Determinar la La lista de Adiciona al esquema de responsabilida-
colaboracion responsabilidades. des, para cada funcion o metodo, quien
entre objetos La lista de objetos. la puede llamar y a quien le va a respon-
der
3.1 Tarjetas de responsabilidades 56

Accion A partir de: Produce:

4. Determinar la El esquema de El esquema revisado para que coincida
accesibilidad de colaboracion y con las reglas que se dieron para accesi-
las funciones y responsabilidades bilidad.
datos

Pasemos a analizar nuestro problema.

Paso 1: Descripcion del problema

Descripcion del problema:
Un reloj analogico consiste de una caratula de despliegue, con dos manecillas,
una para horas y una para minutos. Cada manecilla tendra un valor entre 0
y un lmite superior prefijado (en el caso de los minutos es 60, mientras que
para las horas es 12). El usuario del programa debe ser capaz de construir el
reloj inicializando el valor de cada manecilla a las 0 horas con 0 minutos, o
bien, a un valor arbitrario (que podra ser el reloj de la maquina). El usuario
debe ser capaz tambien de incrementar el reloj incrementando la manecilla
de los minutos y algunas veces tambien la manecilla de las horas. El usuario
debera ser capaz de establecer el reloj en un cierto valor, estableciendo el
valor de cada uno de las manecillas. Finalmente, el usuario puede pedirle
al reloj que muestre su valor mostrando la posicion de cada una de las
manecillas.

Del parrafo anterior, podemos distinguir los siguientes objetos:

reloj
manecilla de horas
manecilla de minutos
valor de horas
valor de minutos
valor del reloj
lmites

Podemos ver que el objeto reloj, posee dos objetos que corresponde cada
uno de ellos a una manecilla. Cada manecilla posee un objeto valor y un objeto
lmite. El valor concreto de cada manecilla es suficientemente simple como para
que se lleve en un entero, lo mismo que el lmite; excepto que este ultimo debe ser
constante porque una vez que se fije ya no debera cambiar. Las horas y los minutos
57 Clases y objetos

con su valor y lmite correspondientes, pertenecen a la misma clase. Podemos

entonces mostrar nuestra estructura de la siguiente manera:

Manecilla
Datos: valor
lmite
Funciones: constructores: Poner el lmite
incrementa
pon valor
muestra
Reloj
Datos: horas Una manecilla con lmite 12
minutos Una manecilla con lmite 60
Funciones: constructores
incrementa
pon valor
muestra

En la clase Manecilla tenemos dos variables, valor y lmite, que no queremos

puedan ser manipuladas directamente, sin controlar que se mantenga en los lmites
establecidos, por lo que van a tener acceso privado. Por ello es conveniente agregar
dos responsabilidades (metodos) a esta clase, getValor y getLimite, para que se le
pueda pedir a los objetos de la clase, en caso necesario, que diga cuanto valen1 .

Paso 2: Elaboracion de tarjetas de responsabilidades

En este punto podemos hacer una distribucion de los objetos en clases y un
esquema de las clases determinadas que presente que es lo que tiene que contener
y tener cada clase, anotandolo en una tarjeta, como se ve en la figura 3.1 en la
siguiente pagina.

1
Usaremos la palabra get en estos casos, en lugar del termino en espanol da o dame, ya que
en Java existe la convencion de que los metodos de acceso a los atributos de una clase sean de
la forma get seguidos del identificador del atributo empezado con mayuscula. Similarmente en
los metodos de modificacion o actualizacion de los valores de un atributo la convencion es usar
set seguido del nombre del atributo escrito con mayuscula.
3.1 Tarjetas de responsabilidades 58

Figura 3.1 Tarjetas de clasificacion y acceso.

Clase: Reloj Clase: Manecilla

P constructores P constructores
u incrementa u incrementa
b setValor b setValor
l muestra l muestra
i i getValor
c c getLmite
o o
P P
r horas r valor
i i
v minutos v lmite
a a
d d
o o

Si1 completamos estos esquemas con las responsabilidades de cada quien, van
a quedar como se muestra en la figura 3.2 para la clase Reloj y en la figura 3.3 en
la pagina opuesta para la clase Manecilla.

Figura 3.2 Tarjeta de responsabilidades de la clase Reloj

Clase: Reloj (responsabilidades)

P constructor Inicializa el reloj a una hora dada.
u Para ello, debe construir las manecillas.
b incrementa Incrementa el reloj en un minuto
l
i setValor Pone un valor arbitrario en el reloj
c
o muestra Muestra el reloj
P horas Registra el valor en horas
r
i minutos Registra el valor en minutos
v
a
d
o
59 Clases y objetos

Figura 3.3 Tarjeta de responsabilidades para la clase Manecilla.

Clase: Manecilla (responsabilidades)

P constructor Establece el lmite de la manecilla y da valor
u inicial a la manecilla
b incrementa Incrementa el valor
l setValor Pone valor a la manecilla
i muestra Muestra el valor
c getValor Dice el valor que tiene
o getLimite Regresa el valor del lmite
P valor Tiene la informacion de la manecilla
r limite Tiene la informacion respecto al lmite
i
v
a
d
o
Paso 3: Determinar colaboracion
El tercer paso nos dice que determinemos la colaboracion entre los objetos. En
una primera instancia podemos ver que un objeto de la clase Reloj puede pedirle
a cada uno de los objetos de la clase Manecilla que haga su parte: construirse,
mostrar su valor, incrementarse. Podemos afinar nuestra descripcion de cada una
de las clases, describiendo de manera breve en que consiste cada metodo o funcion
propia y definiendo la colaboracion (quien inicia las acciones, o quien le solicita a
quien):

Clase: Cliente: Descripcion:

Manecilla
Datos valor el valor actual de la manecilla, en el rango
0..lmite
1.
lmite el valor en el que el reloj da la vuelta o
se vuelve a poner en ceros
Metodos Constructor Reloj Pone el valor de la manecilla en ceros y
establece el lmite
incrementa Reloj Suma 1 al valor y lo regresa a cero si es
necesario
3.1 Tarjetas de responsabilidades 60

Clase: Cliente: Descripcion:

setValor Reloj Pone el valor
muestra Reloj Muestra el valor que tiene la manecilla
Reloj
Datos horas Una manecilla con lmite 12
minutos Una manecilla con lmite 60
Metodos Constructor usuario Manda un mensaje a ambas manecillas ins-
talando sus lmites respectivos
incrementa usuario Incrementa la manecilla de minutos, y si es
necesario la de horas
setValor usuario Establece el tiempo en el reloj y para ello lo
establece en las manecillas horas y minutos
muestra usuario Pide a las manecillas que se acomoden

En forma esquematica las tarjetas quedan como se muestran en las figuras 3.4 y 3.5
en la pagina opuesta.

Figura 3.4 Tarjeta de colaboraciones de la clase Manecilla.

Clase: Manecilla (colaboracion)

P constructor El Reloj a la manecilla
u incrementa El Reloj a la manecilla
b setValor El Reloj a la manecilla
l
i muestra El Reloj a la manecilla
c getValor El Reloj a la manecilla
o getLimite El Reloj a la manecilla
P valor
r
i limite
v
a
d
o
61 Clases y objetos

Figura 3.5 Tarjeta de colaboraciones de la clase Reloj.

Clase: Reloj (colaboracion)

P constructor El usuario al Reloj
u incrementa El usuario al Reloj
b
l setValor El usuario al Reloj o Reloj a s mismo
i muestra El usuario al Reloj
c
o
P horas
r minutos
i
v
a
d
o

Tenemos ya completo el paso de analisis y diseno, ya que tenemos las tarjetas

de responsabilidades completas. Pasemos ahora al siguiente paso en la elaboracion
de un programa, que consiste en la instrumentacion del diseno para ser ejecutado
en una computadora.
Si bien el diseno orientado a objetos no es un concepto reciente (aparece alre-
dedor de 1972), lo que si es mas reciente es la popularidad de las herramientas que
facilitan la transicion de un modelo orientado a objetos a un programa orientado
a objetos. El primer lenguaje que maneja este concepto es Simula (hermanito de
Algol 60), aunque su popularidad nunca se generalizo.
Al mismo tiempo que Wirth disenaba el lenguaje Pascal (una herramienta
de programacion para el diseno estructurado), se diseno Smalltalk, un lenguaje
orientado a objetos, de uso cada vez mas generalizado hoy en da. Tambien se han
hecho muchas extensiones a lenguajes estructurados para proveerlos de la capa-
cidad de manejar objetos. Entre ellos tenemos Objective Pascal, C++, Objective
C, Modula 3, Ada. Muchos de los abogados de la programacion orientada a obje-
tos consideran a este tipo de extensiones como sucias, pues en muchas ocasiones
mezclan conceptos, o cargan con problemas que se derivan de tratar de mantener la
relacion con sus lenguajes originales. Hemos seleccionado Java como herramienta
de instrumentacion pues contamos con amplia bibliografa al respecto, aceptacion
generalizada fuera de los ambientes academicos, acceso a muy diversas versiones
de la herramienta. Estamos conscientes, sin embargo, de que Java es un lenguaje
sumamente extenso, por lo que no pretendemos agotarlo en este curso.
3.2 Programacion en Java 62

3.2 Programacion en Java

En todo lenguaje de programacion hay involucrados tres aspectos, relativos a

los enunciados escritos en ese lenguaje:
Sintaxis: Se refiere a la forma que tiene que tomar el enunciado. Cada lenguaje
tiene sus propias reglas y correspondera a la gramatica para un lenguaje
natural. Utilizamos para describir la sintaxis lo que se conoce como BNF
extendido.
Semantica: Se refiere de alguna manera al significado del enunciado. General-
mente el significado corresponde a la manera como se ejecuta el enunciado,
una vez traducido a lenguaje de maquina (en el caso de Java a bytecode).
Usaremos lenguaje natural y predicados para describir este aspecto.
Pragmatica: Se refiere a restricciones o caractersticas dadas por la computadora
o la implementacion del lenguaje. Por ejemplo, un entero en Java tiene un
lmite superior e inferior, que no corresponde a lo que entendemos como
entero. Este lmite es impuesto por la implementacion del lenguaje o de la
computadora en la que se van a ejecutar los programas. Usaremos lenguaje
natural para hablar de la pragmatica de un enunciado.
Hablemos un poco de BNF extendido, donde cada enunciado se muestra como si
fuera una formula:
xtermino a definiry :: xexpresion regulary
En esta notacion del lado izquierdo de ::= aparece lo que sera un tipo de ele-
mentos, lo que vamos a definir, como por ejemplo acceso, encerrado entre x y y
para distinguir al conjunto de alguno de sus representantes. El ::= se lee se
define como; del lado derecho se encuentra una xexpresion regulary, que puede
contener a su vez conjuntos o elementos del lenguaje. Una expresion regular es una
sucesion de smbolos terminales y no terminales (como en cualquier gramatica),
pero donde extendemos la gramatica de la siguiente manera: usamos parentesis
para agrupar cuando queramos que aparezca un parentesis tal cual lo marcare-
mos con negritas ; el smbolo | para denotar opciones; el smbolo * para
denotar que el grupo anterior se puede repetir cero o mas veces; y + para de-
notar que el grupo anterior se puede repetir una o mas veces. A los elementos
del lenguaje (representantes de los conjuntos, smbolos terminales) los escribimos
con negritas, tal como deben aparecer en el archivo fuente. Conforme vayamos
avanzando quedara mas claro el uso de BNF.
Cuando describamos un recurso del lenguaje, sea este un enunciado o la manera
de organizar a estos, hablaremos al menos de los dos primeros aspectos; el tercero
63 Clases y objetos

lo trataremos en aquellos casos en que tenga sentido.

Como Java es un lenguaje orientado a objetos, la modularidad de los programas
en Java se da a traves de clases. Una clase es, como ya dijimos, una plantilla para
la construccion de objetos, una lista de servicios que los objetos de la clase van a
poder realizar.
Otro elemento que utiliza Java para construir sus aplicaciones es la interfaz.
Una interfaz en Java describe a un grupo de servicios, en terminos de lo que los
objetos de las clases que la implementen saben hacer, esto es, lista unicamente
los servicios que la clase en cuestion va a dar, utilizando que datos de entrada y
proporcionando que resultados. Una interfaz corresponde a un contrato. Posterior-
mente podemos construir una o mas clases capaces de cumplir con ese contrato. A
esto ultimo le llamamos implementar a la interfaz. Trataremos de trabajar siem-
pre a traves de interfaces, pues nos dan un nivel de abstraccion mas alto que el
que nos dan las clases.
Decimos que declaramos una interfaz o una clase cuando escribimos la plantilla
en un archivo, al que denominamos archivo fuente. Se acostumbra, aunque no es
obligatorio, que se coloque una clase o interfaz por archivo2 para tener facilmente
identificable el archivo fuente de la misma. El nombre que se de al archivo, en este
caso, debe coincidir con el nombre de la clase o interfaz. Por ejemplo, la clase Reloj
debera estar en un archivo que se llame Reloj.java; de manera similar, la interfaz
ServiciosReloj debera estar en un archivo que se llame ServiciosReloj.java.

3.2.1. Declaraciones en Java

Lo primero que haremos en Java es, entonces, la definicion (declaracion) de

una interfaz. La sintaxis para ello se puede ver en la figura 3.6 en la siguiente
pagina.
Las palabras que aparecen en negritas tienen que aparecer tal cual. Ese es el
caso de interface y el ; que aparece al final de cada xencabezado de metodoy. Los
que aparecen entre x y y deben ser proporcionados por el programador, siguiendo
ciertas reglas para ello. En Java el punto y coma (;) se usa para terminar enun-
ciados, como las declaraciones (los encabezados de un metodo juegan el papel de
una declaracion). Por ejemplo, la sintaxis para el xaccesoy es como se ve en la figu-
ra 3.7 en la siguiente pagina, mientras que un xidentificadory es cualquier sucesion
de letras, dgitos y caracter de subrayado, que empiece con letra o subrayado.
2
La unica restriccion real para que haya mas de una clase en un archivo es en terminos de
identificarla, pues no habra un archivo fuente con el nombre de la clase. Pero s habra el archivo
correspondiente al bytecode de la clase (nombre.class).
3.2 Programacion en Java 64

Figura 3.6 Encabezado de una interfaz.

Sintaxis:
x declaracion de interfazy ::=
xaccesoy interface xidentificadory {
xencabezado de metodoy;
(xencabezado de metodoy;)*
}
Semantica:
Se declara una interfaz en un archivo. El nombre del archivo debe tener
como extension .java y coincide con el nombre que se le de a la interfaz.
Una interfaz, en general, no tiene declaraciones de atributos, sino unica-
mente de metodos, de los cuales unicamente se da el encabezado. Los en-
cabezados de los distintos metodos se separan entre s por un ; (punto y
coma). El que unicamente contenga encabezados se debe a que una interfaz
no dice como se hacen las cosas, sino unicamente cuales cosas sabe hacer.

Figura 3.7 Sintaxis para el xaccesoy.

Sintaxis:
xacceso y ::= public | private | protected | package |
Semantica:
El acceso a una clase determina quien la puede usar:
public La puede usar todo mundo.
private No tiene sentido para una clase ya que delimita a usar la clase a la
misma clase: no se conoce fuera de la clase.
protected Solo la pueden ver las clases que extienden a esta. No tiene
sentido para clases.
package Solo la pueden ver clases que se encuentren declaradas en el mismo
subdirectorio (paquete). Es el valor por omision.
Puede no haber regla de acceso, en cuyo caso el valor por omision es package.
En el caso de las interfaces, el acceso solo puede ser de paquete o publico, ya
que el concepto de interfaz tiene que ver con anunciar servicios disponibles.
65 Clases y objetos

Siguiendo la notacion de BNF extendido, el enunciado de Java para denotar a

un elemento del conjunto xidentificadory quedara como se ve en la figura 3.8.

Figura 3.8 Reglas para la formacion de un xidentificadory.

Sintaxis:
xidentificador y ::= (xletra y | )(xletray | xdgitoy | )*
Semantica:
Los identificadores deben ser nemonicos, esto es, que su nombre ayude a la
memoria para recordar que es lo que representan. No pueden tener blancos
insertados. Algunas reglas no obligatorias (aunque exigidas en este curso)
son:
Clases: Empiezan con mayuscula y consiste de una palabra descriptiva,
como Reloj, Manecilla.
Metodos: Empiezan con minusculas y se componen de un verbo da,
calcula, mueve, copia seguido de uno o mas sustantivos. Cada uno
de los sustantivos empieza con mayuscula.
Variables: Nombres sugerentes con minusculas.
Constantes: Nombres sugerentes con mayusculas.
Hay que notar que en Java los identificadores pueden tener tantos caracteres
como se desee. El lenguaje, ademas, distingue entre mayusculas y minuscu-
las no es lo mismo carta que Carta.

Una interfaz puede servir de contrato para mas de una clase (que se llamen
distinto). Es la clase la que tiene que indicar si es que va a cumplir con algun
contrato, indicando que va a implementar a cierta interfaz.
El acceso a los metodos de una interfaz es siempre publico o de paquete. Esto
se debe a que una interfaz anuncia los servicios que da, por lo que no tendra
sentido que los anunciara sin que estuvieran disponibles.
Siempre es conveniente poder escribir comentarios en los programas, para que
nos recuerden en que estabamos pensando al escribir el codigo. Tenemos tres tipos
de comentarios:
Empiezan con // y terminan al final de la lnea.
Todo lo que se escriba entre /* y */. Puede empezar en cualquier lado y
terminar en cualquier otro. Funcionan como separador.
Todo lo que se escriba entre /** y */. Estos comentarios son para JavaDoc,
de tal manera que nuestros comentarios contribuyan a la documentacion del
programa.
3.2 Programacion en Java 66

Utilizaremos de manera preponderante los comentarios hechos para JavaDoc,

en particular para documentar interfaces, clases y metodos. Los comentarios deben
tener en el primer renglon unicamente /, y cada uno de los renglones subsecuen-
tes, menos el ultimo, deberan empezar con un asterisco. En el ultimo renglon
aparecera unicamente /. A partir del segundo renglon debera aparecer una des-
cripcion breve del objetivo de la clase o interfaz.
En el caso de los comentarios de las clases e interfaces, tenemos entre otros un
campo, @author, que nos indica quien es el autor de esa clase o interfaz.
La interfaz para nuestro reloj debera anunciar a los servicios que listamos para
el reloj en la figura 3.4 en la pagina 60 excepto por el constructor , y la interfaz
para la clase Manecilla debe listar los servicios que listamos en la figura 3.5 en la
pagina 61 tambien excluyendo al constructor . Pospondremos por el momento
la codificacion de los encabezados, hasta que veamos este tema con mas detalle. La
codificacion del encabezado de las interfaces para Reloj y Manecilla se encuentran
en los listados 3.1 y 3.2.

Codigo 3.1 Encabezado de la interfaz para Reloj (ServiciosReloj)

/
P aque te : R e l o j .
D e f i n e l o s s e r v i c i o s que van a d a r l o s o b j e t o s de l a c l a s e
Reloj .
/
public interface S e r v i c i o s R e l o j {
/ L i s t a de metodos a i m p l e m e n t a r /
}

Codigo 3.2 Encabezado de la interfaz para Manecilla (ServiciosManecilla)

/
P aque te : R e l o j .
D e f i n e l o s s e r v i c i o s que van a d a r l o s o b j e t o s de l a c l a s e
Reloj .
/
public interface S e r v i c i o s M a n e c i l l a {
/ L i s t a de metodos a i m p l e m e n t a r /
}

Veamos en la figura 3.9 en la pagina opuesta la sintaxis y semantica del enca-

bezado de una clase. Esta es una descripcion parcial, ya que por el momento no
tiene sentido ver la definicion completa.
67 Clases y objetos

Figura 3.9 Encabezado de una clase.

Sintaxis:
xdeclaracion de clasey ::= xaccesoy class xidentificadory
( |p implements (xidentificadory)+)
( | extends xidentificadory) {
xdeclaracionesy
( | xmetodo mainy)
}
Semantica:
Se declara una clase en un archivo. El nombre del archivo debe tener como
extension .java y, en general, coincide con el nombre que se le de a la
clase. Una clase debe tener xdeclaracionesy y puede o no tener xmetodo
mainy. La clase puede o no adoptar una interfaz para implementar. Si lo
hace, lo indica mediante la frase implements e indicando a cual o cuales
interfaces implementa. Las xdeclaracionesy corresponden a los ingredientes o
variables y a los metodos que vamos a utilizar. Una xvariabley corresponde a
una localidad (cajita, celda) de memoria donde se va a almacenar un valor.
El xmetodo mainy se usa para poder invocar a la clase desde el sistema
operativo. Si la clase va a ser invocada desde otras clases, no tiene sentido
que tenga este metodo. Sin embargo, muchas veces para probar que la clase
funciona se le escribe un metodo main. En Java todo identificador tiene que
estar declarado para poder ser usado.

Cuando un archivo que contiene interfaces o clases se compila bien apareceran

en el subdirectorio correspondiente un archivo con el nombre de cada una de las
clases o interfaces, pero con el sufijo .class, que es la clase o interfaz pero en
bytecode. Este es el archivo que va a ser interpretado por la Maquina Virtual de
Java y el que puede ser ejecutado o invocado.
Vamos codificando lo que ya sabemos como. Tenemos dos interfaces, Servi-
ciosReloj y ServiciosManecilla, para los que tenemos que definir los servicios que
cada una de ellas va a contratar. Regresamos a las tarjetas de responsabilidades
donde los servicios corresponden a los verbos, y van a ser implementados a traves
de metodos. Sabemos que hay cinco tipos posibles de metodos:
(a) Constructores. Son los que hacen que los objetos de esa clase existan.
(b) De acceso. Son los que permiten conocer el estado del objeto.
3.2 Programacion en Java 68

(c) De actualizacion o modificacion. Son los que permiten modificar el estado

del objeto.
(d) De implementacion. Son los que dan los servicios que se requieren del ob-
jeto.
(e) Auxiliares. Los que requiere el objeto para dar sus servicios de manera ade-
cuada.
Como los metodos involucrados en la interfaz deben ser publicos o de paquete,
solo los de tipo b, c y d van a aparecer en la definicion de la interfaz correspondien-
te. Asimismo, tampoco se ponen en la interfaz a los metodos constructores, pues
la interfaz no define ni es capaz de construir objetos. Pospondremos la descripcion
de los metodos de tipo a y e para cuando revisemos con detalle la definicion de
clases.
Lo que aparece en la interfaz es unicamente el encabezado de los metodos que
van a ser de acceso publico o de paquete. Los metodos de actualizacion o de imple-
mentacion pueden recibir como entrada datos a los que llamamos parametros. Los
parametros tambien se pueden usar para manipulacion o para dejar all informa-
cion. Un parametro es, simplemente, una marca de lugar para que ah se coloquen
datos que el metodo pueda usar y que pueda reconocer usando el nombre dado
en la lista. Si regresamos al smil de una obra de teatro, podemos pensar que los
parametros corresponden a la lista de los personajes que viene, adicionalmente,
con una descripcion de si el personaje es alto, viejo, mujer, etc. (porque el puro
nombre no me indica a que clase de actor contratar para ese papel). El guion
viene despues en terminos de estos personajes: Hamlet dice o hace. El guion
nunca dice quien va a hacer el papel de Hamlet; eso se hace cuando se monta
la obra. De manera similar con los parametros, no es sino hasta que se invoca al
metodo que hay que pasar valores concretos. A la lista de parametros se les llama
tambien parametros formales. Cuando se invoque el metodo deberan aparecer los
actores que van a actuar en lugar de cada parametro. A estos les llamamos los
argumentos o parametros reales. Daremos la sintaxis de los parametros cuando
aparezcan en alguna definicion sintactica.
En el encabezado de un metodo cualquiera se localiza lo que se conoce como
la firma del metodo, que consiste de los tipos de los parametros y el nombre del
metodo. Ademas de la firma, en el metodo se marca de alguna manera el tipo de
metodo de que se trata. Esto lo revisaremos conforme veamos los distintos tipos
de metodos.
Para documentar los distintos metodos de nuestra aplicacion utilizaremos tam-
bien JavaDoc, donde cada comentario empieza y termina como ya mencionamos.
En el caso de los metodos, en el segundo renglon debera aparecer una descripcion
corta del objetivo del metodo (que puede ocupar mas de un renglon) que debe
69 Clases y objetos

terminar con un punto. Despues del punto se puede dar una explicacion mas am-
plia. A continuacion debera aparecer la descripcion de los parametros, cada uno
en al menos un renglon precedido por @param y el nombre del parametro, con una
breve explicacion del papel que juega en el metodo. Finalmente se procedera a
informar del valor que regresa el metodo, precedido de @returns y que consiste de
una breve explicacion de que es lo que calcula o modifica el metodo.

Metodos de acceso
Los metodos de acceso los tenemos para que nos informen del estado de un
objeto, esto es, del valor de alguno de los atributos del objeto. Por ello, la firma
del metodo debe tener informacion respecto al tipo del atributo que queremos
observar. La sintaxis se puede ver en la figura 3.10, donde las definiciones de xtipo
y, xaccesoy e xidentificadory son como se dieron antes.
Figura 3.10 Encabezado para los metodos de acceso.
Sintaxis:
x encabezado demetodo de acceso y ::=
xaccesoy xtipoy xidentificadory ( xParametros y)
Semantica:
La declaracion de un metodo de acceso consiste del tipo de valor que desea-
mos ver, ya que nos va a regresar un valor de ese tipo, seguido de la firma
del metodo, que incluye a los xParametrosy. El identificador del metodo es
arbitrario, pero se recomienda algo del estilo getAtributo, que consista
de un verbo que indica lo que se va a hacer, y un sustantivo que indique el
atributo que se busca o el valor que se desea calcular.

Los tipos que se manejan en Java pueden ser primitivos o de clase. Un tipo
primitivo es aquel cuyas variables no son objetos y son atomicos, esto es, no se
subdividen en otros campos o atributos. En la tabla 3.3 en la siguiente pagina se
encuentra una lista, con los tipos primitivos y sus rangos.
Otro tipo de dato que vamos a usar mucho, pero que corresponde a una clase
y no un dato primitivo como en otros lenguajes, son las cadenas, sucesiones de
caracteres. La clase se llama String. Las cadenas (String) son cualquier sucesion
de caracteres, menos el de fin de lnea, entre comillas. Los siguientes son objetos
tipo String:
"Esta es una cadena 1 2 3 "
""
3.2 Programacion en Java 70

Cuadro 3.3 Tipos primitivos y sus rangos.

Identificador Capacidad
boolean true o false
char 16 bits, Unicode 2.0
byte 8 bits con signo en complemento a 2
short 16 bits con signo en complemento a 2
int 32 bits con signo en complemento a 2
long 64 bits con signo en complemento a 2
float 32 bits de acuerdo al estandar IEEE 754-1985
double 64 bits de acuerdo al estandar IEEE 754-1985

La primera es una cadena comun y corriente y la segunda es una cadena vaca,

que no tiene ningun caracter.
La operacion fundamental con cadenas es la concatenacion, que se representa
con el operador +. Podemos construir una cadena concatenando (sumando) dos
o mas cadenas:

"a"+"b"+"c" "abc"
"Esta cadena es"+"muy bonita " "Esta cadena esmuy bonita "

Una de las ventajas del operador de concatenacion de cadenas es que fuerza a

enteros a convertirse en cadenas cuando aparecen en una expresion de concatena-
cion de cadenas. Por ejemplo, si tenemos una variable LIM que vale 12, tenemos
lo siguiente:

"El lmite es: "+LIM+"." "El lmite es: 12."

Hablaremos mas, mucho mas, de la clase String mas adelante.

En la figura 3.11 damos la sintaxis y semantica para la declaracion de los
xParametrosy.
Cuando invocamos a un metodo le pasamos el numero y tipo de argumentos
que define su firma, en el orden definido por la firma. A esto se le conoce como
paso de parametros. En general se definen tres objetivos en el paso de parametros:
parametros de entrada, parametros de salida y parametros de entrada y salida. A
estos tres tipos se asocian mecanismos de paso de parametros, entre los que estan
el paso por valor, donde se evalua al argumento y se pasa nada mas unas copia
de ese valor; el paso por referencia, donde se toma la direccion en memoria y eso
71 Clases y objetos

es lo que se pasa como argumento; la evaluacion perezosa, donde no se evalua

el argumento hasta que se vaya usar dentro de la implementacion del metodo;
dependiendo de que tipo de paso de parametros contemos, es el efecto que vamos
a tener sobre los argumentos. En el caso de Java todos los argumentos se pasan
por valor, incluyendo a las referencias a los objetos. Aclararemos mas este punto
cuando lo enfrentemos.

Figura 3.11 Especificacion de parametros.

Sintaxis:
xParametrosy::= |
xparametroy(, xparametroy)*
xparametroy ::= xtipoy xidentificadory
Semantica:
Los parametros pueden estar ausentes o bien consistir de una lista de
parametros separados entre s por coma (,). Un parametro marca lugar
y tipo para la informacion que se le de al metodo. Lo que le interesa al
compilador es la lista de tipos (sin identificadores) para identificar a un
metodo dado, ya que se permite mas de un metodo con el mismo nombre,
pero con distinta firma.

Por ejemplo, los metodos de una Manecilla que dan los valores de los atributos
privados tienen firmas como se muestra en el listado 3.3. En general, podemos
pedirle a cualquier metodo que regrese un valor, y tendra entonces la sintaxis de
los metodos de acceso. Como lo que queremos del Reloj es que se muestre, no que
nos diga que valor tiene, no tenemos ningun metodo de acceso para esta clase.

Codigo 3.3 Metodos de acceso para los atributos privados de Manecilla (ServiciosManecilla)
interface ServiciosManecilla {
...
public int getValor ( ) ;
public int getLimite ( ) ;
...
} // S e r v i c i o s M a n e c i l l a
3.2 Programacion en Java 72

Metodos de implementacion
Estos metodos son los que dan los servicios. Por ello, el metodo muestra cuya
firma aparece en el listado 3.4 es de este tipo. Es comun que este tipo de metodos
regresen un valor que indiquen algun resultado de lo que hicieron, o bien que
simplemente avisen si pudieron o no hacer lo que se les pidio, regresando un
valor booleano. En el caso de que sea seguro que el metodo va a poder hacer lo
que se le pide, sin contratiempos ni cortapisas, se indica que no regresa ningun
valor, poniendo en lugar de xtipo yla palabra void. Por ejemplo, el encabezado del
metodo que muestra la Manecilla queda como se muestra en el listado 3.4. Tambien
en el listado 3.5 mostramos el metodo de implementacion muestra para la interfaz
ServiciosReloj.

Codigo 3.4 Metodos de implementacion de la interfaz ServiciosManecilla

interface ServiciosManecilla {
...
public void muestra ( ) ;
...
} // S e r v i c i o s M a n e c i l l a

Codigo 3.5 Metodos de implementacion de la interfaz ServiciosReloj

interface ServiciosReloj {
public void muestra ( ) ;
} // R e l o j

Como pueden ver, ninguno de estos dos metodos regresa un valor, ya que
simplemente hace lo que tiene que hacer y ya. Tampoco tienen ningun parametro,
ya que toda la informacion que requerira es el estado del objeto, al que tienen
acceso por ser metodos de la clase.

Metodos de manipulacion
Los metodos de manipulacion son, como ya mencionamos, aquellos que cam-
bian el estado de un objeto. Generalmente tienen parametros, pues requieren in-
formacion de como modificar el estado del objeto. Los metodos que incrementan
y que asignan un valor son de este tipo, aunque el metodo que incrementa no re-
quiere de parametro ya que el valor que va a usar es el 1. Muchas veces queremos
que tambien nos proporcionen alguna informacion respecto al cambio de estado,
73 Clases y objetos

como pudiera ser un valor anterior o el mismo resultado; tambien podramos que-
rer saber si el cambio de estado procedio sin problemas. En estos casos el metodo
tendra valor de regreso, mientras que si no nos proporciona informacion sera un
metodo de tipo void. Por ejemplo, el metodo que incrementa a la Manecilla nos
interesa saber si al incrementar llego a su lmite. Por ello conviene que regrese un
valor de 0 si no llego al lmite, y de 1 si es que llego (dio toda una vuelta). La
firma de este metodo se muestra en los listados 3.6 y 3.7.

Codigo 3.6 Metodos de manipulacion para la interfaz ServiciosManecilla

interface ServiciosManecilla {
/ I n c r e m e n t a a l a m a n e c i l l a en una u n i d a d .
@ r e t u r n 0 s i no l l e g o a l l m i t e y 1 s i l l e g o /
public int incrementa ( ) ;
/ E s t a b l e c e un v a l o r a r b i t r a r i o en e s t a m a n e c i l l a .
@param v a l E l v a l o r que s e d e s e a e s t a b l e c e r . /
public void s e t V a l o r ( i n t v a l ) ;
} // S e r v i c i o s M a n e c i l l a

Codigo 3.7 Metodos de Manipulacion para la interfaz ServiciosReloj

interface ServiciosReloj {
/
I n c r e m e n t a e s t e r e l o j en un minuto .
/
public void incrementa ( ) ;
/
Establece e l v a l o r del h o r a r i o y e l minutero .
@param h r s e l v a l o r a e s t a b l e c e r en e l h o r a r i o .
@param mins e l v a l o r a e s t a b l e c e r en e l m i n u t e r o . /
p u b l i c v o i d s e t V a l o r ( i n t h r s , i n t mins ) ;
} // S e r v i c i o s R e l o j

Noten que el metodo setValor de ServiciosManecilla tiene un parametro, que es

el nuevo valor que va a tomar la manecilla, mientras que el metodo con el mismo
nombre de la clase ServiciosReloj tiene dos parametros, ya que requiere los valores
para las horas y para los minutos.
Procedemos a construir las clases que implementen a cada una de estas inter-
faces. Identificamos dos clases en nuestro sistema, Manecilla y Reloj. Como la clase
Manecilla no se usara mas que dentro de Reloj, la ponemos en el mismo archivo
que a Reloj, pero dejando a esta como la primera. El archivo se llamara Reloj.java
3.2 Programacion en Java 74

Codigo 3.8 Encabezados para la implementacion de Reloj y Manecilla

/
C l a s e p a r a r e p r e s e n t a r a un R e l o j a n a l o g i c o
E l R e l o j debe s e r c a p a z de m a n t e n e r l a hora ,
i n c r e m e n t a r s e minuto p o r minuto , y p o n e r s e
a una c i e r t a h o r a
/
p u b l i c c l a s s R e l o j implements S e r v i c i o s R e l o j {
/ Aca va l o c o r r e s p o n d i e n t e a d e c l a r a c i o n e s de R e l o j /
public void incrementa ( ) {
/ Aca va l a i m p l e m e n t a c i o n de i n c r e m e n t a /
} // i n c r e m e n t a
p u b l i c v o i d s e t V a l o r ( i n t h r s , i n t mins ) {
/ Aca va l a i m p l e m e n t a c i o n . /
} // s e t V a l o r
public void muestra ( ) {
/ Aca va l a i m p l e m e n t a c i o n . /
} // m u e s t r a
} // R e l o j
// E n c a b e z a d o s p a r a l a i m p l e m e n t a c i o n de Manecilla
/
Una m a n e c i l l a debe s e r c a p a z de i n c r e m e n t a r s e ,
y p o d e r s e r v i r t a n t o p a r a h o r a s , como m i n u t o s
y segundos
/
c l a s s M a n e c i l l a implements S e r v i c i o s M a n e c i l l a {
/ Aca va l o c o r r e s p o n d i e n t e a l a s d e c l a r a c i o n e s
de l a c l a s e M a n e c i l l a
/
public int getValor () {
/ Aca va l a i m p l e m e n t a c i o n
/
} // g e t V a l o r
public int getLimite () {
/ Aca va l a i m p l e m e n t a c i o n
/
} // g e t L i m i t e
public void muestra ( ) {
/ Aca va l a i m p l e m e n t a c i o n .
/
} // m u e s t r a
} // M a n e c i l l a

porque este es el objetivo principal del programa. Veamos como queda lo que lle-
vamos del programa en el listado 3.8 (omitimos los comentarios de JavaDoc para
75 Clases y objetos

ahorrar algo de espacio). Como declaramos que nuestras clases Reloj y Manecilla
implementan, respectivamente, a las interfaces ServiciosReloj y ServiciosManecilla,
estas clases tendran que proporcionar las implementaciones para los metodos que
listamos en las interfaces correspondientes. El esqueleto construido hasta ahora
se puede ver en el listado 3.8. Como a la clase Manecilla unicamente la vamos a
utilizar desde la clase Reloj no le damos un archivo fuente independiente.

De las cinco variedades de metodos que listamos, nos falta revisar a los metodos
constructores y a los metodos auxiliares, que tienen sentido solo en el contexto de
la definicion de clases.

Metodos auxiliares
Estos metodos son aquellos que auxilian a los objetos para llenar las solicitudes
que se les hacen. Pueden o no regresar un valor, y pueden o no tener parametros:
depende de para que se vayan a usar. Dado que el problema que estamos atacando
por el momento es relativamente simple, no se requieren metodos auxiliares para
las clases.

En cuanto a las interfaces no se presentan otra categora de metodos, ya que las

interfaces no describen objetos, sino unicamente los contratos a los que se obligan
las clases que los implementen.

Metodos constructores
Una clase es un patron (descripcion, modelo, plano) para la construccion de
objetos que sean ejemplares (instances) de esa clase. Por ello, las clases s tie-
nen constructores que determinan el estado inicial de los objetos construidos de
acuerdo a esa clase.

En Java los metodos constructores tienen una sintaxis un poco distinta a la de

otros tipos de metodos. Esta se puede ver en la figura 3.12 en la siguiente pagina.

Un constructor es el que permite el instanciamiento (la construccion) de un

objeto de una clase dada, para que sea asociado a (referido por) una variable
de ese tipo. Su objetivo principal es el de establecer el estado inicial del objeto
(inicializar los atributos). Puede recibir para la construccion datos en la forma de
parametros.
3.2 Programacion en Java 76

Figura 3.12 Encabezado de un constructor.

Sintaxis:
xconstructory ::=xaccesoy xidentificador de Clasey ( xParametrosy ) {
ximplementaciony
}
xParametrosy ::=xparametroy(, xparametroy) |
xparametroy ::=xtipoy xidentificadory
Semantica:
Los constructores de una clase son metodos que consisten en un acceso
que puede ser cualquiera de los dados anteriormente seguido del nombre
de la clase y entre parentesis los xParametrosy del metodo. Un parametro
corresponde a un dato que el metodo tiene que conocer (o va a modificar).
Cada parametro debera tener especificado su tipo. Los nombres dados a ca-
da parametro pueden ser arbitrarios, aunque se recomienda, como siempre,
que sean nemonicos y no se pueden repetir.

Codigo 3.9 Constructores para la clase Reloj

/ . . . /
p u b l i c c l a s s R e l o j implements S e r v i c i o s R e l o j {
/ . . . /
/
Constructor .
@param limH l m i t e p a r a l a s h o r a s .
@param limM l m i t e p a r a l o s m i n u t o s .
/
R e l o j ( i n t limH , i n t limM ) {
/ C o n s t r u c t o r : e s t a b l e c e l o s l m i t e s /
// xImplementacion y
} // Firma : R e l o j ( i n t , i n t )
/
Constructor .
@param limH L m i t e p a r a l a s h o r a s .
@param limM L m i t e p a r a l o s m i n u t o s
@param h r s Horas a c t u a l e s .
@param mins M i n u t o s a c t u a l e s .
/
R e l o j ( i n t limH , i n t limM , i n t h r s , i n t mins ) {
// xImplementaciony
} // Firma : R e l o j ( i n t , i n t , i n t , i n t )
} // R e l o j
77 Clases y objetos

Podemos tener tantos constructores como queramos, siempre y cuando se dis-

tingan por sus firmas. Por ejemplo, podemos tener un constructor que no tenga
parametros, o uno que tenga otra organizacion con sus parametros. Un segundo
constructor para Manecilla pudiera ser uno que establece un valor prefijado para
la manecilla. Algo similar podemos hacer con la clase Reloj y lo podemos ver en
el listado 3.10. Los constructores siempre tienen el mismo nombre que la clase de
la que son constructores. No es necesario decir que tipo de valor regresan, porque
regresan (construyen) a un objeto de su clase.

Codigo 3.10 Constructores para la clase Manecilla

/ . . . /
p u b l i c c l a s s M a n e c i l l a implements S e r v i c i o s M a n e c i l l a {
/ . . . /
/ C o n s t r u c t o r .
@param l i m Cota s u p e r i o r p a r a e l v a l o r que puede tomar l a
manecilla .
/
Manecilla ( int lim ) {
// xImplementacion y
} // Firma : M a n e c i l l a ( i n t )

/ C o n s t r u c t o r que e s t a b l e c e l a h o r a a c t u a l .
@param l i m Cota s u p e r i o r p a r a e l v a l o r de l a m a n e c i l l a .
/
M a n e c i l l a ( i n t lim , i n t v a l )\ {
/ C o n s t r u c t o r : pone v a l o r maximo y v a l o r i n i c i a l /
// xImplementacion y
} // Firma : M a n e c i l l a ( i n t , i n t )

...
} // M a n e c i l l a

Es importante notar que la firma de un metodo consiste unicamente del nombre

del metodo junto con los tipos de los parametros. Por lo tanto, los dos encabezados
que se encuentran en el listado 3.11 en la siguiente pagina tienen la misma firma,
y el compilador dara un mensaje de metodo duplicado, aunque el nombre de los
parametros sea distinto.
3.2 Programacion en Java 78

Codigo 3.11 Metodos con la misma firma

p u b l i c R e l o j ( i n t h r s , i n t mins , i n t limH , i n t limM )
// Firma : R e l o j ( i n t , i n t , i n t , i n t )

public R e l o j ( i n t lim1 , i n t lim2 , i n t val1 , i n t v a l 2 )

// f i r m a : R e l o j ( i n t , i n t , i n t , i n t )

Toda clase tiene un constructor por omision, sin parametros, que puede ser in-
vocado, siempre y cuando no se haya declarado ningun constructor para la clase.
Esto es, si se declaro, por ejemplo, un constructor con un parametro, el construc-
tor sin parametros ya no esta accesible. Por supuesto que el programador puede
declarar un constructor sin parametros que sustituya al que proporciona Java por
omision.

El estado inicial que da el constructor por omision al objeto es, basicamente,

cero en los atributos numericos, falso en los atributos logicos y referencia nula
(null) en los atributos que son objetos.

Atributos

Antes de definir la implementacion de los metodos trabajemos con los atribu-

tos que dimos en las tarjetas. Los sustantivos deberan ser atributos (variables o
constantes) datos mientras que los verbos fueron metodos procesos o calcu-
los. Lo primero que tenemos que hacer es lugar para los objetos o datos primitivos
que se encuentran en cada clase. Esto lo hacemos mediante una declaracion. En
la declaracion especificamos el nombre que le queremos dar al atributo ya sea
objeto o primitivo y el tipo que va a tener entero, tipo Manecilla, etc. Vea-
mos la sintaxis y semantica de una declaracion de atributo (dato, campo) en la
figura 3.13 en la pagina opuesta.

Declaremos los atributos que se presentan en el programa que estamos armando

en el listado 3.12 en la pagina 80 omitimos los comentarios ya presentados para
ahorrar un poco de espacio .
79 Clases y objetos

Figura 3.13 Declaracion de un atributo

Sintaxis:
xdeclaracion de atributoy ::=xaccesoy xmodificadory xtipo y
xidentificador y(,xidentificadory)*;
xmodificador y ::=final | static |
xtipo y ::=xtipo primitivoy | xidentificador de clase y
Semantica:
Todo identificador que se declara, como con el nombre de las clases, se le
debe dar el xaccesoy y si es constante (final) o no. Por el momento no ha-
blaremos de static. Tambien se debe decir su tipo, que es de alguno de los
tipos primitivos que tiene Java, o bien, de alguna clase a la que se tenga
acceso; lo ultimo que se da es el identificador. Se puede asociar una lista de
identificadores separados entre s por una coma, con una combinacion de
acceso, modificador y tipo, y todas las variables de la lista tendran las mis-
mas caractersticas. Al declararse un atributo, el sistema de la maquina le
asigna una localidad, esto es, un espacio en memoria donde guardar valores
del tipo especificado. La cantidad de espacio depende del tipo. A los atri-
butos que se refieren a una clase se les reserva espacio para una referencia,
que es la posicion en el heap donde quedara el objeto que se asocie a esa
variable3 .

Las declaraciones de las lneas 5:, 7:, 13: y 15: son declaraciones de atributos del
tipo que precede al identificador. En la lnea 5: se estan declarando dos atributos
de tipo Manecilla y acceso privado, mientras que en la lnea 13: se esta declarando
un atributo de tipo entero y acceso privado. En la lnea 15: aparece el modificador
final, que indica que a este atributo, una vez asignado un valor por primera vez,
este valor ya no podra ser modificado. Siguiendo las reglas de etiqueta de Java,
el identificador tiene unicamente mayusculas. En el caso de los atributos de tipo
Manecilla, debemos tener claro que nada mas estamos declarando un atributo, no
el objeto. Esto quiere decir que cuando se construya el objeto de tipo Manecilla,
la variable horas se referira a este objeto, esto es, contendra una referencia a un
objeto de tipo Manecilla. Como los objetos pueden tener muy distintos tamanos
sera difcil acomodarlos en el espacio de ejecucion del programa, por lo que se
construyen siempre en un espacio de memoria destinado a objetos, que se llama
heap 4 , y la variable asociada a ese objeto nos dira la direccion del mismo en el heap.
4
El valor de una referencia es una direccion del heap. En esa direccion se encuentra el objeto
construido.
3.2 Programacion en Java 80

Codigo 3.12 Declaracion de atributos de las clases

1: / . . .
2: /
3: p u b l i c c l a s s R e l o j implements S e r v i c i o s R e l o j {
4: / R e c u e r d a l a h o r a d e l r e l o j . /
5: private M a n e c i l l a horas ,
6: / R e c u e r d a l o s m i n u t o s d e l r e l o j . /
7: minutos ;
8: } // R e l o j
9: / . . .
10: /
11: p u b l i c c l a s s M a n e c i l l a implements S e r v i c i o s M a n e c i l l a {
12: / R e c u e r d a e l v a l o r de l a m a n e c i l l a . /
13: private int valor ;
14: / Da una c o t a s u p e r i o r p a r a e l v a l o r de l a m a n e c i l l a . /
15: p r i v a t e f i n a l i n t LIM ;
16: // Se e s t a b l e c e a l c o n s t r u i r l a
17: } // M a n e c i l l a

El metodo main
El metodo main corresponde a la colaboracion que queremos se de entre clases.
En el se define la logica de ejecucion. No toda clase tiene un metodo main, ya que
no toda clase va a definir una ejecucion. A veces pudiera ser nada mas un recurso
(como es el caso de la clase Manecilla). El sistema operativo (la maquina virtual
de Java) reconoce al metodo main y si se invoca a una clase procede a ejecutar
ese metodo. El encabezado para este metodo se encuentra en el listado 3.13.

Codigo 3.13 Encabezado para el metodo main

p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
// ximplementacion y
} // main

Se ve bastante complicado, aunque no lo es tanto. El significado de void y public

ya lo sabemos. Lleva el modificador static porque solo debe haber un metodo de
estos para la clase, esto es, para todos los objetos de la clase. Finalmente, el
parametro que tiene es un arreglo (denotado por [ ]) de cadenas (String) que son
las cadenas que aparecen en la lnea de comandos cuando se invoca desde el sistema
operativo (un arreglo es simplemente una sucesion de datos). La implementacion
de este metodo es como la de cualquier otro. Cuando veamos implementacion en
general daremos las restricciones que presenta.
81 Clases y objetos

3.2.2. Alcance de los identificadores

Para estos momentos ya tenemos bastantes nombres en el programa; algunos
se repiten, como el nombre de la clase en el nombre de los constructores o los
identificadores de los parametros en metodos distintos. Es importante saber, cada
nombre, que alcance tiene, esto es, desde donde puede el programa referirse a el.

Figura 3.14 Acceso a atributos o metodos de objetos

Sintaxis:
xReferencia a atributo o metodoy::=
(xreferencia de objeto o clasey.) (xid de atributoy |
xinvocacion a metodoy)
Semantica:
El operador . es el de selector, y asocia de izquierda a derecha. Lo usamos
para identificar, el identificador que se encuentra a su derecha, de que objeto
forma parte. Tambien podemos usarlo para identificar a alguna clase que
pertenezca a un paquete. En el caso de un identificador de metodo, este
debera presentarse con los argumentos correspondientes entre parentesis. la
xreferencia de objetoy puede aparecer en una variable o como resultado de
una funcion que regrese como valor una referencia, que se encuentre en el
alcance de este enunciado. Podemos pensar en el . como un operador del
tipo referencia.

La pista mas importante para esto son las parejas de llaves que abren y cierran.
Para las que corresponden a la clase, todos los nombres que se encuentran en las
declaraciones dentro de la clase son accesibles desde cualquier metodo de la misma
clase. Adicionalmente, los nombres que tengan acceso publico o de paquete son
accesibles tambien desde fuera de la clase.
Sin embargo, hemos dicho que una clase es nada mas una plantilla para cons-
truir objetos, y que cada objeto que se construya va a ser construido de acuerdo
a esa plantilla. Esto quiere decir que, por ejemplo en el caso de la clase Manecilla,
cada objeto que se construya va a tener su atributo valor y su atributo LIM. Si
este es el caso, como hacemos desde fuera de la clase para saber de cual objeto
estamos hablando? Muy facil: anteponiendo el nombre del objeto al del atributo,
separados por un punto. Veamos la forma precisa en la figura 3.14.
Si tenemos en la clase Reloj dos objetos que se llaman horas y minutos, podremos
3.2 Programacion en Java 82

acceder a sus metodos publicos, como por ejemplo incrementa como se muestra en
el listado 3.14.

Codigo 3.14 Acceso a atributos de los objetos

horas . incrementa ()
minutos . incrementa ()

Es claro que para que se puedan invocar estos metodos desde la clase Reloj
deben tener acceso publico o de paquete. Tambien los objetos horas y minutos
tienen que ser conocidos dentro de la clase Reloj.
Sin embargo, cuando estamos escribiendo la implementacion de algun metodo,
al referirnos, por ejemplo, al atributo valor no podemos saber de cual objeto,
porque el metodo va a poder ser invocado desde cualquier objeto de esa clase.
Pero estamos asumiendo que se invoca, forzosamente, con algun objeto. Entonces,
para aclarar que es el atributo valor del objeto con el que se esta invocando,
identificamos a este objeto con this. Cuando no aparece un identificador de objeto
para calificar a un atributo, dentro de los metodos de la clase se asume entonces
al objeto this. En el codigo que sigue las dos columnas son equivalentes para
referirnos a un atributo dentro de un metodo de la clase.

this.incrementa() incrementa()
this.valor valor
this.horas.LIM horas.LIM

En cuanto a los parametros de un metodo, estos existen sola y exclusivamente

dentro de la implementacion del metodo, entre las llaves. Son lo que se conoce
como nombres o variables locales, locales al metodo. Si en la clase existe algun
atributo cuyo nombre sea el mismo que el del parametro, el nombre del parametro
bloquea al nombre del atributo, y para referirse al atributo dentro del metodo se
tendra que usar al selector this vease el listado 3.15 en la pagina opuesta.
En este listado el atributo horas de la clase Reloj se ve bloqueado por el
parametro horas, por lo que para poder ver al atributo hay que rescatar que se
trata del atributo del objeto con el que se este invocando al metodo.
83 Clases y objetos

Codigo 3.15 Bloqueo de nombres de atributos

p u b l i c c l a s s R e l o j implements S e r v i c i o s R e l o j {
M a n e c i l l a horas ,
minutos ;
public void s e t V a l o r ( i n t horas , i n t minutos ) {
this . horas . setValor ( horas ) ;
t h i s . minutos . s e t V a l o r ( minutos ) ;
} // R e l o j . s e t V a l o r
...
} // c l a s s R e l o j

3.2.3. Implementacion de metodos en Java

La implementacion de cada uno de los metodos nos va a decir el como y

con quien va a cubrir el objeto ese servicio.
Figura 3.15 Sintaxis para la implementacion de un metodo
Sintaxis:
ximplementaciony ::=xLista de enunciadosy
xLista de enunciadosy ::=xenunciado y xLista de enunciadosy |
xenunciadoy ::=xenunciado simple y; | xenunciado compuesto y
xenunciado simpley ::=xdeclaracion localy | xinvocacion de metodo y
| xenunciado de asignaciony
| return | return xexpresiony
Semantica:
La implementacion de un metodo, no importa de cual categora sea, con-
siste de una lista de enunciados entre llaves. Si queremos que el metodo
no haga nada, entonces no ponemos ningun enunciado entre las llaves. Los
enunciados pueden ser simples o compuestos5 . Un enunciado simple puede
ser una invocacion a un metodo, puede ser una declaracion de variables o
puede ser una asignacion de valor a una variable. Noten que todos los enun-
ciados simples terminan con punto y coma ; sin importar el contexto en
el que aparecen. Es importante mencionar que aquellas variables declaradas
en la implementacion de un metodo, as como los parametros formales, van
a ser accesibles (reconocidas) unicamente dentro de la implementacion del
metodo en cuestion, a diferencia de las variables de la clase, atributos, que
van a ser accesibles (reconocidos) en las implementaciones de cualquiera de
los metodos de la clase.
3.2 Programacion en Java 84

En todo lo que llevamos hasta ahora simplemente hemos descrito los ingredien-
tes de las clases y no hemos todava manejado nada de como hacen los metodos
lo que tienen que hacer. En general un metodo va a consistir de su encabezado
y una lista de enunciados entre llaves, como se puede ver en la figura 3.15 en la
pagina anterior.

Las declaraciones
Cuando estamos en la implementacion de un metodo es posible que el metodo
requiera de objetos o datos primitivos auxiliares dentro del metodo. Estas varia-
bles auxiliares se tienen que declarar para poder ser usadas. El alcance de estas
variables es unicamente entre las llaves que corresponden al metodo. Ninguna va-
riable se puede llamar igual que alguno de los parametros del metodo, ya que si
as fuera, como los parametros son locales se estara repitiendo un identificador en
el mismo alcance. La sintaxis para una declaracion se puede ver en la figura 3.16.
Figura 3.16 Declaracion de variables locales

Sintaxis:
xdeclaracion de variable localy ::= xtipoy xLista de identificadoresy;
Semantica:
La declaracion de variables locales es muy similar a la de parametros for-
males, excepto que en este caso s podemos declarar el tipo de varios iden-
tificadores en un solo enunciado. La xLista de identificadoresy es, como su
nombre lo indica, una sucesion de identificadores separados entre s por una
coma (,).

Hay que notar que localmente unicamente se pueden declarar variables, ya

sea de tipo primitivo o referencia, y son conocidas, al igual que los parametros,
unicamente dentro del metodo en el que se estan declarando. No se puede declarar
una variable que repita algun identificador usado para los parametros, ya que los
parametros tambien se comportan, dentro del metodo, como variables locales. Al
terminar la ejecucion del metodo, estas variables desaparecen.
El unico metodo que requiere de variables auxiliares es el que muestra el reloj,
ya que queremos construir unas cadenas de caracteres para que den el mensaje
de que hora es. Tambien requerimos de algun objeto que haga de dispositivo de
salida, para poder mostrar ah la hora del reloj; en otras palabras, necesitamos
poder hacer entrada y salida.
5
No entraremos por ahora a lo que es un enunciado compuesto, ya que todava no los vamos
a usar.
85 Clases y objetos

La entrada y salida de Java es un poco complicada para ser manejada por

principiantes. Por ello, proporcionamos, al menos en una primera parte del curso,
una clase Consola que va a permitir hacer entrada y salida de distintos objetos
y datos primitivos de Java consultar la documentacion proporcionada por el
ayudante. Por el momento, todo lo que tenemos que hacer es declarar un objeto
tipo Consola para que podamos ah mostrar el estado del reloj. Podemos ver estas
declaraciones en el listado 3.16.
Codigo 3.16 Declaraciones locales en el metodo muestra de Reloj
1: p u b l i c c l a s s R e l o j implements S e r v i c i o s R e l o j {
2: ...
3: /
4: M ue s t ra e l e s t a d o de e s t e r e l o j .
5: /
6: public void muestra ( ) {
7: S t r i n g mensaje1 , mensaje2 , m e n s a j e 3 ;
8: Consola consola ;
9: ...

100: } // m u e s t r a
101: ...
102: } // c l a s s R e l o j

Tenemos un pequeno problema con la clase Consola y es la manera en que

nuestro programa la va a identificar. La va a encontrar sin problemas si se en-
cuentra en el mismo subdirectorio que nuestras clases, o bien si se encuentra en
alguno de los paquetes de Java. Pero no sucede ni una cosa ni la otra. Por lo tanto,
tendremos que avisarle a Java que vamos a usar esta clase y el paquete en donde
se encuentra. Esto se hace mediante la directiva import, seguida de toda la ruta
que nos puede llevar a esta clase. Por ejemplo, en mi maquina, mis clases estan
en un subdirectorio progs y la clase Consola con todo lo que necesita se encuentra
en un subdirectorio icc1/interfaz, por lo que el enunciado import que va al inicio
del archivo donde esta la clase que lo usa sera, cambiando las diagonales por
puntos selectores,
import icc1.interfaz.Consola;
que es la ubicacion relativa de la clase Consola.
Otro detalle con la consola es que, en realidad, no queremos una consola cada
vez que le pidamos al reloj que se muestre, sino que vamos a querer que se muestre
siempre en la misma consola. Por lo tanto, la declaracion no debe ser local al
metodo muestra, sino que tiene que ser para toda la clase. De esa manera se
inicializa cuando se construye y desaparece cuando la clase ya no esta presente.
3.2 Programacion en Java 86

Tenemos una tercera opcion para la consola, y es declararla en la clase que

usa el Reloj, ya que es el usuario el que debe proporcionar la consola donde se
vea el Reloj. Si este es el caso, entonces la declaracion estara en la clase UsoReloj
y tendra que pasar como parametro al metodo muestra. Podemos ver la version
final del encabezado y las declaraciones de este metodo en el listado 3.17.

Codigo 3.17 Version final del encabezado y declaraciones de muestra()

/
M ue s t ra e l e s t a d o de e s t e r e l o j .
@param c o n s o l a La c o n s o l a en que m u e s t r a e s t e r e l o j .
/
public void muestra ( Consola c o n s o l a ) {
S t r i n g mensaje1 , mensaje2 , m e n s a j e 3 ;
/ I m p l e m e n t a c i o n /
} // m u e s t r a

Vamos a utilizar, por el momento, unicamente dos metodos de la clase Consola,

uno de los constructores y el que escribe en la Consola. Sus firmas se encuentran
a continuacion:

Consola () // Abre una c o n s o l a de 400 p o r 600 p i x e l e s

imprimeln ( String ) // E s c r i b e l a c a d e n a en l a c o n s o l a y da un
// s a l t o de l n e a .

Dado lo anterior, agregamos a la clase UsoReloj la declaracion de una Consola

para poder mostrar ah nuestro Reloj. Con lo que llevamos hecho no tenemos
todava una Consola, ya que no hemos construido un ejemplar de la misma.

El enunciado return
Cuando un metodo esta marcado para regresar un valor, en cuyo caso el tipo
del metodo es distinto de void, el metodo debe tener entre sus enunciados a return
xexpresiony. En el punto donde este enunciado aparezca, el metodo suspende su
funcionamiento y regresa el valor de la xexpresiony al punto donde aparecio su
invocacion. Cuando un metodo tiene tipo void, vamos a utilizar el enunciado re-
turn para salir del metodo justo en el punto donde aparezca este enunciado. Por
ejemplo, los metodos de acceso lo unico que hacen es regresar el valor del atributo,
87 Clases y objetos

por lo que quedan como se muestra en el listado 3.18.

Codigo 3.18 Implementacion de los metodos de acceso de la clase Manecilla
class Manecilla
implements S e r v i c i o s M a n e c i l l a {
...
public int getValor () {
return v a l o r ;
} // g e t V a l o r
public int getLimite () {
r e t u r n LIM ;
} // g e t L i m i t e
...
} // M a n e c i l l a

El enunciado de asignacion

Figura 3.17 El enunciado de asignacion

Sintaxis:
xenunciado de asignaciony::=| xvariabley = xexpresiony
xexpresiony ::= xvariabley| xconstantey
| new xconstructory | ( xexpresiony )
| xoperador unarioy xexpresiony
| xexpresiony xoperador binario y xexpresiony
| xmetodo que regresa valor y
| xenunciado de asignaciony
Semantica:
Podemos hablar de que el xenunciado de asignaciony consiste de dos partes,
lo que se encuentra a la izquierda de la asignacion (=) y lo que se encuentra
a la derecha. A la izquierda tiene que haber una variable, pues es donde
vamos a guardar, copiar, colocar un valor. Este valor puede ser, como
en el caso del operador new, una referencia a un objeto en el heap, o un
valor. El; valor puede ser de alguno de los tipos primitivos o de alguna de
las clases accesibles. La expresion de la derecha se evalua (se ejecuta) y el
valor que se obtiene se coloca en la variable de la izquierda. Si la expresion
no es del mismo tipo que la variable, se presenta un error de sintaxis. Toda
expresion tiene que regresar un valor.
3.2 Programacion en Java 88

Tal vez el xenunciado simpley mas importante es el xenunciado de asignaciony,

ya que va a ser el que me va a permitir asignarle un estado inicial a un objeto
y la posibilidad de cambiarlo. Tambien es el que me permite construir objetos y
asociar una variable a cada objeto que construyo. Es conveniente recordar que
las clases son unicamente plantillas para la construccion de objetos. Para que, en
efecto, se realice algo se requiere construir objetos y asociarlos a variables para
que podamos pedirles que hagan algo. El xenunciado de asignaciony se muestra
en la figura 3.17 en la pagina anterior.
La sintaxis de la expresion para la construccion de objetos se encuentra en la
figura 3.18.

Figura 3.18 Construccion de objetos

Sintaxis:
xconstruccion de objetoy ::=new xinvocacion metodo constructory
Semantica:
Para construir un objeto se utiliza el operador new y se escribe a conti-
nuacion de el (dejando al menos un espacio) el nombre de alguno de los
constructores que hayamos declarado para la clase, junto con sus argumen-
tos. El objeto queda construido en el heap y tiene todos los elementos que
vienen descritos en la clase.

La invocacion de un metodo constructor o, para el caso de cualquier metodo

del objeto mismo, se puede ver en la figura 3.19.

Figura 3.19 Invocacion de metodo

Sintaxis:
xinvocacion de metodoy ::=xnombre del metodoy(xArgumentosy )
xArgumentosy ::=xargumentoy (,xargumentoy)* |
xargumentoy ::=expresion
Semantica:
Los xArgumentosy tienen que coincidir en numero, tipo y orden con los
xParametrosy que aparecen en la declaracion del metodo. La sintaxis indi-
ca que si la declaracion no tiene parametros, la invocacion no debe tener
argumentos.
Si el metodo regresa algun valor, entonces la invocacion podra aparecer
en una expresion. Si su tipo es void tendra que aparecer como enunciado
simple.
89 Clases y objetos

El operador new nos regresa una direccion en el heap donde quedo construido
el objeto (donde se encuentran las variables del objeto). Tengo que guardar esa
referencia en alguna variable del tipo del objeto para que lo pueda usar. Si nos
lanzamos a programar los constructores de la clase Reloj, lo hacemos instanciando
a las manecillas correspondientes. La implementacion de estos constructores se
pueden ver en el listado 3.19.

Codigo 3.19 Constructores de la clase Reloj

1: / I n i c i a en c e r o s /
2: R e l o j ( i n t limH , i n t limM ) {
3: h o r a s = new M a n e c i l l a ( limH ) ;
4: / Usamos e l p r i m e r p a r a m e t r o como argumento /
5: m i n u t o s = new M a n e c i l l a ( limM ) ;
6: / Usamos e l s e g u n d o p a r a m e t r o como argumento /
7: } // R e l o j ( i n t , i n t )
8:
9: / I n i c i a en h o r a p r e e s t a b l e c i d a /
10: R e l o j ( i n t limH , i n t limM , i n t h r s , i n t mins ) {
11: h o r a s = new M a n e c i l l a ( limH , h r s ) ;
12: m i n u t o s = new M a n e c i l l a ( limM , mins ) ;
13: } // R e l o j ( i n t , i n t , i n t , i n t )

Para la clase Manecilla, que esta compuesta unicamente de valores primitivos,

estos no se tienen que instanciar, por lo que la asignacion basta. La implementacion
se encuentra en el listado 3.20.

Codigo 3.20 Constructores de la clase Manecillas

1: / I n i c i a en c e r o s /
2: Manecilla ( int lim ) {
3: LIM = l i m ;
4: } // M a n e c i l l a ( i n t ) \
5:
6: / I n i c i a en v a l o r p r e e s t a b l e c i d o /
7: M a n e c i l l a ( i n t lim , i n t v a l ) {
8: LIM = l i m ;
9: valor = val ;
10: } // M a n e c i l l a ( i n t , i n t )

Podemos seguir con la implementacion del resto de los metodos de la clase

Manecilla, que son los mas sencillos. El nombre de los metodos indica que es lo
que se tiene que hacer, por lo que obviaremos los comentarios, excepto cuando
3.3 Expresiones en Java 90

valga la pena aclarar algo. Para la implementacion de estos metodos utilizare-

mos ampliamente expresiones aritmeticas, para poder colocarlas del lado derecho
de una asignacion. Por ello, conviene primero revisar como son las expresiones
aritmeticas en Java.

3.3 Expresiones en Java

Una expresion en Java es cualquier enunciado que nos regresa un valor. Por
ejemplo, new Manecilla(limH) es una expresion, puesto que nos regresa un obje-
to de la clase Reloj. Podemos clasificar a las expresiones de acuerdo al tipo del
valor que regresen. Si regresan un valor numerico entonces tenemos una expre-
sion aritmetica; si regresan falso o verdadero tenemos una expresion booleana; si
regresan una cadena de caracteres tenemos una expresion tipo String. Tambien
podemos hacer que las expresiones se evaluen a un objeto de determinada clase.
Cuando escribimos una expresion aritmetica tenemos, en general, dos dimen-
siones en las cuales movernos: una vertical y otra horizontal. Por ejemplo, en la
formula que da la solucion de la ecuacion de segundo grado
?2
x1 
b b
2a

4ac

estamos utilizando tres niveles verticales para indicar quien es el dividendo y

quien el divisor. Tambien, para indicar potencia simplemente elevamos un poco el
numero 2, e indicamos que la raz se refiere a b2
4ac extendiendo la casita a
que cubra a la expresion.
Cuando escribimos una expresion para un programa de computadora no con-
tamos con estos niveles, sino que tenemos que linealizar la expresion: hacer que
todo se encuentre en la misma lnea vertical, pero manteniendo la asociatividad
y la precedencia. La asociatividad nos habla de a quien afecta un operador da-
do, mientras que la precedencia se refiere al orden en que se tienen que evaluar
las subexpresiones. Cada operador tiene una precedencia y asociatividad, pero se
pueden alterar estas usando parentesis. Los parentesis cumplen dos propositos:

Agrupan subexpresiones, de tal manera que se asocien a un operador. Por

ejemplo, para indicar que el operando de la raz es b2
4ac encerraramos
esta subexpresion entre parentesis.
91 Clases y objetos

Cambian el orden en que se evaluan las subexpresiones, ya que en presencia

de parentesis las expresiones se evaluan de adentro hacia afuera. Por ejemplo:

x{px 1q
x
x 1

x{x
x
1 1
x

Como se puede deducir del ejemplo anterior, la division tiene mayor prece-
dencia (se hace antes) que la suma, por lo que en ausencia de parentesis se
evalua como en el segundo ejemplo. Con los parentesis estamos obligando a
que primero se evalue la suma, para que pase a formar el segundo operando
de la division, como se muestra en el primer ejemplo.

Otra diferencia fuerte entre cuando escribimos formulas o expresiones en papel

y cuando las escribimos en un programa es que la multiplicacion siempre debe ser
explcita en el programa:

4ac 4ac
3px 2y q 3  px 2  y q

Finalmente, son pocos los lenguajes de programacion que tienen como opera-
dor la exponenciacion, por lo que expresiones como b2 se tendran que expresar en
terminos de la multiplicacion de b por s misma, o bien usar algun metodo (como
el que usamos para raz cuadrada) que proporcione el lenguaje o alguna de sus
bibliotecas. La famosa formula para la solucion de una ecuacion de segundo
grado quedara entonces
?2
x1 
b b
2a

4ac x1  p
b M ath.sqrtppb  bq
p4  a  cqqq{p2  aq

Con esta organizacion de parentesis, lo primero que se hace es calcular b  b y

4  a  c. Una vez que se tiene el resultado, se resta el segundo del primero. Una
vez que se tiene el resultado, se le saca raz cuadrada (se invoca a un metodo que
sabe sacarla). Despues se resta este resultado de b, se obtiene el producto de 2  a
y lo ultimo que se hace es la division. Si no usaramos parentesis, la expresion se
interpretara as:
?2

b b
4ac a
b M ath.sqrtpb  b
4  a  cq{2  a
2
3.3 Expresiones en Java 92

Otro aspecto importante de los operadores es el numero de operandos sobre el

que trabajan. Estamos acostumbrados a operadores unarios (de un solo operando,
como el
o el ) y binarios (como la suma o la multiplicacion). En general,
podemos tener operadores que tengan mas de dos operandos.
A continuacion damos una lista de operadores (no incluye metodos de la clase
Math), listados en orden de precedencia, y con su asociatividad y numero de
operandos indicado. En general los operadores se evaluan de izquierda a derecha,
para operadores de la misma precedencia o iguales (cuando la sintaxis lo permite),
excepto los operadores de asignacion que se evaluan de derecha a izquierda. En el
caso de estos operadores unicamente la ultima expresion a la derecha puede ser
algo que no sea una variable.
Cuadro 3.4 Operadores de Java
Operandos Smbolo Descripcion Prec
posfijo unario rs arreglos 1
posfijo unario  selector de clase
prefijo n-ario pxparametrosyq lista de parametros
posfijo unario xvariabley auto post-incremento
posfijo unario xvariabley

auto post-decremento
unario prefijo xvariabley auto pre-incremento 2
unario prefijo

xvariabley auto pre-decremento
unario prefijo xexpresiony signo positivo
unario prefijo
xexpresiony signo negativo
unario prefijo xexpresiony complemento en bits 2
unario prefijo ! xexpresiony negacion booleana

unario prefijo new xconstructory instanciador 3

unario prefijo pxtipoyq xexpresiony casting
binario infijo  multiplicacion 4
binario infijo { division
binario infijo % modulo
binario infijo suma 5
binario infijo
rest
binario infijo corrimiento de bits a la iz- 6
quierda llenando con ceros
binario infijo corrimiento de bits a la dere-
cha propangado el sign
binario infijo corrimiento de bits a la dere-
cha llenando con cero
93 Clases y objetos

Cuadro 3.4 Operadores de Java. . . . . . (continua)

Operandos Smbolo Descripcion Prec
binario infijo relacional menor que 7
binario infijo  relacional menor o igual
que
binario infijo relacional mayor que
binario infijo  relacional mayor o igual
que
binario infijo instanceof relacional ejemplar de
binario infijo  relacional, igual a 8
binario infijo ! relacional, distinto d
binario infijo & AND de bits 9
binario infijo ^ XOR de bits 10
binario infijo | OR de bits 11
binario infijo && AND logico 12
binario infijo || OR logico 13
ternario infijo xexp logy?xexpy :xexpy Condicional aritmetica 14
binario infijo  asignacion 15
binario infijo  autosuma y asignacion
binario infijo
 autoresta y asignacion 15
binario infijo  autoproducto y asignacion
binario infijo { autodivision y asignacion
binario infijo % automodulo y asignacion
binario infijo  autocorrimiento derecho con
propagacion y asignacion
binario infijo  autocorrimiento izquierdo y
asignacion
binario infijo  autocorrimiento derecho lle-
nando con ceros y asignacion
binario infijo &  auto-AND de bits y asigna-
cion
binario infijo ^ auto-XOR de bits y asigna-
cion
binario infijo | auto-OR de bits y asignacion

Sabemos que esta es una lista extenssima de operadores. Conforme vayamos

entrando a cada uno de los temas , y requiramos de los operadores, aclararemos
mas su uso y su significado.
3.3 Expresiones en Java 94

Estamos ya en condiciones de escribir practicamente las implementaciones de

todos los metodos en nuestro programa. Lo haremos, siguiendo el mismo orden
que utilizamos para escribir los encabezados.

Implementacion de los constructores

Lo unico que deseamos hacer en los constructores de las clases Manecilla y
Reloj es la de asignar valores iniciales a los atributos. Estos valores vienen como
argumentos de los constructores. La programacion se puede ver en los listados 3.22
y 3.21. Omitimos los comentarios de JavaDoc.

Codigo 3.21 Implementacion de constructores de la clase Manecilla

/ C o n s t r u c t o r que i n i c i a l i z a e l l m i t e /
public Manecilla ( int lim ) {
LIM = l i m ; / Toma e l v a l o r d e l argumento /
} // M a n e c i l l a ( i n t )
/ C o n s t r u c t o r que i n i c i a l i z a l m i t e y v a l o r /
public M a n e c i l l a ( i n t lim , i n t v a l ) {
/ Toma v a l o r de p r i m e r argumento /
LIM = l i m ;
/ Toma v a l o r de s e g u n d o argumento /
valor = val ;
} // M a n e c i l l a ( i n t , i n t )

Codigo 3.22 Implementacion de constructores de la clase Reloj

/ E s t a b l e c e l o s l m i t e s de l a s m a n e c i l l a s /
p u b l i c R e l o j ( i n t limH , i n t limM ) {
/ C o n s t r u y e e l o b j e t o h o r a s , i n v o c a n d o a uno de s u s
c o n s t r u c t o r e s /
horas = new M a n e c i l l a ( limH ) ;
/ Ahora c o n s t r u y e a l o b j e t o m i n u t o s /
m i n u t o s = new M a n e c i l l a ( limM ) ;
} // R e l o j ( i n t , i n t )
/ E s t a b l e c e l o s l m i t e s y e l v a l o r i n i c i a l de
l a s m a n e c i l l a s /
p u b l i c R e l o j ( i n t limH , i n t limM , i n t h r s , i n t mins ) {
/ C o n s t r u y e e l o b j e t o h o r a s , e s t a b l e c i e n d o e l l m i t e
y e l e s t a d o i n i c i a l /
horas = new M a n e c i l l a ( limH , h r s ) ;
/ Ahora c o n s t r u y e a l o b j e t o con e s t a d o i n i c i a l /
m i n u t o s = new M a n e c i l l a ( limM , mins ) ;
} // R e l o j ( i n t , i n t , i n t , i n t )

Hay que recordar que estos metodos, por ser constructores, de hecho regresan
95 Clases y objetos

un objeto de la clase de la que son constructores.

Implementacion de los metodos de acceso

Los metodos de acceso, como ya mencionamos, regresan un valor del tipo del
atributo que deseamos observar. En el listado 3.23 se encuentran las implemen-
taciones de los metodos de acceso de la clase Manecilla a la clase Reloj no le
declaramos ningun metodo de acceso.

Codigo 3.23 Metodos de acceso de la clase Manecilla

/
I n f o r m a l m i t e de m a n e c i l l a
@ r e t u r n c o n t e n i d o de LIM
/
public int getLimite () {
r e t u r n LIM ;
} // M a n e c i l l a . g e t L i m i t e ( )
/
I n f o r m a v a l o r de m a n e c i l l a
R e g r e s a c o n t e n i d o de v a l o r
/
public int getValor () {
return v a l o r ;
} // M a n e c i l l a . g e t V a l o r ( )

Implementacion de los metodos de manipulacion

En estos metodos tenemos todos aquellos que que cambian el estado de los
objetos. Los que corresponden a la clase Reloj se encuentran en el listado 3.24 y
las de la clase Manecilla en el listado 3.25 en la siguiente pagina.

Codigo 3.24 Metodos de manipulacion de la clase Reloj 1/2

/
Cambia e l e s t a d o de l a s d o s m a n e c i l l a s
@params h r s e l nuevo v a l o r p a r a h o r a s
@params mins e l nuevo v a l o r p a r a m i n u t o s
p u b l i c v o i d s e t V a l o r ( i n t h r s , i n t mins ) {
horas . setValor ( hrs ) ; / p i d e a h o r a s que cambie /
m i n u t o s . s e t V a l o r ( mins ) ; / p i d e a m i n u t o s que cambie /
} // R e l o j . s e t V a l o r ( i n t , i n t )
3.3 Expresiones en Java 96

Codigo 3.24 Metodos de manipulacion de la clase Reloj 2/2

/
I n c r e m e n t a 1 minuto y ve s i s e r e q u i e r e
incrementa horas
/
public void incrementa ( ) {
horas . s e t V a l o r ( horas . getValor + minutos . incrementa ( ) ) ;
/ M a n e c i l l a s . i n c r e m e n t a d a r a 1 s i d i o l a v u e l t a
y 0 s i no /
} // R e l o j . i n c r e m e n t a ( )

Codigo 3.25 Metodos de manipulacion de la clase Manecilla

/ C o p i a e l v a l o r c u i d a n d o que e s t e en r a n g o s /
public void s e t V a l o r ( i n t v a l ) {
v a l o r = v a l % LIM ; / C a l c u l a modulo LIM /
} // M a n e c i l l a . s e t V a l o r ( i n t )
/ I n c r e m e n t a en 1 e l v a l o r , c u i d a n d o de que quede en
r a n g o s . R e g r e s a 1 s i l l e g o a l LIM y 0 s i no /
public int incrementa () {
v a l o r ++; / i n c r e m e n t a en 1 /
v a l o r %= LIM ; / V e r i f i c a s i a l c a n z o LIM /
r e t u r n ( v a l o r == 0 ) ? 1 : 0 ;
/ S i v a l o r e s c e r o , a l c a n z o a
LIM , p o r l o que debe r e g r e s a r 1 ;
s i no e s a s , r e g r e s a 0 /
} // M a n e c i l l a . i n c r e m e n t a ( )

Implementacion de metodos de implementacion

El unico metodo que tenemos de implementacion es, como ya dijimos, el que
muestra el reloj, que se encuentra en el listado 3.26.

Codigo 3.26 Metodos de implementacion de la clase Reloj

public void muestra ( Consola c o n s o l a ) {
/ E l u s u a r i o d i c e donde m o s t r a r /
S t r i n g mensaje1 , mensaje2 , m e n s a j e 3 ;
m e n s a j e 1 = "Son las " ;
m e n s a j e 2 = " horas con " ;
m e n s a j e 1 = " minutos ." ;
c o n s o l a . i m p r i m e ( m e n s a j e 1+h o r a s . g e t V a l o r ( ) +
m e n s a j e 2+m i n u t o s . g e t V a l o r ()+ m e n s a j e 3 ) ;
/ E l o p e r a d o r + con c a d e n a s f u e r z a a l o s e n t e r o s
g e t V a l o r ( ) a c o n v e r t i r s e a c a d e n a s /
} // R e l o j . m u e s t r a ( C o n s o l a )
97 Clases y objetos

Tenemos ya las clases terminadas. Ahora tendramos que tener un usuario que
comprara uno de nuestros relojes. Hagamos una clase cuya unica funcion sea
probar el Reloj. La llamaremos UsoReloj. Se encuentra en el listado 3.27.

Codigo 3.27 Clase usuaria de la clase Reloj

import i c c 1 . i n t e r f a z . C o n s o l a ;

public class UsoReloj {

p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
/ D e c l a r a c i o n e s :
/ d e c l a r a c i o n de una v a r i a b l e t i p o R e l o j /
Reloj r e l o j i t o ;
/ Donde m o s t r a r e l r e l o j /
Consola c o n s o l i t a ;
/ C o n s t r u c c i o n de l o s o b j e t o s :
V a l o r e s i n i c i a l e s /
r e l o j i t o = new R e l o j ( 1 2 , 6 0 , 1 1 , 5 8 ) ;
/ E l c o n s t r u c t o r s i n p a r a m e t r o s /
c o n s o l i t a = new C o n s o l a ( ) ;

/ M a n i p u l a c i o n d e l r e l o j i t o /
r e l o j i t o . incrementa ( ) ;
r e l o j i t o . muestra ( c o n s o l i t a ) ;
r e l o j i t o . incrementa ( ) ;
r e l o j i t o . muestra ( c o n s o l i t a ) ;
r e l o j i t o . setValor (10 ,59);
r e l o j i t o . muestra ( c o n s o l i t a ) ;
r e l o j i t o . incrementa ( ) ;
r e l o j i t o . muestra ( ) ;
} // main
} // U s o R e l o j

Se estaran preguntando por que no se declaro a relojito y consolita como atri-

butos de la clase. La razon es que un metodo estatico de la clase no puede tener
acceso a atributos de esa clase. Por ello hay que declararlo en el metodo. De cual-
quier forma, como la clase Reloj es publica, cualquiera puede pedir constructores
de esa clase.

3.3.1. Declaracion y definicion simultaneas

No hemos mencionado que en Java se permite asignar valor inicial a los atri-
butos y a las variables locales en el momento en que se declaran. Esto se consigue
3.3 Expresiones en Java 98

simplemente con el operador de asignacion y una expresion:

public int valor = 0;

R e l o j r e l o j i t o = new R e l o j ( 1 2 , 6 0 ) ;

Para el caso de los atributos de un objeto, no se le ve mucho caso asignar

estado inicial a los atributos, excepto cuando queramos que todos los objetos de
esa clase compartan el estado inicial. Por ejemplo, en el caso de los objetos de la
clase Reloj es posible que queramos que todos los objetos empiecen con las 0 horas
y 0 minutos; pero en el caso de los objetos de la clase Manecilla, si le dieramos
valor inicial al atributo Lim despues ya no podramos volverle a asignar un valor,
y todos los objetos tendran el mismo lmite, algo que no queremos que suceda.
 Manejo de cadenas
y expresiones 4

Uno de los ingredientes que mas comunmente vamos a usar en nuestros pro-
gramas son las expresiones. Por ello, dedicaremos este captulo a ellas.

4.1 Manejo de cadenas en Java

Una expresion es cualquier sucesion de operadores y operandos que producen

(regresan) un valor al evaluarse. El valor puede ser numerico, de cadenas, una
referencia a un objeto, booleano, o de cualquier otra clase accesible al metodo en
la que se encuentra la expresion.
Las cadenas de caracteres van a ser de lo que mas vamos a usar en nuestro
desarrollo profesional. Practicamente todo el manejo que hagamos involucrara ca-
denas, ya sea como ttulos, o como objeto de busquedas, de agrupamiento, etc.
Las cadenas en Java son una clase que nos proporciona el paquete Java.Lang y
esta accesible sin necesidad de importarlo. Cada vez que declaramos una cadena,
mediante el identificador de tipo String, reservamos espacio unicamente para la
referencia, ya que se trata de objetos. Sin embargo, por lo comun que son las
4.1 Manejo de cadenas en Java 100

cadenas la sintaxis de Java es mucho mas flexible para la creacion de cadenas que
de objetos en general y nos permite cualquiera de los siguientes formatos:

i. En la declaracion. Simplemente inicializamos la variable con una cadena:

S t r i n g c a d e n a = "Esta es una cadenita " ;

ii. En una asignacion. Se asigna una cadena a una variable tipo String:

S t r i n g cadenota ;
c a d e n o t a = "Una cadena "+ " muy larga " ;

iii. Al vuelo. Se construye una cadena como una expresion, ya sea directamente
o mediante funciones de cadenas:

" Cadena Muy Larga " . t o L o w e r C a s e ( )

Es importante mencionar que las cadenas, una vez creadas, no pueden ser
modificadas. Si se desea modificar una cadena lo que se debe hacer es construir
una nueva con las modificaciones, y, en todo caso, reasignar la nueva. Por ejemplo,
si queremos pasar a mayusculas una cadena, podramos tener la siguiente sucesion
de enunciados:

S t r i n g m i n u s c = "esta en minusculas " ;

minusc = minusc . toUpperCase ( ) ;

Notese que en el primer renglon de este codigo la cadena contiene unicamente

minusculas. En el lado derecho de la asignacion en el segundo renglon se construye
una cadena nueva que es la cadena minusc pero pasada a mayusculas; lo ultimo
que se hace es reasignar la referencia de minusc a que ahora apunte a esta nueva
cadena.
Lo distinto cuando a manejo de cadenas se refiere es que no necesitamos el
operador new aunque lo podemos usar con alguno de los metodos constructores
para construir un objeto tipo String.
La clase String proporciona muchsimos metodos para trabajar con cadenas. No
mostramos todos, pues algunos de ellos tienen parametros o entregan valores que
no hemos visto todava. A continuacion se encuentra una tabla con los metodos
que podemos querer usar de la clase String.
101 Manejo de cadenas y expresiones

Cuadro 4.1 Metodos de la clase String

Firma Descripcion
Constructores:
String () Construye una nueva cadena nula en el
String ( String ) primer caso, y otra que es copia de la
primera en el segundo. En ambos casos
regresa un apuntador al heap.
Metodos para crear nuevas cadenas:
String concat( String ) Crea una nueva cadena que es a la
que se le solicita el metodo, seguida del
argumento.
String replace (char, char) Crea una nueva cadena en la que
reemplaza las apariciones del primer
caracter por el segundo.
String replace ( String , String ) Crea una nueva cadena en la que re-
emplaza las apariciones de la primera
cadena por la segunda.
String substring (int) Crean una nueva cadena que es una
String substring (int , int) subcadena de la cadena. La subcadena
empieza en el primer entero y termina,
en el primer caso al final de la cadena
y en el segundo en el segundo entero.
String toLowerCase() Crea una nueva cadena convirtiendo to-
dos los caracteres a minusculas.
String toUpperCase() Crea una nueva cadena convirtiendo to-
dos los caracteres a mayusculas.
String trim() Crea una nueva cadena quitando los
blancos del principio y final
Metodos para crear nuevas cadenas:
static String valueOf(boolean) Crea una cadena con el valor que
static String valueOf(char) corresponde al tipo del dato. Como es
static String valueOf(int)
estatica se puede llamar desde la clase:
String .valueOf( valor ) .
4.1 Manejo de cadenas en Java 102

Cuadro 4.1 Metodos de la clase String (continua)

Firma Descripcion
Metodos para crear nuevas cadenas: (continua)
static String valueOf(long) Crea una cadena con el valor que
static String valueOf( float ) corresponde al tipo del dato. Como es
static String valueOf(double)
estatica se puede llamar desde la clase:
String .valueOf( valor ) .
Metodos de comparacion:
int compareTo(String) Compara dos cadenas en el orden del
codigo Unicode.
$
'
'
' 0 si las cadenas son identicas
'
'
& 0 si xcad1y va despues en el orden
'
que xcad2y.
'
'
'
'
'
'
0 si xcad1y va antes en el orden
% que xcad2y.
boolean equals(Object) Dice si la cadena en el parametro es
identica a la que invoca.
boolean equalsIgnoreCase( String ) Dice si las cadenas son iguales, igno-
rando diferencias entre mayusculas y
minusculas.
Metodos de busqueda:
boolean endsWith(String) Dice si la cadena con la que se invoca
termina con la cadena en el parametro.

int indexOf(int) El primer entero corresponde al codi-

int indexOf(int , int) go de un caracter en Unicode (se pue-
int indexOf(String )
de pasar como argumentos tambien un
caracter). La cadena se refiere a una
int indexOf(String , int)
subcadena. En las 4 versiones, regresa
la primera posicion en la cadena don-
de se encuentra el primer parametro. Si
se da un segundo parametro, este indi-
ca que se busque a partir de esa posi-
cion. Regresa -1 si no encuentra lo que
esta buscando.
103 Manejo de cadenas y expresiones

Cuadro 4.1 Metodos de la clase String (continua)

Firma Descripcion
boolean startsWith ( String ) Determina si es que la cadena empieza
boolean startsWith ( String , int) con la cadena que trae como argumen-
to. En la segunda version, ve a partir
del caracter denotado por el argumen-
to entero.
int lastIndexOf (char) El caracter corresponde a un caracter
int lastIndexOf (char, int) (se puede pasar como argumentos tam-
int lastIndexOf ( String )
bien un codigo entero de un caracter
en Unicode). La cadena se refiere a una
int lastIndexOf ( String , int)
subcadena. En las 4 versiones, regresa
la ultima posicion en la cadena donde se
encuentra el primer parametro. Si se da
un segundo parametro, este indica que
se busque a partir de esa posicion. Re-
gresa -1 si no encuentra lo que esta bus-
cando.
boolean regionMatches Determina si una region de la cade-
boolean (int , String , na es igual a una region de la cade-
int , int)
na en el argumento. La segunda ver-
sion, si el argumento booleano es ver-
regionMatches
dadero, compara ignorando diferencias
(boolean,int, entre mayusculas y minusculas. El pri-
String , int , int) mer entero es la posicion de la region
en la cadena que invoca. el segundo en-
tero es loa posicion inicial en la cadena
del argumento. La tercera posicion es el
numero de caracteres a comparar.
Metodos de conversion
char charAt(int) Regresa el caracter que se encuentra en
la posicion dada por el argumento.
String toString () Genera la representacion en cadena del
objeto con el que se le invoca.
Otros Metodos
int length () Regresa el tamano de la cadena, el
numero de caracteres.
4.2 Implementacion de una base de datos 104

4.2 Implementacion de una base de datos

Supongamos que tenemos un conjunto de cadenas almacenadas de alguna for-

ma (nos preocuparemos de la implementacion despues). Por ejemplo, tengo los
nombres de los estudiantes del grupo con su carrera y quiero poder extraer datos
de all. Tenemos, entonces, lo que se conoce como una base de datos. Identifique-
mos las operaciones que deseamos poder hacer con esa base de datos:

Problema: Mantener una base de datos con listas de cursos.

Descripcion:

Cada objeto del curso consiste del numero del grupo (una cadena), la lista de
alumnos y el numero de alumnos. La lista de alumnos consiste de alumnos,
donde para cada alumno tenemos su nombre completo, su numero de cuenta,
la carrera en la que estan inscritos y su clave de acceso a la red.
Las operaciones que queremos se puedan realizar son:

(a) Localizar a un estudiante, proporcionando cualquiera de sus datos, que lo

distingan de los otros estudiantes.
(b) Dado un dato particular de un estudiante, recuperar su nombre, clave,
cuenta o carrera.
(c) Agregar estudiantes.
(d) Quitar estudiantes.
(e) Poder emitir la lista de todo el grupo.
(f) Emitir la sublista de los que contienen cierto valor en alguno de sus cam-
pos.

Entonces, nuestra tarjeta de responsabilidades, en cuanto a la parte publica se

refiere, se puede ver en la figura 4.1.
105 Manejo de cadenas y expresiones

Figura 4.1 Tarjeta de responsabilidades para Curso.

Clase: Curso Responsabilidades

Constructores A partir de una base de datos inicial y a partir de
P cero.
daNombre Regresa el nombre completo de un estudiante
u daCarrera Regresa la carrera de un estudiante
daClave Regresa la clave de acceso de un estudiante
b
daCuenta Regresa el numero de cuenta de un estudiante
l agregaEstudiante Agrega a un estudiante, proporcionando los datos
correspondientes.
i quitaEstudiante Elimina al estudiante identificado para eliminar.
listaCurso Lista todos los estudiantes del curso
c losQueCazanCon Lista a los estudiantes que cazan con algun criterio
especfico
o armaRegistro Regresa el registro bonito para imprimir

De esto, podemos definir ya una interfaz de Java que se encargue de definir

estos servicios. La podemos ver en el Listado 4.1.

Codigo 4.1 Interfaz para el manejo de una base de datos 1/3

1: /
2: Da e l manejo de una b a s e de d a t o s s o b r e l a que s e
3: d e s e a n h a c e r c o n s u l t a s .
4: /
5:
6: p u b l i c i n t e r f a c e C o n s u l t a s {
7: /
8: P ro duc e l a l i s t a de t o d o s l o s r e g i s t r o s en l a
9: b a s e de d a t o s .
10: @ r e t u r n Una c a d e n a con l a l i s t a e d i t a d a .
11: /
12: public String l i s t a C u r s o ( ) ;
4.2 Implementacion de una base de datos 106

Codigo 4.1 Interfaz para el manejo de una base de datos 2/3

13: /
14: Dada l a p o s i c i o n d e l r e g i s t r o , r e g r e s a e l nombre
15: d e l alumno en e s a p o s i c i o n .
16: @param c u a l La p o s i c i o n d e l r e g i s t r o .
17: @ r e t u r n Una c a d e n a que c o n t i e n e e l nombre c o m p l e t o
18: d e l r e g i s t r o en e s a p o s i c i o n .
19: /
20: p u b l i c S t r i n g daNombre ( i n t c u a l ) ;
21:
22: /
23: Dada l a p o s i c i o n d e l r e g i s t r o , r e g r e s a l a c a r r e r a
24: d e l alumno en e s a p o s i c i o n .
25: @param c u a l La p o s i c i o n d e l r e g i s t r o .
26: @ r e t u r n Una c a d e n a que c o n t i e n e e l nombre de l a
27: c a r r e r a d e l r e g i s t r o en e s a p o s i c i o n .
28: /
29: public String daCarrera ( int cual ) ;
30:
31: /
32: Dada l a p o s i c i o n d e l r e g i s t r o , r e g r e s a l a c a r r e r a
33: d e l alumno en e s a p o s i c i o n .
34: @param c u a l La p o s i c i o n d e l r e g i s t r o .
35: @ r e t u r n Una c a d e n a que c o n t i e n e l a c a r r e r a d e l
36: r e g i s t r o en e s a p o s i c i o n .
37: /
38: public String daCarrera ( int cual ) ;
39:
40: /
41: Dada l a p o s i c i o n d e l r e g i s t r o , r e g r e s a e l numero
42: de c u e n t a d e l alumno en e s a p o s i c i o n .
43: @param c u a l La p o s i c i o n d e l r e g i s t r o .
44: @ r e t u r n Una c a d e n a que c o n t i e n e e l numero de c u e n t a
45: d e l r e g i s t r o en e s a p o s i c i o n .
46: /
47: p u b l i c S t r i n g daCuenta ( i n t c u a l ) ;
48:
49: /
50: Dada l a p o s i c i o n d e l r e g i s t r o , r e g r e s a l a c l a v e
51: de a c c e s o d e l alumno en e s a p o s i c i o n .
52: @param c u a l La p o s i c i o n d e l r e g i s t r o .
53: @ r e t u r n Una c a d e n a que c o n t i e n e l a c l a v e de
54: a c c e s o d e l r e g i s t r o en e s a p o s i c i o n .
55: /
56: public S t r i n g daClave ( int cual ) ;
107 Manejo de cadenas y expresiones

Codigo 4.1 Interfaz para el manejo de una base de datos 3/3

57: /
58: Dada l a p o s i c i o n d e l r e g i s t r o , r e g r e s a una c a d e n a que
59: c o n t i e n e e l r e g i s t r o c o m p l e t o d e l alumno en e s a p o s i c i o n .
60:
61: @param c u a l La p o s i c i o n d e l r e g i s t r o .
62: @return Una c a d e n a que c o n t i e n e e l numero de
63: c u e n t a d e l r e g i s t r o en e s a p o s i c i o n .
64: /
65: public String armaRegistro ( int cual ) ;
66:
67: /
68: L i s t a a l o s e s t u d i a n t e s cuyo r e g i s t r o c o n t i e n e como
69: s u b c a d e n a a l a c a d e n a en e l p a r a m e t r o .
70:
71: @param s u b c a d La s u b c a d e n a que buscamos .
72: @return Una c a d e n a con un r e g i s t r o p o r r e n g l o n .
73: /
74: p u b l i c S t r i n g losQueCazanCon ( S t r i n g s u b c a d ) ;

En la interfaz que acabamos de dar, casi todos los metodos que hacen la con-
sulta trabajan a partir de saber la posicion relativa del registro que queremos. Sin
embargo, una forma comun de interrogar a una base de datos es proporcionandole
informacion parcial, como pudiera ser alguno de los apellidos, por lo que conviene
agregar un metodo al que le proporcionamos esta informacion y nos debera de-
cir la posicion relativa del registro que contiene esa informacion. Este metodo lo
podemos ver en el Listado 4.2.

Codigo 4.2 Posicion de un registro que contenga una subcadena (Consultas)

75: /
76: Dada una c a d e n a con e l nombre d e l alumno , r e g r e s a l a
77: p o s i c i o n d e l r e g i s t r o que c o n t i e n e e s e nombre .
78:
79: @param nombre E l nombre d e l alumno que buscamos .
80:
81: @ r e t u r n Un e n t e r o que c o r r e s p o n d e a l a p o s i c i o n
82: r e l a t i v a d e l r e g i s t r o que c o n t i e n e a l nombre .
83: /
84: p u b l i c i n t d a P o s i c i o n ( S t r i n g nombre ) ;

Sin embargo, pudieramos buscar una porcion del registro que se repite mas de
una vez, y quisieramos que al interrogar a la base de datos, esta nos diera, uno tras
4.2 Implementacion de una base de datos 108

otro, todos los registros que tienen esa subcadena. Queremos que cada vez que le
pidamos no vuelva a empezar desde el principio, porque entonces nunca pasara
del primero. Le agregamos entonces un nuevo parametro para que la busqueda
sea a partir de un posicion. El encabezado de este metodo se puede ver en el
Listado 4.3.

Codigo 4.3 Posicion de un registro a partir de otra posicion (Consultas)

85: /
86:
87: Dados una c a d e n a con e l nombre d e l alumno y a p a r t i r
88: de c u a l p o s i c i o n b u s c a r , r e g r e s a l a p o s i c i o n d e l r e g i s t r o
89: que c o n t i e n e e s e nombre , s i n e x a m i n a r a l o s que e s t a n a n t e s
90: de l a p o s i c i o n dada .
91:
92: @param nombre E l nombre d e l alumno que buscamos .
93:
94: @param d e s d e A p a r t i r de donde s e va a h a c e r
95: l a b u s q u e da .
96:
97: @ r e t u r n Un e n t e r o que c o r r e s p o n d e a l a p o s i c i o n
98: r e l a t i v a d e l r e g i s t r o que c o n t i e n e a l nombre ,
99: b u s c a d o a p a r t i r de desde .
100:
101: /
102: p u b l i c i n t d a P o s i c i o n ( S t r i n g nombre , i n t d e s d e ) ;

Definida ya la interfaz, procedemos a disenar una implementacion para la

misma. Siguiendo la metodologa que tenemos para definir las clases, una vez
definidas las responsabilidades debemos decidir cual es la informacion que requiere
la clase para poder brindar los servicios anunciados en la interfaz. Lo primero que
necesitamos es la informacion que corresponde a la base de datos y, de alguna
manera, la descripcion de que contiene cada registro. La manera como he decidido
guardar esta base de datos es en una cadena enorme, pero subdividida en pedazos
del mismo tamano. A cada uno de estos pedazos lo vamos a manejar como un
registro. Ademas, cada registro lo vamos a dividir en campos, donde cada campo
corresponde a una unidad de informacion; por ejemplo, el nombre del estudiante
corresponde a un campo, as como la clave a otro, el numero de cuenta a un tercero
y as sucesivamente. Esto nos facilita ver a la base de datos como si fuera una tabla,
donde cada renglon de la tabla corresponde a un registro y cada columna de la
tabla a un campo (o atributo). Supongamos que tenemos una lista de alumnos
como la que se muestra en la Tabla 4.2 en la pagina opuesta:
109 Manejo de cadenas y expresiones

Cuadro 4.2 Listado del contenido de nuestra base de datos

Nombre: Carrera: Cuenta: Clave:

Aguilar Sols Aries Olaf Matematico 97541219-1 aguilarS
Cruz Cruz Gil Noe Computacion 99036358-4 cruzCruz
Garca Villafuerte Israel Computacion 02598658-3 garciaVi
Hubard Escalera Alfredo Computacion 00276238-7 hubardE
Tapia Vazquez Rogelio Actuara 02639366-8 tapiaV
... ... ... ...

Como ya mencionamos, vamos a representar a la base de datos con una cadena

en la que colocaremos a todos los registros. Si no forzamos a que cada registro ocu-
pe el mismo numero de posiciones no podramos decir de manera sencilla donde
termina un registro y empieza el siguiente. En cada uno de los registros, el nume-
ro de posiciones que ocupa, por ejemplo, el nombre tambien debe ser el mismo,
tambien para que podamos calcular, de manera sencilla, la posicion en la cadena
donde empieza cada campo dentro de cada registro. La declaracion con valores
iniciales para esta lista se vera, entonces, como sigue:

private String
lista =
" Aguilar Sols Aries Olaf " + "Mate" + " 975412191 " + " aguilarS " +
"Cruz Cruz Gil Noe " + "Comp" + " 990363584 " + " cruzCruz " +
" Garca Villafuerte Israel " + "Comp" + " 025986583 " + " garciaV " +
" Hubard Escalera Alfredo " + "Comp" + " 002762387 " + " hubardE " +
" Tapia Vazquez Rogelio " + "Actu" + " 026393668 " + " tapiaV " ;

Recuerden que podemos construir una cadena concatenando cadenas, usando

el operador +. Ademas, aparecen los caracteres blancos dentro de las cadenas
con , para que podamos ver facilmente el numero de posiciones que ocupa.
Dividimos la cadena arbitrariamente en registros, uno por renglon, y cada
registro en campos. Noten que cada nombre ocupa 25 posiciones y cada carrera
4; el numero de cuenta ocupa 9 posiciones y la clave de acceso 8 posiciones. Cada
elemento de mi lista ocupa, entonces, 46 posiciones. Notese tambien que elegimos
codificar la carrera, pues con cuatro caracteres tengo suficiente para reconocer
la carrera; para el numero de cuenta usamos 9 posiciones, pues la que estara
entre el octavo dgito y el noveno siempre contiene un guion; por ultimo, para la
4.2 Implementacion de una base de datos 110

clave de usuario utilizamos 8 posiciones, completando cuando es necesario como

lo hicimos en el nombre.

La lista empieza en 0, y tiene, en total, 5  46  230 posiciones (de la 0 a la

229). El primer registro empieza en la posicion 0; el segundo registro empieza en
la posicion 46. En general, el i-esimo registro empieza en la posicion pi
1q  46.
Por que i
1? Porque hay que saltar i
1 registros para llegar a donde empieza
el i-esimo.

El primer nombre empieza donde el primer registro; el segundo nombre donde

el segundo registro y as sucesivamente. La carrera que corresponde al primer
registro empieza en la posicion 25, una vez saltadas las primeras 25 posiciones (de
la 0 a la 24) que corresponden al nombre. La del segundo registro empieza en la
posicion 71 (46+25), que corresponde a saltar las primeras 46 posiciones (de la
0 a la 45) que corresponden al primer registro, mas las primeras 25 (de la 0 a la
24) posiciones que corresponden la nombre del segundo registro. En general, la
posicion de la carrera del i-esimo registro empieza en la posicion pi
1q  46 25,
donde 46 es el numero de posiciones que hay que saltar por cada elemento de
la tabla que se encuentra antes que el que queremos, y 25 es el desplazamiento
(offset) del campo que deseamos a partir del principio del elemento. En general,
si se desea el j-esimo campo del i-esimo registro, se obtiene la posicion inicial del
i-esimo registro (pi
1q  46) y a eso se le suma el total de las posiciones que
ocupan los campos desde el primero hasta el j
1.

Construyamos una clase para manejar listas de cursos. Ya tenemos, de la inter-

faz, los metodos publicos que vamos a requerir; ahora hay que decidir que atributos
requiere la clase para poder dar esos servicios. Si estamos hablando de un grupo
en la Facultad de Ciencias es conveniente que se guarde el numero del grupo.
Tambien es conveniente que cada base de datos me pueda responder, de manera
sencilla, el numero de registros que tiene en ese momento. Estos tres atributos son
privados y en todo caso se tiene acceso a ellos a traves de metodos de acceso. La
tarjeta de responsabilidades, incluyendo a estos atributos privados se encuentra
en la figura 4.2.

Como parte de la informacion que requiere la clase es conveniente declarar los

tamanos del registro y de los campos como constantes para poder dar expresiones
aritmeticas en terminos de estas constantes. De esa manera si decidimos cambiar el
tamano de alguno de los campos unicamente tenemos que localizar la declaracion
de la constante para hacerlo. El inicio de la codificacion la podemos ver en el
listado 4.4 en la pagina opuesta.
111 Manejo de cadenas y expresiones

Figura 4.2 Tarjeta de responsabilidades para Curso.

Clase: Curso Responsabilidades

Constructores A partir de una base de datos inicial y a partir
P de cero.
u daNombre Regresa el nombre completo de un estudiante
daCarrera Regresa la carrera de un estudiante
b
daClave Regresa la clave de acceso de un estudiante
l daCuenta Regresa el numero de cuenta de un estudiante
i agregaEstudiante Agrega a un estudiante, proporcionando los
c datos necesarios.
quitaEstudiante Elimina a un estudiante despues de identifi-
o carlo.
listaCurso Lista todos los estudiantes del curso
losQueCazanCon Lista a los estudiantes que cazan con algun
criterio especfico
armaRegistro Regresa el registro bonito para imprimir
P lista Base de datos con los alumnos inscritos
r
i grupo Numero que identifica al grupo
v
a numero de registros En cada momento, el numero de registros que
d contiene el grupo
o

Codigo 4.4 Clase que maneja listas de cursos (Curso) 1/2

1: import i c c 1 . i n t e r f a z . C o n s o l a
2: /
3: Base de d a t o s , a b a s e de c a d e n a s , que emula l a l i s t a de un c u r s o
4: de l i c e n c i a t u r a . T i e n e l a s o p c i o n e s n o r m a l e s de una b a s e de
5: d a t o s y f u n c i o n a m e d i a n t e un Menu
6: /
7: c l a s s C u r s o implements C o n s u l t a s {
8: private String l i s t a ; / Base de d a t o s /
9: private S t r i n g grupo ; / C l a v e d e l g r u p o /
10: p r i v a t e i n t numRegs ; / Numero t o t a l de r e g i s t r o s /
4.2 Implementacion de una base de datos 112

Codigo 4.4 Clase que maneja listas de cursos. (Curso)2/2

11: /
12: TAM XXXX : Tamano d e l campo
13: OFF XXXX : D i s t a n c i a d e l campo XXXX a l p r i n c i p i o d e l r e g i s t r o
14: /
15: p r i v a t e s t a t i c f i n a l i n t TAM REG = 46;
16: p r i v a t e s t a t i c f i n a l i n t TAM NMBRE = 2 5 ;
17: p r i v a t e s t a t i c f i n a l i n t TAM CARRE = 4 ;
18: p r i v a t e s t a t i c f i n a l i n t TAM CTA = 9;
19: p r i v a t e s t a t i c f i n a l i n t TAM CLVE = 8 ;
20: p r i v a t e s t a t i c f i n a l i n t OFF NMBRE = 0 ;
21: p r i v a t e s t a t i c f i n a l i n t OFF CARRE = 2 5 ;
22: p r i v a t e s t a t i c f i n a l i n t OFF CTA = 29;
23: p r i v a t e s t a t i c f i n a l i n t OFF CLVE = 3 8 ;

En esta pequena prueba estamos utilizando unicamente una funcion de ca-

denas (String), substring, que me entrega la subcadena que empieza en el primer
parametro y termina en el segundo parametro, ambos enteros. Este metodo lo
invocamos desde la lista de nombres y datos adicionales. Una tabla de metodos
relevantes de la clase String en esta etapa se encuentran en la tabla 4.1 en la pagi-
na 101. Tenemos un metodo que nos encuentra la primera posicion del i-esimo
registro, daPosI(int i), y a partir de ah nos saltamos los campos que van antes del
que queremos. As, el campo que corresponde al nombre esta en la posicion 0 de
cada registro - OFF NMBRE = 0 mientras que para llegar al campo con la clave
de usuario hay que saltar el tamano del nombre, mas el tamano de la cuenta mas
el tamano de la carrera OFF CLVE = 38 = 25 + 4 + 9. Similarmente localizamos
el inicio de cada uno de los otros campos.
Veamos ahora la implementacion de los constructores en el diagrama de la
figura 4.3. En este diagrama vemos que lo que tenemos que hacer en cada uno de
los constructores es darle valor inicial a los datos privados de la clase.

Figura 4.3 Diagrama de Warnier-Orr para los constructores.

$
'
&Construye lista inicial
Constructor Registra numero de estudiantes
'
%Registra clave del grupo

Habamos comentado que queremos dos constructores, uno que trabaje a partir
de una lista que de el usuario, y otro que inicie con una lista vaca y vaya agregando
113 Manejo de cadenas y expresiones

nombres conforma el usuario los va dando. El codigo para ambos casos se puede
ver en el listado 4.5.
Codigo 4.5 Constructores para la clase Curso (Curso)
24: /
25: C o n s t r u y e una b a s e de d a t o s a p a r t i r de l o s d a t o s que de e l
26: usuario .
27: @param g r u p o La c l a v e d e l g r u p o
28: @param l i s t a La l i s t a b i e n armada d e l g r u p o
29: @param c u a n t o s E l numero de r e g i s t r o s que s e r e g i s t r a n
30: /
31: p u b l i c C u r s o ( S t r i n g grupo , S t r i n g l i s t a ) {
32: t h i s . l i s t a = l i s t a == n u l l
33: ? ""
34: : lista ;
35: t h i s . g r u p o = g r u p o == n u l l
36: ? "????"
37: : grupo ;
38: numRegs = l i s t a . l e n g t h ()==0
39: ?0
40: : l i s t a . l e n g t h ( ) /TAM REG + 1 ;
41: }
42: /
43: C o n s t r u y e una b a s e de d a t o s v a c a p e r o con numero de g r u p o
44: @param g r u p o Numero de g r u p o
45: /
46: public Curso ( S t r i n g grupo ) {
47: t h i s . l i s t a = "" ;
48: t h i s . g r u p o = g r u p o == n u l l
49: ? "????"
50: : grupo ;
51: numRegs = 0 ;
52: }

El metodo que da la lista completa es muy sencillo, ya que unicamente regresa

la lista. Lo podemos ver en el listado 4.6.

Codigo 4.6 Metodo que regresa toda la lista (Curso)

53: /
54: Da a c c e s o a l a b a s e de d a t o s c o m p l e t a
55: @return toda l a l i s t a
56: /
57: public String daLista () {
58: return l i s t a ;
59: }
4.2 Implementacion de una base de datos 114

Para los metodos que regresan un determinado campo de un registro tenemos

el algoritmo que se muestra en la figura 4.4.

Figura 4.4 Diagrama de Warnier-Orr para regresar el contenido de un campo.

$
'
'
' Da el inicio del i-esimo registro
'
'
'
'
'
'
'
'
&apunta al inicio del campo en ese registro
Da campo del i-esimo registro
'
'
'
'
'
'
Apunta al final del campo
'
'
'
'
'
%Toma la subcadena correspondiente

Como siempre nos vamos a estar moviendo al inicio del i-esimo registro vamos
a elaborar un metodo, privado, que me de el caracter en el que empieza el i-esimo
registro, mediante la formula

posicion  pi
1q  T AM REG.
Hay que tomar en cuenta aca al usuario, que generalmente va a numerar los
registros empezando desde el 1 (uno), no desde el 0 (cero). Con esto en mente y
de acuerdo a lo que es la que discutimos al inicio de este tema, el metodo queda
como se puede observar en el listado 4.7.

Codigo 4.7 Calculo de la posicion donde empieza el i-esimo registro (Curso)

60: /
61: Da e l numero de c a r a c t e r en e l que e m p i e z a e l i
e s i m o
62: registro .
63: @param i e l o r d i n a l d e l r e g i s t r o
64: @ r e t u r n e l c a r a c t e r en e l que e m p i e z a
65: /
66: private int daPosI ( int i ) {
67: r e t u r n ( i
1) TAM REG ;
68: }

Los metodos que regresan un campo siguen todos el patron dado en la figura 4.4
y su implementacion se puede ver en el listado 4.8 en la pagina opuesta.
115 Manejo de cadenas y expresiones

Codigo 4.8 Metodos que regresan el contenido de un campo (Curso)

69: /
70: R e g r e s a e l nombre c o m p l e t o d e l i
e s i m o r e g i s t r o .
71: @param e l o r d i n a l d e l r e g i s t r o
72: @ r e t u r n l a c a d e n a que c o r r e s p o n d e a l nombre
73: /
74: p u b l i c S t r i n g daNombre ( i n t i ) {
75: i n t empza , t e r m i n a ;
76: empza = d a P o s I ( i ) + OFF NMBRE ;
77: t e r m i n a = d a P o s I ( i ) + OFF NMBRE + TAM NMBRE;
78: r e t u r n l i s t a . s u b s t r i n g ( empza , t e r m i n a ) ;
79: }
80: /
81: R e g r e s a l a c a r r e r a d e l i
e s i m o r e g i s t r o
82: @param i e l o r d i n a l d e l r e g i s t r o
83: @ r e t u r n l a s u b c a d e n a que c o r r e s p o n d e a l a c a r r e r a
84: /
85: public String daCarrera ( int i ) {
86: i n t empza , t e r m i n a ;
87: empza = d a P o s I ( i ) + OFF CARRE ;
88: t e r m i n a = d a P o s I ( i ) + OFF CARRE + TAM CARRE ;
89: S t r i n g c l a v e = l i s t a . s u b s t r i n g ( empza , t e r m i n a ) ;
90: i n t c u a l C l a v e = " actbiofismatcom "
91: }
92: /
93: R e g r e s a e l numero de c u e n t a d e l i
e s i m o r e g i s t r o
94: @param i e l o r d i n a l d e l r e g i s t r o
95: @ r e t u r n l a s u b c a d e n a que c o r r e s p o n d e a l numero de c u e n t a
96: /
97: p u b l i c S t r i n g daCuenta ( i n t i ) {
98: i n t empza , t e r m i n a ;
99: empza = d a P o s I ( i ) + OFF CTA ;
100: t e r m i n a = d a P o s I ( i ) + OFF CTA + TAM CTA ;
101: r e t u r n l i s t a . s u b s t r i n g ( empza , t e r m i n a ) ;
102: }
103: /
104: R e g r e s a l a c l a v e de a c c e s o d e l i
e s i m o r e g i s t r o
105: @param i e l o r d i n a l d e l r e g i s t r o
106: @ r e t u r n l a s u b c a d e n a que c o r r e s p o n d e a l a c l a v e de a c c e s o
107: /
108: public S t r i n g daClave ( int i ) {
109: i n t empza , t e r m i n a ;
110: empza = d a P o s I ( i )+OFF CLVE ;
111: t e r m i n a = d a P o s I ( i )+OFF CLVE + TAM CLVE ;
112: r e t u r n l i s t a . s u b s t r i n g ( empza , t e r m i n a ) ;
113: }
4.2 Implementacion de una base de datos 116

Los metodos que acabamos de programar asumen que se sabe el numero de

registro que se esta buscando, por lo que tenemos que dar un metodo que dada
una subcadena regrese el numero del registro que se esta buscando. Como existe la
posibilidad de que no se encuentre la subcadena, se debe verificar esa posibilidad.
El algoritmo para este metodo se muestra en la figura 4.5.

Figura 4.5 Encontrar el numero de registro al que pertenece una subcadena.

$
'
' lugar la posicion
# de la subcadena
'
'
'
'
' inicio la posicion del inicio del registro
Determinar ''
&Se encontro? lugar Calcular el numero de registro
numero
'
de registro '
'
' !
'
'
' Se encontro? H
'
'
%Regresar lugar

Para encontrar la posicion de la subcadena simplemente usamos metodos de

la clase String. Para encontrar el inicio del registro, simplemente le quitamos lo
que sobre del multiplo mas cercano del tamano del registro. Y finalmente vemos
cuantos registros caben en ese numero.

Codigo 4.9 Metodo que da el primer registro con subcadena (Curso)

114: /
115: Da e l o r d i n a l que c o r r e s p o n d e a l p r i m e r o r e g i s t r o que c o n t i e n e
116: a l a subcadena
117: @param nombre s u b c a d e n a a b u s c a r
118: @ r e t u r n e l o r d i n a l d e l r e g i s t r o , o
1 s i no hay
119: /
120: p u b l i c i n t d a P o s i c i o n ( S t r i n g nombre ) {
121: i n t l u g a r = l i s t a . t o L o w e r C a s e ( ) . i n d e x O f ( nombre . t o L o w e r C a s e ( ) ) ;
122: i n t s o b r a n = ( l u g a r >= 0 ) ? ( l u g a r % TAM REG) : 0 ;
123: r e t u r n ( l u g a r >= 0 ) ? ( ( l u g a r
s o b r a n ) / TAM REG) +1
124: : lugar ;
125: }

Supongamos ahora que no queremos al primero que contenga la subcadena,

sino uno que este despues de cierta posicion. El algoritmo es practicamente el
mismo, excepto que usamos otra firma de la funcion indexOf, la que toma en cuenta
117 Manejo de cadenas y expresiones

una posicion inicial a partir de donde buscar. Le damos al metodo daPosicion otra
firma que tome en cuenta este parametro adicional. La programacion se encuentra
tambien en los listados 4.9 en la pagina opuesta y 4.10.

Codigo 4.10 Metodo que da el siguiente registro con subcadena (Curso)

126: /
127: Da e l o r d i n a l que c o r r e s p o n d e a l r e g i s t r o que c o n t i e n e
128: a l a s ub c a d e na , a p a r t i r de l a p o s i c i o n dada
129: @param nombre s u b c a d e n a a b u s c a r
130: @param d e s d e numero de c a r a c t e r a p a r t i r d e l c u a l b u s c a r
131: @ r e t u r n e l o r d i n a l d e l r e g i s t r o , o
1 s i no hay
132: /
133: p u b l i c i n t d a P o s i c i o n ( S t r i n g nombre , i n t d e s d e ) {
134: i n t nvoReg = ( d e s d e ) TAM REG ;
135: i n t l u g a r = l i s t a . t o L o w e r C a s e ( ) . i n d e x O f ( nombre . t o L o w e r C a s e ( ) ,
136: nvoReg ) ;
137: i n t s o b r a n = l u g a r % TAM REG ;
138: r e t u r n ( l u g a r >= 0 ) ? ( ( l u g a r
s o b r a n ) / TAM REG) +1
139: : lugar ;
140: }

El unico metodo que nos falta de los que trabajan con un registro particular
es el que arma un registro para mostrarlo. El algoritmo es sumamente sencillo, y
lo mostramos en la figura 4.6. Lo unico relevante es preguntar si el registro que
nos piden existe o no.

Figura 4.6 Edicion del i-esimo registro, si es que existe.

$ !
'
'
& Existe el registro i? Arma el registro i
Regresar el i-esimo
registro '
' !
%Existe el registro i? D que no existe

La programacion correspondiente se encuentra en el listado 4.11 en la siguiente

pagina. El caracter zt que aparece entre cada dos elementos del listado es un
tabulador, que lo que hace es alinear bien los campos para listarlos bonito.
4.2 Implementacion de una base de datos 118

Codigo 4.11 Edicion de un registro individual (Curso)

141: /
142: Arma e l r e g i s t r o p a r a m o s t r a r que s e e n c u e n t r a en l a i
e s i m a
143: p o s i c i o n .
144: @param i l a p o s i c i o n d e l r e g i s t r o
145: @ r e t u r n e l r e g i s t r o armado o un m e n s a j e de que no e x i s t e
146: /
147: public String armaRegistro ( int i ) {
148: return ( i > 0) ?
149: daNombre ( i ) + "\t" + d a C a r r e r a ( i ) + "\t" +
150: daCuenta ( i ) + "\t" + d a C l a v e ( i )
151: : "No se encontro al nombre buscado " ;
152: }

De las funciones mas comunes a hacer con una lista de un curso es listar toda
la lista completa. Sabemos cuantos registros tenemos, todo lo que tenemos que
hacer es recorrer la lista e ir mostrando uno por uno. A esto le llamamos iterar
sobre la lista. El algoritmo podra ser el que se ve en la figura 4.7.

Figura 4.7 Algoritmos para listar el curso.

$ $
'
'
' '
'
'
'
'
' '
'
'
& &arma el registro i
lista curso muestra i-esimo registro
'
' '
'
'
'
'
pi  1, . . . , numRegsq '
'
'
'
'
avanza
% %

En Java tenemos varios enunciados compuestos que iteran. El mas general de

ellos es de la forma
$
'
'
'
xenunciado simpley
Ejecuta enunciado compuesto
& xenunciado simpley
(mientras se cumpla xcondiciony) '
' ...
'
%
xenunciado simpley

y su sintaxis es como se muestra en la figura 4.8 en la pagina opuesta.

119 Manejo de cadenas y expresiones

Figura 4.8 Enunciado compuesto while.

Sintaxis:
xenunciado compuesto whiley::=
while ( xexpresion booleanay ) {
xenunciado simple o compuestoy
xenunciado simple o compuestoy
...
xenunciado simple o compuestoy
}
Semantica:
Lo primero que hace el programa es evaluar la xexpresion booleanay. Si esta
se evalua a verdadero, entonces se ejecutan los enunciados que estan entre
las llaves, y regresa a evaluar la xexpresion booleanay. Si se evalua a falso,
brinca todo el bloque y sigue con el enunciado que sigue al while.

En cualquier iteracion que utilicemos, y en particular en la que acabamos de

presentar, hay varios aspectos que hay que tener presentes:
i. Cual es el estado de las variables involucradas cuando se llega por primera
vez a evaluar la condicion de la iteracion?
ii. Cual es el mnimo numero de veces que se va a ejecutar el cuerpo de la
iteracion?
iii. Que es lo que se hace dentro del cuerpo de la iteracion que obliga a la
iteracion a terminar?
En el caso de la iteracion while, se debe llevar a cabo un proceso de iniciali-
zacion, que consiste en, de ser necesario declarar y, asignar valores iniciales que
garanticen y dejen claro el estado al llegar a la cabeza de la iteracion. Esta itera-
cion puede no ejecutarse, ya que la condicion puede no cumplirse desde la primera
vez que se intenta iterar; por ultimo, en el cuerpo de la iteracion se debe cambiar
el estado de una o mas de las variables involucradas en la condicion, para que
haya posibilidad de salir de la iteracion.
Un buen ejemplo del uso de esta iteracion es, por ejemplo, encontrar el lmite de
una sucesion dado un margen de error. Lo que haremos sera calcular sucesivamente
terminos, hasta que la diferencia entre el ultimo termino calculado y el actual sea
menor que una cierta epsilon. El algoritmo para ello se encuentra en la figura 4.9
en la siguiente pagina.
4.2 Implementacion de una base de datos 120

1
Figura 4.9 Encontrar el lmite de 2n , dado
$ $
'
'
' '
& = .001
'
'
'
' Inicializar double f Actl 1{2
'
'
' '
%
'
' double f Ant 0
'
'
&
Calcular lmite de #
1
'
' Calcular siguiente termino f Ant f Actl
2n '
'
'
'
' (mientras |fant
factl | ) f Actl f Ant{2
'
'
'
'
'
' !
'
% Final Reporta f Actl

La implementacion de este pequeno metodo se muestra en el listado 4.12.

Codigo 4.12 Calculo del lmite de una sucesion

p u b l i c double l i m i t e ( double v a r e p s i l o n ) {
/ I n i c i a l i z a r /
double e p s i l o n = v a r e p s i l o n ;
double f A c t l = 1 / 2 ;
double f A n t = 1 ;
/ I t e r a c i o n /
w h i l e ( Math . a b s ( f A c t l
f A n t ) < e p s i l o n ) {
fAnt = FActl ;
fActl = fActl / 2;
} // f i n d e l w h i l e
/ F i n a l /
return f A c t l ;
}

Como se puede ver, esta iteracion es ideal cuando no tenemos claro el numero
de iteraciones que vamos a llevar a cabo y deseamos tener la posibilidad de no
ejecutar el cuerpo ni siquiera una vez. Por ejemplo, si el valor de que nos pasaran
como parametro fuera mayor que 1{2, la iteracion no se llevara a cabo ni una vez.
Hay ocasiones en que deseamos que un cierto enunciado se ejecute al menos
una vez. Supongamos, por ejemplo, que vamos a sumar numeros que nos den desde
la consola hasta que nos den un
1. El algoritmo se puede ver en la figura 4.10.
121 Manejo de cadenas y expresiones

Figura 4.10 Sumar numero mientras no me den un
1

$ #
'
' suma 0
'
'
' Inicializar
'
' numro 0
'
'
&
Sumar una lista Sumar numeros #
Sumar numero ledo
de numeros '
'
' (mientras numero
'
'
'  Leer siguiente numero
'
'
'
-1) !
%Final Entregar resultado

Veamos la descripcion de este enunciado compuesto de iteracion en la figu-

ra 4.11.

Figura 4.11 Enunciado compuesto do . . . while

Sintaxis:
xenunciado compuesto do. . . whiley::=
do {
xenunciado simple o compuestoy
xenunciado simple o compuestoy
...
xenunciado simple o compuestoy
} while ( xexpresion booleanay );
Semantica:
Lo primero que hace el enunciado al ejecutarse es ejecutar los enunciados
que se encuentran entre el do y el while. Es necesario aclarar que estos enun-
ciados no tienen que estar forzosamente entre llaves (ser un bloque) pero las
llaves me permiten hacer declaraciones dentro del enunciado, mientras que
sin las llaves, como no tengo un bloque, no puedo tener declaraciones loca-
les al bloque. Una vez ejecutado el bloque procede a evaluar la xexpresion
booleanay. Si esta se evalua a verdadero, la ejecucion continua en el primer
enunciado del bloque; si es falsa, sale de la iteracion y sigue adelante con el
enunciado que sigue al do . . . while.

Tambien en esta iteracion tenemos que tener cuidado en inicializar y declarar

4.2 Implementacion de una base de datos 122

variables necesarias antes de entrar a la iteracion. No podemos declararlas dentro

porque entonces no las conoce en la xexpresion booleanay. Pero como primero
hace y despues pregunta, podemos hacer la inicializacion como parte del bloque.
Veamos como queda el pequeno algoritmo que se muestra en la figura 4.11 en el
listado 4.13.

Codigo 4.13 Suma de numeros ledos

public i n t sumaLeidos ( Console cons ) {
i n t suma = 0 ;
i n t numero = 0 ;
do {
suma += numero ;
numero = c o n s . l e e I n t ( ) ;
} w h i l e ( numero !=
1);
r e t u r n suma ;
}

Es claro que lo que se puede hacer con un tipo de iteracion se puede hacer con la
otra. Si queremos que el bloque se ejecute al menos una vez usando un while, lo que
hacemos es colocar el bloque inmediatamente antes de entrar a la iteracion. Esto
nos va a repetir el codigo, pero el resultado de la ejecucion va a ser exactamente
el mismo. Por otro lado, si queremos usar un do. . . while pero queremos tener
la posibilidad de no ejecutar ni una vez, al principio del bloque ponemos una
condicional que pruebe la condicion, y como cuerpo de la condicional colocamos el
bloque original. De esta manera si la condicion no se cumple al principio el bloque
no se ejecuta. Esto quiere decir que si un lenguaje de programacion unicamente
cuenta con una de estas dos iteraciones, sigue teniendo todo lo necesario para
elaborar metodos pensados para la otra iteracion.
Tenemos una tercera iteracion conocida como for, que resulta ser el canon
de las iteraciones, en el sentido de que en un solo enunciado inicializa, evalua
una expresion booleana para saber si entra a ejecutar el enunciado compuesto e
incrementa al final de la ejecucion del enunciado compuesto. Lo veremos cuando
sea propicio su uso. Por lo pronto volveremos a nuestro problema de manejar una
pequena base de datos.
La lista del curso debemos mostrarla en algun medio. Para usar dispositivos
de entrada y salida utilizaremos por lo pronto una clase construida especialmente
para ello, se llama Consola y se encuentra en el paquete icc1.interfaz. Tenemos que
crear un objeto de tipo Consola, y a partir de ese momento usarlo para mostrar
y/o recibir informacion del usuario. Veamos los principales metodos que vamos a
usar por el momento en la tabla 4.3 en la pagina opuesta.
123 Manejo de cadenas y expresiones

Podemos regresar ahora al problema de listar todo el curso en una pantalla

proporcionada por el usuario, usando la clase Consola y el enunciado compuesto
while. La programacion se encuentra en el listado 4.14.

Codigo 4.14 Metodo que lista todo el curso (Curso)

153: /
154: L i s t a t o d o e l c o n t e n i d o de l a b a s e de d a t o s
155: @param c o n s o l a e l f l u j o de s a l i d a donde va a l i s t a r
156: /
157: public void l i s t a C u r s o ( Consola c o n s o l a ) {
158: i n t i =1;
159: w h i l e ( i <= numRegs ) {
160: consola . imprimeln ( armaRegistro ( i ) ) ;
161: i ++;
162: } // w h i l e
163: } // l i s t a C u r s o

Cuadro 4.3 Metodos de la clase Consola.

Firma Descripcion
Constructores
Consola() Construyen una pantalla para interaccionar con el
Consola(String) programa. El valor por omision (si no tiene argumen-
Consola(int, int) tos enteros) es de 400600 en pixeles, o del tamano
Consola(int, int, String) que se le indique si se dan argumentos enteros. Si se
le proporciona una cadena, esta cadena aparece como
ttulo de la pantalla. La pantalla permanece hasta que
se destruya con el boton correspondiente. Ningun otro
proceso, mas que el programa, dara atencion mientras
la consola este activa. Cuidado porque lo que se te-
clee se guarda para cuando desparezca la consola!
Escritura
void imprime(String) El primero coloca la cadena en la pantalla que
void imprimeln(String) corresponde al objeto Consola (lo escribe). El segun-
do, una vez que termino de escribir la cadena, manda
un caracter de fin de lnea. En el primero, una segun-
da escritura se hara a partir de donde termino la pri-
mera, mientras que con la segunda firma, la siguiente
escritura se hara empezando renglon nuevo.
4.2 Implementacion de una base de datos 124

Cuadro 4.3 Metodos de la clase Consola. (continua)

Firma Descripcion
Hay algunos caracteres que toman un significado es-
pecial. Ya vimos uno de ellos, el tabulador. Veamos
algunos mas que pueden ser utiles.
zn lnea nueva z zz Una sola z
z comillas dentro del texto
z Apostrofe dentro del texto
Lectura
String leeString() Abre una pequena pantallita en la que pide una cade-
String leeString(String) na. Se selecciona con el raton la pantallita y se teclea
la cadena, terminando con Enter . En la segunda fir-
ma se coloca el mensaje como ttulo de la pantallita.
Esta desaparece cuando se termina de teclear la ca-
dena.

El proceso de agregar un estudiante es bastante simple, ya que en las especifi-

caciones del problema no se menciona que la lista se tenga que mantener en orden.
Simplemente armamos el registro y lo agregamos al final. El unico problema es
garantizar el tamano de los campos, pues el usuario puede no tomarlo en cuenta.
El algoritmo se muestra en la figura 4.12.

Figura 4.12 Algoritmo para agregar un estudiante.

$
'
'
'
'
'
'
'
'
'
Ajusta tamano de nombre
'
'
&Ajusta tamano de clave
Agrega registro Ajusta tamano de carrera
'
'
'
'
'
'
Ajusta tamano de numero de cuenta
'
'
'
'
'
%
Agrega la cadena completa a la lista

Para ajustar los tamanos de las cadenas, primero les agregamos al final un
monton de blancos, para luego truncarla en el tamano que debe tener. La progra-
macion se encuentra en el listado 4.15 en la pagina opuesta.
125 Manejo de cadenas y expresiones

Codigo 4.15 Metodo que agrega un estudiante a la lista (Curso)

164: /
165: Agrega un e s t u d i a n t e a l a b a s e de d a t o s .
166: @param nombre
167: @param c u e n t a
168: @param c l v e
169: @param c a r r e
170: /
171: p u b l i c v o i d a g r e g a E s t ( S t r i n g nombre , S t r i n g c u e n t a ,
172: String clve , String carre ) {
173: String blancos = " ";
174: S t r i n g defNmbre =
175: nombre . t r i m ( ) . c o n c a t ( b l a n c o s ) . s u b s t r i n g ( 0 ,TAM NMBRE ) ;
176: S t r i n g defCuenta = cuenta . trim ( ) . concat ( blancos ) .
177: s u b s t r i n g ( 0 ,TAM CTA ) ;
178: String defClave = c l v e . trim ( ) . concat ( blancos ) .
179: s u b s t r i n g ( 0 , TAM CLVE ) ;
180: String defCarre =
181: c a r r e . t r i m ( ) . c o n c a t ( b l a n c o s ) . s u b s t r i n g ( 0 ,TAM CARRE ) ;
182: S t r i n g e s t u d n t e = defNmbre + d e f C a r r e + d e f C u e n t a + d e f C l a v e ;
183: l i s t a = l i s t a . concat ( estudnte ) ;
184: numRegs++;
185: }

Figura 4.13 Posibles situaciones para eliminar a un registro.

Caso 1
loooooooooooooooooooooooooooooooooooooooooooooomoooooooooooooooooooooooooooooooooooooooooooooon

loooooooooooooooooomoooooooooooooooooon Caso 2 looooooooooooooooooooooooomooooooooooooooooooooooooon

loooooooooooooooooooooooooooooooooooooooooooooomoooooooooooooooooooooooooooooooooooooooooooooon Caso 3
4.2 Implementacion de una base de datos 126

Para eliminar a un estudiante de la lista, usando subcadenas, no es tan facil.

Si el estudiante que queremos quitar es el primero, la lista se convierte en lo que
queda de la cadena al quitar el primero; si es el ultimo el que deseamos eliminar,
la lista nueva consiste de la parte hasta donde empieza el ultimo; pero en cambio,
si al que deseamos eliminar se encuentra en una posicion intermedia, tenemos que
partir la lista en tres pedazos: lo que va antes, el registro que deseamos eliminar
y lo que va despues ver figura 4.13 en la pagina anterior. De la figura podemos
ver que tenemos que hacer un analisis por casos. El algoritmo se muestra en la
figura 4.14.

Figura 4.14 Algoritmo para eliminar a un estudiante de la lista.

$ !
'
'
' Es el primero Se queda del segundo al final
'
'
'
'
'
&
Eliminar el !
Es el ultimo Se queda del primero al penultimo
registro i '
'
'
'
'
' !
'
'
% Esta en medio Juntar del 1 al i-1 y del i+1 al final

Conocemos de cual de estas tres situaciones se trata (no hay otra posibilidad)
dependiendo de la posicion del registro:
Es el primero si i vale 1.
Es el ultimo si i vale NUM REGS.
Esta en medio si 1 i NUM REGS.
Para este tipo de enunciado es conveniente que introduzcamos el xenunciado
compuesto condicionaly cuya sintaxis y semantica se encuentra en la figura 4.15 en
la pagina opuesta. Con esto podemos ya pasar a programar el metodo que elimina
al i-esimo registro de nuestra lista, en el listado 4.16 en la pagina opuesta.
El unico metodo que nos falta, para terminar esta seccion, es el que arma una
lista con todos los registros que contienen una subcadena. En este caso todo lo
que tenemos que hacer es, mientras encontremos la subcadena buscada, seguimos
buscando, pero a partir del siguiente registro. El algoritmos lo podemos ver en la
figura 4.16 en la pagina 128.
127 Manejo de cadenas y expresiones

Figura 4.15 Enunciado compuesto condicional

Sintaxis:
xenunciado compuesto condicionaly::=
if ( xexpresion booleanay ) {
xenunciado simple o compuestoy
...
xenunciado simple o compuestoy
} else {
xenunciado simple o compuestoy
...
xenunciado simple o compuestoy
}
Semantica:
Lo primero que hace el programa es evaluar la xexpresion booleanay. Si
esta se evalua a verdadero, entonces se ejecutan los enunciados que estan
entre las primeras llaves y si se evalua a falso se ejecutan los enunciados
que estan a continuacion del else. Pudieramos en ambos casos tener un
unico enunciado, en cuyo caso se pueden eliminar las llaves correspondien-
tes. Tambien podemos tener que no aparezca una clausula else, en cuyo
caso si la expresion booleana se evalua a falso, simplemente se continua la
ejecucion con el enunciado que sigue al if.

Codigo 4.16 Metodo que elimina al registro i (Curso)1/2

186: /
187: Q u i t a a l e s t u d i a n t e que s e e n c u e n t r a en e l p o s i c i o n i
188:
189: D i s t i n g u e e n t r e q u i t a r a l p r i m e r o , a l u l t i m o o a l g u n o de
190: en medio .
191: @param i p o s i c i o n d e l e s t u d i a n t e en l a l i s t a
192: /
193: public void q u i t a E s t ( i n t i ) {
194: int anteriores ;
195: int posteriores ;
196: a n t e r i o r e s = ( i
1 ) TAM REG ; // t e r m i n a n en
197: p o s t e r i o r e s = i TAM REG ; // e m p i e z a n en
4.2 Implementacion de una base de datos 128

Codigo 4.16 Metodo que elimina al registro i. (Curso)2/2

198: boolean noHay = ( i <= 0 | | i > numRegs ) ; // p o s i c i o n i n v a l i d a
199: i f ( noHay ) {
200: return ;
201: }
202: boolean e l P r i m e r o = ( i == 1 ) ;
203: boolean e l U l t i m o = ( i == numRegs ) ;
204: i f ( elPrimero ) l i s t a = l i s t a . substring ( posteriores );
205: else
206: i f ( elUltimo ) l i s t a = l i s t a . substring (0 , a n t e r i o r e s ) ;
207: else l i s t a = l i s t a . s ub s t r i n g (0 , a n t e r i o r e s )
208: + l i s t a . substring ( posteriores );
209: numRegs

;
210: }

Figura 4.16 Metodo que encuentra TODOS los que contienen a una subcadena.
$ $
'
'
' '
'
'
' '
'
'
'
'
' '
'
' donde Primer registro que caza.
'
'
' &
'
'
' P rincipio
'
'
' '
' cazaCon (cadena vaca)
'
' '
'
'
'
'
' '
'
'
' '
%
'
&
Arma cadena $
'
'
'
'
' '
'
'
'
' '
'
' '
'
'cazaCon cazaCon
'
'
' '
& armaRegistropdondeq
Arma siguiente
'
'
'
'
'
'
(mientras hayas
'
'
' '
'
'
'
'
'
encontrado) '
' donde Siguiente registro que caza
'
' '
'
%
%

Lo unico importante en este caso es darnos cuenta que ya tenemos dos ver-
siones que nos dan la posicion de una subcadena, as que la programacion es
practicamente directa. La podemos ver en el listado 4.17 en la pagina opuesta.
129 Manejo de cadenas y expresiones

Codigo 4.17 Metodo que lista a los que cazan con . . . (Curso)
211: /
212: C o n s t r u y e una l i s t a p a r a m o s t r a r con t o d o s l o s r e g i s t r o s que
213: t i e n e n como s u b c a d e n a a l p a r a m e t r o .
214: @param s u b c a d Lo que s e b u s c a en cada r e g i s t r o
215: @ r e t u r n Una c a d e n a que c o n t i e n e a l o s r e g i s t r o s que c a z a n
216: /
217: p u b l i c S t r i n g losQueCazanCon ( S t r i n g s u b c a d ) {
218: S t r i n g cazanCon = "" ;
219: i n t donde = d a P o s i c i o n ( s u b c a d ) ;
220: w h i l e ( donde !=
1) {
221: cazanCon = cazanCon . c o n c a t ( a r m a R e g i s t r o ( donde)+"\n" ) ;
222: donde = d a P o s i c i o n ( subcad , donde ) ;
223: } // w h i l e e n c u e n t r e s
224: r e t u r n cazanCon ;
225: }

Podramos, para probar que nuestros metodos funcionan, programar el metodo

main, pero eso es aburrido. Mejor hagamos una clase que maneje un menu para
esta base de datos en la siguiente seccion.

4.3 Una clase Menu

Contar con una base de datos que tiene las funcionalidades usuales no es
suficiente. Debemos contar con algun medio de comunicacion con la misma, como
pudiera ser un lenguaje de consulta (query language) o, simplemente, un menu que
nos de acceso a las distintas operaciones que podemos realizar sobre la base de
datos. Construiremos un menu para tal efecto.

El funcionamiento de un menu queda esquematizado en el diagrama de la

figura 4.17 en la siguiente pagina. Basicamente, mientras el usuario lo desee, de-
bemos mostrarle una lista de las opciones que tiene, dejarle que elija una de ellas
y proceder a hacer lo que corresponde a la opcion.
4.3 Una clase Menu 130

Figura 4.17 Menu para uso de la clase Curso.

$ $
'
'
' '
'
' Muestra el menu
'
'
' '
'
'
'
'
' '
'
' !
Pide opcion al usuario
'
'
' '
'
' opcion == Termina Salir
'
'
' '
'
'
'
'
' '
'
'
'
' '
' #
'
'
' '
'
' Pide registro
'
'
' '
'
'
opcion == Agrega
'
'
' '
'
'
Agrega registro
'
'
' '
'
'
'
'
' '
'
' $
'
'
' '
'
' '
' Pregunta a quien
'
' '
' '
'
'
'
' '
' '
'
'
'
' '
'
' &Buscalo !
'
'
' '
'
' opcion == Quita Encontrado Qutalo
'
'
' '
'
' '
'
'
Menu '
'
& Maneja Menu '
'
& '
'
' !
'
%
para (mientras desee Encontrado Reporta No encontrado
'
'
' '
'
'
Cursos '
'
'
el usuario) '
'
' $
'
'
' '
'
' '
'
' '
' '
'
'
Pregunta a quien
'
'
' '
'
' '
'
'
' '
' '
&Buscalo !
'
'
' '
'
'
'
'
' '
'
'
opcion == Busca Encontrado Reportalo
'
'
' '
' '
'
'
'
'
' '
'
' '
' !
'
' '
' '
%
'
'
' '
'
'
Encontrado Reporta No encontrado
'
' '
'
'
'
' '
'
' !
'
'
' '
'
'
'
'
' '
'
'
opcion == Lista Lista todo el curso
'
' '
'
'
'
' '
'
' #
'
'
' '
'
'
'
'
% '
'
%
opcion == Todos los Pregunta subcadena
que cazan Arma la lista

El menu que requerimos corresponde a una clase que va a hacer uso de la clase
Curso que ya disenamos. Por lo tanto, podemos empezar ya su codificacion. El
hacerlo en una clase aparte nos permitira, en un futuro, tal vez manejar nuestra
base de datos con un lenguaje de consulta o hasta, posiblemente, con un lenguaje
de programacion.
131 Manejo de cadenas y expresiones

Para construir el codigo correspondiente al del diagrama de la Figura 4.17

tenemos en Java una condicional calculada, en la cual, como su nombre lo indica,
elige una opcion entre varias dependiendo del valor de la variable selectora. La
sintaxis de este enunciado se encuentra en la Figura 4.18.

Figura 4.18 Enunciado switch.

Sintaxis:
switch( xexpresiony ) {
case xvalor1 y:
xlista de enunciados simples o compuestosy;
case xvalor2 y:
xlista de enunciados simples o compuestosy;
case . . .
xlista de enunciados simples o compuestosy;
default:
xlista de enunciados simples o compuestosy;
}
Semantica:
Los valores valor1 , . . . deben ser del mismo tipo que la expresion, a la que
llamamos la selectora del switch y deben ser constantes de ese tipo. El
enunciado switch elige un punto de entrada al arreglo de enunciados de la
lista. Evalua la expresion y va comparando contra los valores que aparecen
frente a la palabra case. El primero que coincide, a partir de ese punto
ejecuta todos los enunciados desde ah hasta que se encuentre un enunciado
break, o el final del switch, lo que suceda antes. Se acostumbra colocar un
enunciado break al final de cada opcion para que unicamente se ejecuten los
enunciados relativos a esa opcion. El switch tiene una clausula de escape,
que puede o no aparecer. Si aparece y la expresion no toma ninguno de
los valores explcitamente listados, se ejecuta el bloque correspondiente a
default. Si no hay clausula de escape y el valor de la expresion no caza con
ninguno de los valores en los cases, entonces el programa abortara dando
un error de ejecucion.

El comando break que mencionamos en la figura 4.18 es muy sencillo, y lo unico

que hace es sacar el hilo de ejecucion del programa hacia afuera del switch. Su
sintaxis y semantica se encuentran definidas con mas precision en la figura 4.19.
Veamos algunos ejemplos de la forma que podran tomar distintos switches.
4.3 Una clase Menu 132

Figura 4.19 Enunciado break.

Sintaxis:
xenunciado breaky ::= break
Semantica:
Hace que el hilo de ejecucion del programa no siga con el siguiente enun-
ciado, sino que salga del enunciado compuesto en el que esta, en este caso
el switch.

boolean e s t a = i !=
1;
switch ( e s t a ) {
case f a l s e :
c o n s o l a . i m p r i m e l n ( "NO esta " ) ;
break ;
case t r u e :
c o n s o l a . i m p r i m e l n ( "SI esta" ) ;
}

Como las unicas dos posibilidades para el selector del switch, una expresion
booleana, es falso o verdadero, no hay necesidad de poner una clausula de escape,
ya que no podra tomar ningun otro valor. Este ejemplo es realmente un enunciado
if disfrazado, ya que si la expresion se evalua a verdadero (true) se ejecuta lo que
corresponde al caso etiquetado con true, mientras que si se evalua a falso, se ejecuta
el caso etiquetado con false. Programado con ifs queda de la siguiente manera:
boolean e s t a = i !=
1;
i f ( esta )
c o n s o l a . i m p r i m e l n ( "SI esta" ) ;
else
c o n s o l a . i m p r i m e l n ( "SI esta" ) ;

Otro ejemplo mas apropiado, ya que tiene mas de dos opciones, es el siguiente:
supongamos que tenemos una clave que nos dice el estado civil de una persona y
que queremos convertirlo a la cadena correspondiente. Las claves son:
s: soltero
c: casado
d: divorciado
v: viudo
u: union libre
En una variable de tipo caracter tenemos una de estas opciones, y deberemos
133 Manejo de cadenas y expresiones

proporcionar una cadena con el texto adecuado. La programacion quedara algo

parecido a lo que se observa en el listado 4.18.

Codigo 4.18 Ejemplo de identificacion del estado civil de un individuo

1: char e s t a d o = d a E s t a d o ( ) ;
2: / d a E s t a d o ( ) a s i g n a v a l o r a e s t a v a r i a b l e /
3: String texto ;
4: switch ( estado ) { / E l e g i m o s de a c u e r d o a l c o n t e n i d o
5: de estado /
6: case s :
7: t e x t o = " soltero " ;
8: break ;
9: case c :
10: t e x t o = " casado " ;
11: break ;
12: case d :
13: t e x t o = " divorciado " ;
14: break ;
15: case u :
16: t e x t o = " union libre " ;
17: break ;
18: default :
19: t e x t o = "no definido " ;
20: break ;
21: } // En l a v a r i a b l e texto queda e l m e n s a j e que c o r r e s p o n d e

En general, la estructura switch lo que hace es ir comparando el valor del se-

lector con cada uno de las constantes que se encuentran alrededor de la palabra
case. Mas de una etiqueta, se pueden aparecer frente a un bloque de codigo, para
referirse a que esa es la accion a realizarse en mas de un caso:

case A : case B : case C :

r e t u r n " Primeros tres casos

Regresamos ahora a la programacion de nuestro problema. La parte corres-

pondiente al manejo del menu se da en un metodo, para no atiborrar al metodo
principal (main) de la clase con codigo. La programacion queda como se muestra
en el listado 4.19 en la siguiente pagina.
4.3 Una clase Menu 134

Codigo 4.19 Encabezado de la clase Menu y el metodo daMenu (MenuCurso) 1/2

1: c l a s s MenuCurso {
2: /
3: Maneja e l menu p a r a e l a c c e s o y m a n i p u l a c i o n de l a b a s e de
4: datos .
5: @param c o n s D i s p o s i t i v o en e l que s e va a i n t e r a c c i o n a r
6: @param miCurso Base de d a t o s con l a que s e va a t r a b a j a r
7: @ r e t u r n l a o p c i o n s e l e c c i o n a d a , d e s p ue s de h a b e r l a e j e c u t a d o
8: /
9: p u b l i c i n t daMenu ( C o n s o l a cons , C u r s o miCurso ) {
10: S t r i n g nombre , c u e n t a , c a r r e r a , c l a v e ;
11: S t r i n g subcad ;
12: String registros ;
13: i n t donde ;
14: S t r i n g menu = "(0)\ tTermina \n"+
15: "(1)\ tAgrega \n"+
16: "(2)\ tQuita \n"+
17: "(3)\ tBusca \n"+
18: "(4)\ tLista todos \n"+
19: "(5)\ tLista subconjunto que contenga a ...." ;
20: c o n s . i m p r i m e l n ( menu ) ;
21: int opcion ;
22: S t r i n g s o p c i o n = c o n s . l e e S t r i n g ( " Elige una opcion --> " ) ;
23: o p c i o n = " 012345 " . i n d e x O f ( s o p c i o n ) ;
24: switch ( opcion ) {
25: case 0 : // S a l i r
26: c o n s . i m p r i m e l n ( " Espero haberte servido .\n"+
27: " Hasta pronto ..." ) ;
28: r e t u r n
1;
29: case 1 : // Agrega E s t u d i a n t e
30: nombre = pideNombre ( c o n s ) ;
31: cuenta = pideCuenta ( cons ) ;
32: c a r r e r a = p i d e C a r r e r a ( cons ) ;
33: c l a v e = pideClave ( cons ) ;
34: miCurso . a g r e g a E s t ( nombre , c u e n t a , c l a v e , c a r r e r a ) ;
35: return 1;
36: case 2 : // Q u i t a e s t u d i a n t e
37: nombre = pideNombre ( c o n s ) ;
38: donde = miCurso . d a P o s i c i o n ( nombre ) ;
39: i f ( donde !=
1) {
40: nombre = miCurso . daNombre ( donde ) ;
41: miCurso . q u i t a E s t ( donde ) ;
42: c o n s . i m p r i m e l n ( "El estudiante :\n\t"
43: + nombre
44: + "\n Ha sido eliminado " ) ;
45: }
135 Manejo de cadenas y expresiones

Codigo 4.19 Encabezado de la clase bfseries Menu y el metodo daMenu (MenuCurso) 2/2
46: else {
47: r e p o r t a N o ( cons , nombre ) ;
48: }
49: return 2;
50: case 3 : // Busca s u b c a d e n a
51: s u b c a d = c o n s . l e e S t r i n g ( "Dame la subcadena a "
52: + " buscar : " ) ;
53: donde = miCurso . d a P o s i c i o n ( s u b c a d ) ;
54: i f ( donde !=
1) {
55: c o n s . i m p r i m e l n ( miCurso . a r m a R e g i s t r o ( donde ) ) ;
56: }
57: else {
58: r e p o r t a N o ( cons , s u b c a d ) ;
59: }
60: return 3;
61: case 4 : // L i s t a t o d o s
62: miCurso . l i s t a C u r s o ( c o n s ) ;
63: return 4;
64: case 5 : // L i s t a con c r i t e r i o
65: s u b c a d = c o n s . l e e S t r i n g ( "Da la subcadena que " +
66: " quieres contengan los " +
67: " registros :" ) ;
68: r e g i s t r o s = miCurso . losQueCazanCon ( s u b c a d ) ;
69: i f ( r e g i s t r o s . e q u a l s ( "" ) ) {
70: c o n s . i m p r i m e l n ( "No hubo ningun registro con " +
71: "este criterio " ) ;
72: }
73: else {
74: cons . imprimeln ( r e g i s t r o s ) ;
75: }
76: return 5;
77: d e f a u l t : // E r r o r , v u e l v e a p e d i r
78: c o n s . i m p r i m e l n ( "No diste una opcion valida .\n" +
79: "Por favor vuelve a elegir ." ) ;
80: return 0;
81: }
82: }

Para el menu construimos una cadena que se muestra separada por renglones,
como se observa en las lneas68 a 73, y le pedimos al usuario que elija un nume-
ro de opcion, en la lnea 76. En esta lnea aparece algo nuevo, ya que estamos
interaccionando con el usuario. La manera de hacerlo es a traves de una consola
(por eso aparece un objeto de esta clase como parametro). Por lo pronto vamos
a leer cadenas, y tenemos la opcion de pedirle o no que escriba una cadena como
4.3 Una clase Menu 136

ttulo de la pequena pantalla en la que solicita el dato. Las dos posible firmas del
metodo de lectura de cadenas de la clase consola son

String leeString ()
String leeString ( String )

En el primer caso simplemente aparecera una pantallita en la que, una vez

seleccionada, se debera teclear la cadena que se desea proporcionar (recuerdese
que podemos tener una cadena de un solo caracter) terminandola con Enter . La
invocacion de este metodo, desde un objeto del tipo Consola puede aparecer en
cualquier lugar donde pudiera aparecer una expresion de cadenas.
Estamos asumiendo que el usuario nos tecleo un dgito. Procedemos a ver
exactamente cual de ellos fue, buscandolo en una cadena que contiene todas las
opciones (si tuvieramos mas de 10 opciones tendramos que asignar letras para
las siguientes, y as poder seguir utilizando este metodo). Esto lo hacemos con el
metodo ya conocido por nosotros, indexOf lnea 77 del listado 4.19 en la pagina
134.
Una vez determinada la opcion que solicito el usuario, deberemos escoger entre
un conjunto de opciones, numeradas del 0 al 5. Para ello vamos a utilizar una
condicional especial, el switch, que se muestra en la figura 4.18 en la pagina 131.
En el caso de nuestro problema, cada bloque del switch termina con un return,
ya que ese es el objetivo del proceso, avisar cual es la ultima opcion que se eligio.
Adicionalmente, se ejecuta lo correspondiente a cada opcion. Las revisaremos una
por una.

4.3.1. Salir

En esta opcion se emite un mensaje para el usuario, avisandole del final del
proceso, y se regresa un valor de -1 para que el programa principal ya no siga
mostrando el menu y termine.

4.3.2. Agrega estudiante

Esta opcion tiene que funcionar como una interface entre el metodo de la
base de datos y el usuario, para agregar de manera correcta a un estudiante. Por
ello, deberemos primero llenar cada uno de los campos del registro (sera absurdo
pedirle al usuario que conociera como esta implementada nuestra base de datos).
137 Manejo de cadenas y expresiones

Por ello se procede a solicitarle al usuario cada uno de los campos involucrados.
Elegimos hacer un metodo distinto para cada campo, para poder indicarle al
usuario que tipo de cadena estamos esperando. La codificacion de cada uno de
estos metodos se encuentran en el listado 4.20. Algunos de estos metodos los
volveremos a usar, ya que nos proporcionan, por parte del usuario, informacion.
Cada uno de estos metodos simplemente le dice al usuario que es lo que espera y
recibe una cadena, que, idealmente, debera ser lo que el usuario espera.

Codigo 4.20 Metodos para agregar un estudiante a la base de datos. (MenuCurso)1/2

83: /
84: P i d e en e l i n p u t s t r e a m e l nombre d e l alumno .
85: @param c o n s e l i n p u t s t r e a m
86: @ r e t u r n E l nombre l e d o
87: /
88: p r i v a t e S t r i n g pideNombre ( C o n s o l a c o n s ) {
89: S t r i n g nombre = c o n s . l e e S t r i n g ( "Dame el nombre del "
90: + " estudiante , empezando por apellido paterno :" ) ;
91: r e t u r n nombre ;
92: }
93: /
94: P i d e en e l i n p u t s t r e a m l a c a r r e r a d e l alumno .
95: @param c o n s e l i n p u t s t r e a m
96: @ r e t u r n La c a r r e r a l e d a
97: /
98: private S t r i n g p i d e C a r r e r a ( Consola cons ) {
99: S t r i n g c a r r e r a = c o n s . l e e S t r i n g ( "Dame una de las "
100: + " carreras :\ tMate \ tComp \ tFisi \ tActu \ tBiol :" ) ;
101: return c a r r e r a ;
102: }
103: /
104: P i d e en e l i n p u t s t r e a m l a c l a v e de a c c e s o d e l alumno .
105: @param c o n s e l i n p u t s t r e a m
106: @ r e t u r n La c l a v e de a c c e s o l e d a
107: /
108: private S t r i n g pideClave ( Consola cons ) {
109: S t r i n g c l a v e = c o n s . l e e S t r i n g ( "Dame la clave de acceso del "
110: + " estudiante :" ) ;
111: return c l a v e ;
112: }
4.3 Una clase Menu 138

Codigo 4.20 Metodos para agregar un estudiante a la base de datos (MenuCurso) 2/2
113: /
114: P i d e en e l i n p u t s t r e a m e l numero de c u e n t a d e l alumno .
115: @param c o n s e l I n p u t S t r e a m
116: @ r e t u r n E l numero de c u e n t a l e d o
117: /
118: private S t r i n g pideCuenta ( Consola cons ) {
119: S t r i n g cuenta =
120: c o n s . l e e S t r i n g ( "Dame el numero de cuenta del "
121: + " estudiante , de 9 dgitos " ) ;
122: return cuenta ;
123: }

4.3.3. Quita estudiante

En esta opcion, tambien, la parte interesante la hace el metodo de la base de

datos, que ya revisamos. Debemos notar, sin embargo, que es aca donde vamos a
verificar que las operaciones sobre la base de datos se hayan realizado de manera
adecuada, preguntando siempre por el resultado de las mismas. El unico metodo
que no hemos visto es uno realmente sencillo que reporta que el estudiante soli-
citado no se encuentra en la base de datos. La programacion de este metodo se
encuentra en el listado 4.21.

Codigo 4.21 Metodo que reporta estudiante inexistente (MenuCurso)

124: /
125: R e p o r t a que e l e s t u d i a n t e b u s c a d o no f u e l o c a l i z a d o .
126: @param c o n s f l u j o de s a l i d a en e l que s e e s c r i b e
127: @param nombre s u b c a d e n a que no f u e l o c a l i z a d a
128: /
129: p r i v a t e v o i d r e p o r t a N o ( C o n s o l a cons , S t r i n g nombre ) {
130: c o n s . i m p r i m e l n ( "El estudiante :\n\t"
131: + nombre
132: + "\n No esta en el grupo " ) ;
133: }
139 Manejo de cadenas y expresiones

4.3.4. Busca estudiante

Tambien realiza su tarea usando metodos que ya explicamos. Al igual que las
otras opciones, verifica que las operaciones sobre la base de datos se realicen de
manera adecuada.

4.3.5. Lista todo el curso

Simplemente invoca al metodo correspondiente de la base de datos.

4.3.6. Lista los que cumplan con algun criterio

Este metodo verifica si algun estudiante cumplio o no con el criterio solicitado,

preguntando si la cadena resultante tiene algo o no. Noten que tiene que usar el
metodo equals(String), ya que de otra manera no estara comparando contenidos
de cadenas y nos dira siempre que no son iguales.

4.3.7. Valor por omision

En este caso, regresaremos un valor que permita al usuario saber que no dio
una opcion correcta y que debe volver a elegir.

4.3.8. Metodo principal de MenuCurso

En este metodo es en el que tenemos que declarar nuestros objetos, tanto la

base de datos como el menu. Una vez hecho esto, simplemente entraremos en una
iteracion mostrando el menu y recibiendo la opcion, mientras el usuario no decida
terminar. La programacion de este metodo se encuentra en el listado 4.22 en la
siguiente pagina.
Lo unico interesante del metodo en el listado 4.22 en la siguiente pagina es
que el enunciado del while es un enunciado vaco, ya que todo se hace cuando se
invoca al menu para que diga si ya le pidieron que salga o no.
4.3 Una clase Menu 140

Codigo 4.22 Metodo principal de la clase MenuCurso (MenuCurso)

134: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
135: int opcion ;
136: C o n s o l a c o n s o l a = new C o n s o l a ( ) ;
137: C u r s o miCurso = new C u r s o (
138: "7001" , // C u r s o
139: " Aguilar Sols Aries Olaf " + "Mate"
140: + " 400001528 " + " aaguilar "
141: + "Cruz Cruz Gil Noe " + "Comp"
142: + " 098034011 " + " ncruz "
143: + " Garca Villafuerte Israel " + "Mate"
144: + " 098159820 " + " igarcia "
145: + " Hubard Escalera Alfredo " + "Comp"
146: + " 099586197 " + " ahubard "
147: + " Tapia Vazquez Rogelio " + "Comp"
148: + " 098162075 " + " rtapia " , // l i s t a
149: 5);
150: MenuCurso miMenu = new MenuCurso ( ) ;
151: w h i l e ( ( o p c i o n = miMenu . daMenu ( c o n s o l a , miCurso ) ) !=
1);
152: }

Con esto damos por terminada nuestra primera aproximacion a una base de
datos. En lo que sigue haremos mas eficiente y flexible esta implementacion, bus-
cando que se acerque mas a lo que es una verdadera base de datos.
 Datos estructurados
5
La implementacion que dimos en el captulo anterior a nuestra base de datos
es demasiado alejada de como abstraemos la lista del grupo. Realmente, cuando
pensamos en una lista es una cierta coleccion de registros, donde cada registro
tiene uno o mas campos. Tratemos de acercarnos un poco mas a esta abstraccion.
El tipo de coleccion que usaremos en esta ocasion es una lista. La definicion
de una lista es la siguiente:

Definicion 5.6 Una lista es:

(a) La lista vaca, aquella que no tiene ningun elemento; o bien
(b) el primer elemento de la lista, seguido de una lista.

Por ejemplo, si una lista nada mas tiene un elemento, esta consiste del primer
elemento de una lista, seguido de una lista vaca.
Toda lista es una referencia a objetos de cierto tipo que contienen determinada
informacion y donde al menos uno de sus campos es una referencia, para acomodar
all a la lista que le sigue. En Java, si una lista es la lista vaca tendra el valor de null,
que corresponde a una referencia nula. Generalmente representamos las listas como
se muestra en la figura 5.1 en la siguiente pagina, con la letra r representando
un campo para guardar all una referencia, y el smbolo representando que no
sigue nadie (una referencia nula).
Como la definicion de la lista es recursiva, debemos siempre tener anclado
5.1 La clase para cada registro 142

al primer elemento de la lista, la cabeza de la misma, como se puede ver en la

figura 5.1.

Figura 5.1 Ilustracion de una lista

cabeza: al primero de la lista

r

Inf o r Inf o r Inf o r Inf o r

Otros nombres que se usan en la literatura sinonimos de referencia son liga,

apuntador, cadena1 .

5.1 La clase para cada registro

Como en el captulo anterior, queremos que cada estudiante de la lista tenga
un campo para nombre, cuenta, carrera y clave, pero en esta ocasion lo haremos
independiente cada uno. Ademas requerimos el campo donde se guarde la referen-
cia al siguiente de la lista. Esta referencia es una referencia a objetos de la misma
clase que los registros: es autoreferida. Entonces, la clase que vamos a tener para
nuestros registros la llamaremos Estudiante. Veamos por lo pronto los atributos
(datos) que tiene esta clase en el listado 5.1.

Codigo 5.1 Atributos de la clase Estudiante

1: import i c c 1 . i n t e r f a z . C o n s o l a ;
2: /
3: Base de d a t o s , a b a s e de l i s t a s de r e g i s t r o s , que emula l a
4: l i s t a de un c u r s o de l i c e n c i a t u r a . T i e n e l a s o p c i o n e s
5: n o r m a l e s de una b a s e de d a t o s y f u n c i o n a m e d i a n t e un Menu
6: /
7: c l a s s E s t u d i a n t e {
8: p r i v a t e S t r i n g nombre , c l a v e , c a r r e r a , c u e n t a ;
9: private Estudiante s i g u i e n t e ;
10: s t a t i c p u b l i c f i n a l i n t NOMBRE = 1 ;
11: s t a t i c p u b l i c f i n a l i n t CUENTA = 2 ;
12: s t a t i c p u b l i c f i n a l i n t CARRERA = 3 ;
13: s t a t i c p u b l i c f i n a l i n t CLAVE = 4 ;

1
Del ingles, chain.
143 Datos estructurados

Combinamos en una sola declaracion los 4 campos (atributos) de informacion

que tiene el registro, ya que todos son del mismo tipo; el atributo siguiente es
el que es una referencia al siguiente de la lista (a la lista que le sigue). Deben
observar que este campo es de tipo Estudiante, que, como todas las variables del
tipo de alguna clase, constituyen referencias.
Todas las constantes lo son de la clase (static final). Eso quiere decir que podran
ser accesibles desde cualquiera de los objetos, y solo existe una copia, la de la clase.
Debemos tener un constructor que inicialice a un objeto de esta clase con
las cadenas adecuadas. Como tenemos al menos un constructor, si queremos uno
sin parametros tambien lo tenemos que programar nosotros. Los constructores se
encuentran en el listado 5.2.

Codigo 5.2 Constructores para la clase Estudiante (Estudiante)

14: /
15: C o n s t r u c t o r s i n p a r a m e t r o s
16: /
17: public Estudiante () {
18: nombre = c a r r e r a = c l a v e = c u e n t a = n u l l ;
19: }
20: /
21: C o n s t r u c t o r a p a r t i r de d a t o s de un e s t u d i a n t e .
22: l o s campos v i e n e n s e p a r a d o s e n t r e s p o r comas ,
23: m i e n t r a s que l o s r e g i s t r o s v i e n e n s e p a r a d o s e n t r e s
24: p o r punto y coma .
25: @param S t r i n g , S t r i n g , S t r i n g , S t r i n g l o s v a l o r e s p a r a
26: cada uno de l o s campos que s e van a l l e n a r .
27: @ r e t u r n E s t u d i a n t e una r e f e r e n c i a a una l i s t a
28: /
29: p u b l i c E s t u d i a n t e ( S t r i n g nmbre , S t r i n g c nt a ,
30: String clve , String crrera ) {
31: nombre = nmbre . t r i m ( ) ;
32: cuenta = cnta . trim ( ) ;
33: clave = clve . trim ( ) ;
34: carrera = c r r e r a . trim ( ) ;
35: siguiente = null ;
36: }

Una vez que tenemos los constructores, tenemos que proveer, para cada campo
al que queramos que se tenga acceso, un metodo de consulta y uno de actuali-
zacion. La programacion de estos metodos se encuentra en el listado 5.3 en la
siguiente pagina.
5.1 La clase para cada registro 144

Codigo 5.3 Metodos de acceso y actualizacion de la clase Estudiante 1/2

37: /
38: R e g r e s a e l c o n t e n i d o d e l campo nombre .
39: @return String
40: /
41: p u b l i c S t r i n g getNombre ( ) {
42: r e t u r n nombre ;
43: }
44: /
45: A c t u a l i z a e l campo nombre .
46: @param S t r i n g e l v a l o r que s e va a a s i g n a r .
47: /
48: p u b l i c v o i d setNombre ( S t r i n g nombre ) {
49: t h i s . nombre = nombre ;
50: }
51: /
52: R e g r e s a e l c o n t e n i d o d e l campo c a r r e r a .
53: @return String
54: /
55: public String getCarrera () {
56: return c a r r e r a ;
57: }
58: /
59: A c t u a l i z a e l campo c a r r e r a .
60: @param S t r i n g e l v a l o r que s e va a a s i g n a r .
61: /
62: public void s e t C a r r e r a ( S t r i n g c a r r e ) {
63: carrera = carre ;
64: }
65: /
66: R e g r e s a e l c o n t e n i d o d e l campo c u e n t a .
67: @return String
68: /
69: public S t r i n g getCuenta () {
70: return cuenta ;
71: }
72: /
73: A c t u a l i z a e l campo c u e n t a .
74: @param S t r i n g e l v a l o r que s e va a a s i g n a r .
75: /
76: public void setCuenta ( S t r i n g cnta ) {
77: cuenta = cnta ;
78: }
145 Datos estructurados

Codigo 5.3 Metodos de acceso y actualizacion de la clase Estudiante 2/2

79: /
80: R e g r e s a e l c o n t e n i d o d e l campo c a l v e .
81: @return String
82: /
83: public String getClave () {
84: return c l a v e ;
85: }
86: / A c t u a l i z a e l campo c l a v e .
87: @param S t r i n g e l v a l o r que s e va a a s i g n a r .
88: /
89: public void s e t C l a v e ( S t r i n g c l v e ) {
90: clave = clve ;
91: }
92: / R e g r e s a e l c o n t e n i d o d e l campo s i g u i e n t e .
93: C o r r e s p o n d e a l a l i s t a que s i g u e a e s t e e l e m e n t o .
94: @ r e t u r n E s t u d i a n t e Una r e f e r e n c i a a l s i g u i e n t e o b j e t o de l a
95: lista
96: /
97: public Estudiante getSiguiente () {
98: return s i g u i e n t e ;
99: }
100: / A c t u a l i z a e l campo s i g u i e n t e .
101: @param E s t u d i a n t e l a r e f e r e n c i a que s e va a a s i g n a r .
102: /
103: public void s e t S i g u i e n t e ( E s t u d i a n t e s i g ) {
104: siguiente = sig ;
105: }

Podemos tambien poner metodos mas generales, dado que todos los atribu-
tos son del mismo tipo, que seleccionen un campo a modificar o a regresar. Los
podemos ver en el codigo 5.4.

Codigo 5.4 Metodos que arman y actualizan registro completo (Estudiante)1/2

106: c l a s s E s t u d i a n t e {
107: /
108: R e g r e s a e l campo s o l i c i t a d o .
109: @param c u a l i d e n t i f i c a d o r d e l campo s o l i c i t a d o
110: @ r e t u r n La c a d e n a con e l campo s o l i c i t a d o
111: /
112: p u b l i c S t r i n g getCampo ( i n t c u a l ) {
113: switch ( c u a l ) {
114: case NOMBRE: r e t u r n getNombre ( ) ;
115: case CUENTA : return getCuenta ( ) ;
5.1 La clase para cada registro 146

Codigo 5.4 Metodos que arman y actualizan registro completo (Estudiante) 2/2

116: case CARRERA : return getCarrera ( ) ;

117: case CLAVE : return getClave ( ) ;
118: default : r e t u r n " Clave invalida " ;
119: } // end o f s w i t c h ( c u a l )
120: }
121: /
122: M o d i f i c a e l campo s o l i c i t a d o .
123: @param c u a l e l campo s o l i c i t a d o .
124: @param c a d e n a e l nuevo v a l o r
125: /
126: p u b l i c v o i d setCampo ( i n t c u a l , S t r i n g c a d e n a ) {
127: switch ( c u a l ) {
128: case NOMBRE: setNombre ( c a d e n a ) ;
129: break ;
130: case CUENTA : s e t C u e n t a ( c a d e n a ) ;
131: Break ;
132: case CARRERA : s e t C a r r e r a ( c a d e n a ) ;
133: break ;
134: case CLAVE : s e t C l a v e ( cadena ) ;
135: break ;
136: default :
137: break ;
138: } // end o f s w i t c h ( c u a l )
139: }

Finalmente, de esta clase unicamente nos faltan dos metodos, uno que regrese
todo el registro armado, listo para impresion, y uno que actualice todos los campos
del objeto. Podemos ver su implementacion en el listado 5.5.

Codigo 5.5 Metodos que arman y actualizan registro completo (2) (Estudiante)1/2

140: / Arma una c a d e n a con e l c o n t e n i d o de t o d o e l r e g i s t r o .

141: @ r e t u r n S t r i n g E l r e g i s t r o armado .
142: /
143: public String getRegistro () {
144: r e t u r n nombre . t r i m ()+"\t"+
145: c u e n t a . t r i m ()+"\t"+
146: c a r r e r a . t r i m ()+"\t"+
147: clave . trim ( ) ;
148: }
147 Datos estructurados

Codigo 5.5 Metodos que arman y actualizan registro completo (2) (Estudiante)2/2

149: / A c t u a l i z a t o d o e l r e g i s t r o de un j a l o n .
150: @param S t r i n g e l nombre ,
151: S t r i n g cuenta
152: String carrera
153: String clave .
154: /
155: p u b l i c v o i d s e t R e g i s t r o ( S t r i n g nmbre , S t r i n g c n ta ,
156: String clve , String crrera ) {
157: nombre = nmbre . t r i m ( ) ;
158: cuenta = cnta . trim ( ) ;
159: clave = clve . trim ( ) ;
160: carrera = c r r e r a . trim ( ) ;
161: }

Como se puede observar, no hay necesidad de disenar los metodos previo a

su programacion, ya que son, en general, muy pequenos y concisos. Es importante
notar que en esta clase no interviene ningun metodo que maneje ningun tipo de
coleccion de objetos, sino unicamente lo que concierne a cada registro en s mismo.

5.2 La lista de registros

Como acabamos de mencionar, la interrelacion entre los distintos registros de

nuestra base de datos la vamos a manejar desde una clase separada a la de los
registros mismos, la lista de registros.
Para toda lista requerimos, como mencionamos en relacion con la figura 5.1
en la pagina 142, un ancla para la lista, algo que sea la referencia al primer
elemento de la lista. De no tener esta referencia, como la lista se va a encontrar en
el heap, no habra manera de saber donde empieza o donde estan sus elementos.
Hagan de cuenta que el heap es el mar, y las declaraciones en una clase son un
barco. Cada vez que se crea un objeto, este se acomoda en el heap (mar), por lo que
tenemos que tener una cuerda (cadena, referencia, apuntador) desde el barco hacia
el primer objeto, y de este al segundo, etc. De esa manera, si jalamos la cuerda
podemos tener acceso a todos los elementos que conforman la lista. Jalar la
cuerda quiere decir, en este contexto, ir tomando referencia por referencia, como
si se tratara de un collar de cuentas. Al igual que en nuestra implementacion
anterior, usaremos un identificador lista que nos indique el primer elemento de la
5.2 La lista de registros 148

lista, una referencia al primer elemento. Por supuesto que esta lista estara vaca
en tanto no le agreguemos ningun objeto del tipo Estudiante. Por lo tanto, la unica
diferencia entre las declaraciones de nuestra implementacion anterior y esta es el
tipo de la lista, quedando las primeras lneas de la clase como se puede apreciar
en el listado 5.6.

Codigo 5.6 Atributos de la clase ListaCurso

1: import i c c 1 . i n t e r f a z . C o n s o l a ;
2: /
3: R e s t r u c t u r a a l a c l a s e Curso p a r a que s e a
4: manejada a t r a v e s de una l i s t a
5: /
6: c l a s s L i s t a C u r s o {
7: / La c a b e z a de l a l i s t a : /
8: private Estudiante l i s t a ;
9: / E l numero de g r u p o /
10: private S t r i n g grupo ;
11: / Cuenta e l numero de r e g i s t r o s /
12: p r i v a t e i n t numRegs ;

Al igual que con la clase Curso, tenemos dos constructores, uno que unicamente
coloca el numero del grupo y otro inicializa la lista y coloca el numero de grupo.
Debemos recordar que lo primero que hace todo constructor es poner los valores
de los atributos que corresponden a referencias en null y los que corresponden a
valores numericos en 0. Los constructores se encuentran en el listado 5.7.

Codigo 5.7 Constructores para la clase ListaCurso 1/2

13: / C o n s t r u c t o r que u n i c a m e n t e a s i g n a numero de g r u p o a l a l i s t a .
14: @param S t r i n g g r E l numero d e l g r u p o
15: /
16: public ListaCurso ( St ri n g gr ) {
17: l i s t a = null ;
18: grupo = gr ;
19: numRegs = 0 ;
20: }
149 Datos estructurados

Codigo 5.7 Constructores para la clase ListaCurso 2/2

21: / C o n s t r u c t o r que a s i g n a e l numero de g r u p o y una s u b l i s t a }
22: inicial .
23: @param E s t u d i a n t e s u b l i s t a .
24: @param S t r i n g g r Numero d e l g r u p o .
25: /
26: public ListaCurso ( Estudiante i n i c i a l e s , St r i ng gr ) {
27: grupo = gr ;
28: lista = iniciales ;
29: numRegs = c u e n t a R e g s ( ) ;
30: }

El segundo constructor tiene dos parametros; el primero de ellos es una re-

ferencia a un objeto de la clase Estudiante y el segundo es una referencia a una
cadena. El constructor inicializa la lista con esta referencia (copia la referencia a
la variable lista) y asigna el numero de grupo.
Dado que tenemos 3 atributos, tenemos que definir tres metodos de acceso
a los atributos. Dos de ellos son muy sencillos: el que me regresa el numero del
grupo y el que me regresa la cabeza de la lista, pues estos unicamente regresan el
valor del atributo. Los podemos ver en el listado 5.8.

Codigo 5.8 Metodos que dan valores de los atributos (ListaCurso)

31: / R e g r e s a l a l i s t a de e s t u d i a n t e s .
32: @ r e t u r n E s t u d i a n t e La c a b e z a de l a l i s t a .
33: /
34: public Estudiante getLista () {
35: return l i s t a ;
36: }
37: / P r o p o r c i o n a e l numero de g r u p o .
38: @return S t r i n g El grupo
39: /
40: public S t r i n g getGrupo ( ) {
41: return grupo ;
42: }

Para regresar el numero de registros en la lista, preferimos contarlos a pie.

Todo lo que tenemos que hacer es colocarnos al principio de la lista e incrementar
u8n contador por cada registro al que podamos llegar. Podemos ver un diagrama
de Warnier-Orr muy sencillo en la figura 5.2 en la siguiente pagina y su progra-
macion correspondiente en el listado 5.9 en la siguiente pagina.
5.2 La lista de registros 150

Figura 5.2 Contando los registros de una lista

$ $ !
'
'
' '
' inicia contador cuantos 0
'
' '
'
'
'
'
' '
&
'
' $
'
'
' Inicio '
&
'
' '
'
'
Colocate al
'
'
' '
'
' inicio de actual lista
'
' % '
%
'
'
' la lista
'
'
'
'
'
' $ $
'
'
& '
' '
&
Cuenta registros '
'
' incrementa
'
'
' cuantos
en una lista '
'
' '
' contador '
%
'
' Cuenta el '
&
'
'
'
'
'
'
registro actual
' $
'
' '
'
' '
'
'
'
(mientras haya) '
' &
'
' '
'
'
pasa al
actual toma el siguiente
'
'
' '
' '
'
' %siguiente %
'
'
'
'
'
'
'
' !
% F inal Entrega el contador

Codigo 5.9 Recorrido de una lista para contar sus registros (ListaCurso)
43: / C a l c u l a e l numero de r e g i s t r o s en l a l i s t a .
44: @ r e t u r n i n t E l numero de r e g i s t r o s
45: /
46: p u b l i c i n t getNumRegs ( ) {
47: int cuantos = 0;
48: Estudiante actual = l i s t a ;
49: w h i l e ( a c t u a l != n u l l ) {
50: c u a n t o s ++;
51: actual = actual . getSiguiente ();
52: }
53: return cuantos ;
54: }
151 Datos estructurados

Este metodo nos da el patron que vamos a usar casi siempre para recorrer una
lista, usando para ello la referencia que tiene cada registro al registro que le sigue.
El patron general es como se muestra en la figura 5.3.

Figura 5.3 Procesando los registros de una lista

$ #
'
'
' Variables para acumular
'
'
'
Inicializacion para el proceso
'
'
' # Colocarse al principio de la lista
Procesa registros
& Procesa el registro actual Proceso
#actual toma el siguiente
en una lista '
'
' (mientras haya)
'
'
'
'
'
'
Entregar
%F inal resultados

Junto con los metodos de acceso, debemos tener metodos que alteren o asig-
nen valores a los atributos. Sin embargo, tanto el atributo numRegs como lista
deberan ser modificados por las operaciones de la base de datos, y no directa-
mente. En cambio, podemos querer cambiarle el numero de grupo a una lista. Lo
hacemos simplemente indicando cual es el nuevo numero de grupo. Podemos ver
este metodo en el listado 5.10.

Codigo 5.10 Modifica el numero de grupo (ListaCurso)

55: / M o d i f i c a e l numero de g r u p o .
56: @param S t r i n g g r E l nuevo numero de g r u p o .
57: /
58: public void setGrupo ( S t r i n g gr ) {
59: grupo = gr ;
60: }

Podemos empezar ya con las funciones propias de la base de datos, como

por ejemplo, agregar un estudiante a la lista. Realmente podramos agregarlo de
tal manera que se mantenga un cierto orden alfabetico, o simplemente agregarlo
en cualquier posicion de la misma. Haremos esto ultimo, y el mantener la lista
ordenada se quedara como ejercicio.
Hay dos posiciones logicas para agregar un registro. La primera de ellas y la
mas sencilla es al inicio de la lista. Basicamente lo que tenemos que hacer es poner
al registro que se desea agregar como el primer registro de la lista. Esto quiere
5.2 La lista de registros 152

decir que la nueva lista consiste de este primer registro, seguido de la vieja lista.
Veamos en la figura 5.4 que es lo que queremos decir. El diagrama de Warnier-Orr
para hacer esto esta en la figura 5.5 y la programacion del metodo se encuentra
en el listado 5.11.

Figura 5.4 Agregando al principio de la lista

$
'
&Pon a nuevo a apuntar a lista
Agrega registro
al principio '
% Pon a lista a apuntar a nuevo

Figura 5.5 Esquema del agregado un registro al principio de la lista

Antes:
r lista

Inf o r Inf o r Inf o r Inf o r

r Inf o r

nuevo

Despues:
r lista

Inf o r Inf o r Inf o r Inf o r

r Inf o r

nuevo
153 Datos estructurados

Codigo 5.11 Agregar un registro al principio de la lista (ListaCurso)

61: / Agrega un r e g i s t r o a l p r i n c i p i o de l a l i s t a
62: @param E s t u d i a n t e nuevo A q u i e n s e va a a g r e g a r
63: /
64: p u b l i c v o i d a g r e g a E s t ( E s t u d i a n t e nuevo ) {
65: nuevo . s e t S i g u i e n t e ( l i s t a ) ;
66: l i s t a = nuevo ;
67: }

Si lo quisieramos acomodar al final de la lista las cosas se complican un poco

mas, aunque no demasiado. Queremos hacer lo que aparece en la figura 5.6.

Figura 5.6 Agregando al final de la lista

r lista

Inf o r Inf o r Inf o r Inf o r

r r
Info
nuevo

Lo que tenemos que hacer es localizar en la lista al registro al que ya no le

sigue ninguno, y poner a ese registro a apuntar al nuevo. El algoritmo queda como
se muestra en la figura 5.7 en la siguiente pagina.
En este algoritmo la condicion para que pare la iteracion es que al registro
actual no le siga nada. Esto, traducido a nuestro entorno, equivale a la expresion
booleana
a c t u a l . g e t S i g u i e n t e ( ) != n u l l

La programacion del algoritmo queda como se ve en el listado 5.12 en la siguiente

pagina.
5.2 La lista de registros 154

Figura 5.7 Agregando al final de la lista

$ $ !
'
'
' '
' lista vaca?
'
' '
'
'
lista apunta a nuevo
'
'
' '
'
'
' '
'
' $
'
'
' '
' '
'
'
' '
'
' '
'
Colocarse al principio
'
' '
' '
'
'
'
'
' Buscar el '
& '
'
de la lista $
'
Agregar ' '
'
' '
'
'
& ultimo '
& '
'
registro '
'
' '
'
registro ' ' lista vaca?
Recorrer registros '
'
& Toma el
al final ' ' '
' '
' ' '
' (Mientras siga
de la lista '
'
' '
'
' '
' '
'
' '
' '
'
' alguno '
'
siguiente
'
'
' '
' '
' '
'
'
' '
'
' '
' al actual) '
' registro
'
' % '
% '
%
'
'
'
'
'
'
'
'
%
Pon al ultimo registro a
apuntar al nuevo

Codigo 5.12 Agregar un registro al final de la lista (ListaCurso)

68: /
69: Agrega e l r e g i s t r o a l f i n a l de l a l i s t a .
70: @param E s t u d i a n t e nuevo E l r e g i s t r o p o r a g r e g a r
71: /
72: p u b l i c v o i d a g r e g a E s t F i n a l ( E s t u d i a n t e nuevo ) {
73: Estudiante actual ;
74: i f ( l i s t a == n u l l ) { // No hay n a d i e en l a l i s t a
75: l i s t a = nuevo ;
76: }
77: else {
78: actual = l i s t a ;
79: w h i l e ( a c t u a l . g e t S i g u i e n t e ( ) != n u l l ) {
80: actual = actual . getSiguiente ();
81: }
82: / Estamos f r e n t e a l u l t i m o r e g i s t r o /
83: a c t u a l . s e t S i g u i e n t e ( nuevo ) ;
84: } // d e l e l s e
85: }

Como se puede ver, seguimos el mismo patron que recorre la lista, pero nuestra
155 Datos estructurados

condicion de parada es un poco distinta. Vamos a parar cuando ya no siga nadie

al actual, o sea, cuando la referencia al siguiente sea nula.
Sin embargo, si la lista esta vaca, nos da un error al tratar de ver el siguiente
de alguien que no existe. Adicionalmente, si la lista esta vaca, agregar al nuevo
registro al principio o al final es equivalente.
Sigamos implementando aquellas funciones que responden al patron de proce-
so que dimos. Por ejemplo, el metodo que lista todos los registros es exactamente
este patron. El algoritmo lo podemos ver en la figura 5.8 y la programacion en el
listado 5.13.

Figura 5.8 Imprimiendo todos los registros

$
'
'
' Toma el primero de la lista
& $
Imprime lista Procesa el registro actual &Imprime el registro actual
'
'
'
% (mientras haya) %
Toma el registro siguiente

Para programar este metodo debemos tomar en consideracion que debemos

escribir en algun dispositivo, por lo que requerimos como parametro un objeto
de la clase Consola. Imprimir el registro es realmente sencillo, porque tenemos un
metodo que nos regresa el registro en forma de cadena.

Codigo 5.13 Imprimiendo toda la lista (ListaCurso)

86: /
87: L i s t a todos l o s r e g i s t r o s d e l Curso .
88:
89: @param C o n s o l a c o n s donde e s c r i b i r .
90: /
91: public void l i s t a T o d o s ( Consola cons ) {
92: Estudiante actual = l i s t a ;
93: int i = 0;
94: w h i l e ( a c t u a l != n u l l ) {
95: i ++;
96: cons . imprimeln ( a c t u a l . g e t R e g i s t r o ( ) ) ;
97: actual = actual . getSiguiente ();
98: }
99: i f ( i == 0 ) {
100: c o n s . i m p r i m e l n ( "No hay registros en la base de datos " ) ;
101: }
102: }
5.2 La lista de registros 156

Para el metodo que escribe todos los registros que cazan con una cierta subca-
dena tambien vamos a usar este patron, pues queremos revisar a todos los registros
y, conforme los vamos revisando, decidir para cada uno de ellos si se elige (im-
prime) o no. El algoritmo se encuentra en la figura 5.9 y la programacion en el
listado 5.14.

Figura 5.9 Imprimiendo registros seleccionados

$ !
'
'
' Principio Toma el primero de la lista
'
' $ $
'
'
' '
' El campo en el registro ' & Acepta
'
'
' '
'
'
'
'
' '
'
'
actual caza con la
' el
'
'
Imprime lista &
'
' %
'
'
'
subcadena? registro
de registros
Procesa el &
'
seleccionados '
' registro actual $
'
'
' '
'
' El campo en el registro &
'
'
'
(mientras haya) ''
'
'
'
' '
'
'
actual NO caza con la
%
'
'
' '
'
' subcadena?
'
% '
%Toma el registro siguiente

Codigo 5.14 Imprimiendo registros seleccionados (ListaCurso)

103: /
104: Imprim e l o s r e g i s t r o s que c a z a n con un c i e r t o p a t r o n .
105: @param C o n s o l a c o n s D i s p o s i t i v o en e l que s e va a e s c r i b i r .
106: @param i n t c u a l Con c u a l campo s e d e s e a c o m pa r ar .
107: @param S t r i n g s u b c a d Con e l que queremos que c a c e .
108: /
109: p u b l i c v o i d losQueCazanCon ( C o n s o l a cons , i n t c u a l ,
110: S t r i n g subcad ) {
111: int i = 0;
112: subcad = subcad . toLowerCase ( ) ;
113: Estudiante actual = l i s t a ;
114: w h i l e ( a c t u a l != n u l l ) {
115: i f ( a c t u a l . getCampo ( c u a l ) . i n d e x O f ( s u b c a d ) !=
1) {
116: i ++;
117: cons . imprimeln ( a c t u a l . g e t R e g i s t r o ( ) ) ;
118: }
119: actual = actual . getSiguiente ();
120: }
121: i f ( i == 0 ) {
122: c o n s . i m p r i m e l n ( "No se encontro ningun registro "
123: + "que cazara " ) ;
124: }
125: }
157 Datos estructurados

En el listado 5.14 en la pagina opuesta hacemos referencia al metodo get-

Campo que implementamos ya en el listado 5.4. En su momento explicamos las
caractersticas del mismo, por lo que ya no hay necesidad de repetirlas.
Para los metodos buscaEst y quitaEst el patron que debemos seguir al recorrer
la lista es un poco distinto, porque tenemos que parar en el momento en que
encontremos lo que estamos buscando, y ya no seguir recorriendo la lista. Pero
deberemos prevenir el que lo que buscamos no se encuentre en la lista. El patron
general para este tipo de busquedas se muestra en la figura 5.10.
Para el caso en que se busca un registro que tenga como subcadena en un
campo determinado a cierta subcadena, el proceso del registro que no caza no es
ninguno, mientras que el proceso del que caza es simplemente regresar la referencia
del registro que cazo. La programacion de este metodo queda como se muestra en
el listado 5.15 en la siguiente pagina.

Figura 5.10 Patron de busqueda de un registro que cumpla con . . .

$ #
'
'
' Colocate el principio de la lista
'
'
'
Inicio
'
'
'
Inicializacion de acumuladores
'
'
'
'
'
' $
'
'
' Revisa registros '
&
'
'
'
'
& (mientras haya y 'Toma el siguiente
Busca algo no lo encuentres)
%
en una lista '
'
'
'
'
' !
'
'
' SI se encontro el registro Procesa el registro
'
'
'
'
'
'
'
'
'
'
'
' !
'
%NO se encontro el registro Emite mensaje

Como se puede observar, la condicion de parada es doble: por un lado se debe

verificar que no se acabe la lista, y por el otro si el registro actual cumple la
condicion que buscamos, que en este caso es que contenga a la subcadena en el
campo indicado.
5.2 La lista de registros 158

Codigo 5.15 Metodo que busca un registro (ListaCurso)

126: /
127: Busca a l r e g i s t r o que c o n t e n g a a l a s u b c a d e n a .
128:
129: @param i n t c u a l C u a l e s e l campo que s e va a comparan .
130: @param S t r i n g s u b c a d La c a d e n a que s e e s t a b u s c a n d o .
131: @return Estudiante El r e g i s t r o deseado o n u l l .
132: /
133: public E s t u d i a n t e buscaSubcad ( i n t cual , S t r i n g subcad ) {
134: Estudiante actual ;
135: subcad = subcad . trim ( ) . toLowerCase ( ) ;
136: actual = l i s t a ;
137: w h i l e ( a c t u a l != n u l l &&
138: ( a c t u a l . getCampo ( c u a l ) .
139: i n d e x O f ( s u b c a d . t o L o w e r C a s e ( ) ) ) ==
1)
140: actual = actual . getSiguiente ();
141: return a c t u a l ;
142: }

5.2.1. Paso por valor y por referencia

Es el momento adecuado para saber que pasa cuando dentro de un metodo

o funcion se altera el valor de un parametro, como sucede en la lnea 135: en el
listado 5.15. En Java se dice que los parametros pasan por valor. Esto quiere decir
que al llamar a un metodo o funcion, se hace una copia del valor de los parametros,
y esto es lo que se entrega al metodo. Por lo tanto, todo lo que el metodo haga con
ese parametro no se reflejara fuera de el, ya que trabaja con una copia. Cuando
un parametro se pasa por valor, se dice que es un parametro de entrada.
A lo mejor esto resulta un poco confuso tratandose de objetos que pasan como
parametros. Cuando se pasa un objeto como parametro, se pasa la copia de una
variable que contiene una referencia. Por lo tanto, las modificaciones que se hagan
al objeto referido por la copia de la variable s se van a reflejar fuera del metodo,
ya que copia o no, contienen una direccion valida del heap. Los cambios a los que
nos referimos son aquellos que se refieren al valor de la referencia, o sea, ponerlos
a apuntar a otro lado. Estos ultimos cambios, en el punto de llamada del metodo,
no se reflejan. Por ejemplo, en la lnea 135: del listado 5.15, los cambios a subcad
se van a ver solo mientras permanezcamos en buscaSubcad. Una vez que salgamos,
podremos observar que la cadena que se utilizo como parametro no sufrio ningun
cambio.
159 Datos estructurados

Algunos lenguajes de programacion pueden pasar parametros por referencia.

Con este metodo lo que se pasa al metodo es la direccion (referencia) donde
se encuentra la variable en cuestion. Si este metodo funcionara en Java. lo que
estaramos pasando sera la direccion en memoria donde se encuentra la variable
que contiene a la referencia. Java no tiene este metodo de pasar parametros, pero
se lo pueden encontrar en lenguajes como C++ y Pascal. Cuando un parametro
se pasa por referencia, generalmente se hace para dejar ah algun valor, por lo que
se dice que es un parametro de salida, o de entrada y salida.
En los lenguajes mencionados se usan parametros por referencia para que los
metodos puedan devolver mas de un valor. En Java esto se hara construyendo
un objeto que tuviera a los campos que queremos regresar, y se regresa al objeto
como resultado del metodo.

5.2.2. Eliminacion de registros

Tal vez el proceso mas complicado es el de eliminar un estudiante, pues se

tienen que verificar varios aspectos de la lista. No es lo mismo eliminar al primer
estudiante que eliminar a alguno que se encuentre en posiciones posteriores a la
primera. Veamos en la figura 5.11 los dos casos.

Figura 5.11 Eliminacion de un estudiante

lista
r Eliminacion del primero

Inf o r Inf o r Inf o r Inf o r

lista
r Eliminacion entre dos registros

Inf o r Inf o r Inf o r Inf o r

En el primer caso tenemos que redirigir la referencia lista a que ahora apunte
hacia el que era el segundo registro. En el segundo caso tenemos que conservar la
5.2 La lista de registros 160

informacion del registro anterior al que queremos eliminar, para poder modificar
su referencia al siguiente a que sea a la que apuntaba el registro a eliminar. El
algoritmo para eliminar un registro se encuentra en la figura 5.12.

Figura 5.12 Eliminacion de un registro en una lista

$
'
'
' !
'
'
'
'
' lista  null? NO se puede
'
'
'
'
'
'
'
'
'
'
'
' !
'
'
' lista  null?
'
'
'

'
'
'
'
' #
'
'
' Modifica a lista a que apunte al segundo
'
'
' Es el primero?
'
'
'
regresa que s se pudo
'
'
'
'
'
'
'
'
'
'
' !
'
'
' Es el primero?
'
'
'

'
Eliminar '
&
un Colocarse en el segundo de la lista
'
'
'
estudiante '
'
'
Anotar como anterior al primero
'
'
'
'
' $
'
'
' Revisar la lista '
&
'
'
'
'
'
'
(mientras haya Y
' moverse al siguiente de la lista
'
' %
'
'
'
no lo encuentre)
'
'
'
'
' #
'
'
' Pon al anterior a apuntar
'
'
' Lo encontre?
'
'
' al siguiente del actual
'
'
'
'
'
'
'
'
'
'
' $
'
'
' '
&
'
'
'
'
'
'
Lo encontre? Avisa que no se pudo
'
% %
161 Datos estructurados

Codigo 5.16 Eliminacion de un registro en una lista (ListaCurso)

143: /
144: Q u i t a e l r e g i s t r o s o l i c i t a d o ( p o r nombre ) de l a l i s t a
145:
146: @param S t r i n g nombre E l nombre d e l r e g i s t r o
147: /
148: p u b l i c boolean q u i t a E s t ( S t r i n g nombre ) {
149: Estudiante anterior , actual ;
150: nombre=nombre . t r i m ( ) . t o L o w e r C a s e ( ) ;
151: i f ( l i s t a == n u l l ) { // E s t a v a c a l a l i s t a : no s e pudo
152: return f a l s e ;
153: }
154: i f ( l i s t a . getNombre ( ) . t r i m ( ) . t o L o w e r C a s e ( ) . e q u a l s ( nombre ) ) {
155: l i s t a = l i s t a . getSiguiente ();
156: return true ;
157: }
158: // No e s i g u a l a l p r i m e r o .
159: anterior = lista ; // E l p r i m e r o
160: a c t u a l = l i s t a . g e t S i g u i e n t e ( ) ; // E l s e g u n d o
161: w h i l e ( a c t u a l != n u l l &&
162: ! ( a c t u a l . getNombre ( ) . t o L o w e r C a s e ( ) .
163: e q u a l s ( nombre . t o L o w e r C a s e ( ) ) ) ) {
164: anterior = actual ;
165: actual = actual . getSiguiente ();
166: }
167: i f ( a c t u a l == n u l l ) { // No s e e n c o n t r o
168: return f a l s e ;
169: }
170: anterior . setSiguiente ( actual . getSiguiente ());
171: // P r o c e s a
172: return true ;
173: }

Estamos aprovechando que podemos salir de un metodo a la mitad del mismo

para que quede un esquema mas simple de la programacion, la que se muestra en
el listado 5.16.
No hay mucho que aclarar en este metodo, ya que corresponde directamente
al algoritmo. En general, se verifica que el estudiante a eliminar no sea el primero;
si lo es, se le elimina; si no lo es, se procede a buscar su ubicacion en la lista,
manteniendo siempre la referencia al anterior, para poder modificar su referencia
al estudiante que se desea eliminar.
5.2 La lista de registros 162

5.2.3. La clase MenuLista

La programacion del menu para tener acceso a la base de datos del curso es
sumamente similar al caso en que los registros eran cadenas, excepto que ahora,
para agregar a cualquier estudiante hay que construir un objeto de la clase Estu-
diante. El algoritmo es el mismo, por lo que ya no lo mostramos. La programacion
de encuentra en el listado 5.17.
Es en esta clase donde realmente se van a crear objetos nuevos para poderlos ir
enlazando en la lista. Por ejemplo, para agregar un estudiante, una vez que tene-
mos los datos (lneas 95: en la pagina 164- 98: en la pagina 164 en el listado 5.17),
procedemos a invocar al metodo agrega de la clase ListaCurso. Este metodo tiene
como argumento un objeto, que es creado en el momento de invocar a agrega
ver lnea 99: en la pagina 164 del listado 5.17. Este es el unico metodo en el que
se crean objetos, y esto tiene sentido, ya que se requiere crear objetos solo cuando
se desea agregar a un estudiante.
Para el caso de los metodos de la clase ListaCurso que regresan una referencia a
un objeto de tipo estudiante, es para lo que se declaro la variable donde lnea 76:
en la pagina 164 del listado 5.17. En estos casos el objeto ya existe, y lo unico que
hay que pasar o recibir son las variables que contienen la referencia.

Codigo 5.17 Menu para el manejo de la lista (MenuLista)1/5

1: import i c c 1 . i n t e r f a z . C o n s o l a ;
2:
3: c l a s s M e n u L i s t a {
4: /
5: R e p o r t a que e l e s t u d i a n t e b u s c a d o no f u e l o c a l i z a d o .
6:
7: @param c o n s OutputStream en e l que s e e s c r i b e
8: @param nombre s u b c a d e n a que no f u e l o c a l i z a d a
9: /
10: static final String blancos =
11: " ";
12: p r i v a t e s t a t i c f i n a l i n t SALIR = 0 ,
13: AGREGAR = 1 ,
14: QUITAR = 2 ,
15: BUSCAR = 3 ,
16: LISTARTODO = 4 ,
17: LISTARALGUNOS = 5 ;
163 Datos estructurados

Codigo 5.17 Menu para el manejo de la lista (MenuLista) 2/5

18: p r i v a t e v o i d r e p o r t a N o ( C o n s o l a cons , S t r i n g nombre ) {
19: c o n s . i m p r i m e l n ( "El estudiante :\n\t" +
20: nombre +
21: "\n No esta en el grupo " ) ;
22: }
23: /
24: P i d e en e l I n p u t S t r e a m e l nombre d e l alumno .
25: @param c o n s e l I n p u t S t r e a m
26: @ r e t u r n E l nombre l e d o
27: /
28: p r i v a t e S t r i n g pideNombre ( C o n s o l a c o n s ) {
29: S t r i n g nombre = c o n s . l e e S t r i n g ( "Dame el nombre del " +
30: " estudiante , empezando por apellido paterno :" ) ;
31: r e t u r n nombre ;
32: }
33: /
34: P i d e en e l I n p u t S t r e a m l a c a r r e r a d e l alumno .
35: @param c o n s e l I n p u t S t r e a m
36: @ r e t u r n La c a r r e r a l e d a
37: /
38: private S t r i n g p i d e C a r r e r a ( Consola cons ) {
39: S t r i n g c a r r e r a = c o n s . l e e S t r i n g ( "Dame una de las " +
40: " carreras :\t" +
41: "Mate\ tComp \ tFisi \ tActu \ tBiol :" ) ;
42: return c a r r e r a ;
43: }
44: / P i d e en e l I n p u t S t r e a m l a c l a v e de a c c e s o d e l alumno .
45: @param c o n s e l I n p u t S t r e a m
46: @ r e t u r n La c l a v e de a c c e s o l e d a
47: /
48: private S t r i n g pideClave ( Consola cons ) {
49: String clave =
50: c o n s . l e e S t r i n g ( "Dame la clave de acceso del " +
51: " estudiante :" ) ;
52: return c l a v e ;
53: }
54: / P i d e en e l I n p u t S t r e a m e l numero de c u e n t a d e l alumno .
55: @param c o n s e l I n p u t S t r e a m
56: @ r e t u r n E l numero de c u e n t a l e d o
57: /
58: private S t r i n g pideCuenta ( Consola cons ) {
59: S t r i n g cuenta =
60: c o n s . l e e S t r i n g ( "Dame el numero de cuenta del" +
61: " estudiante , de 9 dgitos " ) ;
62: return cuenta ;
63: }
5.2 La lista de registros 164

Codigo 5.17 Menu para el manejo de la lista (MenuLista)3/5

64: /
65: Maneja e l menu p a r a e l a c c e s o y m a n i p u l a c i o n de l a b a s e de
66: datos .
67:
68: @param c o n s D i s p o s i t i v o en e l que s e va a i n t e r a c c i o n a r
69: @param miCurso Base de d a t o s con l a que s e va a t r a b a j a r
70: @ r e t u r n l a o p c i o n s e l e c c i o n a d a , d e s p ue s de h a b e r l a e j e c u t a d o
71: /
72: p u b l i c i n t daMenu ( C o n s o l a cons , L i s t a C u r s o miCurso ) {
73: S t r i n g nombre , c u e n t a , c a r r e r a , c l a v e ;
74: S t r i n g subcad ;
75: String registros ;
76: E s t u d i a n t e donde ;
77: int cual ;
78: String scual ;
79: S t r i n g menu = "(0)\t Termina \n " +
80: "(1)\t Agrega \n " +
81: "(2)\t Quita \n " +
82: "(3)\t Busca \n " +
83: "(4)\t Lista todos \n "
84: "(5)\t Lista subconjunto que contenga a ...." ;
85: c o n s . i m p r i m e l n ( menu ) ;
86: int opcion ;
87: S t r i n g s o p c i o n = c o n s . l e e S t r i n g ( " Elige una opcion --> " ) ;
88: o p c i o n = " 012345 " . i n d e x O f ( s o p c i o n ) ;
89: switch ( opcion ) {
90: case SALIR : // S a l i r
91: c o n s . i m p r i m e l n ( " Espero haberte servido .\n" +
92: " Hasta pronto ..." ) ;
93: r e t u r n
1;
94: case AGREGAR : // Agrega E s t u d i a n t e
95: nombre = pideNombre ( c o n s ) ;
96: cuenta = pideCuenta ( cons ) ;
97: c a r r e r a = p i d e C a r r e r a ( cons ) ;
98: c l a v e = pideClave ( cons ) ;
99: miCurso . a g r e g a E s t ( new E s t u d i a n t e ( nombre , c u e n t a ,
100: clave , carrera ) ) ;
101: return 1;
102: case QUITAR : // Q u i t a e s t u d i a n t e
103: nombre = pideNombre ( c o n s ) ;
104: donde = miCurso . b u s c a S u b c a d ( E s t u d i a n t e .NOMBRE, nombre ) ;
105: i f ( donde != n u l l ) {
106: nombre = donde . getNombre ( ) ;
107: miCurso . q u i t a E s t ( nombre ) ;
108: c o n s . i m p r i m e l n ( "El estudiante :\n \t" +
109: nombre + "\n Ha sido eliminado " ) ;
110: }
165 Datos estructurados

Codigo 5.17 Menu para el manejo de la lista (MenuLista) 4/5

111: e l s e r e p o r t a N o ( cons , nombre ) ;
112: return 2;
113: case BUSCAR : // Busca s u b c a d e n a
114: s u b c a d = c o n s . l e e S t r i n g ( "Dame la subcadena a "+
115: " buscar : " ) ;
116: do {
117: s c u a l = cons . l e e S t r i n g (
118: " Ahora dime de cual campo : 1: Nombre "
119: + "2: Cuenta , 3: Carrera , 4: Clave " ) ;
120: c u a l = " 01234 " . i n d e x O f ( s c u a l ) ;
121: i f ( c u a l < 1) {
122: c o n s . i m p r i m e l n ( " Opcion no valida " ) ;
123: }
124: } while ( c ual < 1 ) ;
125: donde = miCurso . b u s c a S u b c a d ( c u a l , s u b c a d ) ;
126: i f ( donde != n u l l ) {
127: c o n s . i m p r i m e l n ( donde . g e t R e g i s t r o ( ) ) ;
128: }
129: else {
130: r e p o r t a N o ( cons , s u b c a d ) ;
131: }
132: return 3;
133: case LISTARTODOS : // L i s t a t o d o s
134: miCurso . l i s t a T o d o s ( c o n s ) ;
135: return 4;
136: case LISTARALGUNOS : // L i s t a con c r i t e r i o
137: s u b c a d = c o n s . l e e S t r i n g ( "Da la subcadena que " +
138: " quieres contengan los " +
139: " registros :" ) ;
140: do {
141: s c u a l = cons . l e e S t r i n g (
142: " Ahora dime de cual campo : 1: Nombre , "
143: + "2: Cuenta , 3: Carrera , 4: Clave " ) ;
144: c u a l = " 01234 " . i n d e x O f ( s c u a l ) ;
145: i f ( c u a l < 1) {
146: c o n s . i m p r i m e l n ( " Opcion no valida " ) ;
147: }
148: } while ( c ual < 1 ) ;
149: miCurso . losQueCazanCon ( cons , c u a l , s u b c a d ) ;
150: return 5;
151: default : // E r r o r , v u e l v e a p e d i r
152: c o n s . i m p r i m e l n ( "No diste una opcion valida .\n " +
153: "Por favor vuelve a elegir ." ) ;
154: return 0;
155: } // s w i t c h
156: } // daMenu
5.2 La lista de registros 166

Codigo 5.17 Menu para el manejo de la lista (MenuLista) 5/5

157: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
158: int opcion ;
159: C o n s o l a c o n s o l a = new C o n s o l a ( ) ;
160: L i s t a C u r s o miCurso = new L i s t a C u r s o ( "4087" ) ;
161: M e n u L i s t a miMenu = new M e n u L i s t a ( ) ;
162: w h i l e ( ( o p c i o n = miMenu . daMenu ( c o n s o l a , miCurso ) ) !=
1);
163: }
164: }

Con esto damos por terminado este captulo. Se dejan como ejercicios las
siguientes mejoras:

Conseguir que al agregar un registro, este se agregue en el lugar que le toca

alfabeticamente.

Si la lista esta ordenada, al buscar a un registro, se sabe que no se encontro en

cuanto se localiza el primer registro con llave mayor a la llave del que se
busca, por lo que se puede hacer la busqueda mas eficiente.
 Herencia
6
En los lenguajes orientados a objetos, la herencia, que conlleva la capacidad
de reutilizar codigo de manera inteligente, es una de las caractersticas mas im-
portantes de este enfoque.

6.1 Extension de clases

Una de las caractersticas mas valiosas en el codigo que hacemos es la posibili-

dad de reutilizarlo, esto es, tomar un codigo que ya trabaja para cierta aplicacion
y usarlo en otra aplicacion parecida pero no identica. En el contexto de lengua-
jes tradicionales esto se logrando copiando aquellas partes del programa que nos
sirven y modificandolas para que se ajusten a nuevas situaciones. Estos mecanis-
mos son, en el mejor de los casos muy laboriosos, y en el peor muy susceptibles a
errores.
Uno de los mayores beneficios de la Orientacion a Objetos es la posibilidad de
extender clases ya construidas construir subclases de tal manera que se pueda
seguir utilizando la clase original en el contexto original, pero se pueda, asimismo,
agregarle atributos a la subclase, redefinir algunos de los metodos para que tomen
en cuenta a los nuevos atributos o agregar metodos nuevos.
La clase original es la superclase con respecto a la nueva; decimos que la
6.1 Extension de clases 168

subclase hereda los atributos y metodos de la superclase. Que herede quiere decir
que, por el hecho de extender a la superclase, tiene al menos todos los atributos
y metodos de la superclase.
Si regresamos por unos momentos a nuestro ejemplo de la base de datos para
listas de cursos, veremos que hay muchas otras listas que se nos ocurre hacer y
que tendran la misma informacion basica. Quitemos la clave de usuario, porque
esa informacion no la necesitan mas que en el centro de computo, y entonces
nuestra clase EstudianteBasico quedara definida como se muestra en el listado 6.1.
Omitimos los comentarios para tener un codigo mas fluido.

Codigo 6.1 Superclase EstudianteBasico 1/2

1: import i c c 1 . i n t e r f a z . C o n s o l a ;
2: /
3: R e g i s t r o b a s i c o p a r a una Base de Datos de e s t u d i a n t e s
4: de l a F a c u l t a d de C i e n c i a s .
5: /
6: c l a s s E s t u d i a n t e B a s i c o {
7: p r i v a t e S t r i n g nombre , c a r r e r a , c u e n t a ;
8: private EstudianteBasico s i g u i e n t e ;
9:
10: s t a t i c p u b l i c f i n a l i n t NOMBRE = 1 ;
11: s t a t i c p u b l i c f i n a l i n t CUENTA = 2 ;
12: s t a t i c p u b l i c f i n a l i n t CARRERA = 3 ;
13:
14: public EstudianteBasico () {
15: nombre = c a r r e r a = c u e n t a = n u l l ;
16: }
17: p u b l i c E s t u d i a n t e B a s i c o ( S t r i n g nmbre , S t r i n g c nta ,
18: String crrera ) {
19: nombre = nmbre . t r i m ( ) ;
20: cuenta = cnta . trim ( ) ;
21: carrera = c r r e r a . trim ( ) ;
22: siguiente = null ;
23: }
24: p u b l i c S t r i n g getNombre ( ) {
25: r e t u r n nombre ;
26: }
27: p u b l i c v o i d setNombre ( S t r i n g nombre ) {
28: t h i s . nombre = nombre ;
29: }
30: public String getCarrera () {
31: return c a r r e r a ;
32: }
169 Herencia

Codigo 6.1 Superclase EstudianteBasico 2/2

33: public void s e t C a r r e r a ( S t r i n g c a r r e ) {
34: carrera = carre ;
35: }
36: public S t r i n g getCuenta () {
37: return cuenta ;
38: }
39: public void setCuenta ( S t r i n g cnta ) {
40: cuenta = cnta ;
41: }
42: public EstudianteBasico getSiguiente () {
43: return s i g u i e n t e ;
44: }
45: public void s e t S i g u i e n t e ( E s t u d i a n t e B a s i c o s i g ) {
46: siguiente = sig ;
47: }
48: public String getRegistro () {
49: r e t u r n nombre . t r i m ()+"\t" +
50: c u e n t a . t r i m ()+"\t" +
51: carrera . trim ( ) ;
52: }
53: p u b l i c S t r i n g getCampo ( i n t c u a l ) {
54: S t r i n g cadena ;
55: switch ( c u a l ) {
56: case E s t u d i a n t e B a s i c o .NOMBRE:
57: c a d e n a = getNombre ( ) . t r i m ( ) . t o L o w e r C a s e ( ) ;
58: break ;
59: case E s t u d i a n t e B a s i c o . CUENTA :
60: cadena = getCuenta ( ) . tr i m ( ) . toLowerCase ( ) ;
61: break ;
62: case E s t u d i a n t e B a s i c o . CARRERA :
63: cadena = g e t C a r r e r a ( ) . tr i m ( ) . toLowerCase ( ) ;
64: break ;
65: default :
66: c a d e n a = " Campo no existente " ;
67: }
68: return cadena ;
69: }
70: p u b l i c v o i d s e t R e g i s t r o ( S t r i n g nmbre , S t r i n g c n ta ,
71: String crrera ) {
72: nombre = nmbre . t r i m ( ) ;
73: cuenta = cnta . trim ( ) ;
74: carrera = c r r e r a . trim ( ) ;
75: }
76: }
6.1 Extension de clases 170

Se nos ocurren distintos tipos de listas que tomen como base a EstudianteBasico.
Por ejemplo, un listado que le pudiera servir a una biblioteca tendra, ademas de la
informacion de EstudianteBasico, los libros en prestamo. Un listado para la Division
de Estudios Profesionales debera tener una historia academica y el primer ano
de inscripcion a la carrera. Un listado para calificar a un grupo debera tener un
cierto numero de campos para las calificaciones. Por ultimo, un listado para las
salas de computo debera contar con la clave de acceso.
En todos los casos que listamos, la informacion original debe seguir estando
presente, as como los metodos que tiene la superclase. Debemos indicar, entonces,
que la clase que se esta definiendo extiende a la superclase, heredando por lo tanto
todos los metodos y atributos de la superclase. La sintaxis en Java se muestra a
continuacion.

Sintaxis:
xsubclase que hereday ::= class xsubclasey extends xsuperclasey {
xdeclaraciones de campos y metodosy
}
Semantica:
La xsubclasey es una nueva declaracion, que incluye (hereda) a todos los
campos de la superclase, junto con todos sus metodos. Las xdeclaraciones
de campos y metodosy se refiere a lo que se desea agregar a la definicion de
la superclase en esta subclase.

Si alguna de las declaraciones hechas en la xsubclasey coincide en tipo o fir-

ma con algo declarado en la xsuperclasey, entonces los campos o metodos de la
superclase quedaran tapados o escondidos (redefinidos) para la xsubclasey.
Pongamos por ejemplo la programacion de una subclase para las listas con cali-
ficaciones. El registro debera contener lo que contiene EstudianteBasico, agregando-
le nada mas lugar para las calificaciones de los examenes.El encabezado de la clase
quedara como se ve en el listado 6.2.

Codigo 6.2 Encabezado para la subclase EstudianteCurso

c l a s s E s t u d i a n t e C u r s o extends E s t u d i a n t e B a s i c o {

A partir de ese momento podemos asumir que EstudianteCurso contiene todos

los campos y metodos que tiene EstudianteBasico. Los unicos metodos que no here-
171 Herencia

da implcitamente son los constructores con parametros. Si existe un constructor

sin parametros, ya sea el que esta por omision o alguno que haya declarado el
programador, este va a ser invocado siempre que se invoque a algun constructor
de la subclase EstudianteCurso. Regresaremos a esto en cuanto programemos los
constructores para la subclase.
Cuando tenemos extension de clases tiene sentido hablar del tipo de acceso que
hemos mencionado muy poco, el acceso protegido (protected). Este tipo de acceso
se usa para cuando queremos que las clases que extienden a la actual puedan tener
acceso a ciertas variables o metodos, ya que funciona como si fuera acceso publico
para las clases que extienden, pero como si fuera privado para las clases ajenas
a la clase actual. Los datos con acceso privado no son accesibles mas que para
la clase actual. El acceso protegido funciona como el privado para clases que no
heredan, y como publico para las clases que heredan.
Cuando un metodo de una superclase tiene un cierto acceso, si se redefine
ese metodo en una subclase el acceso no puede ser restringido. Esto es, si en la
superclase el metodo tena acceso publico, en la subclase debera mantener ese
mismo acceso. Si en la superclase tena acceso de paquete, en la subclase puede
tener acceso de paquete o publico, pero el acceso no puede ser ni protegido ni
privado.

6.2 Arreglos

En esta seccion estudiaremos estructuras repetitivas de datos, organizados

como vectores, matrices, etc.

6.2.1. Arreglos de una dimension

Podemos pensar en las calificaciones de cada estudiante como un vector,

calif0 , calif1 , . . . , calif14

donde estamos asumiendo que cada estudiante tiene lugar para, a lo mas, 15
calificaciones (del 0 al 14). Se ve, asimismo, muy util el poder manejar a cada una
de las calificaciones refiriendonos a su subndice, en lugar de declarar calif0, calif1,
etc., imitando el manejo que damos a los vectores en matematicas.
6.2 Arreglos 172

Es importante notar que lo que tenemos es una coleccion de datos del mismo
tipo que se distinguen uno de otro por el lugar que ocupan. A estas colecciones les
llamamos en programacion arreglos. La declaracion de arreglos tiene la siguiente
sintaxis:

Sintaxis:
xdeclaracion de arregloy ::= xtipoy[ ] xidentificadory;
Semantica:
Se declara una variable que va a ser una referencia a un arreglo de objetos
o datos primitivos del tipo dado.
Veamos algunos ejemplos:
int [ ] arregloDeEnteros ; // Arreglo de enteros
EstudianteBasico [ ] estudiantes ; // Arreglo de objetos del tipo
// EstudianteBasico.
float [ ] vector ; // Arreglo de reales.
String [ ] cadenas; // Arreglo de cadenas

Noten como en la declaracion no estamos diciendo el tamano del arreglo. Esto

es porque en este momento Java no tiene por que saber el numero de elementos,
ya que lo unico que esta reservando es una variable donde guardar la referencia
de donde quedara, en el heap, el arreglo.
Podemos en la declaracion de los arreglos determinar el tamano que van a
tener. Lo hacemos como en las cadenas, inicializando el arreglo en el momento de
declararlo, proporcionando una lista de los elementos que queremos en el arreglo.
En ese caso, el tamano del arreglo quedara fijado al numero de elementos que se
de en la lista. La sintaxis para este tipo de declaracion es:

Sintaxis:
xdeclaracion de arreglos con inicializaciony ::=
xtipoy[ ] xidentificadory = { xlistay };
Semantica:
Para inicializar el arreglo se dan, entre llaves, valores del tipo del arreglo,
separados entre s por coma. El arreglo tendra tantos elementos como apa-
rezcan en la lista, y cada elemento estara creado de acuerdo a la lista. En
el caso de un arreglo de objetos, la lista debera contener objetos que ya
existen, o la creacion de nuevos mediante el operador new.

Extendamos los ejemplos que acabamos de dar a que se inicialicen en el mo-

mento de la declaracion:
173 Herencia

Arreglo de enteros con 5 elementos, todos ellos enteros. Corresponden a los

primeros 5 numeros primos.

int [ ] primos = {2,3,5,7,11};

Arreglo de reales con tres elementos.

float [ ] vector = { 3.14, 8.7, 19.0 };

Arreglo de dos cadenas, la primera de ellas con el valor S y la segunda

con el valor No.

String [ ] cadenas = { "S", "No"};

Arreglo de objetos del tipo EstudianteBasico con tres elementos, el primero

y tercero con el constructor por omision y el segundo con los datos que se
indican.

E s t u d i a n t e B a s i c o paco =
new E s t u d i a n t e ( "Paco" ,
" 095376383 " ,
"Compu" ) ;

EstudianteBasico [ ] estudiantes =
{new E s t u d i a n t e ( ) ,
paco ,
new E s t u d i a n t e ( )
};
Veamos en las figuras 6.1 a 6.3 a continuacion como se crea el espacio para los
arreglos que se mostraron arriba. En los esquemas marcamos las localidades de
memoria que contienen una referencia con una @en la esquina superior izquier-
da. Esto quiere decir que su contenido es una direccion en el heap. Las localidades
estan identificadas con rectangulos. El numero que se encuentra ya sea inmedia-
tamente a la izquierda o encima del rectangulo corresponde a la direccion en el
heap.
6.2 Arreglos 174

Figura 6.1 int[ ] primos = {2,3,5,7,11};

MEMORIA 1000 1004 1008 1012 1016

2 3 5 7 11
r [0] [1] [2] [3] [4]
primos 1000
HEAP

Figura 6.2 float [ ] vector = { 3.14, 8.7, 19.0};

vector @ 2124 2124 2130 2136

3,14 8,7
19,0
[0] [1] [2]

MEMORIA HEAP

Figura 6.3 String [ ] cadenas = { S, No};

3826
Si
2784
@ 3826
r0s
@
@ 4218
r1s 4218
2784
No

MEM HEAP
175 Herencia

Figura 6.4 Declaracion del contenido de un arreglo de objetos

1500 1506 1512

@ null @ null @ null
@ = referencia
1820 1826 1832
@ null @ null @ null

1020
@ [0]
1500
@ 2054 2060 2066
1026 2054 [1] @4020 @5100 @3200
1032
@ [2]
1820

3200
Compu

4020
estudiantes @1020
Paco

5100
095376383
looooooooooooooooooooooooooooooooooooooomooooooooooooooooooooooooooooooooooooooon

MEM HEAP

EstudianteBasico [ ] estudiantes = {%
new E s t u d i a n t e ( ) ,
new E s t u d i a n t e ( "Paco" , " 095376383 " , "Compu" ) ,
new E s t u d i a n t e ( ) } ;

La manera normal de darle tamano a un arreglo es creandolo, con el enun-

ciado new y especificando el numero de elementos que va a tener el arreglo. En
este caso las referencias a objetos se inicializan en null mientras que los datos
numericos se inicializan en 0 (cero). La sintaxis precisa se da a continuacion.
6.2 Arreglos 176

Sintaxis:
xdeclaracion de un arreglo con tamano dadoy ::=
xtipoy xidentificadory = new xtipoy[xexpresion enteray];
Semantica:
Se inicializa la referencia a un arreglo de referencias en el caso de objetos,
o de datos en el caso de tipos primitivos.

Si los ejemplos que dimos antes los hubieramos hecho sin la inicializacion seran:

1: i n t [ ] p r i m o s = new i n t [ 5 ] ;
2: E s t u d i a n t e B a s i c o [ ] e s t u d i a n t e s = new E s t u d i a n t e B a s i c o [ 3 ] ;
3: f l o a t [ ] v e c t o r = new f l o a t [ 3 ] ;
4: S t r i n g [ ] c a d e n a s = new S t r i n g [ 2 ] ;

y los esquemas de su organizacion en memoria quedara como se muestra en las

figuras 6.5 a 6.8.
La creacion de los arreglos en la modalidad que estamos presentando no
tiene por que darse en la declaracion, sino que, como con cualquier otro dato,
ya sea este primitivo u objeto, se puede hacer como un enunciado de asignacion
comun y corriente. Lo unico que hay que tener en mente es que a una misma
referencia se le pueden asignar distintos espacios en el heap.

Figura 6.5 int [ ] primos = new int[5];

1000 1004 1008 1012 1016

primos @ 1000 0 0 0 0 0
r0s r1s r2s r3s r4s

MEMORIA HEAP
177 Herencia

Figura 6.6 EstudianteBasico [ ] estudiantes = new EstudianteBasico[3];

5124 5130 5136

estudiantes @ 5124 @null @null @null
r0s r1s r2s
MEMORIA HEAP

Figura 6.7 float [ ] vector = float [3];

2134 2140 2146

vector @ 2134 0,0 0,0 0,0
r0s r1s r2s
MEMORIA HEAP

Figura 6.8 String [ ] cadenas = new String[2];

27844 27850
cadenas @ 27844 @null @null
r0s r1s
MEMORIA HEAP

Uso de los elementos de un arreglo

En el caso de los arreglos de una dimension, para usar a un elemento del arreglo
debemos seleccionarlo, de manera similar a como seleccionamos a un atributo o
metodo de un objeto. Mientras que en el caso de los objetos se utiliza el operador
punto (.), en el caso de los arreglos de una dimension se usa el operador r s, cuya
sintaxis es:
6.2 Arreglos 178

Sintaxis:
xseleccion de un elemento de un arregloy ::=
xid. de arregloy [ xexpresion enteray ]
Semantica:
El operador r s es el de mayor precedencia de entre los operadores de Java.
Eso indica que evaluara la expresion dentro de ella antes que cualquier otra
operacion (en la ausencia de parentesis). Una vez obtenido el entero corres-
pondiente a la xexpresion enteray que pudiera ser una constante entera
procedera a elegir al elemento con ese ndice en el arreglo. El resultado
de esta operacion es del tipo de los elementos del arreglo. De no existir el
elemento al que corresponde el ndice calculado, el programa abortara con
el mensaje ArrayIndexOutOfBoundsException. Al primer elemento del arre-
glo le corresponde siempre el ndice 0 (cero) y al ultimo elemento el ndice
n
1, donde el arreglo se creo con n elementos.
Es importante apreciar que el tamano de un arreglo no forma parte del tipo.
Lo que forma parte del tipo es el numero de dimensiones (vector, matriz, cubo,
. . . ) y el tipo de sus elementos.

Los arreglos son estructuras de datos estaticas

Cuando decimos que un arreglo no puede cambiar de tamano una vez creado,
nos estamos refiriendo al espacio asignado en el heap. Sin embargo, es perfecta-
mente valido que una misma referencia apunte a un arreglo de un cierto tamano,
para pasar despues a apuntar a uno de otro tamano. Supongamos, por ejemplo,
que tenemos la siguiente secuencia de enunciados:
1: int [ ] enteros ;
2: ...
3: e n t e r o s = new i n t [ 5 ] ;
4: int i = 0;
5: while ( i < 5) {
6: e n t e r o s [ i ] = ( i + 1) 2 ;
7: i ++;
8: }
9: e n t e r o s = new i n t [ 9 ] ;
La secuencia de pasos que se dan durante la ejecucion se puede observar en la
figura 6.9 en la pagina opuesta. El numero entre parentesis a la izquierda de cada
subesquema corresponde al numero de instruccion que se termino de ejecutar.
179 Herencia

Figura 6.9 Reasignacion de arreglos

p1q
enteros @ null

p5q
1260 1264 1268 1272 1276
enteros @ 1260
2 4 6 8 10
[0] [1] [2] [3] [4]
p6q
enteros @ 2580
2580 2584 2588 2592 2596 2600 2604 2608 2612 2616
r0s 0 0 0 0 0 0 0 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]

Como se puede observar en esta figura, el arreglo que se crea en la lnea 3 del
codigo no es el mismo que el que se crea en la lnea 7: no se encuentran en la
misma direccion del heap, y no contienen lo mismo. Insistimos: no es que haya
cambiado el tamano del arreglo, sino que se creo un arreglo nuevo.

6.2.2. Iteracion enumerativa

En el codigo que acabamos de presentar utilizamos una iteracion que no

habamos visto (pero que se entiende que hace) y que es una de las formas de
iteracion mas comun en los lenguajes de programacion. Como el ttulo de esta
seccion lo indica, se utiliza para hacer un recorrido asociado a un tipo discreto y
que se pueda numerar (podramos utilizar tambien caracteres). La sintaxis general
de este enunciado se da en el cuadro que sigue.
6.2 Arreglos 180

Sintaxis:
xenunciado de iteracion enumerativay ::=
for ( xenunciado de inicializaciony ;
xexpresion booleanay ;
xlista de enunciadosy )
xenunciado simple o compuestoy
Semantica:
En la ejecucion va a suceder lo siguiente:
1. Se ejecuta el xenunciado de inicializaciony.
2. Se evalua la xexpresion booleanay.
a) Si es verdadera, se continua en el paso 3.
b) Si es falsa, se sale de la iteracion.
3. Se ejecuta el xenunciado simple o compuestoy.
4. Se ejecuta la xlista de enunciadosy.
5. Se regresa al paso 2.
Cualquiera de las tres partes puede estar vaca, aunque el ; s tiene que
aparecer. En el caso de la primera y tercera parte, el que este vaco indica
que no se hace nada ni al inicio del enunciado ni al final de cada iteracion.
En el caso de una xexpresion booleanay, se interpreta como la constante
true.

Vimos ya un ejemplo sencillo del uso de un while para recorrer un arreglo uni-
dimensional. Sin embargo, para este tipo de tareas el for es el enunciado indicado.
La misma iteracion quedara de la siguiente forma:
1: int [ ] enteros ;
2: ...
3: e n t e r o s = new i n t [ 5 ] ;
4: f o r ( i n t i = 0 ; i < 5 ; i++ ) {
5: e n t e r o s [ i ] = ( i + 1) 2 ;
6: }

Hay una pequena diferencia entre las dos versiones. En el caso del for, la varia-
ble i es local a el, mientras que en while tuvimos que declararla fuera. En ambos
casos, sin embargo, esto se hace una unica vez, que es el paso de inicializacion.
Otra manera de hacer esto con un for, usando a dos variables enumerativas,
una para i y otra para i + 1, pudiera ser como sigue:
181 Herencia

1: int [ ] enteros ;
2: ...
3: e n t e r o s = new i n t [ 5 ] ;
4: f o r ( i n t i = 0 , j = 1 ; i < 5 ; i ++, j ++) {
5: enteros [ i ] = j 2;
6: }
Del ejemplo anterior hay que notar que tanto i como j son variables locales al
for; para que esto suceda se requiere que la primera variable en una lista de este
estilo aparezca declarada con su tipo, aunque la segunda (tercera, etc.) variable no
debe aparecer como declaracion. Si alguna de las variables esta declarada antes y
fuera del for aparecera el mensaje de que se esta repitiendo la declaracion, aunque
esto no es correcto. Lo que s es valido es tener varios fors, cada uno con una
variable local i.
Por supuesto que el xenunciado simple o compuestoy puede contener o consistir
de, a su vez, algun otro enunciado for o while o lo que queramos. La ejecucion va
a seguir el patron dado arriba, terminando la ejecucion de los ciclos de adentro
hacia afuera.

EJEMPLO 6.2.7
Supongamos que queremos calcular el factorial de un entero n que nos pa-
san como parametro. El metodo podra estar codificado como se muestra en el
codigo 6.3.

Codigo 6.3 Calculo de n!

p u b l i c long f a c t o r i a l ( i n t n ) {
long f a c t = 1 ;
f o r ( i n t i = 2 ; i <= n ; i ++) {
fact = fact i ;
}
return f a c t ;
}

EJEMPLO 6.2.8
Supongamos ahora que queremos tener dos variables para controlar la itera-
cion, donde la primera nos va a decir en cual iteracion va (se incrementa de 1 en
6.2 Arreglos 182

1) y la segunda se calcula sumandose uno al doble de lo que lo que llevaba. El

encabezado del for sera:
f o r ( i n t i =1, j =1; i <= 8 && j < 2 0 0 ; i ++, j = 2 j + 1 ) {
c o n s . i m p r i m e l n ( "i=\t" + i + "\tj =\t" + j ) ;
}

En este ejemplo tenemos dos inicializaciones simultaneas y dos enunciados de

iteracion que se ejecutan al final del bloque, antes de regresar a volver a iterar.
Lo que escribira este segmento de programa es lo siguiente:

i= 1 j= 1
i= 2 j= 3
i= 3 j= 7
i= 4 j= 15
i= 5 j= 31
i= 6 j= 63
i= 7 j= 127

Cuando i vale 8, se deja de cumplir la expresion booleana i 8&&j 200. Al

terminar la iteracion donde escribe . . . j  127, inmediatamente despues, antes de
regresar al encabezado, calcula j  j  2 1  255, que ya no cumple la expresion
booleana, por lo que ya no vuelve a entrar para i  8.
Es conveniente mencionar que en el encabezado que acabamos de ver se decla-
ran dos variables, i y j que solo van a ser reconocidas dentro del cuerpo del for.
Regresaremos mas adelante a utilizar este enunciado. Sin embargo, recomendamos
que cuando la expresion booleana no sea numerica o no tenga que ver con relacio-
nes entre enteros, mejor se use alguna de las otras iteraciones que presentamos.
Si estuvieramos en un lenguaje de programacion que unicamente tuviera la
iteracion while, el codigo sera como se muestra en el listado 6.4.

Codigo 6.4 Codificacion de iteracion for con while

int i = 1 ,
j = 1; / I n i c i a l i z a c i o n /
w h i l e ( i <= 8 && j < 2 0 0 ) { / e x p r e s i o n b o o l e a n a /
c o n s . i m p r i m e l n ( "i=\t" + i "\tj = " + j ) ; / c u e r p o /
i ++; / e n u n c i a d o s de i t e r a c i o n /
j j 2 + 1 ; / e n u n c i a d o s de i t e r a c i o n /
} // w h i l e
183 Herencia

EJEMPLO 6.2.9
Podemos tener iteraciones anidadas, como lo dice la descripcion de la sintaxis.
Por ejemplo, queremos producir un triangulo con la siguiente forma:

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8 9

En este caso debemos recorrer renglon por renglon, y en cada renglon reco-
rrer tantas columnas como renglones llevamos en ese momento. El codigo para
conseguir escribir esto se encuentra en el listado 6.5.

Codigo 6.5 Construccion de un triangulo de numeros

f o r ( i n t i = 1 ; i <= 9 ; i ++) { / r e c o r r e l o s r e n g l o n e s /
f o r ( j = 1 ; j <= i ; j ++) { / r e c o r r e l a s c o l u m n a s /
c o n s . i m p r i m e ( j + "\t" ) ; / e s c r i b e e l v a l o r de l a /
/ columna , s i n t e r m i n a r /
/ e l r e n g l o n . /
}
cons . imprimeln ( ) ; / cambia de r e n g l o n /
}

Conforme resolvamos mas problemas utilizaremos todo tipo de iteraciones y

aprenderemos a elegir la mas apropiada para cada caso.

6.2.3. Arreglos de mas de una dimension

Es obvio que podemos necesitar arreglos de mas de una dimension, como por
ejemplo matrices. Para Java los arreglos de dos dimensiones son arreglos de arre-
6.2 Arreglos 184

glos, y los de tres dimensiones son arreglos de arreglos de arreglos, y as su-

cesivamente. La declaracion se hace poniendo tantas parejas de corchetes como
dimensiones queramos en un arreglo, como se puede ver a continuacion.
int [ ] [ ] matriz ; // 2 d i m e n s i o n e s : m a t r i z
EstudianteBasico [ ] [ ] [ ] f a c u l t a d ; // 3 d i m e n s i o n e s : cubo
Por la manera en que maneja Java los arreglos, si quiero inicializar un arreglo,
por ejemplo, de dos dimensiones, tendre que darle entre llaves las inicializaciones
para cada uno de los renglones:
int [ ] [ ] matriz = {{2 ,2 ,3 ,3} ,{3 ,4 ,5} ,{8}};
Reconocemos inmediatamente tres sublistas encerradas entre llaves, lo que
indica que el arreglo matriz tiene tres renglones. Cada uno de los renglones tiene
tamano distinto, y esto se vale, pues siendo un arreglo de arreglos, cada uno de los
arreglos en la ultima dimension puede tener el numero de elementos que se desee.
Un esquema de como quedaran en memoria se puede ver en la figura 6.10.

Figura 6.10 Acomodo en memoria de un arreglo de dos dimensiones

2128 2134 2140 2146 2152

2 2 3 3
[0] [1] [2] [3]

@ 3600 3200 3206 3212

1730 [0]
@ 3200 3 4 5
1736 [1]
matriz @ 1730 @ 2128
[0] [1] [2]
1742 [2]
3600
8
[0]
looooooooooooooooooooooooooooooooooooooooomooooooooooooooooooooooooooooooooooooooooon
MEM H E A P

Podemos, para un arreglo de 3 dimensiones, tener la siguiente sucesion de

enunciados:
185 Herencia

i n t [ ] [ ] [ ] cubos ;
c u b o s = new i n t [ 3 ] [ ] [ ] ;
c u b o s [ 0 ] = new i n t [ 6 ] [ ] ;
c u b o s [ 1 ] = new i n t [ 3 ] [ 3 ] ;
c u b o s [ 2 ] = new i n t [ 2 ] [ ] ;

y tendramos un arreglo de 3 dimensiones; en la primera tenemos tres elementos:

el primer elemento es un arreglo de 6 arreglos, aunque no sabemos todava de
que tamano es cada uno de los 6 arreglos; el segundo elemento es un arreglo de
tres arreglos de tres elementos; el tercer elemento es un arreglo de dos arreglos y
no sabemos cuantos elementos en cada arreglo.
Como podemos tener tambien variables o expresiones enteras que nos den el
tamano de un arreglo, es importante que en cualquier momento podamos saber el
tamano de alguna de las dimensiones del mismo. Para eso, la clase que corresponde
a los arreglos tiene una variable length que nos regresa el tamano del arreglo.
Por ejemplo, para los enunciados que acabamos de hacer, cubos[0].length es 6,
cubos[1][1].length es 3 y cubos[2].length es 2.
Resumiendo, los arreglos en Java tienen las siguientes caractersticas:
(a) Un arreglo es un objeto. Esto quiere decir que cuando declaramos un arreglo
simplemente estamos reservando espacio en memoria para la referencia, la
direccion en el heap donde se encontraran los elementos del arreglo.
(b) Es una estructura de datos estatica: una vez dado su tamano, el arreglo no
puede achicarse o agrandarse.
(c) Podemos tener arreglos del numero de dimensiones y del tipo que queramos.
(d) Los arreglos son estructuras de datos homogeneas, porque todos sus elementos
son del mismo tipo.
(e) Los arreglos de dos dimensiones no tienen por que tener el mismo numero de
elementos en cada renglon del arreglo.Esto se extiende en todas las dimensio-
nes que tenga el arreglo.

Uso de arreglos de dos o mas dimensiones

De manera similar a como lo hacemos en arreglos de una dimension, podemos
seleccionar a un elemento de un arreglo de mas de una dimension dando una
expresion entera para cada una de las dimensiones. Los elementos se van eligiendo
de izquierda a derecha, en el mismo orden en que fueron creados. No hay que
perder de vista que en el caso de Java una matriz es un arreglo de arreglos, y
por la manera en que los representa internamente se puede dar un error de ndice
en cualquiera de las dimensiones, por lo que es importante mantener presente
la construccion del arreglo cuando se seleccionan elementos dentro de el. Las
primeras k
1 dimensiones, si se selecciona a un elemento de ellos, obtendremos
6.2 Arreglos 186

una referencia a arreglos; es unicamente en la ultima dimension (la del extremo

derecho) donde obtendremos ya un elemento del tipo dado para el arreglo.

6.2.4. Los arreglos como parametros o valor de regreso de un metodo

En algunos otros lenguajes el paso de arreglos como parametros es realmen-

te complicado. Afortunadamente, por el manejo de arreglos que tiene Java (de
guardar las referencias nada mas) este aspecto es muy sencillo en este lenguaje.
Para pasar un arreglo como parametro, unicamente hay que indicarle a Java el
numero de dimensiones que debera tener el argumento, y el tipo de los elementos.
Esto es necesario porque tiene que saber cuantos brincos tiene que dar, a traves de
las listas de referencias, para encontrar a los elementos solicitados. Por ejemplo,
en el Listado 6.6 en la pagina opuesta, en la lnea 7: se indica que se van a pasar
dos arreglos de enteros como argumentos, cada uno de ellos de dos dimensiones;
mientras que en la lnea 22: (del mismo listado) se indica que los argumentos seran
dos arreglos de enteros, cada uno de una dimension. No se puede especificar el
tamano de una dimension en un parametro, pues el tipo del parametro tiene que
ver nada mas con el tipo de los elementos y el numero de dimensiones; lo que
hay que especificar para cada parametro de un metodo es, unicamente, el tipo
del parametro. Lo mismo sucede con el valor que regresa un metodo: unicamente
hay que especificar el tipo del valor que regresa el metodo, que en el caso de los
arreglos, repetimos una vez mas, consiste del tipo de los elementos y el numero de
dimensiones. El metodo suma en la lnea 7: regresa un arreglo de enteros de dos
dimensiones, mientras que el metodo con el mismo nombre suma de la lnea 22:
regresa un arreglo de enteros de una dimension.
Cuando se pasa un arreglo como argumento (en el momento de invocar al
metodo) tenemos que pasar el nombre de lo que espera el metodo. Por ejemplo,
en el Listado 6.6 en la pagina opuesta, podemos ver las invocaciones a los metodos
que se llaman suma. La primer invocacion es en la lnea 41: y se le pasan como
argumentos los identificadores uno y dos, que estan declarados como arreglos de
enteros de dos dimensiones, que coincide con el tipo de los parametros.
La otra invocacion esta en la lnea 12:, dentro del metodo cuya firma es su-
ma(int[][],int[][]). En este caso le estamos pasando al metodo dos arreglos de en-
teros, cada uno de una dimension. Como Java maneja los arreglos a traves de
referencias y vectores de referencias (como ya vimos), se le pasa simplemente una
de las referencias (de la primera dimension) a uno de los arreglos de una dimen-
sion. Cuando en Java declaramos una matriz, en realidad estamos construyendo
un arreglo en el que cada elemento es un arreglo; cuando declaramos un cubo, es-
187 Herencia

tamos declarando un arreglo en el que cada elemento es un arreglo en el que cada

elemento es un arreglo en el que cada elemento es un entero; y as sucesivamente.

Codigo 6.6 Arreglos como parametros y valor de regreso de una funcion 1/2

1: p u b l i c c l a s s A r r e g l o s {
2: /
3: Suma d os a r r e g l o s de do s d i m e n s i o n e s .
4: @param Los a r r e g l o s
5: @ r e t u r n e l a r r e g l o que c o n t i e n e a l a suma
6: /
7: p u b l i c i n t [ ] [ ] suma ( i n t [ ] [ ] A , i n t [ ] [ ] B) {
8: i n t min1 = Math . min (A . l e n g t h , B . l e n g t h ) ;
9: i n t [ ] [ ] laSuma = new i n t [ min1 ] [ ] ;
10: / I n v o c a m o s a q u i e n s a b e sumar a r r e g l o s de una d i m e n s i o n /
11: f o r ( i n t i =0; i <min1 ; i ++) {
12: laSuma [ i ] = suma (A [ i ] , B [ i ] ) ;
13: } // end o f f o r ( ( i n t i =0; i <min1 ; i ++)
14:
15: r e t u r n laSuma ;
16: } // f i n suma ( i n t [ ] [ ] , i n t [ ] [ ] )
17: /
18: Suma d o s a r r e g l o s de una d i m e n s i o n
19: @param Dos a r r e g l o s de una d i m e n s i o n
20: @ r e t u r n Un a r r e g l o con l a suma
21: /
22: p u b l i c i n t [ ] suma ( i n t [ ] A , i n t [ ] B) {
23: i n t tam = Math . min (A . l e n g t h , B . l e n g t h ) ;
24:
25: i n t [ ] r e s u l t = new i n t [ tam ] ;
26: f o r ( i n t i =0; i <tam ; i ++) {
27: r e s u l t [ i ] = A[ i ] + B[ i ] ;
28: }
29: return r e s u l t ;
30: } // f i n suma ( i n t [ ] , i n t [ ] )
31: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
32: C o n s o l a c o n s = new C o n s o l a ( ) ;
33: / Los d o s a r r e g l o s a sumar /
34: i n t [ ] [ ] uno = { { 3 , 4 , 5 } , { 2 , 8 , 7 , 5 } , { 3 , 4 , 7 } } ;
35: i n t [ ] [ ] dos = { { 8 , 4 , 2 , 1 } , { 8 , 7 , 2 , 3 } , { 4 , 3 , 5 , 1 } } ;
36: / A r r e g l o p a r a g u a r d a r l a suma /
37: i n t [ ] [ ] miSuma ;
6.3 Aspectos principales de la herencia 188

Codigo 6.6 Arreglos como parametros y valor de regreso de una funcion 2/2
38: / O b j e t o p a r a p o d e r u s a r l o s metodos /
39: A r r e g l o s p r u e b i t a = new A r r e g l o s ( ) ;
40: / I n v o c a c i o n a l a suma de d os m a t r i c e s /
41: miSuma = p r u e b i t a . suma ( uno , do s ) ;
42: / I m p r e s i o n de l o s r e s u l t a d o s /
43: f o r ( i n t i =0; i <miSuma . l e n g t h ; i ++) {
44: f o r ( i n t j =0; j <miSuma [ i ] . l e n g t h ; j ++) {
45: c o n s . i m p r i m e ( miSuma [ i ] [ j ]+"\t" ) ;
46: } // end o f f o r ( i n t j =0; j <miSuma [ i ] . l e n g t h ; j ++)
47: cons . imprimeln ( ) ;
48: } // end o f f o r ( i n t i =0; i <miSuma . l e n g t h ; i ++)
49: } // f i n main ( )
50: }

El resultado de la invocacion de esta clase se puede ver en la Figura 6.11.

Figura 6.11 Ejecucion de la clase Arreglos

11 8 7
10 15 9 8
7 7 12

En el listado anterior se pregunta por el tamano de cada arreglo que se va

a manejar para no abortar el programa por ndices invalidos (aborta dando el
mensaje ArrayindexOutOfBoundsException). Queda pendiente el uso de los arreglos.
Cuando hay que construirlos y cuando no? Por ejemplo, en la lnea 9: se construye
la primera dimension, pero la segunda no, y en la lnea 25: tambien se construye
el arreglo. Esto se debe a que en el primer caso el i-esimo renglon aparece del
lado izquierdo de una asignacion (lnea 12:) y lo mismo sucede con cada uno de
los elementos en la lnea 27: para los elementos del arreglo result. Sin embargo, en
la lnea 12: no se dice cuantos elementos va a tener la segunda dimension, porque
cuando suma regrese la referencia a un arreglo de una dimension, esta referencia
se copiara en el lugar correspondiente (el arreglo de referencias de la primera
dimension). Lo mismo sucede en la lnea 41:, donde al regresar el metodo a un
arreglo de dos dimensiones, como lo que esta regresando es una referencia, esta
simplemente se copia.
Con esto damos por terminado el tema de arreglos, que tienen un manejo muy
uniforme y flexible en Java.
189 Herencia

6.3 Aspectos principales de la herencia

Regresamos a hablar mas sobre la herencia en lenguajes orientados a objetos,
que es una de las caractersticas mas importantes de esta clase de lenguajes de
programacion.

6.3.1. Super y subclases

Tenemos ya las herramientas necesarias para hacer las declaraciones de nues-
tras subclase, as que proseguiremos donde nos quedamos en la seccion 6.1 en la
pagina 167, que era en la declaracion de un arreglo para guardar las calificacio-
nes del estudiante. Tambien desarrollaremos el constructor de la subclase ver
listado 6.7. Cuando se crea un objeto cuyo tipo es una subclase, lo primero que
hace el objeto es invocar al constructor sin parametros de la superclase. Si no
hay tal porque hayamos declarado constructores con parametros nada mas
el constructor de la subclase debera llamar explcitamente a algun constructor
de la superclase. Esto se hace con el identificador super seguido por la lista de
argumentos entre parentesis.
Supongamos, por ejemplo, que el numero de calificaciones que deseamos guar-
dar para un estudiante dado depende del curso que este tomando. Entonces, la
creacion del arreglo de calificaciones se hara en el constructor, como se puede ver
en el listado 6.7.

Codigo 6.7 Campos y constructor de EstudianteCurso

1: c l a s s E s t u d i a n t e C u r s o extends E s t u d i a n t e B a s i c o {
2: float [ ] c a l i f s ;
3: / C o n s t r u c t o r .
4: @params S t r i n g nombre E l nombre d e l e s t u d i a n t e .
5: @params S t r i n g c u e n t a Numero de c u e n t a .
6: @params S t r i n g c a r r e r a La c a r r e r a en l a que e s t a i n s c r i t o .
7: @params i n t n u m C a l i f s Numero de c a l i f i c a c i o n e s que vamos a
8: guardar para e l e s t u d i a n t e .
9: /
10: p u b l i c E s t u d i a n t e C u r s o ( S t r i n g nombre , S t r i n g c u e n t a ,
11: String carrera , int numCalifs ) {
12: super ( nombre , c u e n t a , c a r r e r a ) ;
13: c a l i f s = new f l o a t [ n u m C a l i f s ] ;
14: f o r ( i n t i =0; i < n u m C a l i f s ; i ++) c a l i f s [ i ] = 0 ;
15: }
6.3 Aspectos principales de la herencia 190

Una vez hecho y entendido el constructor, se agregan toda clase de metodos

que manejan a la parte que se extendio en la subclase. La mayora de los meto-
dos nuevos unicamente manipulan al nuevo campo, por lo que no tienen nada
merecedor de atencion ver listado 6.8.

Codigo 6.8 Metodos nuevos para la subclase EstudianteCurso

16: / R e g r e s a l a s c a l i f i c a c i o n e s que t i e n e e l e s t u d i a n t e .
17: @ r e t u r n s i n t [ ] un a r r e g l o con l a s c a l i f i c a c i o n e s .
18: /
19: public float [ ] g e t C a l i f s () {
20: return c a l i f s ;
21: }
22: / R e g r e s a una d e t e r m i n a d a c a l i f i c a c i o n .
23: @params i n t i R e g r e s a r l a i
e s i m a c a l i f i c a c i o n .
24: @ r e t u r n s f l o a t c a l i f s [ i ] . /
25: public float g e t C a l i f s ( int i ) {
26: i f ( ( i >= 0 ) && ( i < c a l i f s . l e n g t h ) ) return c a l i f s [ i ] ;
27: e l s e r e t u r n
1;
28: }
29: / Pone una d e t e r m i n a d a c a l i f i c a c i o n .
30: @params i n t i E l l u g a r de l a c a l i f i c a c i o n .
31: @params f l o a t x La c a l i f i c a c i o n .
32: /
33: public void s e t C a l i f ( i n t i , f l o a t x ) {
34: i f ( i >= 0 && i < c a l i f s . l e n g t h ) {
35: califs [ i ] = x;
36: }
37: }
38: / Da e l p r o m e d i o d e l e s t u d i a n t e .
39: @re t urns f l o a t El promedio
40: /
41: public f l o a t getPromedio () {
42: f l o a t suma = 0 ;
43: f o r ( i n t i = 0 ; i < c a l i f s . l e n g t h ; i ++) {
44: suma += c a l i f s [ i ] ;
45: }
46: r e t u r n suma / c a l i f s . l e n g t h ;
47: }

El unico metodo interesante es getRegistro, ya que existe un metodo con la

misma firma en la superclase. El efecto de declarar un metodo en la subclase con
la misma firma que el de la superclase es que, de hecho, se esconde el metodo de
la superclase. Cualquier uso que se quiera dar a ese metodo dentro de la subclase
tendra que ser identificado por el prefijo super seguido de un punto observese la
191 Herencia

lnea 62 del listado 6.9.

Codigo 6.9 Redefinicion del metodo getRegistro()

48: /
49: V a c a e l r e g i s t r o . E s t e metodo u t i l i z a a l de l a s u p e r c l a s e
50: p a r a d a r l e p a r t e de l a cadena , y d e s p ue s c o m p l e t a con l a s
51: calificaciones .
52: @ r e t u r n s S t r i n g l a c a d e n a que c o n t i e n e a l r e g i s t r o
53: /
54: public String getRegistro () {
55: S t r i n g c a d e n a = super . g e t R e g i s t r o ( ) ;
56: f o r ( i n t i = 0 ; i < c a l i f s . l e n g t h ; i ++) {
57: i f ( i % 5 == 0 ) c a d e n a += "\n" ;
58: // Cambia de r e n g l o n cada 5
59: c a d e n a += c a l i f s [ i ] + "\t" ;
60: }
61: return cadena ;
62: }

6.4 Polimorfismo

Una de las grandes ventajas que nos ofrece la herencia es el poder manipu-
lar subclases a traves de las superclases, sin que sepamos concretamente de cual
subclase se trata. Supongamos, para poner un ejemplo, que declaramos otra sub-
clase de EstudianteBasico que se llama EstudianteBiblio y que de manera similar
a como lo hicimos con EstudianteCurso extendemos adecuadamente y redefinimos
nuevamente el metodo getRegistro(). Podramos tener el codigo que sigue:
1: EstudianteBasico [ ] estudiantes = {
2: new E s t u d i a n t e C u r s o ( " Pedro ,. . . )
3: new EstudianteBiblio (. . . )
4: };
En estas lneas declaramos un arreglo con dos elementos del tipo Estudiante-
Basico, donde el primero contiene a un EstudianteCurso mientras que el segundo
contiene a un EstudianteBiblio. Como las subclases contienen todo lo que contiene
la superclase, y como lo que guardamos son referencias, podemos guardar en un
arreglo de la superclase elementos de las subclases. Es mas; si hacemos la siguiente
solicitud
S t r i n g cadena = e s t u d i a n t e s [ 0 ] . g e t R e g i s t r o ( ) ;
6.4 Polimorfismo 192

se da cuenta de que lo que tiene ah es una referencia a algo del tipo EstudianteCur-
so, por lo que utilizara la implementacion dada en esa subclase para dar respuesta
a esta solicitud. Decimos que gobierna el tipo de la referencia, no el tipo de la
declaracion. La decision de a cual de las implementaciones de getRegistro() debe
ser invocada se toma en ejecucion, ya que depende de la secuencia de ejecucion
el tipo de la referencia guardada en la localidad del arreglo. A esta capacidad de
los lenguajes orientados a objetos de resolver dinamicamente el significado de un
nombre de metodo es a lo que se llama polimorfismo, ya que el mismo nombre (de
hecho, la misma firma) puede tomar significados distintos dependiendo del estado
del programa.

El operador instanceof
Supongamos que estamos en la seccion escolar de la Facultad, donde tienen
registros de alumnos de distintos tipos, y que le piden al coordinador que por
favor le entregue una lista de todos los registros que tiene para la biblioteca. El
coordinador debera tener un programa que identifique de que clase es cada uno de
los objetos que se encuentran en la lista (arreglo, lista ligada, etc.). El operador
instanceof hace exactamente esto. Es un operador binario, donde las expresiones
que lo usan toman la siguiente forma:
xexpresion de objetoy instanceof xidentificador de clasey
y regresa el valor booleano verdadero si, en efecto, el objeto dado en la expresion
de la izquierda es un ejemplar de la clase dada a la derecha; y falso si no. Para
un proceso como el que acabamos de describir tendramos un codigo como el que
sigue, suponiendo que tenemos los registros en una lista, como se puede observar
en el listado 6.10.

Codigo 6.10 Registros en un arreglo

EstudianteBasico [ ] estudiantes ;
/ Aca s e i n i c i a l i z a e l a r r e g l o y s e van a g r e g a n d o l o s
estudiantes .
/
int i ;
String reporte ;
f o r ( i = 0 , r e p o r t e = "" ; i < e s t u d i a n t e s . l e n g t h ; i ++) {
i f ( e s t u di ant e s [ i ] instanceof E s t u d i a n t e B i b l i o ) {
r e p o r t e += e s t u d i a n t e s [ i ] . g e t R e g i s t r o ( ) ;
}
}
...
193 Herencia

Supongamos ahora que queremos una lista de estudiantes con su calificacion

final del curso, pero sin las calificaciones parciales. El metodo getRegistro no sa-
tisface esto. Tendramos un codigo similar al anterior en el listado 6.11.

Codigo 6.11 Otra version del metodo getRegistro

EstudianteBasico [ ] estudiantes ;
/
Aca s e i n i c i a l i z a e l a r r e g l o y s e van a g r e g a n d o l o s
estudiantes .
/
int i ;
String reporte ;
f o r ( i = 0 , r e p o r t e = "" ; i < e s t u d i a n t e s . l e n g t h ; i ++) {
i f ( e s t u di ant e s [ i ] instanceof EstudianteCurso ) {
/
Aca hay p r o b l e m a s , p u e s queremos u n i c a m e n t e e l
nombre d e l e s t u d i a n t e y s u p r o m e d i o ! E l nombre y
s u s d a t o s , p e r o no hay manera de a c c e d e r a l metodo
que c o r r e s p o n d e a l a s u p e r c l a s e . Por l o t a n t o hay
que a r m a r l o a p i e :
/
r e p o r t e += e s t u d i a n t e s [ i ] . getNombre ( ) + "\t"
+ (( EstudianteCurso ). estudiantes [ i ] ) .
getPromedio ( ) ;
}
}
...

El casting que se hizo en la ultima lnea es necesario, porque en el momento de

compilacion no se sabe la subclase que correspondera al elemento en cuestion, por
lo que en ejecucion se debera pedir que se interprete el registro de esa manera.
Si no lo puede hacer, porque ese no sea el caso, habra un error de ejecucion de
InvalidClassException.
En general, cuando tenemos una declaracion asociada con una superclase y
queremos hacer uso de metodos o atributos declarados para la subclase (desde un
programa principal u otra clase que no este relacionada jerarquicamente con la
super y subclase) tendremos que hacer un casting con el nombre de la subclase para
que en tiempo de compilacion identifique que estamos hablando de la subclase.
6.5 Clases abstractas 194

6.5 Clases abstractas

Supongamos que tenemos una jerarqua de clases para las figuras geometricas,
que se podra ver como en la figura 6.12.

Figura 6.12 Jerarqua de clases

Figura geometrica

Lnea Superficie Volumen

recta elipse parabola cubo icosaedro cilindro

cuadrado crculo rectangulo

La superclase es Figura Geometrica y reconocemos que toda figura geometrica

debe tener los siguientes servicios:
dibujarse,
moverse,
borrarse,
crearse.
En el caso de las lneas podemos obtener su longitud. En el caso de las su-
perficies, podemos obtener su permetro y su area. En el caso de los volumenes,
podemos querer obtener su volumen. Por ejemplo, en el caso de las superficies
podemos tener una lista de puntos que las definen. Y as sucesivamente.
Cuando estamos en la raz del arbol realmente todo lo que podemos decir es
que se trata de una figura geometrica. Se trata de una clase abstracta de la que
no podemos decir mucho todava y de la que no puede haber objetos que sean,
en abstracto, una figura geometrica. Conforme vamos bajando por el arbol hacia
las hojas se van concretando algunas de las caractersticas, pero en el caso de la
jerarqua que nos ocupa, en el segundo nivel todava no podemos tener objetos que
sean una superficie si no decimos que clase de superficie es. En la figura 6.12 los
nodos ovalados representan clases abstractas, mientras que los nodos rectangulares
representan clases concretas.
195 Herencia

En una jerarqua cualquiera de clases tenemos las mismas caractersticas que

hemos visto hasta ahora, donde cada subclase hereda todo lo heredable de la
superclase, excepto que para uno o mas metodos de la clase no damos su imple-
mentacion. Si una clase tiene al menos un metodo sin implementacion la clase es
abstracta y se tiene que indicar eso como se indica a continuacion:

Sintaxis:
xencabezado de clase abstractay ::= abstract class xidentificadory
Semantica:
Le estamos indicando al compilador dos cosas:
No pueden crearse objetos de esta clase.
Contiene al menos un metodo cuya implementacion no esta definida.

Aquellos metodos que no se puede definir su implementacion en el nivel de la

jerarqua en la que esta la clase, se les precede tambien de la palabra abstract y se
escribe unicamente su encabezado seguido de un ;. En el listado 6.12 podemos ver
un ejemplo con la jerarqua de clases que dimos antes. No pondremos las clases
completas porque no es el objetivo en este momento.

Codigo 6.12 Clases abstractas y concretas

/ R a z de l a j e r a r q u a . C l a s e a b s t r a c t a /
abstract class FiguraGeometrica {
/ E s q u i n a i n f e r i o r i z q u i e r d a /
i n t x1 , y1 ;
abstract public void p i n t a ( ) ;
a b s t r a c t p u b l i c v o i d mueve ( i n t x2 , i n t y2 ) ;
a b s t r a c t p u b l i c v o i d c o p i a ( i n t x2 , i n t y2 ) ;
......
}
/ S i g u i e n t e n i v e l de l a j e r a r q u a . Tambien a b s t r a c t a /
a b s t r a c t c l a s s L i n e a extends F i g u r a G e o m e t r i c a {
abstract public void l o n g i t u d ( ) ;
......
}
......
/ T e r c e r n i v e l de l a j e r a r q u a . C l a s e c o n c r e t a /
c l a s s R e c t a extends L i n e a {
public void p i n t a ( ) {
...
}
...
}
...
6.6 Interfaces 196

No hay la obligacion de que todos los metodos en una clase abstracta sean
abstractos. Dependera del diseno y de las posibilidades que tenga la superclase
para definir algunos metodos para aquellas clases que hereden. Aun cuando la
clase no tenga metodos abstractos, si queremos que no se creen objetos de esa
clase la declaramos como abstracta.

6.6 Interfaces

La herencia en Java es simple, esto es, cada clase puede heredar de a lo mas
una superclase. Pero muchas veces necesitamos que hereden de mas de una clase.
Las interfaces corresponden a un tipo, como las clases, que definen exclusivamente
comportamiento. Lo unico que pueden tener las interfaces son constantes estaticas
y metodos abstractos, por lo que definen el contrato que se establece con aquellas
clases que implementen esa interfaz. Se dice que una clase implementa una interfaz,
porque cuando una clase hereda de una interfaz debe dar la implementacion de los
metodos declarados en la interfaz. La sintaxis para la declaracion de una interfaz
es:

Sintaxis:
xencabezado de interfazy ::= interface xidentificadory
...
Semantica:
Se declara un tipo que corresponde a constantes y encabezados de metodos.

Como todo lo que se declare dentro de una interfaz es publico, pues corresponde
siempre a lo que puede hacer un objeto, no se usa el calificativo public en los
enunciados dentro de la declaracion de la interfaz. Como forzosamente todos los
metodos son abstractos, ya que no tienen implementacion, tampoco se pone este
calificativo frente a cada metodo. Y como solo se permiten constantes estaticas, los
calificativos de static y final se omiten en las declaraciones de constantes dentro
de una interfaz. Por lo tanto, las constantes y metodos en una interfaz seran
declarados nada mas con el tipo de la constante o el tipo de valor que regrese el
metodo, los identificadores y, en el caso de las constantes el valor; en el caso de
los metodos, los parametros.
Pensemos en el comportamiento de una lista, como las que hemos estado vien-
197 Herencia

do. Sabemos que no importa de que sea la lista, tiene que tener un metodo que
agregue, uno que busque, etc. Dependiendo de los objetos en la lista y de la imple-
mentacion particular, la implementacion de cada uno de los metodos puede variar.
Tenemos aca un caso perfecto para una interfaz. En el listado 6.13 podemos ver
la declaracion de una interfaz de este tipo.

Codigo 6.13 Interfaz para manejar una lista

1: interfaz Lista {
2: void agrega ( Object obj ) ;
3: boolean q u i t a ( S t r i n g cad ) ;
4: O b j e c t b u s c a ( i n t c u a l , S t r i n g cad ) ;
5: String armaRegistro ( ) ;
6: void l i s t a T o d o s ( Consola cons ) ;
7: v o i d l o s Q u e C a z a n ( i n t c u a l , S t r i n g cad ) ;
8: }

Como se ve en el listado 6.13 ninguno de los metodos tiene su implementacion.

Cualquier clase que implemente a esta interfaz tiene que dar la implementacion
de todos y cada uno de los metodos dados en esta declaracion. Por ejemplo, si
deseamos una Lista de EstudianteCurso podramos tener declaraciones como las
que se ven en el listado 6.14.

Codigo 6.14 Herencia con una interfaz

1: c l a s s L i s t a C u r s o implements L i s t a {
2: EstudianteCurso cabeza ;
3: ...
4: O b j e c t b u s c a ( i n t c u a l , S t r i n g cad ) {
5: ...
6: }
7: ...
8: }

Dado que las interfaces corresponden a tipos, igual que las clases, podemos
declarar variables de estos tipos. Por ejemplo,

Lista miLista ;

y usarse en cualquier lugar en que se pueda usar un objeto de una clase que imple-
menta a la interfaz Lista, de la misma manera que se puede usar una variable de
la clase Object en cualquier lugar de cualquier objeto. Sin embargo, si deseamos
6.6 Interfaces 198

que el objeto sea visto como la subclase, tendremos que aplicar lo que se cono-
ce como casting, que obliga al objeto a comportarse como de la subclase. Se
logra poniendo el tipo al que deseamos conformar al objeto de tipo Object entre
parentesis, precediendo a la variable:
E s t u d i a n t e C u r s o nuevo = ( E s t u d i a n t e C u r s o ) b u s c a ( 1 , " Pedro " ) ;

El metodo busca nos regresa un objeto de tipo Object (la referencia), pero
sabemos, por la implementacion de busca que en realidad nos va a regresar un
una referencia a un objeto de tipo EstudianteCurso, por lo que podemos aplicar el
casting.
Una clase dada puede extender a una sola superclase, pero puede implementar
a tantas interfaces como queramos. Como no tenemos la implementacion de los
metodos en las interfaces, aun cuando una misma firma aparezca en mas de una
interfaz (o inclusive en la superclase) la implementacion que se va a elegir es la
que aparezca en la clase, por lo que no se presentan conflictos.
Las interfaces tambien pueden extender a una o mas interfaces de la misma
manera que subclases extienden a superclases. La sintaxis es la misma que con la
extension de clases:

Sintaxis:
interface xidentif1 y extends xidentif2 y, . . . , xidentifn y

Semantica:
De la misma manera que con las clases, la subinterfaz hereda todos
los metodos de las superinterfaces.

En adelante se hara un uso mas intenso de herencia y seguiremos, como hasta

ahora, insistiendo en el uso de interfaces.
 Administracion de
la memoria durante 7
ejecucion

7.1 El stack y el heap

Revisitaremos el tema asignacion de espacio durante la ejecucion del programa,

pues hay varios grandes detalles a los que no les hemos dado la importancia
adecuada. Empecemos por lo que sucede en la memoria de la maquina durante
la ejecucion del programa y para ello veamos el concepto de la estructura de
bloques de Java y que sucede con ella durante ejecucion. La estructura de bloques
sintactica (estaticamente) tiene la forma que se ve en la figura 7.1 en la siguiente
pagina. Un archivo de Java puede tener una o mas clases declaradas. Hasta ahora
hemos hablado extensamente de los campos que se declaran en la clase y como son
accesibles desde cualquier metodo de la misma. Tambien hemos visto el papel que
juegan los parametros en los metodos de las clases, que corresponde a variables
locales de las mismas. Adicionalmente a los parametros tenemos las variables
declaradas dentro de un metodo, a las que unicamente dentro de ese metodo,
al igual que los parametros, se tiene acceso de ah viene el nombre de locales.
7.1 El stack y el heap 200

Adicionalmente a esto, cuando se abren bloques de enunciados en las condicionales

o en las iteraciones se pueden declarar variables que unicamente son locales dentro
de ese bloque de enunciados. Solo son conocidas dentro del bloque1 .
Esto nos define dos niveles lexicograficos distintos: el global, que se refiere a
lo que se puede utilizar desde cualquier punto de cualquiera de nuestras clases,
dados los permisos adecuados, y el local, que es aquello que se encuentra dentro
de un metodo. Adicionalmente, dentro de los metodos podemos tener bloques
de enunciados que incluyan declaraciones. Estas declaraciones son unicamente
visibles dentro del bloque de instrucciones2 .

Figura 7.1 Estructura de bloques de un programa.

Clase
atributos

metodo

metodo
bloque

bloque

metodo
bloque

metodo
bloque
bloque

1
Sin embargo, si existe alguna declaracion de una variable con el mismo nombre fuera del
bloque y que la precede, el compilador dara error de sintaxis por identificador ya declarado.
2
No pueden tener el mismo identificador que una declaracion previa y fuera del bloque.
201 Administracion de la memoria durante ejecucion

Para los metodos estaticos, como es el caso del metodo main de las clases esto
funciona un poco distinto, ya que este tipo de metodos no tiene acceso mas que a
los atributos o metodos estaticos de la misma clase, y a los metodos o atributos
publicos o de paquete de las clases a las que se tenga acceso. Olvidandonos un poco
de los metodos estaticos (de clase) podemos decir que la estructura de bloques
nos da lo que conocemos como el rango de una variable, que se refiere a aquellos
puntos de la clase donde la variable puede ser utilizada. Si regresamos a nuestro
esquema de los espejos/cristales, tenemos que desde dentro de un bloque podemos
ver hacia afuera: desde el nivel local tenemos acceso a las variables de la clase - el
rango de las variables de la clase es toda la clase. Desde dentro de un metodo, sin
embargo, no podemos ver lo que esta declarado dentro de otro metodo o bloques.
Pero, que pasa cuando el nombre de una variable de clase se repite dentro de
un bloque como parametro o variable local? En este caso, decimos que la variable
local bloquea a la variable global: si existe una variable local con el mismo nombre,
todas las referencias a esa variable en ese bloque se refieren a la variable local. El
compilador utiliza a la variable que le queda mas cerca, siempre y cuando tenga
acceso a ella, la pueda ver.
El rango de una variable es estatico, pues esta definido por la estructura del
programa: de ver el listado podemos decir cual es el rango de una variable dada, y
definirlo como publico (global, pero atado a un objeto) o local (declarado dentro
de un metodo o como privado para una clase). Es el compilador el que se encarga
de resolver todo lo relacionado con el rango de las variables, siguiendo la estructura
de bloques.
Durante la ejecucion del programa, esta estructura presenta un cierto anida-
miento, distinto del anidamiento sintactico o lexicografico, donde desde dentro
de un metodo se puede llamar a cualquiera de los que esta en rango, o sea, cual-
quiera de los metodos declarados en la clase o que sean publicos de otras clases.
Se lleva a cabo una anidamiento dinamico durante ejecucion, donde se establece
una cadena de llamadas tal que el ultimo metodo que se llamo es el primero que
se va a abandonar.
Supongamos que tenemos la clase del listado 7.1.
En el esquema de la figura 7.2 en la pagina 203 tenemos los bloques en el orden
en que son invocados, mostrando el anidamiento en las llamadas. El nombre del
metodo junto con el valor de sus parametros se encuentra sobre la lnea que lo
demarca. En la esquina superior derecha de cada bloque se encuentra el nivel de
anidamiento dinamico que tiene cada metodo. El valor de las variables, tanto de los
atributos como de las variables locales, dependera del anidamiento lexicografico.
Por ejemplo, dentro del metodo B en el que se le asigna valor a una variable
entera a, esta es una variable local, por lo que el valor del atributo a no se va a
ver modificado. Por ello, en la llamada de la lnea 29: al metodo B, los valores con
7.1 El stack y el heap 202

los que es llamado son los originales de a y b, o sea 3 y 2.

Codigo 7.1 Clase que ilustra el anidamiento dinamico

1: class Cualquiera {
2:
3: private int a = 3 , b = 2;
4: ...
5: p u b l i c v o i d A( i n t i ) {
6: ...
7:
8: B( i , a ) ;
9: ...
10: }
11: ...
12: p u b l i c v o i d B( i n t i , i n t j ) {
13:
14: int a = i + j ;
15: ...
16: C();
17: ...
18: }
19: public void C( ) {
20:
21: int k = 2 a ;
22: ...
23: }
24:
25: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
26: i n t m = 10 , n = 5 ;
27: C u a l q u i e r a o b j e t o = new C u a l q u i e r a ( ) ;
28: o b j e t o . A(m) ;
29: o b j e t o . B( a , b ) ;
30: objeto .C( ) ;
31: }
32: }

Al esquema de bloques le sigue un diagrama de Warnier en la figura 7.3 en la

pagina opuesta que nos muestra la relacion entre las llamadas.
203 Administracion de la memoria durante ejecucion

Figura 7.2 Diagrama de anidamiento dinamico.

main [1]
Constructor de objeto [2]

A(10) [2]
B(10,3) [3]
C( ) [4]

B(3,2) [2]
C( ) [3]

C( ) [2]

Figura 7.3 Secuencia de llamadas en el listado 7.1.

$
'
'
'
'
' $
Construccion de objeto
'
'
' '
' ...
'
' '
'
' $
'
'
' '
& '
&. . .
'
'
'
'
'
'
Llamada a A(10) Llamada a B(10,3) Llamada a C()
' '
& '
'
' %. . .
Secuencia de '
'
%. . .
Ejecucion ''
'
' $
'
'
' '
&. . .
'
'
'
'
'
'
Llamada a B(3,2) Llamada a C()
'
'
' %. . .
'
'
' !
'
%Llamada a C() . . .

Lo que me indican los dos diagramas anteriores, es que la ejecucion del pro-
grama debe proseguir de la siguiente manera:
7.1 El stack y el heap 204

1. . . Entrar a ejecutar main.

2. . . Entrar a ejecutar el constructor de Cualquiera.

2. . . Salir de ejecutar el constructor de Cualquiera.
2. . . Entrar a ejecutar el metodo A(10).
3. . . Entrar a ejecutar el metodo B(10,3).
4. . . Entrar a ejecutar el metodo C().
4. . . Salir de ejecutar el metodo C().
3. . . Salir ejecutar el metodo B(10,3).
2. . . Salir de ejecutar el metodo A(10).
2. . . Entrar a ejecutar el metodo B(3,2).
3. . . Entrar a ejecutar el metodo C().
3. . . Salir de ejecutar el metodo C().
2. . . Salir ejecutar el metodo B(3,2).
2. . . Entrar a ejecutar el metodo C().
2. . . Salir de ejecutar el metodo C().

1. . . Salir de ejecutar main.

Tanto en el esquema como en la secuencia de ejecucion (donde omitimos para

cada funcion la ejecucion de lo que no fuera llamadas a metodos), asociamos
un entero a cada llamada. Esto es con el objeto de identificar los anidamientos
dinamicos - los que estan definidos por la secuencia de ejecucion del programa. Este
esquema muestra varios aspectos importantes que tienen que ver con la ejecucion
de un programa. Revisemos algunos de ellos:
1. El anidamiento dinamico (en ejecucion) no forzosamente coincide con el
estatico (sintactico). Mientras que lexicograficamente hablando unicamen-
te tenemos el nivel global y el local, dinamicamente podemos tener tantos
niveles como queramos, uno por cada vez que desde dentro de una funcion
llamamos a otra.
2. La ultima rutina a la que entramos es la primera de la que salimos.
3. Cuando aparece una funcion f como argumento de una funcion g, la llamada
a f se hace inicia y termina antes que la llamada a g. Para poder llamar a g
debemos tener el valor de sus argumentos, por lo que es necesario que antes
de entrar a g obtengamos el valor de f.
4. El nivel dinamico que le corresponde a una funcion f que aparece como
argumento de una funcion g es el mismo que el de la funcion g.
205 Administracion de la memoria durante ejecucion

Para poder hacer esto, la ejecucion del programa se lleva a cabo en la memoria
de la maquina, organizada esta como un stack, que es una estructura de datos con
las siguientes caractersticas:
a) Respecto a su estructura:
La estructura es lineal, esto es, podemos pensarla con sus elementos for-
mados uno detras del otro.
Es una estructura homogenea, donde todos sus elementos son del mismo
tipo.
Es una estructura dinamica, esto es, crece y se achica durante ejecucion.
Tiene asociado un tope, que corresponde al ultimo elemento que se coloco en
el stack.
b) Respecto a su uso:
Un stack empieza siempre vaco, sin elementos.
Conforme progresa la ejecucion, se van colocando elementos en el stack
y se van quitando elementos del stack, siguiendo siempre esta regla: los
elementos se colocan siempre en el tope del stack y cuando se remueven,
se hace tambien del tope del stack.
Veamos un esquema de un stack en la figura 7.4.

Figura 7.4 Esquema de una stack o pila.

tope
... ...
crece ... ...
hacia
... ...
arriba
... ...
... ...

stack o pila

El tope del stack corresponde a un apuntador que me indica cual es el siguiente

lugar en el que se van a colocar datos en el stack. Suponiendo que la primera
posicion a ocupar en un stack es la 0, si el tope vale 0 quiere decir que el stack
esta vaco.
Para poder ejecutar un programa, el sistema cuenta con un contador de pro-
grama (Program Counter:PC ) que apunta a (contiene la direccion de) la siguiente
7.1 El stack y el heap 206

instruccion a ejecutarse. El codigo del programa se encuentra en una seccion de

memoria, y las variables y la ejecucion se hace sobre el stack. Los objetos se en-
cuentran en el heap. El algoritmo para ejecutar un programa se encuentra en la
figura 7.5.

Figura 7.5 Algoritmo para ejecutar un programa.

$ $
'
'
' '
'
' Toma la siguiente instruccion
'
'
' '
'
'
'
'
' '
'
'
Obten los operandos
'
'
' '
'
' Incrementa el contador$del programa
'
'
' '
'
'
'
' '
' '
'
' Suma
'
& Ejecuta instrucciones '
& '
'
Ejecuta '
'
'
programa '
(Hasta que encuentres
' '
'
'
'
'
' '
'
' &Resta

'
'
'
la de parar) '
'
' Ejecuta la instruccion
'
'
' '
'
' '
'
'
' '
' '
'
' .
'
'
' '
'
' '
'
'
' '
' '
'
' .
'
% '
% '
% .

Antes de empezar a ejecutar un programa, el sistema operativo debe cargar

en el stack de ejecucion todo lo que corresponde a lo que esta accesible para la
clase que se va a ejecutar, que incluye los nombres de las clases accesibles y las
variables y metodos de la clase que se va a ejecutar. A esto le llamamos el paso 0
en la ejecucion de un programa.
Cuando se esta ejecutando un programa un metodo se puede invocar desde
distintos puntos del programa. En el punto de llamada de un metodo la ejecucion
debe transferirse a ejecutar ese metodo, y una vez terminada le ejecucion del
mismo, regresar al punto desde donde se hizo la invocacion, para continuar con
la ejecucion del programa. A la posicion en la que se encuentra la llamada se le
conoce como punto de llamada e indica el punto al que debe regresar la ejecucion
del programa una vez que termine la funcion. Esta ultima caracterstica hace
que se le utilice como direccion de regreso. La ejecucion del programa, como ya
mencionamos, se lleva a cabo en el stack. Cada vez que se invoca a un metodo -
el programa principal main es una funcion invocada por el sistema operativo - se
tiene que montar al metodo en el stack, anotando muy claramente a donde debe
regresar la ejecucion al terminar la rutina. Al terminar la ejecucion del metodo,
207 Administracion de la memoria durante ejecucion

se desmonta del stack al mismo. Para montar un metodo al stack hay que
construir lo que se conoce como su registro de activacion, que es una tabla en
la que hay lugar para los parametros y las variables locales del metodo, de tal
manera que durante la ejecucion se encuentren siempre en la parte superior del
stack.
Al invocar un metodo (para transferirse a ejecutarlo), el sistema debe realizar
los siguientes pasos:

1. Dejar un lugar en el stack para que el metodo coloque ah el valor que va a

regresar, si es que regresa valor.
2. Hacer la marca en el stack, copiando ah el contenido del contador del pro-
grama.
3. Buscar en el stack, en el registro de activacion global, la direccion de codigo
donde se encuentra definida ese metodo. Copiar esa direccion al contador
del programa (es donde va a continuar la ejecucion cuando se termine de
montar al metodo en el stack).
4. Construir el registro de activacion del metodo, dejando un lugar para cada
parametro, en el orden en que estan declarados, y un lugar para cada variable
local (o estructura de datos publica o privada, si se trata de una clase).
5. Evaluar los argumentos, para entregarle al metodo una lista de valores e
irlos colocando en el registro de activacion.
6. Copiar al stack, en el orden en que aparece, el registro de activacion (el
ultimo es el que queda en el tope del stack).
7. Copiar los valores de los argumentos a los parametros.
8. Conforme se va ejecutando el metodo, se van colocando en el stack las va-
riables y objetos que se van declarando.

Un metodo tiene acceso a su bloque local (lo que se encuentra a partir de la

ultima marca en el stack) y al bloque global (lo que se encuentra en la base o
fondo del stack y hasta la primera marca en el stack). En la base del stack se
encuentran los identificadores de las clases a las que se tiene acceso desde la clase
en ejecucion.
Cuando termina la ejecucion del metodo, el control debe regresar al punto
de llamada. La ejecucion del metodo termina cuando se llega a un enunciado de
return o bien se llega al final del bloque que define al metodo. Antes de continuar
la ejecucion en el punto de llamada, el sistema tiene que hacer lo siguiente:
7.1 El stack y el heap 208

1. Localizar la marca del stack mas cercana al tope, la ultima que se coloco.
2. Colocar en el contador del programa la direccion de regreso que se encuentra
en esa marca.
3. Si el enunciado que causa la terminacion de la rutina es un return, colocar
el valor en el lugar inmediatamente abajo de la marca del stack correspon-
diente.
4. Quitar del stack todo lo que se encuentra a partir de la marca, incluyendola.
Se quita algo del stack simplemente bajando el apuntador al tope del
stack a que apunte al ultimo registro que se quito (recordar que lo ultimo
que se coloco es lo primero que se quita). No hay necesidad de borrar la
informacion pues la ejecucion solo va a tomar en cuenta aquella informacion
que se encuentre antes del tope del stack.
5. Continua la ejecucion en el lugar del codigo al que apunta el contador del
programa.

Para ilustrar estos pasos, vamos a seguir el programa que escribimos, y que
tiene los renglones numerados. Por supuesto que la ejecucion del programa no
se lleva a cabo directamente sobre el texto fuente. El compilador y ligador del
programa producen un programa en binario (lenguaje de maquina) que se coloca
en un cierto segmento de la memoria. El contador del programa va apuntando a
direcciones de este segmento de memoria y en cada momento apunta a una ins-
truccion de maquina. Es suficiente para nuestros propositos manejar el programa
a nivel de enunciado. En los esquemas del stack que presentamos a continuacion,
lo que corresponde a direcciones en memoria de datos (el stack) se preceden con
un * mientras que lo que corresponde a memoria de programa se precede con
un #. El contador del programa apunta a la siguiente instruccion a ejecutarse.
El tope del stack apunta al primer lugar vaco en el stack (si el tope del stack
contiene un 0, quiere decir que no hay nadie en el stack).
Al ejecutar el paso 0, se cargan al stack todos los atributos y nombres de
metodos de la clase3 , quedando el stack como se observa en la figura 7.6.
El sistema operativo sabe que el primer metodo a ejecutarse es main, por lo
que inicia la ejecucion con el. Sigamos los pasos, uno a uno, para ver como lo hace:

1. Como main no entrega valor, no deja espacio en el stack.

2. Marca el stack para poder montar al metodo.
3
No ilustraremos las clases a las que tiene acceso para ahorrar espacio, y porque sera practi-
camente interminable.
209 Administracion de la memoria durante ejecucion

Figura 7.6 Estado del stack al iniciarse la ejecucion de una clase.

xvoidy main #25:

xvoidy C #19:
xvoidy B #12:
xvoidy A #5:
xinty b *2
xinty a *3
d.r. Sistema
Operativo
clase Cualquiera

3. Localiza la direccion de main en el stack, y ve que es la direccion de codigo

24. El stack y los contadores quedan como se ve en la figura 7.7.

Figura 7.7 El stack al iniciarse la llamada a main.

d.r. Sistema
Operativo 25:
main
xvoidy main #25: Contador del
xvoidy C #19: Programa
xvoidy B #12:
xvoidy A #5:
xinty b *2
xinty a *3
d.r. Sistema
Operativo
clase Cualquiera

4. Construye el registro de activacion para main. El registro de activacion cons-

truido se puede ver en la figura 7.8 en la siguiente pagina. En el registro se
7.1 El stack y el heap 210

va dando lugar para cada una de las declaraciones locales. En el caso de

declaraciones de objetos, se colocan en el stack las referencias a los objetos
que se van a localizar en el heap.

Figura 7.8 Registro de activacion para main.

xCualquieray objeto # heap

xinty n *5
xinty m *10
xStringr sy args # heap

5 y 6 Se monta el registro de activacion en el stack. El stack queda como se ve en

la figura 7.9.

Figura 7.9 El stack listo para iniciar la ejecucion de main.

xCualquieray objeto #heap

xinty n *5
xinty m *10
xStringr sy args #heap
d.r. Sistema
Operativo 25:
main
xvoidy main #25: Contador del
xvoidy C #19: Programa
xvoidy B #12:
xvoidy A #5:
xinty b *2
xinty a *3
d.r. Sistema
Operativo
clase Cualquiera
211 Administracion de la memoria durante ejecucion

Una vez armado el stack, se procede a ejecutar la rutina. En este momento es

accesible todo lo que corresponde a las variables y metodos publicos de las clases
a las que se tiene acceso, a traves de los objetos construidos, y lo que esta desde
la ultima marca hasta el tope del stack.
7. Empieza la ejecucion en el enunciado #25:, con las declaraciones locales de
main ya montadas en el stack.
Las lneas de codigo 26: y 27: corresponden a las declaraciones que ya hici-
mos, as que procedemos a ejecutar la lnea 28:. Para ello debemos invocar
el metodo A del objeto objeto. Volvamos a seguir la ejecucion, en lo que se
refiere al manejo del stack.
1 a 3: Como el metodo no regresa valor, no dejamos un lugar en el sta-
ck. Ponemos la marca, colocando en ella la direccion de codigo que se
encuentre en el contador del programa. Asimismo, se coloca en el con-
tador del programa la direccion del metodo. Todo esto se puede ver en
la figura 7.10 en la siguiente pagina.
Figura 7.10 El stack durante la ejecucion de main.

direccion de
regreso: #29:
A(10)
xCualquieray objeto #heap
xinty n *5
xinty m *10
#5:

xStringr sy args #heap Contador del

d.r. Sistema Programa
Operativo
main

4 a 6 Al evaluar los argumentos, tenemos la lista (10). Montamos en el

stack el registro de activacion y colocamos los valores de la lista en el
espacio reservado para los argumentos. El contenido del stack en este
momento se puede ver en la figura 7.11.
8. Continuar la ejecucion del programa en la lnea de codigo #5:.
7.1 El stack y el heap 212

Figura 7.11 El stack durante la ejecucion de A.

xinty i *10
direccion de
regreso: #29:
A(10)
xCualquieray objeto #heap
xinty n *5
xinty m *10
#5:

xStringr sy args #heap Contador del

d.r. Sistema Programa
Operativo
main

En la lnea #8: tenemos una llamada al metodo B(i,a), por lo que nuevamente
marcamos el stack, copiamos la direccion del PC a la marca, armamos el registro
de activacion para B y lo montamos en el stack, colocamos la direccion donde
empieza B a ejecutarse en el PC y proseguimos la ejecucion en ese punto. En el
momento inmediato anterior a que se ejecute B, el stack se presenta como se puede
observar en la figura 7.12.
Al llegar a la lnea de codigo #16: hay una llamada desde B al metodo C, por
lo que nuevamente se marca el stack, se actualiza el contador del programa y se
monta en el stack el registro de activacion de C(). El resultado de estas acciones
se pueden ver en la figura 7.13 en la pagina 214.
Se ejecuta el metodo C() y al llegar al final del mismo el sistema desmonta
el registro de activacion de C() del stack, coloca en el contador del programa
la direccion que se encuentra en la marca y elimina la marca puesta por esta
invocacion. El stack se ve como en la figura 7.14 en la pagina opuesta.
Se termina la ejecucion de B(10,3) en la lnea #18:, por lo que se desmonta el
registro de activacion de b(10,3) del stack, se copia la direccion de regreso de la
marca al PC y se quita la marca del stack, quedando el stack como se muestra en
la figura 7.15.
213 Administracion de la memoria durante ejecucion

Figura 7.12 El stack antes de empezar a ejecutar B.

xinty a *13
xinty j *3
xinty i *10
direccion de
regreso: #9:
B(10,3)
xinty i *10
direccion de
regreso: #29:
A(10)
xCualquieray objeto #heap
xinty n *5
xinty m *10
xStringr sy args #heap
d.r. Sistema
Operativo #14:
main
xvoidy main #25:
Contador del
xvoidy C #19: Programa
xvoidy B #12:
xvoidy A #5:
xinty b *2
xinty a *3
d.r. Sistema
Operativo
clase Cualquiera
7.1 El stack y el heap 214

Figura 7.13 El stack antes de empezar a ejecutar C desde la lnea #16:.

xinty k *6
direccion de
regreso: #17:
C()
xinty a *13
xinty j *3
xinty i *10
direccion de
regreso: #9:
B(10,3)
xinty i *10
direccion de
regreso: #29:
A(10)
xCualquieray objeto #heap
xinty n *5
xinty m *10
xStringr sy args #heap
d.r. Sistema
Operativo #19:
main
xvoidy main #25:
Contador del
xvoidy C #19: Programa
xvoidy B #12:
xvoidy A #5:
xinty b *2
xinty a *3
d.r. Sistema
Operativo
clase Cualquiera
215 Administracion de la memoria durante ejecucion

Figura 7.14 El stack al terminar de ejecutarse C().

xinty a *13
xinty j *3
xinty i *10
direccion de
regreso: #9:
B(10,3)
xinty i *10
direccion de
regreso: #29:
A(10)
xCualquieray objeto # heap
xinty n *5 #17:
xinty m *10
Contador
xString[ ]y args # heap del
direccion de Programa
regreso: #29:
main

Figura 7.15 El stack al terminar la ejecucion de B(10,3).

xinty i *10
direccion de
regreso: #29:
A(10)
xCualquieray objeto # heap
xinty n *5
xinty m *10
xString[ ]y args # heap #9:
d. r. Sistema Contador
Operativo del
main Programa
7.1 El stack y el heap 216

Se llega al final del metodo A(10), por lo que se desmonta el registro de ac-
tivacion de A(10), se copia la direccion de regreso de la marca al contador del
programa y quita la marca del stack. Podemos observar el estado del stack en este
momento en la figura 7.16.

Figura 7.16 El stack al terminar la ejecucion de A(10).

xCualquieray objeto #heap

xinty n *5
xinty m *10
xStringr sy args #heap
d.r. Sistema
Operativo #29:
main
xvoidy main #25:
Contador del
xvoidy C #19: Programa
xvoidy B #12:
xvoidy A #5:
xinty b *2
xinty a *3
d.r. Sistema
Operativo
clase Cualquiera

Al llegar la ejecucion del programa a la lnea 29: se encuentra con otra invoca-
cion a B(3,2), que son los campos de la clase. Se coloca la marca en el stack con
direccion de regreso 30:, se actualiza el PC para que marque el inicio del metodo
B y se monta al stack el registro de activacion de B(3,2). Los resultados de estas
acciones se muestran en la figura 7.17.
217 Administracion de la memoria durante ejecucion

Figura 7.17 El stack antes de la ejecucion de B(3,2).

xinty a *5
xinty j *2
xinty i *3
direccion de
regreso: #29:
B(3,2)
xCualquieray objeto #heap
xinty n *5
xinty m *10
xStringr sy args #heap
d.r. Sistema
Operativo #12:
main
xvoidy main #25:
Contador del
xvoidy C #19: Programa
xvoidy B #12:
xvoidy A #5:
xinty b *2
xinty a *3
d.r. Sistema
Operativo
clase Cualquiera

Al ejecutar al metodo B(3,2), en la lnea 16: se invoca al metodo C(), por lo

que el sistema hace lo conducente con el stack, quedando este como se muestra en
la figura 7.18.
7.1 El stack y el heap 218

Figura 7.18 El stack antes de la ejecucion de C().

xinty k *6
direccion de
regreso: #17:
C()
xinty a *5
xinty j *2
xinty i *3
direccion de
regreso: #29:
B(3,2)
xCualquieray objeto #heap
xinty n *5
xinty m *10
xStringr sy args #heap
d.r. Sistema
Operativo #22:
main
xvoidy main #25:
Contador del
xvoidy C #19: Programa
xvoidy B #12:
xvoidy A #5:
xinty b *2
xinty a *3
d.r. Sistema
Operativo
clase Cualquiera

Termina de ejecutarse C() en la lnea 18: y el stack regresa a verse como en la

figura 7.17 en la pagina anterior, excepto que el PC vale ahora 17:. Esta situacion
se muestra en la figura 7.19.
219 Administracion de la memoria durante ejecucion

Figura 7.19 El stack al terminar la ejecucion deC().

xinty a *5
xinty j *2
xinty i *3
direccion de
regreso: #29:
B(3,2)
xCualquieray objeto # heap
xinty n *5
xinty m *10
xString[ ]y args # heap #14:
d. r. Sistema Contador
Operativo del
main Programa

Al continuar la ejecucion el programa, llega al final del metodo B(3,2) y sale

de el, dejando el stack como se ve en la figura 7.20, con el PC apuntando a la
direccion de codigo 30:.

Figura 7.20 El stack al terminar la ejecucion de B(3,2).

xCualquieray objeto # heap

xinty n *5
xinty m *10
xString[ ]y args # heap #30:
d. r. Sistema Contador
Operativo del
main Programa
7.1 El stack y el heap 220

En la lnea 30: nuevamente se hace una llamada al metodo C(), por lo que se
marca el stack y se monta su registro de activacion. El resultado se puede ver en
la figura 7.21 en la pagina opuesta.

Figura 7.21 El stack antes de empezar la ejecucion de C().

xinty k *6
direccion de
regreso: #31:
C()
xCualquieray objeto #heap
xinty n *5
xinty m *10
xStringr sy args #heap
d.r. Sistema
Operativo #14:
main
xvoidy main #25:
Contador del
xvoidy C #19: Programa
xvoidy B #12:
xvoidy A #5:
xinty b *2
xinty a *3
d.r. Sistema
Operativo
clase Cualquiera

Al terminarse de ejecutar C() se desmonta su registro de activacion del stack,

se copia la direccion de regreso de la marca al PC y se quita la marca. El stack
queda como se muestra en la figura 7.22, con el PC apuntando a la lnea 31: del
codigo.
221 Administracion de la memoria durante ejecucion

Figura 7.22 El stack listo para iniciar la ejecucion de main.

xCualquieray objeto #heap

xinty n *5
xinty m *10
xStringr sy args #heap
d.r. Sistema
Operativo #31:
main
xvoidy main #25: Contador del
xvoidy C #19: Programa
xvoidy B #12:
xvoidy A #5:
xinty b *2
xinty a *3
d.r. Sistema
Operativo
clase Cualquiera

Como la lnea 31: es la que termina main, se descarga del stack el registro de
activacion de este metodo, se copia al PC la direccion de regreso de la marca y se
quita la marca. En ese momento termina la ejecucion del programa, por lo que se
libera el stack y el PC.
En todo momento durante la ejecucion, el sistema puede utilizar lo que se
encuentre en el bloque global, mas aquello que se encuentre por encima de la ultima
marca en el stack y hasta inmediatamente antes de la celda antes de la ultima
marca que se puso. De esta manera, Cada metodo crea su propio ambiente de
ejecucion.
Resumiendo, el stack se utiliza para la administracion de la memoria en eje-
cucion. Cada vez que se invoca una rutina o metodo, se construye el registro de
activacion de la misma y se coloca en el stack. Cada vez que se sale de un metodo,
se quita del stack el registro de activacion de la rutina que esta en el tope y la
ejecucion continua en la direccion de regreso desde la que se invoco a esa instancia
7.1 El stack y el heap 222

del metodo.
Durante la ejecucion de un programa, el sistema trabaja con dos variables, el
tope del stack, que indica cual es la siguiente celda en la que se va a colocar in-
formacion, y el contador del programa, que indica cual es la siguiente instruccion
que se va a ejecutar. En ambos casos, decimos que las variables son apuntadores,
pues el tope del stack apunta a una celda en el stack (contiene una direccion del
stack) y el contador del programa apunta a una direccion de memoria del progra-
ma donde se encuentra almacenado el codigo del programa.

En el stack se le da lugar a:

Todo lo declarado publico en el paquete (o conjunto de programas).

Todas las estructuras de datos de las clases.
Apuntadores a todos los metodos miembros de clases.
A los resultados que entregan las funciones.
A los parametros formales de cada metodo.
A las variables locales de cada metodo conforme se van declarando.

Decimos que cada metodo tiene su ambiente propio de trabajo, en la medida

en que, al cargarse su registro de activacion en el stack, su entorno lo constituye
ese registro de activacion y el registro de activacion global. En nuestros esquemas,
las celdas intermedias entre la primera y ultima marca no son accesibles en ese
momento de la ejecucion. Esto nos da dos conceptos importantes en programacion:

Rango de un identificador Se refiere a los puntos del programa desde donde

el identificador puede ser referido. El rango esta dado de manera estatica
por la estructura de bloques del programa. El compilador se encarga de que
las referencias a los identificadores sean validas.

Existencia de una variable Se refiere a los momentos, durante la ejecucion, en

que una variable conserva su valor. Una variable declarada existe mientras
se encuentre en el stack. Deja de existir cuando se quita del stack el registro
de activacion que la contiene.

Como ya mencionamos antes, de existir identificadores duplicados, el compi-

lador busca a la declaracion mas cercana en el stack, pero busca unicamente en
los registros de activacion vivos (despiertos), el global y el local, primero en el
local. Por ello, al declarar una variable repitiendo un nombre global, se crea una
instancia fresca y nueva, que no tiene relacion alguna con la variable global ori-
ginal y que de hecho, oculta a la variable global original. Java permite ver datos
223 Administracion de la memoria durante ejecucion

miembros de una clase que han sido ocultados por declaraciones locales utilizando
el identificador de objeto this seguido del operador . y a continuacion el nombre
del atributo. Debo insistir en que el bloque o registro de activacion en el que se
encuentra la variable debe ser visible desde el punto de ejecucion y unicamente
se aplica a variables que hayan sido ocultadas por una reutilizacion del nombre.
Si la variable se encuentra en un registro de activacion inaccesible, entonces el
compilador emitira un mensaje de error.

7.2 Recursividad

En matematicas nos encontramos frecuentemente con definiciones o funciones

recursivas. El ejemplo tpico de este tipo de funciones es la definicion del metodo
factorial:
$
'
&1 si n  1
n!
'
% n  pn
1q! si n 1
Si escribimos un metodo en Java que refleje esta definicion, tendramos lo
siguiente:

long f a c t o r i a l ( i n t n ) {
i f ( n <= 0 ) {
r e t u r n
1;
}
i f ( n > 1) {
r e t u r n ( f a c t o r i a l ( n
1) n ) ;
}
else {
return 1;
}
}

La ejecucion del metodo es como sigue: en la invocacion desde fuera (el

metodo main o algun otro metodo), se llama con un argumento n, que debe ser un
valor entero. Si el entero es mayor que 1, procede el metodo a llamarse nuevamente
a s mismo, pero disminuyendo en 1 al argumento. Si el argumento vale 1, el
metodo logra salir. Veamos la ejecucion de este metodo dentro de una clase en el
listado 7.2, para poder seguir su ejecucion en el stack.
7.2 Recursividad 224

Codigo 7.2 La funcion factorial

1: class Factorial {
2: long f a c t o r i a l ( i n t n ) {
3: i f ( n <= 0 ) {
4: r e t u r n
1;
5: }
6: i f ( n > 1) {
7: r e t u r n ( f a c t o r i a l ( n
1)
8: n);
9: } else {
10: return 1;
11: }
12: }
13: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
14: C o n s o l a c o n s = new C o n s o l a ( ) ;
15: F a c t o r i a l f = new F a c t o r i a l ( ) ;
16: c o n s . i m p r i m e l n ( "4! es " +
17: f . factorial (4));
18: }
19: }

El stack, una vez que se cargo el registro de activacion de main, se muestra en

la figura 7.23.

Figura 7.23 Estado del stack al iniciarse la ejecucion de una clase.

xFactorialy f # heap
xConsolay cons # heap
d.r. Sistema
Operativo
main
xvoidy main #13: #16:

xlongy factorial #2: Contador

d.r. Sistema del
Operativo Programa
clase Factorial

Numeramos las lneas del programa para poder hacer referencia a ellas en
225 Administracion de la memoria durante ejecucion

la ejecucion, que empieza en la lnea 13:. En las lneas 13: y 15: tenemos las
declaraciones e inicializaciones de variables locales a main, y en las lneas 16: y 17:
esta el unico enunciado realmente de ejecucion de main. La primera llamada de
factorial desde main deja el stack como se ve en la figura 7.24

Figura 7.24 Estado del stack al iniciarse la llamada de factorial desde main.

xinty n *4
direccion de
regreso #17:
factorial(4)
xlongy valor de regreso
xFactorialy f # heap
xConsolay cons # heap
d.r. Sistema
Operativo
main
xvoidy main #13: #3:

xlongy factorial #2: Contador

d.r. Sistema del
Operativo Programa
clase Factorial

Se ejecuta la condicional de la lnea 3:, pero como n es mayor que 1 no se

hace nada. Despues se evalua la condicional de la lnea 6:, y como es verdadera se
ejecuta el enunciado en las lneas 7: y 8: que es una llamada recursiva a factorial.
Vuelve a entrar a ejecutar factorial y el stack se ve como en la figura 7.25 en la
siguiente pagina.
7.2 Recursividad 226

Figura 7.25 Estado del stack al iniciarse la llamada de factorial desde factorial.

xinty n *3
direccion de
regreso #7:
factorial(3)
xlongy valor de regreso
xinty n *4
direccion de
regreso #17:
factorial(4)
xlongy valor de regreso
xFactorialy f # heap
xConsolay cons # heap
d.r. Sistema
Operativo
main
xvoidy main #13: #3:

xlongy factorial #2: Contador

d.r. Sistema del
Operativo Programa
clase Factorial

Nuevamente se evalua a falso la primera condicion, y como se evalua a ver-

dadero la condicion en la lnea 6: volvemos a llamar a factorial desde la lnea 7:,
quedando el stack como se puede apreciar en la figura 7.26 en la pagina opuesta.
Como n sigue siendo mayor que 1, volvemos a llamar a factorial con 1 como
argumento. El stack se ve como se muestra en la figura 7.27 en la pagina 228.
En esta llamada las condicionales de las lneas 3: y 6: ambas se evaluan a
falso, por lo que se ejecuta el enunciado de la lnea 10:, y se regresa el valor 1.
Esto se traduce en colocar en el espacio reservado para ello cerca del tope del
stack ese valor, quitar del tope del stack el registro de activacion de la llamada de
factorial(1) y continuar la ejecucion en la lnea 8: para hacer la multiplicacion. El
stack se ve como se muestra en la figura 7.28 en la pagina 229.
227 Administracion de la memoria durante ejecucion

En este punto se puede terminar de ejecutar la invocacion de factorial(2), por

lo que nuevamente se hace la multiplicacion y se coloca el resultado inmediata-
mente abajo de la ultima marca en el stack; se procede a desmontar el registro de
activacion de factorial(2).El stack se muestra en la figura 7.29 en la pagina 230.

Figura 7.26 Estado del stack al iniciarse la llamada de factorial desde factorial.

xinty n *2
direccion de
regreso #7:
factorial(2)
xlongy valor de regreso
xinty n *3
direccion de
regreso #7:
factorial(3)
xlongy valor de regreso
xinty n *4
direccion de
regreso #17:
factorial(4)
xlongy valor de regreso
xFactorialy f # heap
xConsolay cons # heap
d.r. Sistema
Operativo
main
xvoidy main #13: #3:

xlongy factorial #2: Contador

d.r. Sistema del
Operativo Programa
clase Factorial
7.2 Recursividad 228

Figura 7.27 Estado del stack al iniciarse la llamada de factorial desde factorial.

xinty n *1
direccion de
regreso #7:
factorial(1)
xlongy valor de regreso
xinty n *2
direccion de
regreso #7:
factorial(2)
xlongy valor de regreso
xinty n *3
direccion de
regreso #7:
factorial(3)
xlongy valor de regreso
xinty n *4
direccion de
regreso #17:
factorial(4)
xlongy valor de regreso
xFactorialy f # heap
xConsolay cons # heap
d.r. Sistema
Operativo
main
xvoidy main #13: #3:

xlongy factorial #2: Contador

d.r. Sistema del
Operativo Programa
clase Factorial
229 Administracion de la memoria durante ejecucion

Figura 7.28 Estado del stack al terminarse la llamada de factorial(1).

xlongy valor de regreso *1

xinty n *2
direccion de
regreso #7:
factorial(2)
xlongy valor de regreso
xinty n *3
direccion de
regreso #7:
factorial(3)
xlongy valor de regreso
xinty n *4
direccion de
regreso #17:
factorial(4)
xlongy valor de regreso
xFactorialy f # heap
xConsolay cons # heap
d.r. Sistema
Operativo
main
xvoidy main #13: #8:

xlongy factorial #2: Contador

d.r. Sistema del
Operativo Programa
clase Factorial

Se sale de la llamada de factorial(3), acomodando el resultado del producto del

resultado entregado por factorial(2) y 3. El stack se puede ver en la figura 7.30 en
la pagina 231.
Nuevamente, al regresar con el valor de factorial(3) en la lnea 7:, lo multiplica
por 4, usando para ello el valor que coloco la ejecucion de factorial(3) en el stack.
7.2 Recursividad 230

Despues de quitar el registro de activacion y la marca de factorial(3) el stack se ve

como se muestra en la figura 7.31 en la pagina opuesta.

Figura 7.29 Estado del stack al terminarse la llamada de factorial(2).

xlongy valor de regreso *2

xinty n *3
direccion de
regreso #7:
factorial(3)
xlongy valor de regreso
xinty n *4
direccion de
regreso #17:
factorial(4)
xlongy valor de regreso
xFactorialy f # heap
xConsolay cons # heap
d.r. Sistema
Operativo
main
xvoidy main #13: #8:

xlongy factorial #2: Contador

d.r. Sistema del
Operativo Programa
clase Factorial

En este momento se procede a escribir el valor de factorial(4) que fue entregado

y colocado en el stack. Se termina de ejecutar el programa, y de manera similar a
metodos no recursivos, se libera el stack y el contador del programa.
231 Administracion de la memoria durante ejecucion

Figura 7.30 Estado del stack al terminarse la llamada de factorial(3).

xlongy valor de regreso *6

xinty n *4
direccion de
regreso #17:
factorial(4)
xlongy valor de regreso
xFactorialy f # heap
xConsolay cons # heap
d.r. Sistema
Operativo
main
xvoidy main #13: #8:

xlongy factorial #2: Contador

d.r. Sistema del
Operativo Programa
clase Factorial

Figura 7.31 Estado del stack al terminarse la llamada de factorial desde main.

xlongy valor de regreso 24

xFactorialy f # heap
xConsolay cons # heap
d.r. Sistema
Operativo
main
xvoidy main #13: #18:

xlongy factorial #2: Contador

d.r. Sistema del
Operativo Programa
clase Factorial
7.2 Recursividad 232

Debemos insistir en que usamos la funcion factorial para mostrar la situacion

en el stack porque es facil de mostrar los cambios que va sufriendo el stack, no
porque sea un buen ejemplo para la recursividad. De hecho, dado que ya vimos el
trabajo escondido que tenemos con la recursividad, una forma mas economica de
calcular factorial es con una iteracion simple, que no involucra manejo del stack.
El metodo quedara codificado como se ve en el listado lis:s7-3.

Codigo 7.3 Factorial calculado iterativamente

s t a t i c p u b l i c long f a c t o r i a l ( i n t t o p e ) {
long f a c t = 1 ;
f o r ( i n t i = 2 ; i <= t o p e ; i ++) {
fact = fact i ;
}
return f a c t ;
}

7.2.1. Las torres de Hanoi

Un ejemplo donde se entiende muy bien la utilidad de la recursividad es en el

de las torres de Hanoi. El juego consiste de los siguiente:

El juego consiste de una tabla con tres postes pegados perpendiculares

a la tabla y n discos de radios distintos entre s y con un orificio en el
centro para poder ser colocados en los postes. Al empezar el juego se
encuentran los n discos en un mismo poste, acomodados por tamano
decreciente, el mas grande hasta abajo.

El juego consiste de pasar los n discos a un segundo palo, moviendo

disco por disco; esta prohibido que quede un disco encima de otro que
es menor que el.

En la figura 7.32 se muestra un ejemplo con 8 fichas.

Este juego tiene su origen en un monasterio tibetano, y consista de 64 fichas.
La leyenda deca que cuando se lograran mover las 64 fichas siguiendo las reglas el
mundo se iba a terminar. El algoritmo para lograr mover las n fichas se muestra
en la figura 7.33.
233 Administracion de la memoria durante ejecucion

Figura 7.32 Juego de las torres de Hanoi

Figura 7.33 Estrategia recursiva para las torres de Hanoi

$ $
'
'
' '
&Mover 1 ficha del poste 1 al 3
'
'
'
' n  2? Mover 1 ficha del poste 1 al 2
'
'
' '
%Mover 1 ficha del poste 3 al 2
'
&
Mover n fichas
' ` $
del poste 1 al poste 2 '
'
'
'
' &Mover n
1 fichas del poste 1 al 3
'
'
'
' n 2? Mover 1 ficha del poste 1 al 2
'
'
% '
%Mover n
1 fichas del poste 3 al 2

Lo que me dice esta estrategia es que si solo tenemos dos fichas las sabemos
mover a pie. Para el caso de que tenga mas de dos fichas (n 2), suponemos
que pudimos mover las n
1 fichas que estan en el tope del poste al poste auxiliar,
siguiendo las reglas del juego, despues movimos una sola ficha al poste definitivo, y
para terminar movimos las n
1 fichas del poste auxiliar al definitivo. Como en el
caso del calculo de factorial con recursividad, se entra al metodo decrementando la
7.2 Recursividad 234

n en 1 hasta que tengamos que mover una sola ficha; en cuanto la movemos, pasa-
mos a trabajar con el resto de las fichas. Hay que aclarar que esto funciona porque
se van intercambiando los postes 1, 2 y 3. El codigo (de manera esquematica) se
puede ver en el listado 7.4.

Codigo 7.4 Metodos para las torres de Hanoi

/
R e a l i z a e l m o v i m i e n t o de una f i c h a de un p o s t e a o t r o .
@param p o s t e 1 E l p o s t e d e s d e e l que s e mueven l a s f i c h a s .
@param p o s t e 2 E l p o s t e a l que s e mueve l a f i c h a .
/
p u b l i c v o i d mueveUno ( i n t p o s t e 1 , i n t p o s t e 2 ) {
/ E s c r i b e e l numero de p o s t e c o r r e s p o n d i e n t e
o d i b u j a e l movimiento /
System . o u t . p r i n t l n ( "Del " + p o s t e 1 + " al " + p o s t e 2 ) ;
}

/
Mueve n f i c h a s d e l poste1 a l poste2 , usando e l
poste3 como p o s t e de t r a b a j o .
@param n e l numero de f i c h a s a mover .
@param p o s t e 1 e l p o s t e d e s d e e l c u a l s e mueven .
@param p o s t e 2 e l p o s t e d e s t i n o .
@param p o s t e 3 e l p o s t e de t r a b a j o .
/
p u b l i c v o i d mueveN ( i n t n , i n t p o s t e 1 , i n t p o s t e 2 , i n t p o s t e 3 ) {
i f ( n == 2 ) {
mueveUno ( p o s t e 1 , p o s t e 3 ) ;
mueveUno ( p o s t e 1 , p o s t e 2 ) ;
mueveUno ( p o s t e 3 , p o s t e 2 ) ;
}
else {
mueveN ( n
1, p o s t e 1 , p o s t e 3 , p o s t e 2 ) ;
mueveUno ( p o s t e 1 , p o s t e 2 ) ;
mueveN ( n
1, p o s t e 3 , p o s t e 2 , p o s t e 1 ) ;
}
}

Podemos hacer el ejercicio con 4 fichas, llamando al procedimiento con

mueveN(4,1,2,3). Veamos en la 7.34 los anidamientos que se hacen. Debe ser cla-
ro que en el unico metodo que realmente hace trabajo es mueveUno, ya que para
n 2 todo lo que se hace es una llamada recursiva. Ilustraremos en las figuras
7.35 a 7.42 cual es el trabajo realizado en las llamadas a mueveUno.
235 Administracion de la memoria durante ejecucion

Figura 7.34 Secuencia de llamadas en la torres de Hanoi

mueveN(4,1,2,3)
4  2?
mueveN(3,1,3,2)
3  2?
mueveN(2,1,2,3)
2  2?
mueveUno(1,3) /* 1 */
mueveUno(1,2) /* 2 */
mueveUno(3,2) /* 3 */
mueveUno(1,3) /* 4 */
mueveN(2,2,3,1)
2  2?
mueveUno(2,1) /* 5 */
mueveUno(2,3) /* 6 */
mueveUno(1,3) /* 7 */
mueveUno(1,2) /* 8 */
mueveN(3,3,2,1)
3  2?
mueveN(2,3,1,2)
2  2?
mueveUno(3,2) /* 9 */
mueveUno(3,1) /* 10 */
mueveUno(2,1) /* 11 */
mueveUno(3,2) /* 12 */
mueveN(2,1,2,3)
2  2?
mueveUno(1,3) /* 13 */
mueveUno(1,2) /* 14 */
mueveUno(3,2) /* 15 */
7.2 Recursividad 236

Comprobemos que este algoritmo trabaja viendo una visualizacion con cuatro
fichas. En cada figura mostraremos los movimientos que se hicieron mediante
flechas desde el poste en el que estaba la ficha al poste en el que se coloco. Las
reglas exigen que cada vez que se mueve una ficha, esta sea la que se encuentra
hasta arriba.

Figura 7.35 Situacion de las fichas antes de la llamada

Figura 7.36 Movimientos /* 1 */ al /* 3 */

/* 1 */

/* 2 */
/* 3 */

Figura 7.37 Movimiento /* 4 */

/* 4 */
237 Administracion de la memoria durante ejecucion

Figura 7.38 Movimientos /* 5 */ al /* 7 */

/* 7 */

/* 6 */
/* 5 */

Figura 7.39 Movimiento /* 8 */

/* 8 */

Figura 7.40 Movimientos /* 9 */ al /* 11 */

/* 10 */

/* 11 */ /* 9 */
7.2 Recursividad 238

Figura 7.41 Movimiento /* 12 */

/* 12 */

Figura 7.42 Movimientos /* 13 */ al /* 15 */

/* 13 */

/* 14 */ /* 15 */

Como se puede ver del ejercicio con las torres de Hanoi, 4 fichas provocan
15 movimientos. Podramos comprobar que 5 fichas generan 31 movimientos. Es-
to se debe a la recursividad, que se encuentra escondida en la simplicidad del
algoritmo. Aunque definitivamente es mas facil expresarlo as, que ocupa aproxi-
madamente 10 lneas, que dar las reglas con las que se mueven las fichas de dos
en dos.
Entre otros ejemplos que ya no veremos por el momento, donde la solucion
recursiva es elegante y mucho mas clara que la iterativa se encuentra el recorrido
de arboles, las busquedas binarias y algunos ordenamientos como el de mezcla y
el de Quick.

Con esto damos por terminado una descripcion somera sobre como se com-
porta la memoria durante la ejecucion de un programa, en particular el stack de
ejecucion. Esta descripcion no pretende ser exhaustiva, sino unicamente propor-
cionar una idea de como identifica la ejecucion los puntos de entrada, de regreso
y parametros a una funcion.
 Ordenamientos
usando estructuras 8
de datos

8.1 Base de datos en un arreglo

Habiendo ya visto arreglos, se nos ocurre que puede resultar mas facil guardar
nuestras listas de cursos en un arreglo, en lugar de tenerlo en una lista ligada. Todo
lo que tenemos que hacer es pensar en cual es el tamano maximo de un grupo y
reservar ese numero de localidades en un arreglo. La superclase para el registro
con la informacion del estudiante queda casi exactamente igual al que utilizamos
como EstudianteBasico, excepto que como ahora la relacion de quien sigue a quien
va a estar dada por la posicion en el arreglo, no necesitamos ya la referencia al
siguiente estudiante. Todos los metodos quedan exactamente igual, excepto que
todo lo relacionado con el campo siguiente ya no aparece ver listado 8.1 en la
siguiente pagina.
8.1 Base de datos en un arreglo 240

Codigo 8.1 Superclase con la informacion basica de los estudiantes (InfoEstudiante)1/3

1: import i c c 1 . i n t e r f a z . C o n s o l a ;
2: /
3: Base de d a t o s , a b a s e de l i s t a s de r e g i s t r o s , que emula l a l i s t a
4: de un c u r s o de l i c e n c i a t u r a . T i e n e l a s o p c i o n e s n o r m a l e s de una
5: b a s e de d a t o s y f u n c i o n a m e d i a n t e un Menu .
6: /
7: p u b l i c c l a s s I n f o E s t u d i a n t e implements E s t u d i a n t e {
8: p r o t e c t e d S t r i n g nombre ,
9: cuenta ,
10: carrera ;
11: / C o n s t a n t e s s i m b o l i c a s p a r a i d e n t i f i c a r campo /
12: s t a t i c p u b l i c f i n a l i n t NOMBRE = 1 ;
13: s t a t i c p u b l i c f i n a l i n t CUENTA = 2 ;
14: s t a t i c p u b l i c f i n a l i n t CARRERA = 3 ; \
15: / C o n s t a n t e s p a r a e d i t a r m e j o r l o s campos .
16: R e g i s t r a n e l v a l o r c o r r e s p o n d i e n t e de mayor
17: tamano e n c o n t r a d o p a r a l a c l a s e .
18: /
19: s t a t i c p r o t e c t e d i n t maxTamN=0;
20: s t a t i c p r o t e c t e d i n t maxTamCta = 0 ;
21: s t a t i c p r o t e c t e d i n t maxTamCarr = 0 ;
22: / Para r e g r e s a r l a p o s i c i o n r e l a t i v a d e n t r o de l a l i s t a /
23: protected i n t pos ;
24: / Se u s a p a r a r e l l e n a r b l a n c o s . /
25: s t a t i c protected f i n a l S t r i n g b l a n c o s = r e p l i c a t e ( " " , 1 0 0 ) ;
26:
27: / C o n s t r u c t o r s i n p a r a m e t r o s . /
28: public InfoEstudiante () {
29: nombre = c a r r e r a = c u e n t a = n u l l ;
30: }
31:
32: / C o n s t r u c t o r que c o n s t r u y e e l o b j e t o con l o s d a t o s . /
33: p u b l i c I n f o E s t u d i a n t e ( S t r i n g nmbre , S t r i n g c nt a ,
34: String crrera ) {
35: nombre = nmbre . t r i m ( ) ;
36: cuenta = cnta . trim ( ) ;
37: carrera = c r r e r a . trim ( ) ;
38: maxTamN = Math . max ( nmbre . l e n g t h ( ) , maxTamN ) ;
39: maxTamCta = Math . max ( c u e n t a . l e n g t h ( ) , maxTamCta ) ;
40: maxTamCarr = Math . max ( c a r r e r a . l e n g t h ( ) , maxTamCarr ) ;
41: }
42:
43: / R e g r e s a e l v a l o r d e l a t r i b u t o nombre . /
44: p u b l i c S t r i n g getNombre ( ) {
45: r e t u r n t h i s . nombre ;
46: }
241 Ordenamientos usando estructuras de datos

Codigo 8.1 Superclase con la informacion basica de los estudiantes (InfoEstudiante)2/3

47: /
48: E s t a b l e c e e l v a l o r d e l a t r i b u t o nombre .
49: @param argNombre , c a d e n a .
50: /
51: p u b l i c v o i d setNombre ( S t r i n g argNombre ) {
52: t h i s . nombre = argNombre ;
53: }
54:
55: /
56: R e g r e s a e l v a l o r d e l a t r i b u t o cuenta .
57: /
58: public S t r i n g getCuenta () {
59: return this . cuenta ;
60: }
61:
62: / E s t a b l e c e e l v a l o r d e l a t r i b u t o cuenta . /
63: public void setCuenta ( S t r i n g argCuenta ) {
64: t h i s . cuenta = argCuenta ;
65: }
66:
67: / R e g r e s a e l v a l o r d e l a t r i b u t o carrera . /
68: public String getCarrera () {
69: return this . c a r r e r a ;
70: }
71:
72: / E s t a b l e c e e l v a l o r d e l a t r i b u t o carrera . /
73: public void s e t C a r r e r a ( S t r i n g a r g C a r r e r a ) {
74: this . carrera = argCarrera ;
75: }
76:
77: /
78: R e g r e s a l a p o s i c i o n r e l a t i v a de e s e r e g i s t r o en
79: la l i s t a .
80: @ r e t u r n La p o s i c i o n r e l a t i v a .
81: /
82: public i n t getPos () {
83: r e t u r n po s ;
84: }
85:
86: /
87: R e g i s t r a l a p o s i c i o n r e l a t i v a d e l r e g i s t r o .
88: @param p os La p o s i c i o n r e l a t i v a .
89: /
90: p u b l i c s e t P o s ( i n t p os ) {
91: t h i s . p os = po s ;
92: }
8.1 Base de datos en un arreglo 242

Codigo 8.1 Superclase con la informacion basica de los estudiantes (InfoEstudiante)3/3

93: / R e g r e s a e l campo i n d i c a d o d e l r e g i s t r o dado .
94: @param c u a l S e l e c c i o n a campo en e l r e g i s t r o .
95: @ r e t u r n e l v a l o r de e s e campo en e l r e g i s t r o .
96: /
97: p u b l i c S t r i n g getCampo ( i n t c u a l ) {
98: S t r i n g cadena ;
99: switch ( c u a l ) {
100: case NOMBRE:
101: c a d e n a = getNombre ( ) . t r i m ( ) . t o L o w e r C a s e ( ) ;
102: break ;
103: case CUENTA :
104: cadena = getCuenta ( ) . tr i m ( ) . toLowerCase ( ) ;
105: break ;
106: case CARRERA :
107: cadena = g e t C a r r e r a ( ) . tr i m ( ) . toLowerCase ( ) ;
108: break ;
109: default :
110: c a d e n a = " Campo no existente " ;
111: break ;
112: } // end o f s w i t c h ( c u a l )
113: return cadena ;
114: }
115:
116: / Arma una c a d e n a con e l c o n t e n i d o d e l r e g i s t r o .
117: @return e l contenido del r e g i s t r o .
118: /
119: public String armaRegistro () {
120: r e t u r n ( nombre . t r i m ( ) + b l a n c o s ) . s u b s t r i n g ( 0 , maxTamN + 1 )
121: + "\t"
122: + ( c u e n t a . t r i m ( ) + b l a n c o s ) . s u b s t r i n g ( 0 , maxTamCta + 1 )
123: + "\t"
124: + ( c a r r e r a . t r i m ( ) + b l a n c o s ) . s u b s t r i n g ( 0 , maxTamCarr + 1 )
125: + "\t" ;
126: }
127: / L l e n a un r e g i s t r o con l o s v a l o r e s de l o s a r g u m e n t o s .
128: @param nmbre Cadena con e l nombre .
129: @param c n t a Cadena con e l n umero de c u e n t a .
130: @param c r r e r a Cadena con l a c a r r e r a .
131: /
132: p u b l i c v o i d s e t R e g i s t r o ( S t r i n g nmbre , S t r i n g c n ta ,
133: String crrera ) {
134: nombre = nmbre . t r i m ( ) ;
135: cuenta = cnta . trim ( ) ;
136: carrera = c r r e r a . trim ( ) ;
137: }
138: }
243 Ordenamientos usando estructuras de datos

Como se puede observar en el listado 8.1 en la pagina 240, todo quedo practi-
camente igual, excepto que quitamos todo lo relacionado con la referencia al si-
guiente. En su lugar agregamos un campo para que el registro se identifique
a s mismo en cuanto a la posicion que ocupa en el arreglo, pos y los metodos
correspondientes. Este campo se vera actualizado cuando se entregue la referencia
del registro sin especificar su posicion.
La clase as definida puede ser usada, por ejemplo, para cuando queramos
una lista de estudiantes que tengan esta informacion basica incluida. Un posible
ejemplo se muestra en el listado 8.2. Esta jerarqua se puede extender tanto como
queramos. Si pensamos en estudiantes para listas usamos InfoEstudiante para he-
redar, agregando simplemente campos necesarios para mantener la lista, como en
el caso EstudianteLista del Listado 8.2.

Codigo 8.2 Extendiendo la clase InfoEstudiante (EstudianteLista)

1: p u b l i c c l a s s E s t u d i a n t e L i s t a extends I n f o E s t u d i a n t e {
2: / R e f e r e n c i a a l s i g u i e n t e de l a l i s t a /
3: protected E s t u d i a n t e L i s t a s i g u i e n t e ; \
4: / C o n s t r u c t o r s i n p a r a m t e r o s . /
5: public EstudianteLista () {
6: }
7: / C o n s t r u c t o r a p a r t i r de una c l a s e que i m p l e m e n t e a * Estudiante .
8: /
9: public EstudianteLista ( Estudiante est ) {
10: nombre = e s t . getNombre ( ) ;
11: cuenta = e s t . getCuenta ( ) ;
12: carrera = est . getCarrera ();
13: }
14: / C o n s t r u c t o r con l o s d a t o s p a r a l o s a t r i b u t o s .
15: /
16: p u b l i c E s t u d i a n t e L i s t a ( S t r i n g nmbre , S t r i n g c t a , S t r i n g c a r r ) {
17: super ( nmbre , c t a , c a r r ) ;
18: }
19: / R e g r e s a e l v a l o r d e l a t r i b u t o siguiente . /
20: public EstudianteLista getSiguiente () {
21: return this . s i g u i e n t e ;
22: }
23: / E s t a b l e c e e l v a l o r d e l a t r i b u t o siguiente . /
24: public void s e t S i g u i e n t e ( E s t u d i a n t e L i s t a a r g S i g u i e n t e ) {
25: this . siguiente = argSiguiente ;
26: }
27: }

Si en cambio queremos estudiantes para arreglos, usamos directamente In-

8.1 Base de datos en un arreglo 244

foEstudiante. Por ejemplo, si pensamos en registros para estudiantes de un curso

podemos usar la definicion de EstudianteCalifs para armar un curso ver Lista-
do 8.3.

Codigo 8.3 Extendiendo la clase InfoEstudiante con calificaciones (EstudianteCalifs) 1/3

1: p u b l i c c l a s s E s t u d i a n t e C a l i f s extends I n f o E s t u d i a n t e {
2: / Para a l m a c e n a r l a s c a l i f i c a c i o n e s d e l e s t u d i a n t e /
3: protected f l o a t [ ] c a l i f s ;
4: / V a l o r p o r o m i s i o n p a r a e l numero de c a l i f i c a c i o n e s . /
5: p r o t e c t e d f i n a l i n t MAX CALIFS = 1 0 ;
6: / C o n s t r u c t o r que e s t a b l e c e e l numero de c a l i f i c a c i o n e s
7: como e l v a l o r p o r o m i s i o n .
8: /
9: public E s t u d i a n t e C a l i f s () {
10: c a l i f s = new f l o a t [ MAX CALIFS ] ;
11: }
12: / C o n s t r u c t o r con v a l o r e s p a r a l o s a t r i b u t o s y numero de
13: calificaciones .
14: /
15: p u b l i c E s t u d i a n t e C a l i f s ( i n t c u a n t a s , S t r i n g nmbre , S t r i n g c t a ,
16: String crrera ) {
17: super ( nmbre , c t a , c r r e r a ) ;
18: c a l i f s = new f l o a t [ c u a n t a s ] ;
19: }
20: / C o n s t r u y e un o b j e t o nuevo a p a r t i r de uno en l a i n t e r f a z
21: en l a r a i z de l a e s t r u c t u r a j e r a r q u i c a de c l a s e s .
22: /
23: public E s t u d i a n t e C a l i f s ( Estudiante est , int numCalifs ) {
24: nombre = e s t . getNombre ( ) ;
25: carrera = est . getCarrera ();
26: cuenta = e s t . getCuenta ( ) ;
27: c a l i f s = new f l o a t [ n u m C a l i f s ] ;
28: }
29: / R e g r e s a e l v a l o r d e l a t r i b u t o califs . /
30: public float [ ] g e t C a l i f s () {
31: return this . c a l i f s ;
32: }
33: / E s t a b l e c e e l v a l o r d e l a t r i b u t o califs . /
34: public void s e t C a l i f s ( f l o a t [ ] a r g C a l i f s ) {
35: this . c a l i f s = argCalifs ;
36: }
37: / R e g r e s a e l v a l o r d e l a t r i b u t o MAX CALIFS . /
38: p u b l i c i n t getMAX CALIFS ( ) {
39: r e t u r n t h i s . MAX CALIFS ;
40: }
245 Ordenamientos usando estructuras de datos

Codigo 8.3 Extension de la clase InfoEstudiante con calificaciones (EstudianteCalifs)2/3

41: / C o l o c a l a c a l f i c a c i o n en l a p o s i c i o n i n d i c a d a .
42: @param c a l i f La c a l i f i c a c i on d e s e a d a .
43: @param donde La p o s i c i on d e s e a d a .
44: /
45: p u b l i c boolean s e t C a l i f ( f l o a t c a l i f , i n t donde ) {
46: / A s e g u r a r s e que l a p o s i c i o n e s t e en r a n g o s /
47: i f ( donde < 0 | | donde >= c a l i f s . l e n g t h ) {
48: return f a l s e ;
49: } // end o f i f ( donde < 0 ! ! donde >= c a l i f s . l e n g t h )
50: / A s e g u r a r s e que l a c a l i f i c a c i o n e s t e en r a n g o s /
51: c a l i f = Math . min ( 1 0 . 0 0 f , c a l i f ) ;
52: c a l i f = Math . max ( 0 f , c a l i f ) ;
53: / R e g i s t r a r l a c a l i f i c a c i o n /
54: c a l i f s [ donde ] = c a l i f ;
55: return true ;
56: }
57: / R e g r e s a l a c a l f i c a c i o n en l a p o s i c i o n i n d i c a d a .
58: @param donde La p o s i c i o n d e s e a d a .
59: /
60: p u b l i c f l o a t g e t C a l i f ( i n t donde ) {
61: / A s e g u r a r s e que l a p o s i c i o n e s t e en r a n g o s /
62: i f ( donde < 0 | | donde >= c a l i f s . l e n g t h ) {
63: return 0;
64: } // end o f i f ( donde < 0 ! ! donde >= c a l i f s . l e n g t h )
65: r e t u r n c a l i f s [ donde ] ;
66: }
67: / R e g r e s a una c a d e n a con e l r e g i s t r o armado .
68: /
69: public String armaRegistro () {
70: S t r i n g l i n e a = super . a r m a R e g i s t r o ( ) ;
71: l i n e a += m u e s t r a C a l i f s ( c a l i f s . l e n g t h ) ;
72: return l i n e a ;
73: }
74: / O b t i e n e e l p r o m e d i o de c a l i f i c a c i o n e s .
75: @param e l numero de c a l i f i c a c i o n e s a c o n s i d e r a r .
76: @ r e t u r n e l p r o m e d i o como un f l o a t .
77: /
78: public float calcPromedio ( int cuantos ) {
79: f l o a t suma = 0 . 0 f ;
80: i n t maxI = Math . min ( c a l i f s . l e n g t h , c u a n t o s ) ;
81: f o r ( i n t i = 0 ; i < maxI ; i ++) {
82: suma += c a l i f s [ i ] ;
83: } // end o f f o r ( i n t i = 0 ; . . .
84: r e t u r n suma / maxI ;
85: }
8.1 Base de datos en un arreglo 246

Codigo 8.3 Extension de la clase InfoEstudiante con calificaciones (EstudianteCalifs)3/3

86: / R e g r e s a una c a d e n a con l a s c a l i f i c a c i o n e s b i e n o r g a n i z a d a s .
87: @param e l numero de c a l i f i a c i o n e s a c o n s i d e r a r .
88: @ r e t u r n Una c a d e n a con l a s c a l i f i c i o n e s o r g a n i z a d a s .
89: /
90: public String muestraCalifs ( int cuantas ) {
91: i n t maxI = Math . max ( c a l i f s . l e n g t h , c u a n t a s ) ;
92: S t r i n g armada = "" ;
93: f o r ( i n t i = 0 ; i < maxI ; i ++) {
94: i n t p a r t e E n t e r a = Math . r o u n d ( c a l i f s [ i ]
0 . 5 f ) ;
95: i n t p a r t e F r a c c = Math . r o u n d ( c a l i f s [ i ] 1 0 0 ) % 1 0 0 ;
96: String edita ;
97: i f ( p a r t e E n t e r a > 9) {
98: e d i t a = p a r t e E n t e r a + "." ;
99:
100: } // end o f e l s e
101: else {
102: i f ( p a r t e E n t e r a == 0 ) {
103: e d i t a = "0." ;
104: } // end o f i f ( c a l i f s [ i ] == 0 )
105: else {
106: e d i t a = " " + p a r t e E n t e r a + "." ;
107: } // end o f e l s e
108:
109: } // end o f e l s e
110: i f ( p a r t e F r a c c > 9) {
111: e d i t a += p a r t e F r a c c ;
112: } // end o f i f ( p a r t e F r a c c > 9 )
113: else {
114: i f ( p a r t e F r a c c == 0 ) {
115: e d i t a += "00" ;
116: } // end o f i f ( p a r t e F r a c c == 0 )
117: else {
118: e d i t a += "0" + p a r t e F r a c c ;
119: } // end o f e l s e
120: } // end o f e l s e
121: armada += ( ( i % 5 == 0 && i > 0 )
122: ? "\n"
123: + r e p l i c a t e ( " " ,maxTamN +1) + "\t"
124: + r e p l i c a t e ( " " , maxTamCta + 1 ) +"\t"
125: + r e p l i c a t e ( " " , maxTamCarr + 1 ) +"\t\t"
126: : "\t" )
127: + edita ;
128: } // end o f f o r ( i n t i = 0 ; i < maxI ; i ++)
129: r e t u r n armada ;
130: }
131: }
247 Ordenamientos usando estructuras de datos

Queremos cambiar nuestra estructura de datos de una lista a un arreglo. Estas

dos estructuras de datos tienen semejanzas y diferencias. Veamos primero las
semejanzas:
En ambas estructuras existe una nocion de orden entre los elementos de la
estructura: podemos determinar cual elemento va antes y cual despues. Deci-
mos entonces que ambas estructuras son lineales porque podemos formar
a los elementos en una lnea. En el caso de los arreglos el orden esta dado
por el ndice, y en el caso de las listas esta dado por la posicion relativa entre
los elementos.
Todos los elementos de una lista o de un arreglo son del mismo tipo. Decimos
entonces que ambas estructuras son homogeneas.
En cuanto a las diferencias, mencionamos las siguientes:
Las listas pueden cambiar de tamano durante la ejecucion, mientras que
los arreglos, una vez definido su tamano, este ya no puede cambiar. Las
listas son estructuras dinamicas mientras que los arreglos son estructuras
estaticas.
El acceso al elemento de una lista se lleva a cabo recorriendo cada uno de
los elementos que estan antes que el que buscamos; esto es, es un acceso
secuencial ; el acceso a un elemento de un arreglo es mediante un ndice,
esto es acceso directo.
Dependiendo de que tipo de datos tengamos podremos elegir entre listas o
arreglos para nuestras estructuras de datos. Esta decision debera estar, de alguna
manera, justificada.
Para construir la clase que maneja el arreglo, lo primero es que en lugar de
una cabeza de lista deberemos tener el arreglo, definido de un cierto tamano, que
correspondera al maximo numero de elementos que esperamos. Nuestros algorit-
mos son exactamente igual, excepto que interpretamos de distinta manera toma
el siguiente, o colocate al principio. En el caso de que los registros esten en
un arreglo colocate al principio se interpreta como inicializa un ndice en 0;
y toma el siguiente se interpreta como incrementa en uno a la variable em-
pleada como ndice. Con esta representacion es facil obtener el anterior, ya que
unicamente se decrementa el ndice en 1, si es que existe anterior. Ademas, en
todo momento tenemos que tener cuidado de no tratar de tomar elementos mas
alla del fin del arreglo. Veamos como queda con estos cambios.1 Dado un arreglo
es facil saber cual es el tamano del arreglo, mediante el atributo length, pero no
es igual de facil saber el numero de elementos que se encuentran realmente en el
arreglo. Por lo tanto, es conveniente ir contando los registros que se agregan y los
1
Se recomienda referirse a los diagramas de Warnier-Orr donde se dieron los algoritmos en
su momento.
8.1 Base de datos en un arreglo 248

que se quitan, para que en todo momento se tenga claro el numero de elementos
que tenemos en un arreglo. En el listado 8.4 podemos ver lo relacionado con el
cambio de estructura de datos de una lista a un arreglo.

Codigo 8.4 Base de datos implementada en un arreglo (CursoEnVector)1/2

1: import i c c 1 . i n t e r f a z . C o n s o l a ;
2: p u b l i c c l a s s C u r s o E n V e c t o r implements C u r s o {
3: / En e s t e c u r s o s e van a r e g i s t r a r NUM CALIFS
4: c a l i f i c a c i o n e s . /
5: p r i v a t e i n t NUM CALIFS = 1 0 ;
6: / Numero p o r o m i s i o n de r e g i s t r o s . /
7: p r i v a t e f i n a l i n t MAXREG = 1 0 ;
8:
9: / E l a r r e g l o que a l m a c e n a a l a l i s t a . /
10: private EstudianteVector [ ] l i s t a ;
11: / Numero de g r u p o . /
12: private S t r i n g grupo ;
13: / Numero de e s t u d i a n t e s i n s c r i t o s . /
14: p r i v a t e i n t numRegs = 0 ;
15:
16: / C o n s t r u c t o r que e s t a b l e c e e l numero de g r u p o y c u a n t a s
17: calificaciones .
18: /
19: p u b l i c C u r s o E n V e c t o r ( S t r i n g gr , i n t n u m C a l i f s ) {
20: NUM CALIFS = n u m C a l i f s ;
21: grupo = gr ;
22: numRegs = 0 ;
23: l i s t a = new E s t u d i a n t e V e c t o r [MAXREG ] ;
24: }
25:
26: / C o n s t r u c t o r que e s t a b l e c e e l numero de g r u p o . c u a n t a s
27: c a l i f i c a c i o n e s y c u a l e s e l maximo de e s t u d i a n t e s .
28: /
29: p u b l i c C u r s o E n V e c t o r ( S t r i n g gr , i n t c u a n t o s , i n t n u m C a l i f s ) {
30: NUM CALIFS = n u m C a l i f s ;
31: grupo = gr ;
32: numRegs = 0 ;
33: l i s t a = new E s t u d i a n t e V e c t o r [ c u a n t o s ] ;
34: }
35:
36: / R e g r e s a e l v a l o r d e l a t r i b u t o numRegs . /
37: p u b l i c i n t getNumRegs ( ) {
38: r e t u r n numRegs ;
39: }
249 Ordenamientos usando estructuras de datos

Codigo 8.4 Base de datos implementada en un arreglo (CursoEnVector)2/2

40: / C o n s t r u c t o r que e s t a b l e c e e l numero de g r u p o y una l i s t a
41: i n i c i a l de e s t u d i a n t r e s i n s c r i t o s .
42: /
43: public CursoEnVector ( E s t u d i a n t e [ ] i n i c i a l e s , S t r i n g gr ) {
44: grupo = gr ;
45: i f ( i n i c i a l e s . l e n g t h > MAXREG) {
46: l i s t a = new E s t u d i a n t e V e c t o r [ Math . max ( 2
47: i n i c i a l e s . l e n g t h , 2 MAXREG ) ] ;
48: } // end o f i f ( i n i c i a l e s . l e n g t h )
49: else {
50: l i s t a = new E s t u d i a n t e V e c t o r [MAXREG ] ;
51: } // end o f e l s e
52: f o r ( i n t i = 0 ; i < i n i c i a l e s . l e n g t h ; i ++) {
53: l i s t a [ i ] = new E s t u d i a n t e V e c t o r ( i n i c i a l e s [ i ] ,
54: NUM CALIFS ) ;
55: numRegs ++;
56: } // end o f f o r ( i n t i = 0 ; i < i n i c i a l e s . l e n g t h ; i ++)
57: }

Hay algunas operaciones basicas que vamos a necesitar al trabajar con arreglos.
Por ejemplo, para agregar a un elemento en medio de los elementos del arreglo
(o al principio) necesitamos recorrer a la derecha a todos los elementos que se
encuentren a partir de la posicion que queremos que ocupe el nuevo elemento.
Esto lo tendremos que hacer si queremos agregar a los elementos y mantenerlos
en orden conforme los vamos agregando.
Similarmente, si queremos eliminar a alguno de los registros del arreglo, tene-
mos que recorrer a los que esten mas alla del espacio que se desocupa para que se
ocupe el lugar desocupado. En ambos casos tenemos que recorrer a los elementos
uno por uno y deberemos tener mucho cuidado en el orden en que recorramos a
los elementos. Al recorrer a la derecha deberemos recorrer desde el final del arre-
glo hacia la primera posicion que se desea mover. Si no se hace en este orden se
tendra como resultado el valor del primer registro que se desea mover copiado a
todos los registros a su derecha. El metodo para recorrer hacia la derecha se en-
cuentra en el listado 8.5 en la siguiente pagina. El metodo nos tiene que regresar
si pudo o no pudo recorrer a los elementos. En el caso de que no haya suficiente
lugar a la derecha, nos respondera falso, y nos respondera verdadero si es que
pudo recorrer.
Si deseamos regresar un lugar a la izquierda, el procedimiento es similar, ex-
cepto que tenemos que mover desde el primero hacia el ultimo, para no acabar
con una repeticion de lo mismo.
8.1 Base de datos en un arreglo 250

Codigo 8.5 Corrimiento de registros hacia la derecha e izquierda (CursoEnVector)

58: / R e c o r r e r r e g i s t r o s a p a r t i r d e l que e s t a en l a
59: p o s i c i o n d e s d e c u a n t o s l u g a r e s a l a d e r e c h a .
60: @param i n t d e s d e P o s i c i o n d e l p r i m e r r e g i s t r o a r e c o r r e r .
61: @param i n t c u a n t o s Numero de e s p a c i o s a r e c o r r e r .
62: @ r e t u r n s b o o l e a n S i pudo o no h a c e r l o .
63: /
64: / Hace l u g a r p a r t a i n s e r t a r a un e l e m e n t o en e l l u g a r que
65: l e c o r r e s p o n d e . /
66: p r i v a t e boolean r e c o r r e ( i n t de sde , i n t c u a n t o s ) {
67: i f ( numRegs + c u a n t o s >= l i s t a . l e n g t h )
68: return f a l s e ;
69: f o r ( i n t i = numRegs
1 ; i >= d e s d e ; i

) {
70: l i s t a [ i + cuantos ] = l i s t a [ i ] ;
71: l i s t a [ i + cuantos ] . setPos ( i + cuantos ) ;
72: l i s t a [ i ] = null ;
73: } // end o f f o r ( i n t i = numRegs
1 ; i >= d e s d e ; i

)
74: return true ;
75: }
76: / Se r e c o r r e n r e g i s t r o s a l a i z q u i e r d a p a r a o c u p a r un e s p a c i o
77: @param i n t d e s d e l a p r i m e r a p o s i c i o n que s e r e c o r r e h a c i a l a
78: izquierda
79: /
80: p r i v a t e boolean r e g r e s a ( i n t de sde , i n t c u a n t o s ) {
81: i f ( ( ( d e s d e
c u a n t o s ) < 0 ) | | ( d e s d e > numRegs
1)) {
82: return f a l s e ;
83: } // end o f i f ( ( d e s d e
c u a n t o s ) < 0 )
84:
85: f o r ( i n t i = d e s d e + 1 ; i < numRegs
1 ; i ++) {
86: l i s t a [ i
1] = l i s t a [ i ] ;
87: l i s t a [ i
1 ] . s e t P o s ( i
1);
88: } // end o f f o r ( i n t i = 0 ; i < numRegs
1 ; i ++)
89: numRegs
= c u a n t o s ;
90: return true ;
91: }

El metodo que regresaba la referencia de la lista del primer elemento de

la lista ahora debe regresar la referencia al arreglo completo. Queda como se
muestra en el listado 8.6 en la pagina opuesta, junto con los metodos que ponen
y regresan el numero de grupo, que no cambian.
Para saber el numero de registros en el arreglo ya no nos sirve revisarlo y
ver cuantas referencias distintas de null tiene. Por ejemplo, si el arreglo en vez de
objetos tiene numeros, y un valor valido para los numeros es el 0, no habra forma
de distinguir entre un lugar ocupado por un 0 o un lugar que no estuviera ocupado.
Por ello es conveniente ir contando los registros que se van agregando e ir descon-
251 Ordenamientos usando estructuras de datos

tando los que se quitan, con los registros activos ocupando posiciones consecutivas

Codigo 8.6 Metodos de acceso y manipulacion (CursoEnVector)

92: / R e g r e s a l a l i s t a de e s t u d i a n t e s .
93: /
94: public Estudiante [ ] getLista () {
95: return l i s t a ;
96: }
97: / P r o p o r c i o n a e l numero de g r u p o .
98: /
99: public S t r i n g getGrupo ( ) {
100: return grupo ;
101: }
102: / M o d i f i c a e l numero de g r u p o .
103: /
104: public void setGrupo ( S t r i n g gr ){
105: grupo = gr ;
106: }

en el arreglo. Por ello, ya no se calcula el numero de elementos en el arreglo, sino

que simplemente se regresa este valor. El metodo se encuentra en el listado 8.7.

Codigo 8.7 Metodo de acceso al numero de registros (CursoEnVector)

107: / R e g r e s a e l numero de r e g i s t r o s en l a l i s t a .
108: /
109: p u b l i c i n t getNumRegs ( ) {
110: r e t u r n numRegs ;
111: }

Tenemos tres maneras de agregar registros al arreglo. La primera de ellas, la

mas facil, es agregando al final de los registros, ya que esto no implica mover a
nadie, sino simplemente verificar cual es el siguiente lugar a ocupar. De manera
similar a que cuando el numero de elementos en un arreglo es n los ndices van
del 0 al n
1, si numRegs vale k quiere decir que los k registros ocupan las
posiciones 0 a k
1, por lo que la siguiente posicion a ocupar es, precisamente,
k. En general, numRegs contiene la siguiente posicion a ocuparse. Por lo que si
se agrega al final, lo unico que hay que hacer es ocupar el lugar marcado por
numRegs, incrementando a este ultimo.
Si vamos a agregar los registros siempre al principio del arreglo, lo que tenemos
que hacer es recorrer todos los registros un lugar a la derecha para desocupar
el primer lugar y colocar ah el registro.
8.1 Base de datos en un arreglo 252

Por ultimo, si se desea mantener ordenados los registros con un orden lexi-
cografico, primero tenemos que localizar el lugar que le toca. Una vez hecho esto
se recorren todos los registros a partir de ah un lugar a la derecha, y se coloca en
el lugar desocupado al nuevo registro.
En los tres casos, antes de agregar algun registro deberemos verificar que to-
dava hay lugar en el arreglo, ya que el arreglo tiene una capacidad fija dada en
el momento en que se crea. Como no siempre vamos a poder agregar registros
(algo que no suceda cuando tenamos una lista), todos estos metodos tienen que
decirnos de regreso si pudieron o no.
Para localizar el lugar que le toca a un registro nuevo lo vamos comparando
con los registros en el arreglo, hasta que encontremos el primero mayor que el.
Como el orden esta dado por el nombre, que es una cadena, tenemos que comparar
cadenas. El metodo compareTo de la clase String nos sirve para saber la relacion
entre dos cadenas, de la siguiente forma:

$
&
1 Si s1 s2
'
s1.compareTo(String s2) 0 Si s1 == s2
'
% 1 Si s1 s2

La programacion de estos tres metodos se puede apreciar en el listado 8.8.

Codigo 8.8 Agregando registros a la base de datos (CursoEnVector)1/2

112: /
113: Agrega un r e g i s t r o a l f i n a l de l a l i s t a .
114:
115: @param I n f o E s t u d i a n t e nuevo E l r e g i s t r o a a g r e g a r .
116: /
117: p u b l i c boolean a g r e g a E s t F i n a l ( E s t u d i a n t e nuevo ) {
118: int actual ;
119: i f ( numRegs >= l i s t a . l e n g t h )
120: return f a l s e ;
121: l i s t a [ numRegs++] = nuevo ;
122: return true ;
123: }
253 Ordenamientos usando estructuras de datos

Codigo 8.8 Agregando registros a la base de datos (CursoEnVector)2/2

124: /
125: Agrega un r e g i s t r o a l p r i n c i p i o de l a l i s t a .
126:
127: @param I n f o E s t u d i a n t e nuevo A q u i e n s e va a a g r e g a r
128: /
129: p u b l i c boolean a g r e g a E s t ( I n f o E s t u d i a n t e nuevo ) {
130: // R e c o r r e a t o d o s l o s e s t u d i a n t e s un l u g a r a l a d e r e c h a
131: i f (! recorre (0 ,1)) {
132: return f a l s e ;
133: }
134: l i s t a [ 0 ] = nuevo ;
135: numRegs++;
136: return true ;
137: }
138: /
139: Agrega un r e g i s t r o donde l a t o c a p a r a m an t e n e r l a l i s t a
140: ordenada .
141:
142: @param I n f o E s t u d i a n t e nuevo A q u i e n s e va a a g r e g a r
143: @ r e t u r n s b o o l e a n S i pudo o no a g r e g a r
144: /
145: p u b l i c boolean a g r e g a E s t O r d e n ( I n f o E s t u d i a n t e nuevo ) {
146: i f ( numRegs == l i s t a . l e n g t h ) {
147: return f a l s e ;
148: }
149: int actual = 0;
150: w h i l e ( a c t u a l < numRegs && l i s t a [ a c t u a l ] . daNombre ( )
151: . compareTo ( nuevo . daNombre ( ) ) <= 0 )
152: a c t u a l ++;
153: i f ( a c t u a l == numRegs ) { // E n t r a a l f i n a l
154: l i s t a [ a c t u a l ] = nuevo ;
155: numRegs++;
156: return true ;
157: }
158: i f (! recorre ( actual ,1)) {
159: return f a l s e ;
160: }
161: l i s t a [ a c t u a l ] = nuevo ;
162: numRegs++;
163: return true ;
164: }

Cuando deseamos agregar un registro de tal manera de mantener la lista en

orden, debemos, como ya dijimos, encontrarle el lugar que le toca, entre un registro
lexicograficamente menor o igual a el y el primero mayor que el. Esto lo hacemos
8.1 Base de datos en un arreglo 254

en las lneas 149: 152: del listado 8.8 en la pagina 252. Nos colocamos al principio
del vector, poniendo el ndice que vamos a usar para recorrerlo en 0 lnea 149:. A
continuacion, mientras no se nos acaben los registros del arreglo y estemos viendo
registros lexicograficamente menores al que buscamos condicionales en lneas
150: y 151: incrementamos el ndice, esto es, pasamos al siguiente.
Podemos salir de la iteracion porque se deje de cumplir cualquiera de las dos
condiciones: que ya no haya elementos en el arreglo o que ya estemos entre uno
menor o igual y uno mayor. En el primer caso habremos salido porque el ndice
llego al numero de registros almacenados actual == numRegs en cuyo caso
simplemente colocamos al nuevo registro en el primer lugar sin ocupar del arreglo.
No hay peligro en esto pues al entrar al metodo verificamos que todava hubiera
lugares disponibles.
En el caso de que haya encontrado un lugar entre dos elementos del arreglo,
tenemos que recorrer a todos los que son mayores que el para hacer lugar. Esto
se hace en la lnea 158:, donde de paso preguntamos si lo pudimos hacer segu-
ramente s porque ya habamos verificado que hubiera lugar. Una vez recorridos
los elementos del arreglo, colocamos el nuevo elemento en el lugar que se desocu-
po gracias al corrimiento, y avisamos que todo estuvo bien lneas 161: y 162:
no sin antes incrementar el contador de registros.

Codigo 8.9 Quitando a un estudiante de la base de datos (CursoEnVector)

165: / Q u i t a e l r e g i s t r o s o l i c i t a d o ( p o r nombre ) de l a l i s t a .
166: @param nombre E l e s t u d i a n t e que s e d e s e a e l i m i n a r .
167: /
168: p u b l i c boolean q u i t a E s t ( S t r i n g nombre ) {
169: int actual ;
170: nombre=nombre . t r i m ( ) . t o L o w e r C a s e ( ) ;
171: i f ( numRegs == 0 )
172: r e t u r n f a l s e ; // E s t a v a c a l a l i s t a : no s e pudo
173: actual = 0; // E l p r i m e r o de l a l i s t a
174: w h i l e ( a c t u a l < numRegs &&
175: ! ( l i s t a [ a c t u a l ] . daNombre ( ) . t o L o w e r C a s e ( ) .
176: e q u a l s ( nombre . t o L o w e r C a s e ( ) ) ) ) {
177: a c t u a l ++;
178: }
179: i f ( a c t u a l == numRegs )
180: return f a l s e ; // No s e e n c o n t r o
181: regresa ( actual , 1 ) ;
182: return true ;
183: }

Tambien el metodo que quita a un estudiante va a cambiar. El metodo hace

255 Ordenamientos usando estructuras de datos

lo siguiente: localiza al registro que contenga al nombre completo, que llega como
parametro lneas 174: a 178: del listado 8.9 en la pagina opuesta.
Una vez que encontro el registro en el que esta ese nombre, se procede a
desaparecerlo, recorriendo a los registros que estan despues que el un lugar a
la izquierda, encimandose en el registro que se esta quitando; esto se hace con la
llamada a regresa(actual,1) en la lnea 181: del listado 8.9 en la pagina opuesta. Al
terminar de recorrer a los registros hacia la izquierda, se decrementa el contador
de registros numRegs. La ubicacion de este decremento en el metodo regresa lnea
85: del listado 8.5 en la pagina 250 se justifica bajo la optica de que numRegs
indica la posicion del primer registro vaco; otra opcion hubiera sido poner el
decremento en quitaEst, que estara justificado bajo la optica de que numRegs
cuenta el numero de estudiantes en la base de datos. Como numRegs juega ambos
papeles la respuesta a donde poner el decremento no es unica. El diagrama de
Warnier correspondiente se encuentra en la Figura 8.1.

Figura 8.1 Algoritmo para eliminar a un estudiante

$ $
'
'
' '
' Colocarse al principio
'
' '
'
' $
'
'
' '
& '
'
'
' recorrer '
& Pasar al
'
'
' Localizar el nombre
'
' '
'
' (mientras haya
'
' '
' '
'
y actual buscado) '
siguiente
'
'
' '
% %
'
'
' $
'
'
' '
' '
'
Eliminar '& '
'
'
a un & Recorre un lugar a la izquierda
'
estudiante '
' se encontro a partir de donde se encontro
'
' '
'
'
'
'
' '
' Avisa que s
'
' '
%
'
'
'
'
'
'
'
' $
'
'
' '
'
' &
'
'
' se encontro
'
'
% '
%
Avisa que no

El metodo que busca una subcadena en alguno de los campos en el arreglo

cambia la forma en que nos colocamos al principio: colocarse al principio ahora
implica poner al ndice que vamos a usar para recorrerlo en 0 lnea 191: del
8.1 Base de datos en un arreglo 256

listado 8.10 mientras que tomar el siguiente quiere decir incrementar en 1 el

ndice que se esta usando para recorrer el arreglo lnea 194: del listado 8.10.

Codigo 8.10 Busqueda de una subcadena en algun campo del arreglo (CursoEnVector)
184: / Busca a l r e g i s t r o que c o n t e n g a a l a s u b c a d e n a .
185: @param i n t c u a l C u a l e s e l campo que s e va a c o m pa r ar .
186: @param S t r i n g s u b c a d La c a d e n a que s e e s t a b u s c a n d o .
187: @ r e t u r n s i n t E l r e g i s t r o d e s e a d o o
1. /
188: public I n f o E s t u d i a n t e buscaSubcad ( i n t cual , S t r i n g subcad ) {
189: int actual ;
190: subcad = subcad . trim ( ) . toLowerCase ( ) ;
191: actual = 0;
192: w h i l e ( a c t u a l < numRegs && ( l i s t a [ a c t u a l ] . daCampo ( c u a l ) .
193: i n d e x O f ( s u b c a d . t o L o w e r C a s e ( ) ) ) ==
1)
194: a c t u a l ++;
195: i f ( a c t u a l < numRegs )
196: return l i s t a [ a c t u a l ] ;
197: else
198: return n u l l ;
199: }

Otra diferencia es que cuando en un arreglo preguntamos si ya se nos acabaron

los elementos, lo que hacemos es preguntar si el ndice ya alcanzo al numero de
registros lnea 195: y no si la referencia es nula. Por lo tanto, recorremos el
arreglo mientras nuestro ndice sea menor que el numero de registros el ndice
sea valido y no tengamos enfrente en la posicion actual del arreglo a quien
estamos buscando.
Una vez recorrido el arreglo deberemos averiguar si encontramos o no la sub-
cadena. Si el ndice llego a ser el numero de registros, entonces no lo encontro. Si
no llego, el entero contenido en el ndice corresponde a la posicion de la subcadena
encontrada. El metodo procede, entonces, a regresar el registro que contiene a la
subcadena.
Una pregunta natural es por que no regresamos simplemente el ndice en el
que se encuentra el registro? La respuesta es muy sencilla. El ndice tiene sentido
como mecanismo de acceso al arreglo. Sin embargo, el arreglo es un dato privado
de VectorCurso, por lo que desde CursoMenu, y desde cualquier otra clase, no se
tiene acceso a el. Entonces, el conocer una posicion en el arreglo, desde fuera de
VectorCurso, no solo no nos sirve, sino que va contra los principios del encapsula-
miento, en el que los datos son privados en un 99 % de los casos (para hacer un
dato publico debera estar sumamente justificado). Adicionalmente, la clase que
maneja el menu queda practicamente identica a como estaba para el manejo de
257 Ordenamientos usando estructuras de datos

las listas, y esto es algo deseable. De esa manera podemos decir que la clase Me-
nuVector no tiene que saber como estan implementadas las estructuras de datos
o los metodos de la clase VectorLista, sino simplemente saber usarlos y saber que
le tiene que pasar como parametro y que espera como resultado. Excepto por
los metodos que agregan y quitan estudiantes, que los volvimos booleanos para
que informen si pudieron o no, todos los demas metodos mantienen la firma que
tenan en la implementacion con listas ligadas. Vale la pena decir que podramos
modificar los metodos de las listas ligadas a que tambien contestaran si pudieron
o no, excepto que en el caso de las listas ligadas siempre podran.

Codigo 8.11 Listar todos los registros de la base de datos (CursoEnVector)

200: /
201: L i s t a todos l o s r e g i s t r o s d e l Curso .
202:
203: @param C o n s o l a c o n s donde e s c r i b i r .
204: /
205: public void l i s t a T o d o s ( Consola cons ) {
206: int actual ;
207: f o r ( a c t u a l = 0 ; a c t u a l < numRegs ; a c t u a l ++) {
208: cons . imprimeln ( l i s t a [ a c t u a l ] . d a R e g i s t r o ( ) ) ;
209: }
210: i f ( a c t u a l == 0 ) {
211: c o n s . i m p r i m e l n ( "No hay registros en la base de datos " ) ;
212: }
213: }

Nos falta revisar nada mas dos metodos: el que lista todo el contenido de la base
de datos y el que lista solamente los que cazan con cierto criterio. Para el primer
metodo nuevamente se aplica la transformacion de que colocarse al principio de la
lista implica poner al ndice que se va a usar para recorrerla en 0 lnea 207: en el
listado 8.11. Nuevamente nos movemos por los registros incrementando el ndice
en 1, y verificamos al salir de la iteracion si encontramos lo que buscabamos o no.
En el caso del metodo que lista a los que cazan con cierto criterio listado 8.12
en la siguiente pagina nuevamente se recorre el arreglo de la manera que ya vimos,
excepto que cada uno que contiene a la subcadena es listado. Para saber si se listo o
no a alguno, se cuentan los que se van listando lnea 223: en el listado 8.12 en la
siguiente pagina. Si no se encontro ningun registro que satisficiera las condiciones
dadas, se da un mensaje de error manifestandolo.
8.2 Manteniendo el orden con listas ligadas 258

Codigo 8.12 Listando los que cumplan con algun criterio (CursoEnVector)
214: /
215: Imprim e l o s r e g i s t r o s que c a z a n con un c i e r t o p a t r o n .
216:
217: @param C o n s o l a c o n s D i s p o s i t i v o en e l que s e va a e s c r i b i r .
218: @param i n t c u a l Con c u a l campo s e d e s e a c o m pa r ar .
219: @param S t r i n g s u b c a d Con e l que queremos que c a c e .
220: /
221: p u b l i c v o i d losQueCazanCon ( C o n s o l a cons , i n t c u a l ,
222: S t r i n g subcad ) {
223: int i = 0;
224: subcad = subcad . toLowerCase ( ) ;
225: int actual ;
226:
227: / R e c o r r e m o s b u s c a n d o e l r e g s i t r o /
228: f o r ( a c t u a l = 0 ; a c t u a l < numRegs ; a c t u a l ++) {
229: i f ( l i s t a [ a c t u a l ] . daCampo ( c u a l ) . i n d e x O f ( s u b c a d ) !=
230:
1) {
231: i ++;
232: cons . imprimeln ( l i s t a [ a c t u a l ] . d a R e g i s t r o ( ) ) ;
233: }
234: }
235:
236: / S i no s e e n c o n t r o n i n g u n r e g i s t r o /
237: i f ( i == 0 ) {
238: c o n s . i m p r i m e l n ( "No se encontro ningun registro " +
239: "que cazara " ) ;
240: }
241: }

8.2 Manteniendo el orden con listas ligadas

Tenemos ya una clase que maneja a la base de datos en una lista ligada
(ListaCurso). Podemos modificar levemente ese programa para beneficiarnos de
la herencia y hacer que Estudiante herede de la clase InfoEstudiante, y de esa ma-
nera reutilizar directamente el codigo que ya tenemos para InfoEstudiante. Todo
lo que tenemos que hacer es agregarle los campos que InfoEstudiante no tiene y
los metodos de acceso y manipulacion para esos campos. La programacion de la
259 Ordenamientos usando estructuras de datos

clase utilizando herencia se puede observar en el listado 8.13.

Codigo 8.13 Definicion de la clase Estudiante para los registros (Estudiante) 1/3
1: import i c c 1 . i n t e r f a z . C o n s o l a ;
2: /
3: Base de d a t o s , a b a s e de l i s t a s de r e g i s t r o s , que emula l a l i s t a
4: de un c u r s o de l i c e n c i a t u r a . T i e n e l a s o p c i o n e s n o r m a l e s de una
5: b a s e de d a t o s y f u n c i o n a m e d i a n t e un Menu
6: /
7: c l a s s E s t u d i a n t e extends I n f o E s t u d i a n t e {
8: protected E s t u d i a n t e s i g u i e n t e ;
9: protected S t r i n g c l a v e ;
10: p u b l i c s t a t i c f i n a l i n t CLAVE = 4 ;
11: / C o n s t r u c t o r s i n p a r a m e t r o s . /
12: public Estudiante () {
13: super ( ) ;
14: clave = null ;
15: siguiente = null ;
16: }
17: /
18: C o n s t r u c t o r a p a r t i r de d a t o s de un e s t u d i a n t e .
19: Los campos v i e n e n s e p a r a d o s e n t r e s p o r comas , m i e n t r a s
20: que l o s r e g i s t r o s v i e n e n s e p a r a d o s e n t r e s p o r punto
21: y coma .
22: @param S t r i n g , S t r i n g , S t r i n g , S t r i n g l o s v a l o r e s p a r a
23: cada uno de l o s campos que s e van a l l e n a r .
24: @ r e t u r n E s t u d i a n t e una r e f e r e n c i a a una l i s t a
25: /
26: p u b l i c E s t u d i a n t e ( S t r i n g nmbre , S t r i n g c nt a , S t r i n g c l v e ,
27: String crrera ) {
28: super ( nmbre , c nt a , c r r e r a ) ;
29: clave = clve . trim ( ) ;
30: siguiente = null ;
31: }
32: /
33: R e g r e s a e l c o n t e n i d o d e l campo c l a v e .
34: /
35: public String getClave () {
36: return c l a v e ;
37: }
38: /
39: A c t u a l i z a e l campo c l a v e con e l v a l o r que p a s a como
40: p a r a m e t r o .
41: /
42: public void s e t C l a v e ( S t r i n g c l v e ) {
43: clave = clve ;
44: }
8.2 Manteniendo el orden con listas ligadas 260

Codigo 8.13 Definicion de la clase Estudiante para los registros (Estudiante)2/3

45: /
46: R e g r e s a e l campo que c o r r e s p o n d e a l s i g u i e n t e r e g i s t r o
47: en l a l i s t a
48: /
49: public Estudiante getSiguiente () {
50: return s i g u i e n t e ;
51: }
52: /
53: R e g r e s a e l campo s e l e c c i o n a d o d e l r e g i s t r o dado .
54: @param i n t E s t u d i a n t e E l numero d e l campo y e l r e g i s t r o .
55: @ r e t u r n s S t r i n g La c a d e n a s o l i c i t a d a
56: /
57: p u b l i c S t r i n g getCampo ( i n t c u a l ) {
58: S t r i n g cadena ;
59: switch ( c u a l ) {
60: case I n f o E s t u d i a n t e .NOMBRE:
61: c a d e n a = getNombre ( ) . t r i m ( ) . t o L o w e r C a s e ( ) ;
62: break ;
63: case I n f o E s t u d i a n t e . CUENTA :
64: cadena = getCuenta ( ) . tr i m ( ) . toLowerCase ( ) ;
65: break ;
66: case E s t u d i a n t e . CARRERA :
67: cadena = g e t C a r r e r a ( ) . tr i m ( ) . toLowerCase ( ) ;
68: break ;
69: case E s t u d i a n t e . CLAVE :
70: cadena = g e t C l a v e ( ) . tr i m ( ) . toLowerCase ( ) ;
71: break ;
72: default :
73: c a d e n a = " Campo no existente " ;
74: }
75: return cadena ;
76: }
77: /
78: A c t u a l i z a e l campo s i g u i e n t e con l a r e f e r e n c i a que s e
79: l a pasa .
80: @param s i g La r e f e r e n c i a a c o l o c a r .
81: /
82: public void s e t S i g u i e n t e ( E s t u d i a n t e s i g ) {
83: siguiente = sig ; \
84: }
85: /
86: Arma una c a d e n a con e l c o n t e n i d o de t o d o e l r e g i s t r o .
87: @ r e t u r n Una c a d e n a con e l r e g i s t r o d e s e a d o .
88: /
89: public String getRegistro () {
90: r e t u r n super . g e t R e g i s t r o ()+"\t"+c l a v e . t r i m ( ) ;
91: }
261 Ordenamientos usando estructuras de datos

Codigo 8.13 Definicion de la clase Estudiante para los registros (Estudiante)3/3

92: /
93: A c t u a l i z a t o d o e l r e g i s t r o de un j a l o n .
94: @param S t r i n g e l nombre ,
95: S t r i n g cuenta
96: String carrera
97: String clave .
98: /
99: p u b l i c v o i d s e t R e g i s t r o ( S t r i n g nmbre , S t r i n g c nta ,
100: String clve , String crrera ) {
101: super . s e t R e g i s t r o ( nmbre , c nta , c r r e r a ) ;
102: clave = clve . trim ( ) ;
103: }
104: }

Hay que notar que lo que programamos como de acceso privado cuando no
tomabamos en consideracion la herencia, ahora se convierte en acceso protegido,
para poder extender estas clases.
Algunos de los metodos que enunciamos en esta clase son, simplemente, meto-
dos nuevos para los campos nuevos. Tal es el caso de los que tienen que ver con
clave y siguiente. El metodo getCampo se redefine en esta clase, ya que ahora tiene
que considerar mas posibilidades. Tambien el metodo getRegistro es una redefini-
cion, aunque usa a la definicion de la superclase para que haga lo que corresponda
a la superclase.
Los constructores tambien son interesantes. Cada uno de los constructores,
tanto el que tiene parametros como el que no, llaman al correspondiente cons-
tructor de la superclase, para que inicialice los campos que tiene en comun con la
superclase.
La palabra super se esta utilizando de dos maneras distintas. Una de ellas,
en el constructor, estamos llamando al constructor de la superclase usando una
notacion con argumentos. En cambio, en el metodo getRegistro se usa igual que
cualquier otro objeto, con la notacion punto. En este segundo caso nos referimos
al super-objeto de this, a aquel definido por la superclase.

8.2.1. Revisita de la clase ListaCurso

Vimos en el captulo anterior practicamente todos los metodos relativos al

manejo de listas. Nos falto unicamente el metodo que agrega registros a la base
de datos, manteniendo el orden. Como en la parte anterior seguiremos teniendo al
8.2 Manteniendo el orden con listas ligadas 262

nombre como la llave (key) de nuestros registros, y es el que va a definir el orden.

Igual podramos tener el numero de cuenta o la carrera.
Para agregar un registro tenemos que distinguir entre tres situaciones distintas:
(a) La lista esta vaca, en cuyo caso le toca ser la cabeza de la lista.
(b) Ya hay registros en la lista pero todos van despues que el que se esta agre-
gando.
(c) Le toca entre dos registros que ya estan en la lista, o bien es el ultimo (ambos
casos se tratan igual).
El primer caso es sencillo, ya que simplemente inauguramos la lista con el
registro que se nos da. El segundo caso no es igual al tercero porque el nuevo
registro tiene que quedar en la cabeza de la lista ver figura 8.2, donde las flechas
punteadas son las referencias que deben de quedar. Por lo que la referencia que
queda antes es la de la cabeza de la lista y la que queda despues es la que antes
era la primera.

Figura 8.2 Agregando al principio de la lista

lista

Juan Pedro Samuel Yuridia

nuevo Alberto

En el caso de que no sea el primero que se agrega, y que no le toque al principio

de la lista, se debe recorrer la lista hasta que a su izquierda haya uno menor y a
su derecha uno mayor. Esto se logra, simplemente recorriendo la lista y parando
cuando se encuentre el final de la lista, o bien el primero que va a tener una llave
mayor que el nuevo. Una vez que se encontro el lugar, se modifican las referencias
al siguiente para que quede insertado en la lista ver figura 8.3 en la pagina
opuesta.
263 Ordenamientos usando estructuras de datos

Figura 8.3 Agregando en medio de la lista

lista

Juan Pedro Samuel Yuridia

nuevo Ricardo

El diagrama de Warnier que describe este proceso se encuentra en la figura 8.4

en la siguiente pagina y la programacion del metodo se puede ver en el listado 8.14.

Codigo 8.14 Agregar un registro manteniendo el orden (ListaCurso)1/2

105: / Agrega un e s t u d i a n t e en o r d e n en l a l i s t a .
106: @param E s t u d i a n t e nuevo E l r e g i s t r o a a g r e g a r
107: @ r e t u r n s b o o l e a n S i pudo o no h a c e r l o
108: /
109: p u b l i c boolean a g r e g a E s t O r d e n ( E s t u d i a n t e nuevo ) {
110: S t r i n g scompara = nuevo . daNombre ( ) . t r i m ( ) . t o L o w e r C a s e ( ) ;
111: i f ( l i s t a == n u l l ) // Es e l p r i m e r o que s e mete
112: l i s t a = nuevo ;
113: numRegs++;
114: return true ;
115: }
116: i f ( l i s t a . daNombre ( ) . t r i m ( ) . t o L o w e r C a s e ( )
117: . compareTo ( scompara ) > 0 ) {
118: // Le t o c a e l p r i m e r l u g a r de l a l i s t a , p e r o
119: // no e s e l u n i c o
120: nuevo . p o n S i g u i e n t e ( l i s t a ) ;
121: l i s t a = nuev ;
122: numRegs++;
123: return true ;
124: }
125: Estudiante actual = l i s t a . daSiguiente () ,
126: anterior = lista ;
127: w h i l e ( a c t u a l != n u l l && a c t u a l . daNombre ( ) . t r i m ( )
128: . t o L o w e r C a s e ( ) . compareTo ( scompara ) <= 0 ) {
129: anterior = actual ;
130: actual = actual . daSiguiente ();
131: }
8.2 Manteniendo el orden con listas ligadas 264

Codigo 8.14 Agregar un registro manteniendo el orden (ListaCurso)2/2

132: // S i a c t u a l == n u l l l e t o c a a l f i n a l de l a l i s t a
133: nuevo . p o n S i g u i e n t e ( a c t u a l ) ;
134: a n t e r i o r . p o n S i g u i e n t e ( nuevo ) ;
135: numRegs++;
136: return true ;
137: }

Figura 8.4 Agregando un registro en orden

$ !
'
'
' lista  H Colocalo en la cabeza de la lista
'
'
'
'
'
' $ $
'
'
' ' '
'
' '
'
'
Le toca al & Insertalo antes del
'
'
' '
'
'
' '
'
'
principio
' primer elemento
'
' '
' %
'
'
' '
' de la lista de la lista
'
' '
'
'
' '
'
' $
'
' '
'
'
'
' '
' '
' anterior Primero de
'
' '
' '
'
'
'
& '
'
' '
' la lista
'
' '
'
' actual Segundo de
Agrega registro '
' '
& '
'
'
en orden '
' '
'
'
' lista  H '
' $ la lista
'
' '
' '
'
'
'
' '
'
' Le toca al ' '
& Recorre ' '
' anterior actual
'
'
' '
' '
'
'
' '
'
' principio la lista ' '
'
'
'
' '
' '
' '
&
'
' '
' '
'
'
'
' '
'
'
de la lista
'
'
(mientras
'
'
' '
' '
' la llave ' '
'
' '
' '
'
' '
' actual siguiente
'
' '
' '
' '
'
'
'
' '
'
' '
'
sea menor
'
'
'
'
' '
' '
' o igual) %
'
' '
' '
'
'
% '
% %Insertalo entre anterior y actual

Debemos insistir en que se debe tener cuidado el orden en que se cambian las
referencias. Las referencias que vamos a modificar son la de nuevo y la siguiente
en anterior, que es la misma que tenemos almacenada en actual. Por ello, el orden
para cambiar las referencias podra haber sido
138: a n t e r i o r . p o n S i g u i e n t e ( nuevo ) ;
139: nuevo . p o n S i g u i e n t e ( a c t u a l ) ;
265 Ordenamientos usando estructuras de datos

Lo que debe quedar claro es que una vez modificado anterior.siguiente, esta refe-
rencia ya no se puede usar para colocarla en nuevo.siguiente.

8.3 *Ordenamiento usando arboles

Mantener una lista de cadenas ordenada alfabeticamente es costoso si la lista

la tenemos ordenada en un arreglo o en una lista ligada. El costo se expresa en
terminos de operaciones que debemos realizar para llevar a cabo una insercion,
remocion, modificacion, etc. de la lista. Por ejemplo, cuando tenemos la lista en
un arreglo, agregar a alguien quiere decir:
Encontrarle lugar
Recorrer a todos los que estan despues de el un lugar, para hacerle lugar al
nuevo.
Copiar el nuevo a ese lugar.
Similarmente, para quitar a alguien de la lista, debemos recorrer a todos los
que se encuentren despues de el para mantener a las cadenas en espacio contiguo.
Para el caso de listas ligadas, la remocion e insercion de registros es un poco
mas economica, pero para encontrar a alguien en promedio tenemos que hacer n{2
comparaciones, donde n es el tamano de la lista.
Deseamos mantener la lista ordenada, pero queremos bajar los tiempos de
localizacion de un registro, asumiendo que esta es la operacion mas frecuente
que deseamos hacer. Un metodo bastante eficiente de almacenar informacion que
se debe mantener ordenada (con respecto a algun criterio) es el de utilizar una
estructura de datos llamada arbol binario.
Empecemos por definir lo que es un arbol, para pasar despues a ver, especfi-
camente, a los arboles binarios. Un arbol es una estructura de datos dinamica,
no lineal, homogenea. Esta compuesta por nodos y los nodos estan relacionados
entre s de la siguiente manera:
Cada nodo tiene a un unico nodo apuntando a el. A este se le llama el nodo
padre.
Cada nodo apunta a cero o mas nodos. A estos nodos se les llama los hijos.
A los nodos que no tienen hijos se les llama hojas.
Existe un unico nodo privilegiado, llamado la raz del arbol, que no tiene
padre: corresponde al punto de entrada de la estructura.
A cada nodo le corresponde un nivel en el arbol, y se calcula sumandole 1
al nivel de su padre. La raz tiene nivel 1.
8.3 *Ordenamiento usando arboles 266

La profundidad del arbol es el maximo de los niveles de sus nodos.

Cada nodo del arbol va a tener un campo para la informacion que deseamos
organizar, y n referencias, donde n es el numero maximo de hijos que puede
tener un nodo.
Un arbol es n-ario si el maximo numero de hijos que puede tener es n. Es
binario, si el maximo numero de hijos es 2; terciario para tres hijos, y as suce-
sivamente. Podemos representar arboles con un numero arbitrario de hijos para
cada nodo, pero dejaremos ese tema para cursos posteriores. Tambien podemos
definir los arboles recursivamente:

$
'
&Un nodoque no tiene hijos
Un arbol n-ario es
'
% Un nodo que tiene como hijos a n arboles

A esta definicion le corresponde el esquema en la figura 8.5.

Figura 8.5 Definicion recursiva de un arbol

raz

Info
......

Arbol Arbol

Arbol

En estos momentos revisaremos unicamente a los arboles binarios, por ser estos
un mecanismo ideal para organizar a un conjunto de datos de manera ordenada.
Un arbol binario, entonces, es un arbol donde el maximo numero de hijos para
cada nodo es dos. Si lo utilizamos para organizar cadenas, podemos pensar que
dado un arbol, cada nodo contiene una cierta cadena. Todas las cadenas que se
encuentran en el subarbol izquierdo son menores a la cadena que se encuentra en
la raz. Todas las cadenas que se encuentran en el subarbol derecho, son mayores
267 Ordenamientos usando estructuras de datos

a la que se encuentra en la raz. Un arbol binario bien organizado se muestra en

la figura 8.6.

Figura 8.6 Arbol binario bien organizado

A P

E M Y

C F N R

B D G T

Cuando todos los nodos, excepto por las hojas del ultimo nivel, tienen exac-
tamente el mismo numero de hijos, decimos que el arbol esta completo. Si la pro-
fundidad del subarbol izquierdo es la misma que la del subarbol derecho, decimos
que el arbol esta equilibrado 2 . El arbol del esquema anterior no esta ni completo
ni equilibrado.
Para el caso que nos ocupa, la clase correspondientes a cada Estudiante vuelve
a extender a la clase InfoEstudiante, agregando las referencias para el subarbol
izquierdo y derecho, y los metodos de acceso y manipulacion de estos campos. La
programacion se puede ver en el listado 8.15 en la siguiente pagina.
Como se ve de la declaracion del registro ArbolEstudiante, tenemos una es-
tructura recursiva, donde un registro de estudiante es la informacion, con dos
referencias a registros de estudiantes.

2
En ingles, balanced
8.3 *Ordenamiento usando arboles 268

Codigo 8.15 Clase ArbolEstudiante para cada registro o nodo (ArbolEstudiante)

1: c l a s s A r b o l E s t u d i a n t e extends I n f o E s t u d i a n t e {
2: / R e f e r e n c i a s a s u b a r b o l i z q u i e r d o y d e r e c h o \
3: protected ArbolEstudiante izqrdo ,
4: /
5: C o n s t r u c t o r con l a i n f o r m a c i o n como a r g u m e n t o s .
6: /
7: p u b l i c A r b o l E s t u d i a n t e ( S t r i n g nmbre , S t r i n g c nt a ,
8: String crrera ) {
9: super ( nmbre , c nt a , c r r e r a ) ;
10: izqrdo = dercho = null ;
11: }
12: /
13: P r o p o r c i o n a l a r e f e r e n c i a d e l s u b a r b o l i z q u i e r d o .
14: /
15: public ArbolEstudiante getIzqrdo () {
16: return izqrdo ;
17: }
18: /
19: P r o p o r c i o n a l a r e f e r e n c i a a l s u b a r b o l d e r e c h o .
20: /
21: public ArbolEstudiante getDercho () {
22: return dercho ;
23: }
24: /
25: A c t u a l i z a e l s u b a r b o l i z q u i e r d o .
26: /
27: p u b l i c v o i d s e t I z q r d o ( A r b o l E s t u d i a n t e nuevo ) {
28: i z q r d o = nuevo ;
29: }
30: /
31: A c t u a l i z a e l s u b a r b o l d e r e c h o .
32: /
33: p u b l i c v o i d s e t D e r c h o ( A r b o l E s t u d i a n t e nuevo ) {
34: d e r c h o = nuevo ;
35: }
36: }

8.3.1. Construccion de arboles binarios para ordenamientos

Los arboles de ordenamiento se van construyendo conforme se van insertando

los nodos. Cuando se inicia la insercion y el arbol esta vaco, el primer dato que
llega se coloca en la raz. A partir de ese momento, si el dato nuevo es menor al
269 Ordenamientos usando estructuras de datos

de la raz, va a quedar en el subarbol izquierdo, mientras que si no es menor va

a quedar en el subarbol derecho. Esto quiere decir que si dos registros tienen la
misma llave (en este caso, nombres iguales pero que el resto de la informacion
difiere) el segundo que llegue va a quedar a la derecha del primero que llego (en
el subarbol derecho del nodo que contiene al que llego primero). En el diagrama
del arbol binario que dimos arriba, y si consideramos que la llave es la letra que
aparece, un posible orden de llegada de los registros pudo ser H, P, Y, R,
M, A, E, C, F, D, T, B, N. No cualquier orden de llegada
produce el mismo arbol. En este ejemplo, si los registros van llegando ya ordenados
de menor a mayor, el arbol que se obtiene es el que se puede ver en la figura 8.7.

Figura 8.7 Arbol que se forma si los registros vienen ordenados

A

Esto es lo que conocemos como un arbol degenerado, pues degenero en una

lista. Esta es una situacion poco afortunada, pues cuando utilizamos un arbol para
ordenar, queremos que los datos lleguen con un cierto desorden, que nos garantiza
8.3 *Ordenamiento usando arboles 270

un arbol mas equilibrado. Dados n registros en un arbol, la menor profundidad se

alcanza cuando el arbol esta equilibrado, mientras que la mayor profundidad se
alcanza cuando tenemos un arbol degenerado como el que acabamos de mostrar.
Hay varios resultados importantes respecto a arboles binarios que se reflejan en la
eficiencia de nuestras busquedas. En un arbol equilibrado con n nodos, una hoja
esta, en promedio, a distancia log2 n; mientras que la distancia de la cabeza de
una lista a alguno de sus elementos es en promedio de n{2.
Una forma de buscar que el arbol quede equilibrado es mediante el uso de una
raz que contenga un dato fantasma, y que este dato fantasma resulte ser un buen
dato de en medio para el arbol. Por ejemplo, dado que la M se encuentra a
la mitad del alfabeto, un buen dato fantasma para la raz pudiera ser un registro
con Ms en el. De esa manera, al menos la mitad de los datos quedara a su
izquierda y la otra mitad a su derecha. En general, asumimos que los datos vienen
desordenados, y en este caso tenemos una distribucion adecuada para armar el
arbol.

8.3.2. La clase ArbolOrden

Queremos reutilizar en la medida de lo posible las clases que tenemos tanto

para el manejo de la estructura de datos como del menu que invoca a los metodos
de aquella. Para ello mantendremos las firmas de los metodos publicos de la clase
ListaCurso, excepto que en todo lugar donde aparece un objeto de la clase Estu-
diante nosotros vamos a usar uno de la clase ArbolEstudiante. Hay dos metodos en
esta clase que no vamos a utilizar porque la unica manera en que vamos a meter
registros es manteniendo el orden y que son agregaEst y agregaEstFinal. Lo que
vamos a hacer con estos dos metodos es que regresen el valor false ya que no va a
ser cierto que agreguemos as.
Otro aspecto importante es que como la estructura de datos es recursiva, lo
ideal es manejarla con metodos recursivos. Pero como la firma de cada uno de los
metodos publicos es fija, lo que haremos en cada uno de los metodos publicos es
desde all llamar por primera vez al metodo recursivo que va a hacer el trabajo, y
el metodo recursivo, que va a ser privado, es el que se va a encargar de todo.

8.3.3. Insercion

El algoritmo que nos permite insertar un registro en el arbol es como se muestra

en el diagrama de la figura 8.8 en la pagina opuesta. Queda programado, de
271 Ordenamientos usando estructuras de datos

acuerdo al algoritmo anterior, como se puede apreciar en el listado 8.16 en la

siguiente pagina.
Del algoritmo en la figura 8.8 podemos ver que unicamente podemos agregar
un registro cuando le encontramos lugar como una hoja. Lo que tenemos que hacer
es ir bajando por la izquierda o la derecha del arbol, dependiendo del resultado
de comparar al registro que se desea agregar con el que se encuentra en la raz del
subarbol en turno. El algoritmo se traduce bastante directamente a codigo.

Figura 8.8 Agregar un registro manteniendo el orden

$
'
'
'
'
' $
'
'
' &
'
'
' Arbol vaco Colocalo en la raz
'
'
' %
'
'
'
'
'
'
'
' $ $
'
'
' '
' '
'
'
' '
' '
'
' $
'
' '
'
' '
' '
'
'
' '
' '
' '
'
'
' '
' '
' & Inserta registro en el
'
' '
' '
'
'
Hay subarbol
'
' '
'
' '
' '
'
'
' '
' '
'
izquierdo '
' subarbol izquierdo
'
' '
' Dato menor & %
'
' '
'
'
'
'
Inserta ' '
'
que el de la
'
'
& '
' '
'
' $
'
'
'
raz '
'
nodo
'
' '
' '
'
'
en '
' '
' '
'
' & Coloca el registro como
'
arbol '
'
& '
' Hay subarbol
'
'
' '
'
'
' Arbol vaco '
' izquierdo ' '
' subarbol izquierdo
'
' '
' '
% %
'
' '
'
'
'
'
' '
'
'
' '
'
' #
'
'
' '
' $
'
' '
'
' '
' Hay subarbol Inserta registro en el
'
'
' '
' '
'
'
' '
' '
'
' derecho subarbol derecho
'
' '
'
' '
&
'
'
' '
'
Dato menor
'
' '
'
' $
'
'
' '
'
que el de la
'
' '
&
'
' '
' raz '
'
'
'
' '
'
' '
'
'
'
' '
% '
%
Hay subarbol
'
%
Coloca el registro como
'
'
' derecho subarbol derecho
'
%
8.3 *Ordenamiento usando arboles 272

Codigo 8.16 Agregar un registro en un arbol binario ordenado (ArbolOrden)

1: p u b l i c c l a s s A r b o l O r d e n {
2: / La r a z d e l a r b o l /
3: private ArbolEstudiante r a i z ;
4: private S t r i n g grupo ;
5: p r i v a t e i n t numRegs ;
6: / Agrega un r e g i s t r o a l f i n a l de l a l i s t a
7: @param A r b o l E s t u d i a n t e nuevo E l r e g i s t r o a a g r e g a r .
8: /
9: p u b l i c boolean a g r e g a E s t F i n a l ( A r b o l E s t u d i a n t e nuevo ) {
10: return f a l s e ;
11: }
12: / Agrega un r e g i s t r o a l p r i n c i p i o de l a l i s t a
13: @param I n f o E s t u d i a n t e nuevo A q u i e n s e va a a g r e g a r
14: /
15: p u b l i c boolean a g r e g a E s t ( A r b o l E s t u d i a n t e nuevo ) {
16: return f a l s e ;
17: }
18: / Agrega un r e g i s t r o donde l a t o c a p a r a m an t e n e r l a l i s t a
19: ordenada
20: @param A r b o l E s t u d i a n t e nuevo A q u i e n s e va a a g r e g a r
21: @ r e t u r n s b o o l e a n S i pudo o no a g r e g a r
22: /
23: p u b l i c boolean a g r e g a E s t O r d e n ( A r b o l E s t u d i a n t e nuevo ) {
24: i f ( r a i z == n u l l ) { // Es e l p r i m e r o
25: r a i z = nuevo ;
26: return true ;
27: }
28: r e t u r n meteEnArbol ( r a i z , nuevo ) ;
29: }
30: / Tengo l a s e g u r i d a d de l l e g a r aca con r a i z != n u l l /
31: p r i v a t e boolean meteEnArbol ( A r b o l E s t u d i a n t e r a i z ,
32: A r b o l E s t u d i a n t e nuevo ) {
33: i n t compara = nuevo . daNombre ( ) . t r i m ( ) . t o L o w e r C a s e ( )
34: . compareTo ( r a i z . daNombre ( ) . t r i m ( ) . t o L o w e r C a s e ( ) ) ;
35: i f ( compara < 0 && r a i z . g e t I z q r d o ( ) == n u l l ) {
36: r a i z . p o n I z q r d o ( nuevo ) ;
37: return true ;
38: }
39: i f ( compara >= 0 && r a i z . g e t D e r c h o ( ) == n u l l ) {
40: r a i z . s e t D e r c h o ( nuevo ) ;
41: return true ;
42: }
43: i f ( compara < 0 )
44: r e t u r n meteEnArbol ( r a i z . g e t I z q r d o ( ) , nuevo ) ;
45: else
46: r e t u r n meteEnArbol ( r a i z . g e t D e r c h o ( ) , nuevo ) ;
47: }
273 Ordenamientos usando estructuras de datos

8.3.4. Listar toda la base de datos

Tenemos tres posibles recorridos para listar la informacion en un arbol bina-

rio ordenado, dependiendo de cual sea el orden que sigamos para ir listando el
contenido de cada registro:
Recorrido en preorden
Recorrido simetrico
Recorrido en postorden
El siguiente algoritmo que vamos a revisar es el que se encarga de mostrar
o recorrer la lista. Si nuestra lista unicamente tuviera tres registros, y el arbol
estuviera equilibrado, se vera como en la figura 8.9 (el orden de llegada pudo
haber sido primero Anita y despues Octavio, pero si hubiera llegado primero
Anita u Octavio el arbol no se hubiera armado equilibrado).

Figura 8.9 Ejemplo simple para recorridos de arboles

raz

Manuel

Anita Octavio

Como podemos ver en este esquema, para listar el contenido de los nodos en
orden tenemos que recorrer el arbol de la siguiente manera:

Muestra el hijo izquierdo

Muestra la raz
Muestra el hijo derecho
y este orden de recorrido nos entrega la lista en el orden adecuado. A este recorrido
se le conoce como inorden o simetrico, pues la raz se visita entre los dos hijos.
Tenemos otros ordenes de recorrido posibles. Por ejemplo, si visitaramos primero
a la raz, despues al hijo izquierdo y despues al hijo derecho, tendramos lo que se
conoce como preorden. Y si primero visitaramos a los dos hijos y por ultimo a la
raz, tendramos lo que se conoce como postorden o notacion polaca (este nombre
se utiliza porque los arboles son muy utiles no nada mas para ordenamientos, sino
que se utilizan para denotar la precedencia en operaciones aritmeticas). Dado que
8.3 *Ordenamiento usando arboles 274

los arboles son estructuras recursivas, el hijo izquierdo es, a su vez, un arbol (lo
mismo el hijo derecho). Por ello, si pensamos en el caso mas general, en que el
hijo izquierdo pueda ser un arbol tan complicado como sea y el hijo derecho lo
mismo, nuestro algoritmo para recorrer un arbol binario arbitrario quedara como
se muestra en el esquema de la figura 8.10.

Figura 8.10 Recorrido simetrico de un arbol

$ !
'
'
' Hay hijo izquierdo Visita subarbol izquierdo
'
'
'
'
'
'
'
' $
'
'
' &
'
%H
'
'
'
Hay hijo izquierdo
'
'
&
Visita subarbol Procesa la raz
'
' !
'
'
' Hay hijo derecho Visita subarbol derecho
'
'
'
'
'
'
'
' $
'
'
' &
'
'
'
' %H
Hay hijo derecho
%

En nuestro caso, el proceso del nodo raz de ese subarbol en particular consiste
en escribirlo. El metodo publico que muestra toda la lista queda con la firma como
la tena en las otras dos versiones que hicimos, y programamos un metodo privado
que se encargue ya propiamente del recorrido recursivo, cuya firma sera

p r i v a t e v o i d l i s t a A r b o l ( C o n s o l a cons , A r b o l E s t u d i a n t e r a i z )

Debemos recordar que este es un metodo privado de la clase ArbolOrden, por

lo que siempre que lo invoquemos tendra implcito un objeto de esta clase como
primer argumento. Los metodos listaTodos y listaArbol quedan programados como
se muestra en los listados 8.17 en la pagina opuesta y 8.18 en la pagina opuesta
respectivamente.
275 Ordenamientos usando estructuras de datos

Codigo 8.17 Listado de la base de datos completa (ArbolOrden)

208: / L i s t a t o d o s l o s r e g i s t r o s d e l C u r s o .
209: @param C o n s o l a c o n s donde e s c r i b i r .
210: /
211: public void l i s t a T o d o s ( Consola cons ) {
212: i f ( r a i z == n u l l ) {
213: c o n s . i m p r i m e l n ( "No hay registros en la base de datos " ) ;
214: return ;
215: }
216: l i s t a A r b o l ( cons , r a i z ) ;
217: }

Codigo 8.18 Recorrido simetrico del arbol (ArbolOrden)

218: / R e c o r r i d o s i m e t r i c o r e c u r s i v o de un a r b o l .
219: @param C o n s o l a c o n s Donde e s c r i b i r .
220: A r b o l E s t u d i a n t e r a i z La r a z d e l s u b a r b o l .
221: /
222: p r i v a t e v o i d l i s t a A r b o l ( C o n s o l a cons , A r b o l E s t u d i a n t e r a i z ) {
223: i f ( r a i z == n u l l )
224: return ;
225: l i s t a A r b o l ( cons , r a i z . g e t I z q r d o ( ) ) ;
226: cons . imprimeln ( r a i z . d a R e g i s t r o ( ) ) ;
227: l i s t a A r b o l ( cons , r a i z . g e t D e r c h o ( ) ) ;
228: }

8.3.5. Conservacion de la aleatoriedad de la entrada

Quisieramos guardar el contenido del arbol en disco, para la proxima vez em-
pezar a partir de lo que ya tenemos. Si lo guardamos en orden, cuando lo volvamos
a cargar va a producir un arbol degenerado, pues ya vimos que lo peor que nos
puede pasar cuando estamos cargando un arbol binario es que los datos vengan en
orden (ya sea ascendente o descendente). Por ello, tal vez sera mas conveniente
recorrer el arbol de alguna otra manera. Se nos ocurre que si lo recorremos en
preorden, vamos a producir una distribucion adecuada para cuando volvamos a
cargar el directorio. Esta distribucion va a ser equivalente a la original, por lo que
estamos introduciendo un cierto factor aleatorio. El algoritmo es igual de sencillo
que el que recorre en orden simetrico y se muestra en la figura 8.11 en la siguiente
pagina.
8.3 *Ordenamiento usando arboles 276

Figura 8.11 Recorrido en preorden de un arbol

$
'
'
' Procesa la raz !
'
'
'
'
'
'
Hay hijo izquierdo Recorrelo en preorden
'
'
'
'
' #
'
'
'
'
'
' Hay hijo izquierdo
Recorrido en
'
& H
preorden '
'
' !
'
'
' Hay hijo derecho Recorrelo en preorden
'
'
'
'
'
'
'
' $
'
'
' &
'
'
'
' %H
Hay hijo derecho
%

8.3.6. Busquedas

Para encontrar un registro dado en el arbol, debemos realizar algo similar a

cuando lo insertamos. Compara con la llave de la raz. Si son iguales, ya lo encon-
tramos. Si el que busco es menor, recursivamente busco en el subarbol izquierdo.
Si el que busco es mayor, recursivamente busco en el arbol derecho. Decido que
no esta en el arbol, si cuando tengo que bajar por algun hijo, este no existe. La
unica diferencia entre el algoritmo que inserta y el que busca, es la reaccion cuan-
do debemos bajar por algun hijo (rama) que no existe. En el caso de la insercion
tenemos que crear al hijo para poder acomodar ah la informacion. En el caso de
la busqueda, nos damos por vencidos y respondemos que la informacion que se
busca no esta en el arbol. El algoritmo se muestra en la figura 8.12 en la pagina
opuesta.

Si no se encuentra al estudiante, el metodo debera regresar una referencia nula.

La programacion de este metodo se puede apreciar en el listado 8.19 en la pagina
opuesta.
277 Ordenamientos usando estructuras de datos

Figura 8.12 Busqueda en un arbol ordenado

$ !
'
'
' nombre = campo Regresa esta raz
'
'
'
'
'
' #
'
' $
'
'
' '
' Hay hijo Encuentra nombre en
'
' '
'
'
'
'
' '
' izquierdo subarbol izquierdo
'
' '
&
'
'
'
' nombre campo $
'
'
' '
' '
&
'
' '
'
'
'
& '
'
'
Hay hijo
H
Encuentra nombre % izquierdo '%
en subarbol '
'
'
'
'
' #
'
' $
'
'
' '
' Hay hijo Encuentra nombre en
'
' '
'
'
'
'
' '
' derecho subarbol derecho
'
' '
&
'
'
'
' nombre campo $
'
'
' '
' '
&
'
' '
'
'
'
'
' '
'
'
Hay hijo
H
'
% % derecho ' %

Codigo 8.19 Busqueda del registro con el nombre dado (ArbolOrden)

229: / L o c a l i z a e l nodo d e l a r b o l en e l que e s t a e s t e nombre .
230: @param A r b o l E s t u d i a n t e r a i z La r a z d e l s u b a r b o l en e l que va
231: a buscar .
232: @param S t r i n g nombre E l nombre que e s t a b u s c a n d o .
233: @ r e t u r n s A r b o l E s t u d i a n t e La r e f e r e n c i a de donde s e e n c u e n t r a
234: e s t e r e g i s t r o , o n u l l s i no l o e n c o n t r o .
235: /
236: p r i v a t e A r b o l E s t u d i a n t e buscaDonde ( A r b o l E s t u d i a n t e r a i z ,
237: S t r i n g nombre ) {
238: i f ( r a i z == n u l l ) return n u l l ;
239: i n t compara = nombre . t r i m ( ) . t o L o w e r C a s e ( ) .
240: compareTo ( r a i z . daNombre ( ) . t r i m ( ) . t o L o w e r C a s e ( ) ) ;
241: i f ( compara == 0 ) return r a i z ;
242: i f ( compara < 0 )
243: r e t u r n buscaDonde ( r a i z . g e t I z q r d o ( ) , nombre ) ;
244: else
245: r e t u r n buscaDonde ( r a i z . g e t D e r c h o ( ) , nombre ) ;
246: }
8.3 *Ordenamiento usando arboles 278

Figura 8.13 Busqueda de una subcadena

$ !
'
'
' subarbol vaco regresa nulo
'
'
'
'
'
' !
'
'
'
'
'
'
cadena en raz regresa la raz
'
'
'
'
' #
'
'
&Hay arbol izquierdo donde Busca cadena en
Busca cadena
' subarbol izquierdo
en subarbol '
'
'
'
'
' !
'
'
' 
'
'
'
donde

nulo Regresa donde
'
'
'
'
' #
'
'
' Regresa busqueda en
'
%Hay subarbol derecho
subarbol derecho

El otro tipo de busqueda que tenemos en nuestro programa es el de localizar a

algun registro que contenga a la subcadena pasada como parametro, en el campo
pasado como parametro. Para dar satisfaccion a esta solicitud debemos recorrer el
arbol hasta encontrar la subcadena en alguno de los registros. El problema es que
como se trata de una subcadena no nos ayuda el orden en el arbol. El algoritmo
para esta busqueda se muestra en la figura 8.13 mientras que la programacion se
muestra en el listado 8.20.

Codigo 8.20 Busqueda de subcadena en determinado campo (ArbolOrden)1/2

177: /
178: Busca a l r e g i s t r o que c o n t e n g a a l a s u b c a d e n a .
179:
180: @param i n t c u a l C u a l e s e l campo que s e va a c o m pa r ar .
181: @param S t r i n g s u b c a d La c a d e n a que s e e s t a b u s c a n d o .
182: @ r e t u r n s i n t E l r e g i s t r o d e s e a d o o
1.
183: /
184: public A r b o l E s t u d i a n t e buscaSubcad ( i n t cual , S t r i n g subcad ) {
185: subcad = subcad . trim ( ) . toLowerCase ( ) ;
186: r e t u r n p r e O r d e n ( c u a l , subcad , r a i z ) ;
187: }
279 Ordenamientos usando estructuras de datos

Codigo 8.20 Busqueda de subcadena en determinado campo (ArbolOrden) 2/2

177: / R e c o r r e e l a r b o l en p r e o r d e n h a s t a e n c o n t r a r una s u b c a d e n a .
178: @param i n t c u a l Campo en e l c u a l b u s c a r .
179: @param S t r i n g s u b c a d Cadena a l o c a l i z a r .
180: @param A r b o l E s t u d i a n t e r a i z R a z d e l a r b o l donde va a b u s c a r .
181: @ r e t u r n s A r b o l E s t u d i a n t e E l p r i m e r r e g i s t r o que cumpla
182: /
183: p r i v a t e A r b o l E s t u d i a n t e p r e O r d e n ( i n t c u a l , S t r i n g subcad ,
184: ArbolEstudiante raiz ) {
185: i f ( r a i z == n u l l ) {
186: return n u l l ;
187: }
188: S t r i n g elCampo = r a i z . daCampo ( c u a l ) . t r i m ( ) . t o L o w e r C a s e ( ) ;
189: i f ( elCampo . i n d e x O f ( s u b c a d ) !=
1) {
190: return r a i z ;
191: }
192: A r b o l E s t u d i a n t e donde = n u l l ;
193: i f ( r a i z . g e t I z q r d o ( ) != n u l l ) {
194: donde = p r e O r d e n ( c u a l , subcad , r a i z . g e t I z q r d o ( ) ) ;
195: }
196: i f ( donde != n u l l ) {
197: r e t u r n donde ;
198: }
199: i f ( r a i z . g e t D e r c h o ( ) != n u l l ) {
200: r e t u r n p r e O r d e n ( c u a l , subcad , r a i z . g e t D e r c h o ( ) ) ;
201: } else {
202: return n u l l ;
203: }
204: }

8.3.7. Listado condicionado de registros

Otro metodo importante en nuestro sistema es el listado de aquellos registros

que contengan, en el campo elegido, una subcadena. En este caso, al igual que
en el listado de todos los registros, deberemos recorrer todo el arbol en orden
simetrico, de tal manera que al llegar a cada nodo, si es que el nodo contiene a
la subcadena en el lugar adecuado, lo listemos, y si no no. El algoritmo para este
metodo se parece mucho al que lista a todos los registros, excepto que al visitar la
raz, antes de imprimir, verifica si cumple la condicion. El algoritmo se muestra en
la figura 8.14 en la siguiente pagina. La programacion de este algoritmo se puede
ver en el listado 8.21 en la siguiente pagina.
8.3 *Ordenamiento usando arboles 280

Figura 8.14 Seleccion de registros que cumplen una condicion

$ #
'
'
' Visita subarbol
'
'
'
Hay hijo izquierdo
'
'
'
izquierdo
'
'
'
'
'
' $
'
'
' &
'
'
' %H
Hay hijo izquierdo
'
'
'
'
'
' $
'
'
' '
' subcadena en !
'
'
' '
'
' Reporta el registro
'
& '
& raz
Visita subarbol Procesa la raz
'
' '
' #
'
'
' '
'
' subcadena en
'
' '
%
'
'
'
' # raz H
'
'
'
'
'
' Hay hijo derecho
Visita subarbol
'
'
' derecho
'
'
'
'
'
' $
'
'
' &
'
'
'
' %H
' Hay hijo derecho
%

Codigo 8.21 Listado de registros que contienen a una subcadena (ArbolOrden) 1/2
227: / Imprim e l o s r e g i s t r o s que c a z a n con un c i e r t o p a t r o n .
228: @param C o n s o l a c o n s D i s p o s i t i v o en e l que s e va a e s c r i b i r .
229: @param i n t c u a l Con c u a l campo s e d e s e a c o m pa r ar .
230: @param S t r i n g s u b c a d Con e l que queremos que c a c e .
231: /
232: p u b l i c v o i d losQueCazanCon ( C o n s o l a cons , i n t c u a l ,
233: S t r i n g subcad ) {
234: subcad = subcad . trim ( ) . toLowerCase ( ) ;
235: int cuantos = 0;
236: i f ( r a i z == n u l l )
237: c o n s . i m p r i m e l n ( "No hay registros en la base de"
238: + " datos " ) ;
239: else
240: c u a n t o s = b u s c a C a z a n ( cons , c u a l , subcad , r a i z ) ;
241: i f ( c u a n t o s == 0 )
242: c o n s . i m p r i m e l n ( "No hay registros que cacen ." ) ;
243: }
281 Ordenamientos usando estructuras de datos

Codigo 8.21 Listado de registros que contienen a subcadena (ArbolOrden) 2/2

244: / R e c o r r e e l a r b o l v e r i f i c a n d o s i c a z a n .
245: @param C o n s o l a c o n s Medio p a r a e s c r i b i r .
246: i n t c u a l . Campo en e l que s e va a b u s c a r .
247: S t r i n g s u b c a d Cadena a b u s c a r .
248: A r b o l E s t u d i a n t e r a i z R a z d e l a r b o l a r e c o r r e r .
249: @ r e t u r n s i n t E l t o t a l de r e g i s t r o s que c a z a r o n /
250: p r i v a t e i n t b u s c a C a z a n ( C o n s o l a cons , i n t c u a l , S t r i n g subcad ,
251: ArbolEstudiante raiz ) {
252: int este = 0;
253: i f ( r a i z == n u l l )
254: return 0;
255: e s t e = b u s c a C a z a n ( cons , c u a l , subcad , r a i z . g e t I z q r d o ( ) ) ;
256: i f ( r a i z . daCampo ( c u a l ) . t r i m ( ) . t o L o w e r C a s e ( ) . i n d e x O f ( s u b c a d )
257: !=
1) {
258: cons . imprimeln ( r a i z . d a R e g i s t r o ( ) ) ;
259: e s t e ++;
260: }
261: e s t e += b u s c a C a z a n ( cons , c u a l , subcad , r a i z . g e t D e r c h o ( ) ) ;
262: return e s t e ;
263: }

8.3.8. Eliminacion de nodos

Hemos llegado a la parte mas complicada de manejar en un arbol binario,

que es la eliminacion de alguno de los nodos del arbol. Si el nodo es una hoja,
realmente no hay ningun problema: simplemente hay que regresar al padre del
nodo y nulificar el apuntador a esa hoja.

Una manera de localizar al padre de un nodo es el volver a realizar la busqueda

desde la raz, pero recordando en todo momento al nodo anterior que se visito.
Otra manera es la de poner a cada nodo a apuntar hacia su padre, lo que se
puede hacer trivialmente en el momento de insertar a un nodo, pues al insertarlo
tenemos un apuntado al padre (de quien lo vamos a colgar) y un apuntador al hijo
(a quien vamos a colgar). Optamos por la primera solucion, para no modificar ya
el registro de cada estudiante. La programacion del metodo que localiza al padre
se da en el listado 8.22 en la siguiente pagina. El algoritmo es similar al que se
dio para la busqueda de una subcadena, por lo que ya no lo mostramos.
8.3 *Ordenamiento usando arboles 282

Codigo 8.22 Localizacion del padre de un nodo (ArbolOrden)

147: /
148: Busca a l p a d r e de un nodo , r e c o r r i e n d o e l a r b o l d e s d e l a
149: r a z .
150:
151: @param A r b o l E s t u d i a n t e r a i z R a z d e l s u b a r b o l
152: A r b o l E s t u d i a n t e deQuien A q u i e n s e l e b u s c a e l
153: padre
154: @ r e t u r n s A r b o l E s t u d i a n t e La r e f e r e n c i a d e l p a d r e
155: /
156: private ArbolEstudiante buscaPadre ( ArbolEst udiante r a i z ,
157: A r b o l E s t u d i a n t e deQuien ) {
158: ArbolEstudiante padre = n u l l ;
159: i f ( r a i z . g e t I z q r d o ( ) == deQuien )
160: return r a i z ;
161: i f ( r a i z . g e t D e r c h o ( ) == deQuien )
162: return r a i z ;
163: i f ( r a i z . g e t I z q r d o ( ) != n u l l )
164: p a d r e = b u s c a P a d r e ( r a i z . g e t I z q r d o ( ) , deQuien ) ;
165: i f ( p a d r e == n u l l && r a i z . g e t D e r c h o ( ) != n u l l )
166: r e t u r n b u s c a P a d r e ( r a i z . g e t D e r c h o ( ) , deQuien ) ;
167: else
168: return padre ;
169: }

Como dijimos, una vez que se tiene al padre de una hoja, todo lo que hay que
hacer es identificar si el nodo es hijo izquierdo o derecho y poner el apuntador
correspondiente en null.
Resuelta la eliminacion de una hoja, pasemos a ver la parte mas complicada,
que es la eliminacion de un nodo intermedio. Veamos, por ejemplo, el arbol de la
figura 8.6 en la pagina 267 y supongamos que deseamos eliminar el nodo etiquetado
con E. Como reacomodamos el arbol de tal manera que se conserve el orden
correcto? La respuesta es que tenemos que intercambiar a ese nodo por el nodo
menor de su subarbol derecho. Por que? Si colocamos al nodo menor del subarbol
derecho en lugar del que deseamos eliminar, se sigue cumpliendo que todos los que
esten en el subarbol izquierdo son menores que el, mientras que todos los que esten
en el subarbol derecho son mayores o iguales que el:
Para localizar el elemento menor del subarbol derecho simplemente bajamos a
la raz del subarbol derecho y de ah en adelante seguimos bajando por las ramas
izquierdas hasta que ya no haya ramas izquierdas.El algoritmo para encontrar el
elemento menor de un subarbol se encuentra en la figura 8.15 en la pagina opuesta.
La programacion de este metodo se muestra en el listado 8.23.
283 Ordenamientos usando estructuras de datos

Figura 8.15 Algoritmo para encontrar el menor de un subarbol

$
'
'
'
Baja a hijo derecho
& Baja por hijo izquierdo
Encuentra el menor
'
'
' (mientras haya)
%
Regresa el ultimo visitado

Codigo 8.23 Localiza al menor del subarbol derecho (ArbolOrden)

138: /
139: L o c a l i z a a l menor de un s u b a r b o l .
140:
141: @param A r b o l E s t u d i a n t e r a i z La r a z d e l s u b a r b o l
142: @ r e t u r n s A r b o l E s t u d i a n t e La r e f e r e n c i a d e l menor
143: /
144: p r i v a t e A r b o l E s t u d i a n t e daMenor ( A r b o l E s t u d i a n t e r a i z ) {
145: A r b o l E s t u d i a n t e menor = r a i z ;
146: w h i l e ( menor . g e t I z q r d o ( ) != n u l l )
147: menor = menor . g e t I z q r d o ( ) ;
148: r e t u r n menor ;
149: }

Una vez localizado el menor del subarbol derecho, lo intercambiamos con el

nodo que queremos eliminar, en este caso E. Con este intercambio, logramos
mover a E hacia una hoja, y entonces ya podemos eliminarlo facilmente. Cabe
aclarar que para intercambiar dos nodos preservando su estructura, basta con
intercambiar el campo correspondiente a la informacion, dejando las referencias
sin tocar. Pero puede muy facil suceder que el menor de un subarbol no sea
forzosamente una hoja. Entonces, lo que debemos hacer con el es, nuevamente
intercambiarlo con el menor de su subarbol derecho.
Pudiera presentarse el caso de que el nodo no tuviera subarbol izquierdo. En
ese caso, debemos subir el subarbol derecho al lugar que ocupa ahora el nodo
que deseamos eliminar. Por ejemplo, si en el arbol anterior original desearamos
eliminar al nodo que contiene una A (que no tiene subarbol izquierdo), sim-
plemente subimos al subarbol etiquetado con D y todas las relaciones entre
los nodos se mantienen. En realidad, si el nodo tiene solo a uno de los hijos (sea
el izquierdo o el derecho) el nodo se elimina facilmente subiendo al subarbol que
s tiene a su lugar.
8.3 *Ordenamiento usando arboles 284

Otra situacion a considerar es cuando se desea eliminar a la raz del arbol. En

ese caso no vamos a tener padre, aun cuando el unico nodo en el arbol sea este. A
la raz se le debe tratar de manera un poco diferente. El algoritmo para eliminar
a un nodo se muestra en la figura 8.3.8. La programacion del metodo se puede ver
en el listado 8.24 en la pagina opuesta.

Figura 8.16 Eliminacion de un nodo en un arbol

$ $ !
'
'
' '
' El nodo es hoja
'
' '
'
'
Elimina a la raz
'
'
' '
'
'
' '
'
' #
'
'
' '
'
'
' '
'
'
El nodo tiene solo Pon al subarbol derecho
'
'
' '
'
'
' '
'
'
subarbol derecho

en la raz
'
'
' '
&
'
' #
'
'
'
nodo == raz El nodo tiene solo
'
' '
'
'
Pon al subarbol izquierdo
'
'
' '
'
'
' '
'
'
subarbol izquierdo

en la raz
'
'
' '
'
'
' '
'
' $
'
'
' '
' '
&Localiza menor en subarbol derecho
'
' '
'
' El nodo tiene
'
'
' '
' Intercambia a menor y nodo
'
' '
% ambos hijos '
%
'
& Elimina a quien quedo en menor
Elimina
nodo ' ' $ !
'
'
' '
' El nodo es hoja
'
' '
'
'
Anula el apuntador del padre
'
'
' '
'
'
' '
'
' #
'
'
' '
'
'
' '
'
'
El nodo tiene solo Sube al subarbol derecho
'
'
' '
'
'
' '
'
'
subarbol derecho

al lugar del nodo
'
'
' '
&
'
'
' #
'
'
'
nodo == raz El nodo tiene solo
' Sube al subarbol izquierdo
'
' '
'
'
'
'
' '
' subarbol izquierdo al lugar del nodo
'
' '
'
'
'
'
' '
'
'
' '
' $
'
' '
'
' '
&Localiza menor en subarbol derecho
'
'
' '
' El nodo tiene
'
' '
'
' Intercambia a menor y nodo
'
% % ambos hijos '
% Elimina a quien quedo en menor
285 Ordenamientos usando estructuras de datos

Codigo 8.24 Eliminacion de un nodo en el arbol (ArbolOrden) 1/3

57: /
58: D e f i n e s i un nodo d e l a r b o l e s h o j a /
59: p r i v a t e boolean e s H o j a ( A r b o l E s t u d i a n t e nodo ) {
60: i f ( nodo . g e t I z q r d o ( ) == n u l l && nodo . g e t D e r c h o ( ) == n u l l )
61: return true ;
62: return f a l s e ;
63: }
64: /
65: Q u i t a e l r e g i s t r o s o l i c i t a d o ( p o r nombre ) de l a l i s t a
66: @param S t r i n g nombre E l nombre d e l r e g i s t r o /
67: p u b l i c boolean q u i t a E s t ( S t r i n g nombre ) {
68: A r b o l E s t u d i a n t e donde = buscaDonde ( r a i z , nombre ) ;
69: i f ( donde == n u l l )
70: return f a l s e ;
71: i f ( donde == r a i z && e s H o j a ( r a i z ) ) {
72: raiz = null ;
73: return true ;
74: }
75: i f ( donde == r a i z . g e t I z q r d o ( )
76: && e s H o j a ( r a i z . g e t I z q r d o ( ) ) ) {
77: r a i z . ponIzqrdo ( null ) ;
78: return true ;
79: }
80: i f ( donde == r a i z . g e t D e r c h o ( )
81: && e s H o j a ( r a i z . g e t D e r c h o ( ) ) ) {
82: r a i z . ponIzqrdo ( null ) ;
83: return true ;
84: }
85: r e t u r n b o r r a A ( donde ) ;
86: }
87: p r i v a t e boolean b o r r a A ( A r b o l E s t u d i a n t e donde ) {
88: A r b o l E s t u d i a n t e conQuien ;
89: i f ( donde == r a i z . g e t I z q r d o ( )
90: && e s H o j a ( r a i z . g e t I z q r d o ( ) ) ) {
91: r a i z . ponIzqrdo ( null ) ;
92: return true ;
93: }
94: i f ( donde == r a i z . g e t D e r c h o ( )
95: && e s H o j a ( r a i z . g e t D e r c h o ( ) ) ) {
96: r a i z . ponIzqrdo ( null ) ;
97: return true ;
98: }
99: ArbolEstudiante padre ;
100: i f ( donde == r a i z )
101: padre = n u l l ;
102: else
103: p a d r e = b u s c a P a d r e ( r a i z , donde ) ;
8.3 *Ordenamiento usando arboles 286

Codigo 8.24 Eliminacion de un nodo en el arbol (ArbolOrden)2/3

104: i f ( donde . g e t I z q r d o ( ) == n u l l && donde . g e t D e r c h o ( ) != n u l l
105: && p a d r e == n u l l ) {
106: // Es l a r a z y t i e n e nada mas s u b a r b o l d e r e c h o }
107: r a i z = donde . g e t D e r c h o ( ) ;
108: return true ;
109: }
110: i f ( donde . g e t I z q r d o ( ) != n u l l && donde . g e t D e r c h o ( ) == n u l l
111: && p a d r e == n u l l ) {
112: // S o l o hay s u b a r b o l i z q u i e r d o
113: r a i z = donde . g e t I z q r d o ( ) ;
114: return true ;
115: }
116:
117: i f ( p a d r e == n u l l ) {
118: // T i e n e a l o s do s s u b a r b o l e s
119: conQuien = daMenor ( donde . g e t D e r c h o ( ) ) ;
120: donde . ponNombre ( conQuien . daNombre ( ) ) ;
121: donde . ponCuenta ( conQuien . daCuenta ( ) ) ;
122: donde . p o n C a r r e r a ( conQuien . d a C a r r e r a ( ) ) ;
123: r e t u r n b o r r a A ( conQuien ) ;
124: }
125:
126: i f ( donde . g e t I z q r d o ()== n u l l
127: && donde . g e t D e r c h o ( ) == n u l l ) {
128: // Es h o j a
129: i f ( p a d r e . g e t I z q r d o ()==donde ) {
130: padre . ponIzqrdo ( n u l l ) ;
131: return true ;
132: }
133: i f ( p a d r e . g e t D e r c h o ( ) == donde ) {
134: padre . setDercho ( n u l l ) ;
135: return true ;
136: }
137: }
138: i f ( donde . g e t I z q r d o ( ) == n u l l ) {
139: // S o l o t i e n e s u b a r b o l d e r e c h o
140: i f ( p a d r e . g e t I z q r d o ( ) == donde ) {
141: p a d r e . p o n I z q r d o ( donde . g e t D e r c h o ( ) ) ;
142: return true ;
143: }
144: i f ( p a d r e . g e t D e r c h o ( ) == donde ) {
145: p a d r e . s e t D e r c h o ( donde . g e t D e r c h o ( ) ) ;
146: return true ;
147: }
148: }
287 Ordenamientos usando estructuras de datos

Codigo 8.24 Eliminacion de un nodo en el arbol (ArbolOrden) 3/3

149: i f ( donde . g e t D e r c h o ( ) == n u l l && p a d r e != n u l l ) {
150: i f ( p a d r e . g e t I z q r d o ( ) == donde ) {
151: p a d r e . p o n I z q r d o ( donde . g e t I z q r d o ( ) ) ;
152: return true ;
153: }
154: i f ( p a d r e . g e t D e r c h o ( ) == donde ) {
155: p a d r e . s e t D e r c h o ( donde . g e t I z q r d o ( ) ) ;
156: return true ;
157: }
158: }
159: // Ambos s u b a r b o l e s e x i s t e n
160: conQuien = daMenor ( donde . g e t D e r c h o ( ) ) ;
161: donde . ponNombre ( conQuien . daNombre ( ) ) ;
162: donde . ponCuenta ( conQuien . daCuenta ( ) ) ;
163: donde . p o n C a r r e r a ( conQuien . d a C a r r e r a ( ) ) ;
164: r e t u r n b o r r a A ( conQuien ) ;
165: } // b o r r a A

Por ultimo, el mecanismo para modificar algun registro no puede ser, sim-
plemente, modificar la informacion, pues pudiera ser que la llave cambiara y el
registro quedara fuera de orden. La estrategia que vamos a utilizar para modificar
la informacion de un registro es primero borrarlo y luego reinsertarlo, para evitar
que se modifique la llave y se desacomode el arbol.

8.3.9. La clase MenuOrden

Utilizamos lo que tenemos programado en MenuLista para copiarlo a MenuOr-
den. Sustituimos la llamada a agregaEst por una llamada a agregaEstOrden para
que los vaya acomodando bien en el arbol. Asimismo, todos los parametros o va-
lores de retorno que antes eran de la clase Estudiante ahora pasan a ser de la clase
ArbolEstudiante.
Adicionalmente, en el metodo main cuando se declaran y crean los objetos
miCurso y miMenu, se cambian las clases a que ahora sean de las clases ArbolOrden y
MenuArbol respectivamente. Como tuvimos mucho cuidado en mantener la interfaz
tal cual, con todos los metodos conservando su firma, no hay necesidad de realizar
ningun otro cambio.
Con esto damos por terminado como mantener ordenada una lista de acuerdo
a cierta llave, que corresponde a uno de los campos. Hay muchos algoritmos para
ordenar una lista, pero no es material de estos temas, por lo que no lo revisaremos
aca.
 Manejo de errores
en ejecucion 9

9.1 Tipos de errores

Todos hemos padecido en algun momento errores de ejecucion. Java tiene me-
canismos muy poderosos para detectar errores de ejecucion de todo tipo, a los que
llama excepciones. Por ejemplo, si se trata de usar una referencia nula, Java ter-
minara (abortara) el programa con un mensaje de error. Generalmente el mensaje
tiene la forma:

Exception in thread "main" java.lang.NullPointerException

at MenuLista.main(MenuLista.java:151)

En el primer renglon del mensaje Java nos dice el tipo de excepcion que causo que
el programa abortara, que en este caso es NullPointerException, y a partir del
segundo renglon aparece la historia de la ejecucion del programa, esto es, los
registros de activacion montados en el stack de ejecucion en el momento en que
sucede el error. Hay muchos errores a los que Java va a reaccionar de esta manera,
como por ejemplo usar como ndice a un arreglo un entero menor que cero o ma-
yor o igual al tamano declarado (ArrayIndexOutOfBoundsException) o una division
entre 0 (ArithmeticException).
9.1 Tipos de errores 290

La manera como responde la maquina virtual de Java cuando sucede un error

de ejecucion es que lanza lo que se conoce como una excepcion. Una excepcion
es un objeto de alguna clase que hereda de la clase Throwable y que contiene infor-
macion respecto a donde se produjo el error y que tipo de error es. Dependiendo
de la clase a la que pertenece el objeto, fue el tipo de error que hubo. Tambien
el programador puede crear sus propias excepciones, como un mecanismo mas de
control del flujo del programa.
Dos clases importantes extienden a la clase Throwable, Error y Exception. El
programador puede crear sus propias excepciones extendiendo a la clase Excep-
tion1 .

9.1.1. Excepciones en tiempo de ejecucion (RuntimeException)

Las excepciones de tiempo de ejecucion son las siguientes:

ArithmeticException Es lanzada cuando el programa intenta hacer una operacion
aritmetica invalida, como la division de un entero entre 02 . Podemos ver un
ejemplo en el listado 9.1.

Codigo 9.1 Ejemplo de una excepcion aritmetica

1: import j a v a . i o . ;
2:
3: c l a s s Arit m Ex c {
4: private static int calcula ( int k) {
5: return ( ( i n t )1000 / k ) ;
6: }
7:
8: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
9: int k = 0;
10: System . o u t . p r i n t l n ( "El valor de k es " +
11: calcula (0));
12: }
13: }

En este pequeno programa, el sistema lanzara una ArithmeticException si al

invocar al metodo calcula se le pasa el valor de 0. Java no tiene manera,
1
Es conveniente que aquellas clases que heredan a la clase Exception su nombre termine con
Exception y el resto del nombre sirva para describir el tipo de error que esta detectando.
2
Java contempla el valor infinity, por lo que una division entre 0 cuyo resultado va a ser real
no lanza esta excepcion.
291 Manejo de errores en ejecucion

durante la compilacion, de evitar este error aritmetico. Lo que produce la

ejecucion de este programa se puede ver en la figura 9.1.

Figura 9.1 Ejecucion de AritmExc

elisa@lambda ...ICC1/progs/excepciones % java AritmExc
Exception in thread "main" java.lang.ArithmeticException: / by zero
at AritmExc.calcula(AritmExc.java:5)
at AritmExc.main(AritmExc.java:11)
elisa@lambda ...ICC1/progs/excepciones %

ArrayStoreException Es lanzada cuando el programa intenta guardar un objeto de

tipo erroneo en un arreglo. Veamos el ejemplo en el listado 9.2.

Codigo 9.2 Ejemplo de una excepcion de la subclase ArrayStoreException

1: c l a s s ArraySE {
2: private s t a t i c void guardaObjeto ( Object [ ] a , i n t i ,
3: Object objeto ) {
4: a [ i ] = objeto ;
5: }
6:
7: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
8: I n t e g e r [ ] i n t A r r a y = new I n t e g e r [ 5 ] ;
9: g u a r d a O b j e t o ( i n t A r r a y , 0 , new S t r i n g ( "abc" ) ) ;
10: }
11: }

En la lnea 4:, que es donde se guarda a un objeto en un arreglo, la asig-

nacion es perfectamente compatible. Java no puede detectar en el momento
de compilacion que va a tener un error al llamar a este metodo, ya que los
argumentos son de un tipo que extiende a Object, y por lo tanto permiti-
dos. La ejecucion de este programa produce la salida que se muestra en la
figura 9.2.

Figura 9.2 Ejecucion de ArraySE

elisa@lambda ...ICC1/progs/excepciones % java ArraySE
Exception in thread "main" java.lang.ArrayStoreException
at ArraySE.guardaObjeto(ArraySE.java:4)
at ArraySE.main(ArraySE.java:9)
elisa@lambda ...ICC1/progs/excepciones %
9.1 Tipos de errores 292

ClassCastException Es lanzada cuando el programa intenta aplicar un cast de una

clase a un objeto de otra clase, y la conversion no esta permitida. El pro-
grama en el listado 9.3, al ejecutarse, lanza esta excepcion.

Codigo 9.3 Programa que lanza una excepcion ClassCastException

1: c l a s s ClassCE {
2: private s t a t i c void guardaObjeto ( I n t e g e r [ ] a , i n t i ,
3: Object objeto ) {
4: a [ i ] = ( Integer ) objeto ;
5: }
6:
7: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
8: I n t e g e r [ ] i n t A r r a y = new I n t e g e r [ 5 ] ;
9: g u a r d a O b j e t o ( i n t A r r a y , 0 , new S t r i n g ( "abc" ) ) ;
10: }
11: }

Nuevamente, el programa esta sintacticamente correcto ya que en un arreglo

de objetos de la clase Integer podemos guardar un objeto al que le apliquemos
esa envoltura (lnea 4:). Sin embargo, al pasarle como parametro una cadena,
que es sintacticamente compatible con un objeto, el programa no puede
hacer la coercion, por lo que lanza una excepcion. La ejecucion del programa
ClassCE la podemos ver en la figura 9.3.

Figura 9.3 Ejecucion del programa ClassCE

elisa@lambda ...ICC1/progs/excepciones % java ClassCE
Exception in thread "main" java.lang.ClassCastException: java.lang.String
at ClassCE.guardaObjeto(ClassCE.java:4)
at ClassCE.main(ClassCE.java:9)
elisa@lambda ...ICC1/progs/excepciones %

IllegalArgumentException Esta excepcion es lanzada cuando metodos de Java o de-

finidos por el usuario detecta que un argumento no es como se esperaba. Por
ejemplo, si se desea sacar la raz cuadrada de un numero negativo.
IllegalMonitorStateException Tiene que ver con sincronizacion de procesos. Lo vere-
mos mas adelante.
IndexOutOfBoundsException Es lanzado cuando se intenta usar un elemento de un
arreglo que no existe, porque el ndice dado no esta en el rango dado para
los ndices del arreglo.
293 Manejo de errores en ejecucion

NegativeArraySizeException Se lanza si es que se intenta crear un arreglo con un

numero negativo de elementos.
NullPointerException Se lanza si se trata de usar al objeto referido por una referencia
nula.
SecurityException Se lanza cuando el proceso intenta ejecutar un metodo que no
se puede ejecutar por razones de seguridad. Tiene que ver con el sistema de
seguridad (SecurityManager).
java.util.EmptyStackException Es lanzada cuando un programa, que utiliza la clase
Stack de Java intenta tener acceso a un elemento del stack cuando el stack
esta vaco.
java.util.NoSuchElementException Error relacionado con enumeraciones.
Hay dos aspectos ntimamente relacionados con las excepciones: el primero de
ellos corresponde a las condiciones bajo las cuales una excepcion es disparada o
lanzada (thrown), mientras que el otro aspecto tiene que ver con la manera que
tendra la aplicacion de reaccionar cuando una excepcion es lanzada. Dependiendo
del tipo de excepcion que fue lanzada, la aplicacion debe reaccionar de manera
adecuada frente a ella y actuar en consecuencia. Algunas veces esta respuesta
consistira de alguna forma en que la aplicacion se recupere y siga adelante; otras
veces simplemente le permitira a la aplicacion morir dignamente. A la reaccion
frente a una excepcion se conoce como cachar la excepcion, para poder hacer algo
con ella.
En general, si algun metodo de alguna clase que estemos utilizando avisa que
puede lanzar una excepcion, la aplicacion que use esta clase debera prepararse
para detectar si se lanzo o no la excepcion, y si se lanzo, reaccionar de alguna
manera frente a ella. A los enunciados que comprenden la reaccion frente a la
excepcion que cachan la excepcion es a lo que se conoce como el manejador
de la excepcion.
Se recomienda enfaticamente que las excepciones de tiempo de ejecucion no
sean cachadas (RuntimeException). Este tipo de excepcion indica errores de diseno
en la aplicacion, por lo que si se decide atraparlas esto se debera hacer unica-
mente en una etapa de depuracion del programa, para obtener un poco mas de
informacion sobre la causa de la excepcion.
Sabemos que un metodo es susceptible de lanzar una excepcion si en el enca-
bezado del metodo, a continuacion del parentesis que cierra la lista de parametros,
aparece el enunciado
throws lista de clases de Excepciones

y en el cuerpo del metodo, o de alguno de los metodos invocados dentro de ese

cuerpo, debera aparecer un enunciado
9.2 La clase Exception 294

throw new constructor de una excepcion

En el caso de las excepciones en tiempo de ejecucion RuntimeException

los metodos que pudieran incurrir en algun error de ese tipo no tienen que avisar
que pudieran lanzar este tipo de excepciones. Asimismo, las excepciones seran
lanzadas, en su momento, implcitamente o por el usuario, pero sin necesidad de
avisar que pudieran ocurrir.
Cuando algun enunciado o metodo detecta una excepcion, la maquina virtual
de Java3 busca en su entorno inmediato al manejador de la excepcion. Si lo encuen-
tra, lo ejecuta, y ya sea que procese la excepcion o que simplemente la propague
(la vuelva a lanzar). Si en el entorno inmediato no se encuentra al manejador de
la excepcion, la JVM sigue buscando hacia afuera en la cadena de llamadas del
metodo en cuestion a ver si encuentra a algun manejador de la excepcion. Si no
lo encuentra en la aplicacion se lo pasa a la JVM, que procede a suspender el
programa con el mensaje de error correspondiente, y una historia de la cadena de
llamadas hasta el punto donde la excepcion fue lanzada.
Si en el metodo en el que se lanza una excepcion que no sea de tiempo de
ejecucion no hay un manejador para la excepcion, el metodo debera incluir el
enunciado throws xexcepciony en su encabezado.

9.2 La clase Exception

La clase Exception es una clase muy sencilla que tiene, realmente, muy po-
cos metodos. De hecho, unicamente tiene dos constructores que se pueden usar
en aquellas clases que hereden a Exception. La clase Throwable, superclase de Ex-
ception, es la que cuenta con algunos metodos mas que se pueden invocar desde
cualquier excepcion, ya sea esta de Java o del programador. Veamos primero los
dos constructores de Exception.
public Exception() Es el constructor por omision. La unica informacion que pro-
porciona es el nombre de la excepcion.
public Exception(String msg) Construye el objeto pasandole una cadena, que pro-
porciona informacion adicional a la del nombre de la clase.
3
en adelante JVM.
295 Manejo de errores en ejecucion

La clase Throwable nos va a permitir un manejo mas preciso de las excepciones.

Tiene varios tipos de metodos.

Constructores:
public Throwable() Es el constructor por omision.
public Throwable(String msg) Da la oportunidad de construir el objeto con infor-
macion que se transmite en la cadena.

Metodos del stack de ejecucion:

public native Throwable fillInStackTrace()Coloca en el objeto una copia de la cadena
dinamica del stack de ejecucion en ese momento.
public void printStackTrace() Escribe en la pantalla el contenido del stack de ejecu-
cion, respecto a la cadena de llamadas que llevaron al metodo que esta abor-
tando.
public void printStackTrace(PrintStream s) Lo mismo que el anterior, pero da la op-
cion de escribir a un archivo en disco.

Metodos de acceso a campos:

Devuelve la cadena con que la excepcion fue creada. SI
public String getMessage()
fue creada con el constructor por omision devuelve null.

Metodo descriptivo:
Regresa en una cadena el nombre de la clase a la que per-
public String toString()
tenece y la cadena con la que fue creada, en su caso.

Como la clase Exception extiende a la clase Throwable, cualquier excepcion

que nosotros declaremos que extienda a Exception contara con los metodos de
Throwable.

Las excepciones de tiempo de ejecucion siempre van a imprimir la cadena

producida por toString() y el stack de ejecucion producido por printStackTrace().
De esa manera tenemos informacion muy puntual de cual fue el tipo de error y
donde exactamente se presento.
9.3 Como detectar y cachar una excepcion 296

9.3 Como detectar y cachar una excepcion

Como ya mencionamos, una aplicacion comun y corriente puede lanzar dis-

tintas excepciones de tiempo de ejecucion. Estas excepciones no tienen que ser
vigiladas y detectadas, sino que pasan a la JVM, quien suspende la ejecucion del
programa.
Sin embargo, tambien pueden presentarse excepciones que no son de tiempo de
ejecucion y que s deben ser vigiladas y manejadas de alguna manera. Entre ellas
podemos mencionar las que son lanzadas en relacion con procesos de entrada y sa-
lida (IOException); cuando durante la ejecucion de una aplicacion no se encuentra
una clase que se debe cargar (ClassNotFoundException); cuando se pretende hacer
una copia de un objeto que no es copiable (CloneNotSupportedException); cuando
se da alguna interrupcion en un proceso que se esta ejecutando (InterruptedException);
y algunas mas. Ademas, el usuario puede declarar sus propias clases de excepcio-
nes, que pueden extender a una clase particular de excepciones o la clase generica
Exception.
La deteccion y manejo de una excepcion se lleva a cabo en un bloque que toma
la forma que se muestra en la figura 9.4.

Figura 9.4 Deteccion y manejo de excepciones

Sintaxis:
try {
xenunciados donde puede ser lanzada la excepciony


} catch ( xtipo de excepciony xidentify ) {
xEnunciados que reaccionan frente a la excepciony

}
Semantica:
Se pueden agrupar tantos enunciados como se desee en la clausula try, por
lo que al final de ella se puede estar reaccionando a distintas excepciones.
Se elige uno y solo un manejador de excepciones, utilizando la primera
excepcion que califique con ser del tipo especificado en las clausulas catch.

La parte que aparece a continuacion de cada catch corresponde al manejador

297 Manejo de errores en ejecucion

de cada clase de excepcion que se pudiera presentar en el cuerpo del try. El tipo
de excepcion puede ser Exception, en cuyo caso cualquier tipo de excepcion va
a ser cachada y manejada dentro de ese bloque. En general, una excepcion que
extiende a otra puede ser cachada por cualquier manejador para cualquiera de sus
superclases. Una vez que se lista el manejador para alguna superclase, no tiene
sentido listar manejadores para las subclases.
La manera como se ejecuta un bloque try en el que se pudiera lanzar una
excepcion es la siguiente:
La JVM entra a ejecutar el bloque correspondiente.
Como cualquier bloque en Java, todas las declaraciones que se hagan dentro
del bloque son visibles unicamente dentro del bloque.
Se ejecuta el bloque enunciado por enunciado.
En el momento en que se presenta una excepcion, la ejecucion del bloque se
interrumpe y la ejecucion prosigue buscando a un manejador de la excepcion.
La ejecucion verifica los manejadores, uno por uno y en orden, hasta que
encuentre el primero que pueda manejar la excepcion. Si ninguno de los
manejadores puede manejar la excepcion que se presento, sale de la manera
que indicamos hasta que encuentra un manejador, o bien la JVM aborta el
programa.
Si encuentra un manejador adecuado, se ejecuta el bloque correspondiente
al manejador.
Si no se vuelve a lanzar otra excepcion, la ejecucion continua en el enunciado
que sigue al ultimo manejador.
El programa que se encuentra en el listado 9.4 cacha las excepciones posibles
en el bloque del try mediante una clausula catch para la superclase Exception. Una
vez dentro del manejador, averigua cual fue realmente la excepcion que se disparo,
la reporta y sigue adelante con la ejecucion del programa.

Codigo 9.4 Manejo de una excepcion a traves de la superclase (CatchExc)1/2

1: import j a v a . i o . ;
2:
3: c l a s s CatchExc {
4: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
5: int k = 0;
6: int c ;
7: int i = 3;
8: i n t [ ] e n t e r o s = new i n t [ 3 ] ;
9.3 Como detectar y cachar una excepcion 298

Codigo 9.4 Manejo de una excepcion a traves de la superclase (CatchExc)2/2

9: try {
10: System . o u t . p r i n t l n ( "Dame un entero para trabajar ." ) ;
11: w h i l e ( ( c = System . i n . r e a d ( ) ) >= 0 && c <= 9 )
12: k = k 10 + ( c
( ( i n t ) 0 ) ) ;
13: System . o u t . p r i n t l n ( "Le el valor " + k ) ;
14: c = 1000 / k ;
15: System . o u t . p r i n t l n ( "El valor final de c es " + c ) ;
16: enteros [ i ] = c ;
17: }
18: catch ( E x c e p t i o n e ) {
19: System . o u t . p r i n t l n ( "La excepcion es de la clase :\n\t" +
20: e . getClass ());
21: }
22: System . o u t . p r i n t l n ( "A punto de salir normalmente " +
23: " del metodo main" ) ;
24: }
25: }

Este programa cacha cualquier excepcion que se presente en el bloque try y

la maneja, permitiendo que el programa termine normalmente. Dos ejecuciones
consecutivas del mismo se pueden ver en la figura 9.5.

Figura 9.5 Excepciones de tiempo de ejecucion cachadas con una superclase

elisa@lambda ...ICC1/progs/excepciones % java CatchExc
Dame un entero para trabajar.
0
Lei el valor 0
La excepcion es de la clase :class java.lang.ArithmeticException
A punto de salir normalmente del metodo main
elisa@lambda ...ICC1/progs/excepciones % java CatchExc
Dame un entero para trabajar.
17
Le el valor 17
El valor final de c es 58
La excepcion es de la clase :class java.lang.ArrayIndex
OutOfBoundsException
A punto de salir normalmente del metodo main
299 Manejo de errores en ejecucion

Si queremos que el programa se interrumpa aun despues de lanzada una ex-

cepcion, podemos relanzarla en el manejador. En este caso, el metodo en el que
esto se hace debe avisar que se va a lanzar una excepcion, ya que habra una salida
brusca del mismo. En el listado 9.5 modificamos la clase CatchExc CatchExc1
para que relance la excepcion y termine la ejecucion. En la figura 9.6 en la
siguiente pagina vemos la ejecucion de esta nueva clase.

Codigo 9.5 La excepcion es cachada y relanzada

1: import j a v a . i o . ;
2:
3: c l a s s CatchExc1 {
4: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s )
5: throws E x c e p t i o n {
6: int k = 0;
7: int c ;
8: int i = 3;
9: i n t [ ] e n t e r o s = new i n t [ 3 ] ;
10:
11: try {
12: System . o u t . p r i n t l n ( "Dame un entero para trabajar ." ) ;
13: w h i l e ( ( c = System . i n . r e a d ( ) ) >= 0 && c <= 9 )
14: k = k 10 + ( c
( ( i n t ) 0 ) ) ;
15: System . o u t . p r i n t l n ( "Le el valor "+ k ) ;
16: c = 1000 / k ;
17: System . o u t . p r i n t l n ( "El valor final de c es "+ c ) ;
18: enteros [ i ] = c ;
19: }
20: catch ( E x c e p t i o n e ) {
21: C l a s s en = e . g e t C l a s s ( ) ;
22: System . o u t . p r i n t l n ( "La excepcion es de la clase :" + en ) ;
23: throw ( ( E x c e p t i o n ) en . n e w I n s t a n c e ( ) ) ;
24: }
25: System . o u t . p r i n t l n ( "A punto de salir normalmente " +
26: "del metodo main" ) ;
27: }
28: }

Como la clase a la que pertenece la excepcion se obtiene con el metodo get-

Class() de la clase Class, esto se hace durante ejecucion. Si bien se maneja la
excepcion mediante la clausula catch de la lnea 20:, se vuelve a relanzar, por lo
que la lnea 25: del programa, que se encuentra a continuacion del bloque de la
excepcion, ya no se ejecuta.
9.3 Como detectar y cachar una excepcion 300

Figura 9.6 Ejecucion con relanzamiento de la excepcion

elisa@lambda ...ICC1/progs/excepciones % java CatchExc1
Dame un entero para trabajar.
0
Le el valor 0
La excepcion es de la clase :class java.lang.Arithmetic
Exception
Exception in thread "main" java.lang.ArithmeticException
at java.lang.Class.newInstance0(Native Method)
at java.lang.Class.newInstance(Class.java:237)
at CatchExc1.main(CatchExc1.java:27)
Un metodo, ya sea de las bibliotecas de clases de Java o del programador,
puede lanzar una excepcion, y esta puede ser, nuevamente, una excepcion creada
por el programador o de las clases de Java. Por ejemplo, si deseamos que no haya
divisiones por 0 aun entre reales, podramos tener las clases que se muestran en
los listados 9.6 y 9.7.

Codigo 9.6 Creacion de excepciones propias

1: // A r c h i v o : D i v P o r C e r o E x c e p t i o n . j a v a
2: p u b l i c c l a s s D i v P o r C e r o E x c e p t i o n extends A r i t h m e t i c E x c e p t i o n {
3: public DivPorCeroException () {
4: super ( ) ;
5: }
6: p u b l i c D i v P o r C e r o E x c e p t i o n ( S t r i n g msg ) {
7: super ( msg ) ;
8: }
9: }

Codigo 9.7 Deteccion de excepciones propias (DivPorCeroUso)1/2

// A r c h i v o : D i v P o r C e ro U s o . j a v a
p u b l i c c l a s s D i v P o rC e r o Us o {
public static float sqrt ( float x )
throws D i v P o r C e r o E x c e p t i o n {
i f ( x < 0)
throw new D i v P o r C e r o E x c e p t i o n (
"Se pide raz de numero negativo !" ) ;
else
r e t u r n ( ( f l o a t ) Math . s q r t ( x ) ) ;
}
301 Manejo de errores en ejecucion

Codigo 9.7 Deteccion de excepciones propias (DivPorCeroUso)2/2

p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
// Aca l e e r a m o s un v a l o r p a r a r
f l o a t r = ( ( f l o a t ) Math . random ( ) 1 0 0 0 0 ) ;
f l o a t o t r o = ( f l o a t ) ( Math . random ( ) + . 5 ) ;
System . o u t . p r i n t l n ( "Otro: "+ o t r o ) ;
int signo = ( otro > 1 ? 0 : 1);
i f ( s i g n o == 0 ) // Para f o r z a r l a e x c e p c i o n
r =
r ; // Tener r n e g a t i v o
// Aca t e r m i n a m o s de o b t e n e r un v a l o r p a r a r
System . o u t . p r i n t l n ( "La raz cuadrada de "+ r + " es "
+ sqrt ( r ));
}
}

Como la excepcion que construimos, DivPorCeroException, extiende a Arithme-

ticException y esta ultima no debe ser vigilada, la invocacion a sqrt no tiene que
hacerse dentro de un bloque try. Asimismo, el metodo sqrt no tiene por que avisar
que va a lanzar una excepcion.
Sin embargo, si la excepcion hereda directamente a Exception o a cualquiera
que no sea RuntimeException, el metodo no puede dejar de avisar que va a
lanzar una excepcion: al compilar a la clase DivPorCeroUso, asumiendo que Div-
PorCeroException extiende a Exception, da un error que dice

javac DivPorCeroUso.java
DivPorCeroUso.java:7: unreported exception DivPorCeroException;
must be caught or declared to be thrown
throw new DivPorCeroException("Se pide raz de numero
negativo!");
^
1 error

Compilation exited abnormally with code 1 at Thu Oct 25 17:52:44

javac DivPorCeroUso.java

Una vez corregido esto, la llamada al metodo sqrt tiene que aparecer dentro
de un bloque try que se encargue de detectar la excepcion que lanza el metodo.
Estos cambios se pueden ver en los listados 9.8 en la siguiente pagina y 9.9 en la
siguiente pagina.
9.3 Como detectar y cachar una excepcion 302

Codigo 9.8 Declaracion de excepcion propia

1: // A r c h i v o : D i v P o r C e r o E x c e p t i o n . j a v a }
2: p u b l i c c l a s s D i v P o r C e r o E x c e p t i o n extends E x c e p t i o n {
3: public DivPorCeroException () {
4: super ( ) ;
5: }
6: p u b l i c D i v P o r C e r o E x c e p t i o n ( S t r i n g msg ) {
7: super ( msg ) ;
8: }
9: }
10: // A r c h i v o : D i v P o r C e r o U s o . j a v a

Codigo 9.9 Clase que usa la excepcion creada

1: p u b l i c c l a s s D i v P o rC e r o Us o {
2: public static float sqrt ( float x )
3: throws D i v P o r C e r o E x c e p t i o n {
4: i f ( x < 0)
5: throw new D i v P o r C e r o E x c e p t i o n (
6: "Se pide raz de numero negativo !" ) ;
7: else
8: r e t u r n ( ( f l o a t ) Math . s q r t ( x ) ) ;
9: }
10: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
11: // Aca l e e r a m o s un v a l o r p a r a r
12: f l o a t r = ( ( f l o a t ) Math . random ( ) 1 0 0 0 0 ) ;
13: f l o a t o t r o = ( f l o a t ) ( Math . random ( ) + . 5 ) ;
14: System . o u t . p r i n t l n ( "Otro: "+ o t r o ) ;
15: int signo = ( otro > 1 ? 0 : 1);
16: i f ( s i g n o == 0 ) // Para f o r z a r l a e x c e p c i o n
17: r =
r ; // Trabajamos con r n e g a t i v o
18: // Aca t e r m i n a m o s de o b t e n e r un v a l o r p a r a r
19: try {
20: System . o u t . p r i n t l n ( "La raz cuadrada de "+ r
21: + " es " + s q r t ( r ) ) ;
22: }
23: catch ( D i v P o r C e r o E x c e p t i o n e ) {
24: System . o u t . p r i n t l n ( e . g e t M e s s a g e ( ) ) ;
25: System . e x i t (
1);
26: }
27: }
28: }

Como la excepcion se maneja totalmente dentro del metodo en cuestion, que

303 Manejo de errores en ejecucion

en este caso es main, la excepcion no se propaga hacia afuera de main, por lo que
el metodo no tiene que avisar que pudiera lanzar una excepcion.
Como ya mencionamos antes, las excepciones se pueden lanzar en cualquier
momento: sin simplemente un enunciado mas. Por supuesto que un uso racional
de ellas nos indica que las deberemos asociar a situaciones no comunes o crticas,
pero esto ultimo tiene que ver con la semantica de las excepciones, no con la
sintaxis.
Tal vez el ejemplo del listado 9.9 en la pagina opuesta no muestre lo util que
pueden ser las excepciones, porque redefinen de alguna manera una excepcion
que la JVM lanzara de todos modos. Pero supongamos que estamos tratando de
armar una agenda telefonica, donde cada individuo puede aparecer unicamente
una vez, aunque tenga mas de un telefono. Nuestros metodos de entrada, al tratar
de meter un nombre, detecta que ese nombre con la direccion ya esta registrado.
En terminos generales, esto no constituye un error para la JVM, pero si para el
contexto de nuestra aplicacion. Una manera elegante de manejarlo es a traves de
excepciones, como se muestra en los listados 9.10 a 9.12 en la siguiente pagina.

Codigo 9.10 Excepciones del programador (I)

1: // A r c h i v o : R e g D u p l i c a d o E x c e p t i o n . j a v a
2: p u b l i c c l a s s R e g D u p l i c a d o E x c e p t i o n extends E x c e p t i o n {
3: public RegDuplicadoException () {
4: super ( ) ;
5: }
6: p u b l i c R e g D u p l i c a d o E x c e p t i o n ( S t r i n g msg ) {
7: super ( msg ) ;
8: }
9: }

Codigo 9.11 Uso de excepciones del programador (I)

1: // A r c h i v o : R e g N o E n c o n t r a d o E x c e p t i o n . j a v a
2: p u b l i c c l a s s R e g N o E n c o n t r a d o E x c e p t i o n extends E x c e p t i o n {
3: public RegNoEncontradoException () {
4: super ( ) ;
5: }
6: p u b l i c R e g N o E n c o n t r a d o E x c e p t i o n ( S t r i n g msg ) {
7: super ( msg ) ;
8: }
9: }
9.3 Como detectar y cachar una excepcion 304

Codigo 9.12 Excepciones del programador y su uso (II) (BaseDeDatos)1/2

1: // A r c h i v o : BaseDeDatos . j a v a
2: p u b l i c c l a s s BaseDeDatos {
3: i n t numRegs ;
4: ...
5: public void agrega ( R e g i s t r o reg )
6: throws R e g D u p l i c a d o E x c e p t i o n {
7: ...
8: i f ( actual . equals ( reg ))
9: throw new R e g D u p l i c a d o E x c e p t i o n ( r e g . nombre ) ;
10: ...
11: }
12: ...
13: public void e l i m i n a ( R e g i s t r o reg )
14: throws R e g N o E n c o n t r a d o E x c e p t i o n {
15: ...
16: i f ( a c t u a l == n u l l )
17: throw new R e g N o E n c o n t r a d o E x c e p t i o n ( r e g . nombre ) ;
18: ...
19: }
20: ...
21: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
22: ...
23: w h i l e ( o p c i o n != 0 ) {
24: try {
25: switch ( opcion ) {
26: case 1 : a g r e g a ( r e g ) ;
27: reportaAgregado ( ) ;
28: break ;
29: case 2 : e l i m i n a ( r e g ) ;
30: reportaEliminado ();
31: break ;
32: ...
33: ...
34: } // s w i t c h
35: } // t r y
36: catch ( R e g D u p l i c a d o E x c e p t i o n e ) {
37: // p r o d u c e un manejo ad e c ua d o de l a r e p e t i c i o n
38: System . o u t . p r i n t l n ( "El registro de: "
39: + e . getMessage ( )
40: + "ya existe , por lo que no se agrego " ) ;
41: } // R e g D u p l i c a d o E x c e p t i o n
305 Manejo de errores en ejecucion

Codigo 9.12 Excepciones del programador y su uso (II) (BaseDeDatos)2/2

42: catch ( R e g N o E n c o n t r a d o E x c e p t i o n e ) {
43: // Pro duc e un manejo ade c ua do a l no e n c o n t r a r a l
44: // nombre
45: System . o u t . p r i n t l n ( "El registro de: "
46: + e . getMessage ( )
47: + "no se encontro , por lo que no se elimino " ) ;
48: } // R e g N o E n c o n t r a d o E x c e p t i o n
49: } // w h i l e
50: ...
51: } // main
52: } // c l a s s

El listado 9.12 en la pagina opuesta hace uso del hecho de que cuando en un
bloque se presenta una excepcion, la ejecucion salta a buscar el manejador de la
excepcion y deja de ejecutar todo lo que este entre el punto donde se lanzo la
excepcion y el manejador seleccionado. Como tanto agrega como elimina lanzan
excepciones, su invocacion tiene que estar dentro de un bloque try que va de la
lnea 24: a la lnea 35:. Si es que estos metodos lanzan la excepcion, ya sea en la
lnea 26: o 29:, ya no se ejecuta la lnea 27: en el primer caso y la lnea 30: en el
segundo. Por lo tanto se esta dando un control adecuado del flujo del programa,
utilizando para ello excepciones.
Otra caracterstica que tiene este segmento de aplicacion es que como el bloque
try esta dentro de una iteracion, y si es que se hubiere lanzado una excepcion en
alguno de los metodos invocados, una vez que se llego al final del bloque try y
habiendose o no ejecutado alguno de los manejadores de excepciones asociados al
bloque try, la ejecucion regresa a verificar la condicion del ciclo, logrando de hecho
que el programa no termine por causa de las excepciones. Esta forma de hacer las
cosas es muy comun. Supongamos que le pedimos al usuario que teclee un numero
entero y se equivoca. Lo mas sensato es volverle a pedir el dato al usuario para
trabajar con datos adecuados, en lugar de abortar el programa.

9.4 Las clases que extienden a Exception

Hasta ahora, cuando hemos declarado clases que extienden a Exception no

hemos agregado ninguna funcionalidad a las mismas. No solo eso, sino que uni-
9.4 Las clases que extienden a Exception 306

camente podemos usar sus constructores por omision, los que no tienen ningun
parametro.
El constructor por omision siempre nos va a informar del tipo de excepcion que
fue lanzado (la clase a la que pertenece), por lo que el constructor de Exception
que tiene como parametro una cadena no siempre resulta muy util. Sin embargo,
podemos definir una clase tan compleja como queramos, con los parametros que
queramos en los constructores. Unicamente hay que recordar que si definimos
alguno de los constructores con parametros, automaticamente perdemos acceso
al constructor por omision. Claro que siempre podemos invocar a super() en los
constructores definidos en las subclases.
Podemos, en las clases de excepciones creadas por el usuario, tener mas meto-
dos o informacion que la que nos provee la clase Exception o su superclase Th-
rowable. Por ejemplo, la clase RegNoEncontradoException que disenamos para la
base de datos pudiera proporcionar mas informacion al usuario que simplemente el
mensaje de que no encontro al registro solicitado; podra proporcionar los registros
inmediato anterior e inmediato posterior al usuario. En ese caso, debera poder
armar estos dos registros. Para ello, podramos agregar a la clase dos campos, uno
para cada registro, y dos metodos, el que localiza al elemento inmediato anterior
en la lista y el que localiza al inmediato posterior. En los listados 9.13 y 9.14 en
la pagina opuesta podemos ver un bosquejo de como se lograra esto.

Codigo 9.13 Definicion de Excepciones propias (RegNoEncontradoException)1/2

1: p u b l i c c l a s s R e g N o E n c o n t r a d o E x c e p t i o n extends E x c e p t i o n {
2: p r i v a t e R e g i s t r o regAnt , r e g P o s t ;
3: public RegNoEncontradoException () {
4: super ( ) ;
5: }
6:
7: p u b l i c R e g N o E n c o n t r a d o E x c e p t i o n ( S t r i n g msg ) {
8: super ( msg ) ;
9: }
10:
11: public RegNoEncontradoException ( R e g i s t r o a n t e r i o r ,
12: Registro actual ) {
13: regAnt = b u s c a A n t e r i o r ( padre ) ;
14: regPost = buscaPosterior ( actual ) ;
15: }
16:
17: private Registro buscaAnterior ( Registro a n t e r i o r ) {
18: ...
19: }
307 Manejo de errores en ejecucion

Codigo 9.13 Definicion de Excepciones propias (RegNoEncontradoException)2/2

20: private Registro buscaPosterior ( Actual ) {
21: ...
22: }
23:
24: p u b l i c R e g i s t r o daRegAnt ( ) {
25: return regAnt ;
26: }
27:
28: p u b l i c R e g i s t r o daRegPost ( ) {
29: return regPost ;
30: }
31: }

Codigo 9.14 Definicion de excepciones propias (ejemplo) (Ejemplo)

1: p u b l i c c l a s s E j e m p l o {
2: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
3: ...
4: try {
5: i f ( a c t u a l . s i g == n u l l ) {
6: throw new
7: RegNoEncontradoException ( a c t u a l . g e t A n t e r i o r ( ) ,
8: actual );
9: } // f i n de i f
10: ...
11: } // f i n de t r y
12: catch ( R e g N o E n c o n t r a d o E x c e p t i o n e ) {
13: System . o u t . p r i n t l n ( "El registro debio encontrarse "
14: +" entre \n" ) ;
15: System . o u t . p r i n t l n ( "***" + e . daRegAnt ( ) . daNombre ( )
16: + "***\n" + " y\n" ) ;
17: System . o u t . p r i n t l n ( "***"
18: + e . daRegPost ( ) . daNombre ( )
19: + "***" ) ;
20: } // f i n de c a t c h
21: ...
22: } // main
23: } // c l a s s

En las lneas 6: a 8: tenemos un constructor adicional declarado para nuestra

clase que extiende a Exception. Como se puede ver en las lneas 13: a 17:, el
manejador de la excepcion hace uso de los campos y metodos declarados en la
9.4 Las clases que extienden a Exception 308

excepcion, y que son llenados por el constructor, para proveer mas informacion al
usuario de la situacion presente en el momento de la excepcion. Haciendolo de esta
manera, en el momento de lanzar la excepcion se puede invocar un constructor
que recoja toda la informacion posible del contexto en el que es lanzada, para
reportar despues en el manejador.
Unicamente hay que recordar que todas aquellas variables que sean declaradas
en el bloque try no son accesibles desde fuera de este bloque, incluyendo a los
manejadores de excepciones. Insistimos: si se desea pasar informacion desde el
punto donde se lanza la excepcion al punto donde se maneja, lo mejor es pasarla
en la excepcion misma. Esto ultimo se consigue redefiniendo y extendiendo a la
clase Exception.
Ademas de la informacion que logremos guardar en la excepcion, tenemos
tambien los metodos de Throwable, como el que muestra el estado de los registros
de activacion en el stack, o el que llena este stack en el momento inmediato anterior
a lanzar la excepcion. Todos estos metodos se pueden usar en las excepciones
creadas por el programador.
Veamos en los listados 9.15 y 9.16 otro ejemplo de declaracion y uso de ex-
cepciones creadas por el programador. En este ejemplo se agrega un constructor
y un atributo que permiten a la aplicacion recoger informacion respecto al orden
en que se lanzan las excepciones y el contexto en el que esto sucede.

Codigo 9.15 Excepciones creadas por el programador (MiExcepcion2)

1: // A d e c u a c i o n de l a s e x c e p c i o n e s
2: c l a s s M i E x c e p c i o n 2 extends E x c e p t i o n {
3: private int i ;
4: public MiExcepcion2 () {
5: super ( ) ;
6: }
7: p u b l i c M i E x c e p c i o n 2 ( S t r i n g msg ) {
8: super ( msg ) ;
9: }
10: p u b l i c M i E x c e p c i o n 2 ( S t r i n g msg , i n t x ) {
11: super ( msg ) ;
12: i = x;
13: }
14: public int val () {
15: return i ;
16: }
17: }
309 Manejo de errores en ejecucion

Codigo 9.16 Uso de excepciones creadas por el programador (CaracteristicasExtra)

18: p u b l i c c l a s s C a r a c t e r i s t i c a s E x t r a {
19: p u b l i c s t a t i c v o i d f ( ) throws M i E x c e p c i o n 2 {
20: System . o u t . p r i n t l n ( " Lanzando MiExcepcion2 desde f()" ) ;
21: throw new M i E x c e p c i o n 2 ( ) ;
22: }
23: p u b l i c s t a t i c v o i d g ( ) throws M i E x c e p c i o n 2 {
24: System . o u t . p r i n t l n ( " Lanzando MiExcepcion2 desde g()" ) ;
25: throw new M i E x c e p c i o n 2 ( "Se origino en g()" ) ;
26: }
27: p u b l i c s t a t i c v o i d h ( ) throws M i E x c e p c i o n 2 {
28: System . o u t . p r i n t l n ( " Lanzando MiExcepcion2 desde h()" ) ;
29: throw new M i E x c e p c i o n 2 ( "Se origino en h()" , 4 7 ) ;
30: }
31: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
32: try {
33: f ();
34: }
35: catch ( M i E x c e p c i o n 2 e ) {
36: e . p r i n t S t a c k T r a c e ( System . e r r ) ;
37: }
38: try {
39: g();
40: }
41: catch ( M i E x c e p c i o n 2 e ) {
42: e . p r i n t S t a c k T r a c e ( System . e r r ) ;
43: }
44: try {
45: h();
46: }
47: catch ( M i E x c e p c i o n 2 e ) {
48: e . p r i n t S t a c k T r a c e ( System . e r r ) ;
49: System . e r r . p r i n t l n ( "e.val () = " + e . v a l ( ) ) ;
50: }
51: }
52: }

En esta aplicacion se muestra el uso de distintos constructores, las invocaciones

a los metodos de Throwable y la extension de la informacion que provee la clase
agregando campos. El resultado de la ejecucion se puede ver en la figura 9.7 en la
siguiente pagina.
9.4 Las clases que extienden a Exception 310

Figura 9.7 Ejecucion de CaracteristicasExtra

elisa@lambda ...ICC1/progs/excepciones % java CaracteristicasExtra
Lanzando MiExcepcion2 desde f()
MiExcepcion2
at CaracteristicasExtra.f(CaracteristicasExtra.java:23)
at CaracteristicasExtra.main(CaracteristicasExtra.java:38)
Lanzando MiExcepcion2 desde g()
MiExcepcion2: Se origino en g()
at CaracteristicasExtra.g(CaracteristicasExtra.java:28)
at CaracteristicasExtra.main(CaracteristicasExtra.java:44)
Lanzando MiExcepcion2 desde h()
MiExcepcion2: Se origino en h()
at CaracteristicasExtra.h(CaracteristicasExtra.java:33)
at CaracteristicasExtra.main(CaracteristicasExtra.java:50)
e.val() = 47

Recalcando lo que ya vimos respecto a excepciones, notamos varias cosas en

este listado:
Los metodos f(), g() y h() tienen que avisar que lanzan una excepcion, ya
que MiExcepcion2 no hereda de RuntimeException y por lo tanto se debe
vigilar cuando se ejecute cualquiera de estos tres metodos. Vale la pena decir
que aunque el lanzamiento de la excepcion fuera condicional, de cualquier
manera el metodo tendra que avisar que existe la posibilidad de que lance
la excepcion.
Como los metodos lanzan excepciones, cada uno de ellos tiene que ser invo-
cado en un bloque try.
Como el bloque try consiste unicamente de la invocacion al metodo, una vez
ejecutado el manejador de la excepcion que se encuentra a continuacion del
respectivo catch, la ejecucion continua en la siguiente lnea de codigo. Es
por ello que aunque se lancen las excepciones, la ejecucion continua una vez
ejecutado el manejador.
Si alguno de los metodos lanzaran alguna otra excepcion, el compilador
exigira que hubiera un manejador por cada tipo de excepcion. Se puede
cachar excepciones usando superclases, pero cada clase de excepcion lanzada
por un metodo tiene que tener su manejador propio o uno que se refiera a
la superclase.
Si un metodo lanza una excepcion y no la cacha en el mismo metodo, su
encabezado tiene que especificar que lanza aquellas excepciones que no sean
311 Manejo de errores en ejecucion

cachadas en el mismo metodo.

9.4.1. Relanzamiento de excepciones

Muchas veces el manejador de una excepcion hace algo de administracion de

la clase y despues de esto simplemente vuelve a lanzar la excepcion. Si se le va a
pedir a la excepcion que reporte el punto donde estaba la ejecucion en el momento
en que fue lanzada la excepcion usando printStackTrace la excepcion lanzada
va a tener registro del punto donde fue creada, no del punto desde donde es
finalmente lanzada. Para que la excepcion actualice su informacion respecto al
stack de ejecucion se utiliza el metodo fillInStackTrace al momento de relanzar la
excepcion; esto va a hacer que el stack refleje el ultimo punto donde la excepcion
fue lanzada y no donde fue creada.

9.5 El enunciado finally

Cuando tenemos un programa en el que estamos vigilando el lanzamiento de

excepciones, vamos a tener codigo que, por encontrarse despues del punto donde
se lanzo la excepcion y dentro del bloque try, no va a ser ejecutado. Por ejemplo,
si estoy tratando de asignarle un valor a una variable y la ejecucion no pasa por
ese enunciado porque antes se lanzo una excepcion.
A continuacion de los bloques correspondientes a cachar las excepciones los
bloques catch podemos escribir un bloque de enunciados que se van a ejecutar
ya sea que se haya lanzado una excepcion o no en el bloque try. La clausula finally
siempre se ejecuta, no importa que se haya lanzado o no una excepcion. Veamos
un ejemplo muy sencillo en el listado 9.18 en la siguiente pagina.

Codigo 9.17 Ejemplo con la clausula finally (Excepcion)

1: c l a s s T r e s E x c e p t i o n extends E x c e p t i o n {
2: public TresException () {
3: super ( ) ;
4: }
5: p u b l i c T r e s E x c e p t i o n ( S t r i n g msg ) {
6: super ( msg ) ;
7: }
8: }
9.5 El enunciado finally 312

Codigo 9.18 Ejemplo con la clausula finally (uso)

9: p u b l i c c l a s s F i n a l l y T r a b a j a {
10: s t a t i c int cuenta = 0;
11: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
12: while ( true ) {
13: try {
14: // Post
i n c r e m e n t o . Es c e r o l a p r i m e r a v e z
15: i f ( c u e n t a++ == 0 ) {
16: throw new T r e s E x c e p t i o n ( ) ;
17: }
18: System . o u t . p r i n t l n ( "No hubo excepcion " ) ;
19: }
20: catch ( T r e s E x c e p t i o n e ) {
21: System . e r r . p r i n t l n ( " TresException " ) ;
22: }
23: finally {
24: System . e r r . p r i n t l n ( "En la clausula finally " ) ;
25: i f ( c u e n t a == 2 ) {
26: break ; // s a l d e l w h i l e
27: }
28: }
29: }
30: }
31: }

Como se puede ver la salida de la ejecucion de este algoritmo en la figura 9.8,

el mensaje mandado por el bloque finally se imprime siempre, sin importar si hubo
o no excepcion.

Figura 9.8 Ejecucion de FinallyTrabaja

elisa@lambda ...ICC1/progs/excepciones % java FinallyTrabaja
TresException
En la clausula finally
No hubo excepcion
En la clausula finally

Es interesante tambien notar como, aunque se lance una excepcion, como el

bloque try esta dentro de una iteracion, al salir de ejecutar todo el bloque asociado
a la excepcion, la ejecucion continua con el while.
313 Manejo de errores en ejecucion

finally funciona como una tarea que sirve para dar una ultima pasada al codigo,
de tal manera de garantizar que todo quede en un estado estable. No siempre es
necesario, ya que Java cuenta con recoleccion automatica de basura y destructores
de objetos tambien automaticos. Sin embargo, se puede usar para agrupar tareas
que se desean hacer, por ejemplo en un sistema guiado por excepciones, ya sea que
se presente un tipo de excepcion o no. Veamos un ejemplo con unos interruptores
electricos en el listado 9.19.

Codigo 9.19 Otro ejemplo con la clausula finally (Switch)

1: c l a s s S w i t c h {
2: boolean s t a t e = f a l s e ;
3: boolean r e a d ( ) {
4: return s t a t e ;
5: }
6: v o i d on ( ) {
7: s t a t e = true ;
8: }
9: void o f f ( ) {
10: state = false ;
11: }
12: }

Codigo 9.20 Otro ejemplo con la clausula finally (OnOffException1)

1: c l a s s O n O f f E x c e p t i o n 1 extends E x c e p t i o n {
2: public OnOffException1 () {
3: super ( ) ;
4: }
5: p u b l i c O n O f f E x c e p t i o n 1 ( S t r i n g msg ) {
6: super ( msg ) ;
7: }
8: }

Codigo 9.21 Otro ejemplo con la clausula finally (OnOffException2)

1: c l a s s O n O f f E x c e p t i o n 2 extends E x c e p t i o n {
2: public OnOffException2 () {
3: super ( ) ;
4: }
5: p u b l i c O n O f f E x c e p t i o n 2 ( S t r i n g msg ) {
6: super ( msg ) ;
7: }
8: }
9.5 El enunciado finally 314

Codigo 9.22 Otro ejemplo con la clausula finally (OnOffSwitch)

1: c l a s s O n O ff S w i t c h {
2: s t a t i c S w i t c h sw = new S w i t c h ( ) ;
3: s t a t i c void f ( )
4: throws O n O f f E x c e p t i o n 1 , O n O f f E x c e p t i o n 2 {
5: }
6: }

Codigo 9.23 Otro ejemplo con la clausula finally (ConFinally)

1: p u b l i c c l a s s C o n F i n a l l y {
2: s t a t i c S w i t c h sw = new S w i t c h ( ) ;
3: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
4: try {
5: sw . on ( ) ;
6: // C o d i g o que puede l a n z a r e x c e p c i o n e s
7: O n O ff S w i t c h . f ( ) ;
8: }
9: catch ( O n O f f E x c e p t i o n 1 e ) {
10: System . e r r . p r i n t l n ( " OnOffException1 " ) ;
11: }
12: catch ( O n O f f E x c e p t i o n 2 e ) {
13: System . e r r . p r i n t l n ( " OnOffException2 " ) ;
14: }
15: finally {
16: sw . o f f ( ) ;
17: }
18: }
19: }

En esta aplicacion deseamos que, ya sea que se haya podido o no prender el

interruptor, la aplicacion lo apague antes de salir.
Los bloques try se pueden anidar para colocar de mejor manera las clausulas
finally, obligando a ejecutar de adentro hacia afuera. En el listado 9.24 tenemos
un ejemplo de anidamiento de bloques try.

Codigo 9.24 Anidamiento de bloques try (CuatroException)

1: c l a s s C u a t r o E x c e p t i o n extends E x c e p t i o n {
2: public CuatroException () {
3: super ( ) ;
4: }
5: p u b l i c C u a t r o E x c e p t i o n ( S t r i n g msg ) {
6: super ( msg ) ;
7: }
8: }
315 Manejo de errores en ejecucion

Codigo 9.25 Anidamiento de bloques try (SiempreFinally)

1: p u b l i c c l a s s S i e m p r e F i n a l l y {
2: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
3: System . o u t . p r i n t l n ( " Entrando al primer bloque try" ) ;
4: try {
5: System . o u t . p r i n t l n ( " Entrando al segundo bloque try" ) ;
6: try {
7: throw new C u a t r o E x c e p t i o n ( ) ;
8: }
9: finally {
10: System . o u t . p r i n t l n ( " Finally en el segundo "
11: + " bloque try" ) ;
12: }
13: }
14: catch ( C u a t r o E x c e p t i o n e ) {
15: System . e r r . p r i n t l n ( " Cachando CuatroException en " +
16: "el primer bloque try" ) ;
17: }
18: finally {
19: System . e r r . p r i n t l n ( " Finally en primer bloque try" ) ;
20: }
21: }
22: }

Como en la mayora de los casos, la clausula finally se ejecuta de adentro hacia

afuera. No importa que el primer try no tenga manejador para la excepcion, porque
al lanzarse la excepcion y no encontrar un manejador en su entorno inmediato,
simplemente va a salir y utilizar el manejador del bloque try mas externo. El
resultado de la ejecucion se puede ver en la figura 9.9.

Figura 9.9 Ejecucion de SiempreFinally

elisa@lambda ...ICC1/progs/excepciones % java SiempreFinally
Entrando al primer bloque try
Entrando al segundo bloque try
Finally en el segundo bloque try
Cachando CuatroException en el primer bloque try
Finally en primer bloque try
9.6 Restricciones para las excepciones 316

9.6 Restricciones para las excepciones

Cuando se redefine el metodo de una clase, el metodo redefinido no puede

lanzar mas excepciones (o distintas) que el metodo original. Esto es para que si
alguien usa herencia para manejar ciertos objetos, no resulte que el metodo en la
superclase ya no funciona porque el metodo en la subclase lanza mas excepciones
que el original. Esto es, si un metodo en la superclase no lanza excepciones, ese
metodo redefinido en las subclases tampoco puede lanzar excepciones.
Lo que si puede hacer un metodo redefinido es lanzar excepciones que resultan
de extender a las excepciones que lanza el metodo de la superclase. En este caso
no hay problema. Revisemos, por ejemplo, la aplicacion del listado 9.26.

Codigo 9.26 Manejo de excepciones con herencia 1/3

1: c l a s s B a s e b a l l E x c e p t i o n extends E x c e p t i o n {
2: }
3: c l a s s F o u l extends B a s e b a l l E x c e p t i o n {
4: }
5: c l a s s S t r i k e extends B a s e b a l l E x c e p t i o n {
6: }
7:
8: abstract class Inning {
9: I n n i n g ( ) throws B a s e b a l l E x c e p t i o n {
10: }
11: v o i d e v e n t ( ) throws B a s e b a l l E x c e p t i o n {
12: }
13: a b s t r a c t v o i d a t B a t ( ) throws S t r i k e , F o u l ;
14: void walk ( ) {
15: }
16: }
17:
18: c l a s s S t o r m E x c e p t i o n extends E x c e p t i o n {
19: }
20: c l a s s RainedOut extends S t o r m E x c e p t i o n {
21: }
22: c l a s s PopFoul extends F o u l {
23: }
24:
25: i n t e r f a c e Storm {
26: v o i d e v e n t ( ) throws RainedOut ;
27: v o i d r a i n H a r d ( ) throws RainedOut ;
28: }
317 Manejo de errores en ejecucion

Codigo 9.26 Manejo de excepciones con herencia (StormyInning)2/3

29: p u b l i c c l a s s S t o r m y I n n i n g extends I n n i n g implements Storm {
30: / OK a n a d i r n u e v a s e x c e p c i o n e s p a r a l o s c o n s t r u c t o r e s , p e r o s e
31: deben m a n e j a r l a s e x c e p c i o n e s de l o s c o n s t r u c t o r e s b a s e :
32: /
33: S t o r m y I n n i n g ( ) throws RainedOut , B a s e b a l l E x c e p t i o n {
34: }
35:
36: S t o r m y I n n i n g ( S t r i n g s ) throws Foul , B a s e b a l l E x c e p t i o n {
37: }
38: / Los metodos n o r m a l e s s e t i e n e n que a d a p t a r a l a c l a s e b a s e :
39: ! v o i d w a l k ( ) t h r o w s PopFoul {} // C o m p i l e E r r o r
40: I n t e r f a c e CANNOT add e x c e p t i o n s t o e x i s t i n g methods from t h e
41: base c l a s s :
42: ! p u b l i c v o i d e v e n t ( ) t h r o w s RainedOut { }
43: S i e l metodo no e x i s t e en l a c l a s e base , e n t o n c e s l a
44: e x c e p c i o n s e v a l e :
45: /
46: p u b l i c v o i d r a i n H a r d ( ) throws RainedOut {
47: }
48:
49: / Puedes e l e g i r no l a n z a r n i n g u n a e x c e p c i o n , aun cuando l a
50: v e r s i o n b a s e s l o haga :
51: /
52: public void event ( ) {
53: }
54:
55: / Los metodos que r e d e f i n e n a metodos b a s i c o s pueden l a n z a r
56: excepciones heredadas :
57: /
58: v o i d a t B a t ( ) throws PopFoul {
59: }
60: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
61: try {
62: S t o r m y I n n i n g s i = new S t o r m y I n n i n g ( ) ;
63: s i . atBat ( ) ;
64: } catch ( PopFoul e ) {
65: System . e r r . p r i n t l n ( " PopFoul " ) ;
66: } catch ( RainedOut e ) {
67: System . o u t . p r i n t l n ( " Rained out" ) ;
68: } catch ( B a s e b a l l E x c e p t i o n e ) {
69: System . o u t . p r i n t l n ( " Generic Error " ) ;
70: }
9.7 Recomendaciones generales 318

Codigo 9.26 Manejo de excepciones con herencia (StormyInning)3/3

71:
72: // En l a v e r s i o n d e r i v a d a no s e l a n z a un S t r i k e
73: try {
74: // Que p a s a s i s e u p c a s t ?
75: I n n i n g i = new S t o r m y I n n i n g ( ) ;
76: i . atBat ( ) ;
77: // Debes c a c h a r l a s e x c e p c i o n e s d e l metodo de l a v e r s i o n
78: // en l a c l a s e b a s e :
79: } catch ( S t r i k e e ) {
80: System . o u t . p r i n t l n ( " Strike " ) ;
81: } catch ( F o u l e ) {
82: System . o u t . p r i n t l n ( "Foul" ) ;
83: } catch ( RainedOut e ) {
84: System . o u t . p r i n t l n ( " Rained Out" ) ;
85: } catch ( B a s e b a l l E x c e p t i o n e ) {
86: System . o u t . p r i n t l n ( " Excepcion Generica Badalle " ) ;
87: }
88: }
89: }

9.6.1. Apareamiento de excepciones

En general, el manejador de una excepcion se va a ejecutar en cualquiera de

las situaciones siguientes:

La clase a la que pertenece la excepcion aparece en una clausula catch que

corresponde al bloque try en el que se lanzo la excepcion.
Alguna de las superclases de la excepcion lanzada aparece en una clausula
catch que corresponde al bloque try en el que se lanzo la excepcion.

Cualquiera de estas dos situaciones que se presente, se ejecutara el manejador

que aparezca primero. Si en la lista de manejadores aparecen tanto la superclase
como la clase, y la superclase aparece primero, el compilador dara un mensaje de
error de que el segundo manejador nunca puede ser alcanzado. En la aplicacion
StormyInning del listado 9.26 se pueden observar todas las combinaciones de este
tipo. Los comentarios ilustran tambien algunos puntos que no son validos.
319 Manejo de errores en ejecucion

9.7 Recomendaciones generales

Las excepciones en general se usan en cualquiera de las siguientes circunstancias:

i. Arreglar el problema y llamar otra vez al metodo que causo la excepcion.

ii. Parchar el proceso y continuar sin volver a intentar el metodo.

iii. Calcular algun resultado alternativo en lugar del que el metodo se supone que
deba haber calculado.

iv. Hacer lo que se pueda en el contexto actual y relanzar la excepcion para que
sea manejada en un contexto superior.

v. Hacer lo que se pueda en el contexto actual y lanzar una excepcion distinta

para que sea manejada en un contexto superior.

vi. Terminar el programa.

vii. Simplificar el algoritmo.

viii. Hacer una aplicacion (o biblioteca) mas segura (se refleja a corto plazo en la
depuracion y a largo plazo en la robustez de la aplicacion).

Con esto damos por terminado este tema, aunque lo usaremos extensivamente
en los captulos que siguen.
 Entrada y salida
10
10.1 Conceptos generales

Uno de los problemas que hemos tenido hasta el momento es que las bases
de datos que hemos estado construyendo no tienen persistencia, esto es, una vez
que se descarga la aplicacion de la maquina virtual (que termina) la informacion
que generamos no vive mas alla. No tenemos manera de almacenar lo que cons-
truimos en una sesion para que, en la siguiente sesion, empecemos a partir de
donde nos quedamos. Practicamente en cualquier aplicacion que programemos y
usemos vamos a requerir de mecanismos que proporcionen persistencia a nuestra
informacion.
En los lenguajes de programacion, y en particular en Java, esto se logra me-
diante archivos 1 , que son conjuntos de datos guardados en un medio de almace-
namiento externo. Los archivos sirven de puente entre la aplicacion y el medio
exterior, ya sea para comunicarse con el usuario o para, como acabamos de men-
cionar, darle persistencia a nuestras aplicaciones.
Hasta ahora hemos usado extensamente la clase Consola, que es una clase
programada por nosotros. Tambien hemos usado en algunos ejemplos del captulo
anterior dos archivos (objetos) que estan dados en Java y que son System.out
y System.err. Ambos archivos son de salida; el primero es para salida normal en
consola y el segundo para salida, tambien en consola, pero de errores. Por ejemplo,
cuando un programa que aborta reporta donde se lanzo la excepcion, el reporte
10.1 Conceptos generales 322

lo hace a System.err.
La razon por la que usamos nuestra propia clase hasta el momento es que en
Java practicamente toda la entrada y salida puede lanzar excepciones; eso implica
que cada vez que usemos un archivo para leer, escribir, crearlo, eliminarlo, y en
general cualquier operacion que tenga que ver con archivos, esta operacion tiene
que ser vigilada en un bloque try, con el manejo correspondiente de las excep-
ciones que se pudieran lanzar. Lo que hace nuestro paquete de entrada y salida
es absorber todas las excepciones lanzadas para que cuando usan los metodos de
estas clases ya no haya que vigilar las excepciones.
El disenar los metodos de entrada y salida para que lancen excepciones en
caso de error es no solo conveniente, sino necesario, pues es en la interaccion con
un usuario cuando la aplicacion puede verse en una situacion no prevista, como
datos erroneos, un archivo que no existe o falta de espacio en disco para crear un
archivo nuevo.
Un concepto muy importante en la entrada y salida de Java es el de flujos de
datos. Java maneja su entrada y salida como flujos de caracteres (ya sea de 8 o
16 bits). En el caso de los flujos de entrada, estos proporcionan caracteres, uno
detras de otro en forma secuencial, para que el programa los vaya consumiendo
y procesando. Los flujos de salida funcionan de manera similar, excepto que es
el programa el que proporciona los caracteres para que sean proporcionados al
mundo exterior, tambien de manera secuencial.
En las figuras 10.1 y 10.2 en la pagina opuesta vemos los algoritmos generales
para lectura y escritura, no nada mas para Java, sino que para cualquier lenguaje
de programacion.

Figura 10.1 Algoritmo para el uso de flujos de entrada

$
'
'
'
'
'
'Abrir el flujo
'
' $
&
Lectura de Leer informacion '
&
caracteres '
' (mientras haya) Leer informacion
'' '
%
'
'
'
'
%
Cerrar el flujo
323 Entrada y salida

Figura 10.2 Algoritmo para el uso de flujos de salida

$
'
' Abrir el flujo
'
' $
'
' '
& &
Escritura de Escribir informacion
Escribir informacion
caracteres '
' (mientras haya) '
%
' '
'
'
%
Cerrar el flujo

Podemos ver un esquema de este funcionamiento en las figuras 10.3 y 10.4.

Figura 10.3 Funcionamiento de flujo de entrada

Dispositivo D
A

T Leer
O S Aplicacion

Figura 10.4 Funcionamiento de flujo de salida

Escribir
Aplicacion D
A

T
O S Dispositivo

Los flujos de entrada se manejan a traves de clases especficas para ellos. Al

construir el objeto se abre el flujo; se lee de el o escribe en el utilizando los distintos
metodos que tenga la clase para ello; se cierra invocando al metodo close del objeto
correspondiente.
En lo que sigue elaboraremos metodos para hacer persistente nuestra base de
datos. Antes trataremos de tener una vision mas general de como maneja Java la
entrada y salida.
10.2 Jerarqua de clases 324

10.2 Jerarqua de clases

La entrada y salida se maneja en Java a traves de una jerarqua que incluye

clases e interfaces. Tenemos basicamente dos maneras de hacer entrada y salida:
la primera es leyendo y escribiendo bytes, mientras que la segunda es leyendo y
escribiendo caracteres Unicode. Dado que Java es, fundamentalmente, un lenguaje
cuya caracterstica principal es su portabilidad, se diseno un juego de caracteres
universales, de dos bytes cada uno, que cubre practicamente todos los alfabe-
tos conocidos. Para asegurar la portabilidad de datos, y dado que Java maneja
internamente Unicode, es que se disenaron estas clases que manejan caracteres.
Cada uno de los tipos de entrada y salida tiene una superclase abstracta para
lectura y otra para escritura. De ella se derivan clases concretas que permiten ma-
nipular de alguna forma lo que se esta leyendo o escribiendo. Iremos describiendo
su uso conforme las vayamos presentando.
La entrada y salida se ve siempre como un flujo, ya sea de bytes o de caracteres.
Se va tomando unidad por unidad y se procesa. Cuando este flujo se termina
decimos que se acabo el archivo y tendremos un eof (fin de archivo). Generalmente
procesaremos la informacion hasta encontrar un eof, en cuyo momento daremos
fin al proceso de los datos. Es por esta caracterstica que Java llama a su entrada
y salida streams. Hablaremos de un flujo de bytes o de un flujo de caracteres
(omitiendo Unicode).

10.3 Entrada y salida de bytes

Un byte es un entero que ocupa 8 bits, y en general se da como unidad de
medida para otros tipos que ocupan mas espacio. Los enteros que podemos alma-
cenar en un byte van del -128 al 127. Sin embargo, cuando pensamos en codigo
ASCII, pensamos en caracteres cuyo valor esta entre 0 y 255. Para que podamos
manejar as los bytes, la lectura (y la escritura) se hara siempre en enteros o en
caracteres Unicode, de tal manera que el metodo utilice unicamente el byte mas
bajo (al que corresponden las posiciones mas de la derecha).
En la figura 10.5 en la pagina opuesta se encuentra la jerarqua de clases para
InputStream, mientras que en la figura 10.6 en la pagina 328 esta el esquema de la
jerarqua de clases para OutputStream.
325 Entrada y salida

Figura 10.5 Jerarqua de clases para InputStream.

DataInput

InputStream ObjectInput

ObjectInputStream
LineNumberInputStream

SequenceInputStream
DataInputStream

ByteArrayInputStream
BufferedInputStream

FilterInputStream
PushBackInputStreeam

FileInputStream
CheckedInputSteam

PipedInputStream
CipherInputStream

StringBufferInputStream
DigestInputStream

InflaterInputStream

ProgressMonitorInputStream

A continuacion damos una muy breve explicacion en orden alfabetico de cual es

el uso de cada una de las subclases para entrada. Todas las subclases se encuentran
en el paquete java.io, excepto cuando indiquemos explcitamente que no es as.
10.3 Entrada y salida de bytes 326

public class BufferedInputStream extends FilterInputStream

Lee desde un InputStream guardando lo que va leyendo en un buffer. Esto
permite a la aplicacion marcar una posicion o regresar a bytes ya ledos.
public class ByteArrayInputStream extends InputStream
Contiene un buffer interno que contiene bytes, que se leen del flujo, cuando
es necesario.
public class CheckedInputStream extends FilterInputStream
(Paquete: java.util.zip)
Es un InputStream que mantiene una suma de verificacion (checksum) de
los datos que ha ledo.
public class CipherInputStream extends FilterInputStream
(Paquete: javax.crypto)
Esta compuesto de un InputStream y un Cipher que permite entregar ci-
frados los bytes que lee de la entrada.
public class DataInputStream extends FilterInputStream
implements DataInput
Lee datos primitivos (enteros, reales, booleanos, etc.) de un InputStream
subyacente de manera independiente de la maquina.
public class FileInputStream extends InputStream
El flujo de entrada reside en un archivo en disco.
public class FilterInputStream
Simplemente recibe el flujo de un flujo subyacente y los pasa a la aplica-
cion. Redefine los metodos de entrada para poder transformarla.
public class DigestInputStream extends FilterInputStream
(paquete: java.security)
Actualiza el mensaje digerido (MesasageDigest) usando para ello los bytes
que pasan por el flujo.
public class InflaterInputStream extends FilterInputStream
(Paquete: java.util.zip)
Implementa un filtro para descomprimir datos comprimidos con deflate y
para otros filtros de descompresion.
public abstract class InputStream implements Closeable
Es la superclase de todas las clases que manejan flujos de entrada de bytes.
327 Entrada y salida

public class LineNumberInputStream extends FilterInputStream

(sobreseido2 )
Este flujo lleva la cuenta del numero de lneas que ha ledo. Una lnea
es una sucesion de bytes que terminan con zr, zn o un retorno de carro
seguido de una alimentacion de lnea. Al entregar las lneas ledas convierte
cualquiera de los terminadores a zn.
class ObjectInputStream extends InputStream
implements ObjectInput, ObjectStreamConstants
Escribe datos primitivos y graficas de objetos de Java en un flujo de bytes.
Unicamente objetos que implementen la interfaz Serializable pueden ser
escritos en este flujo.
public class PipedInputStream extends InputStream
Se usa con hilos paralelos de ejecucion, donde uno de los hilos usa un Pipe-
dInputStream para adquirir datos y el otro usa un PipedOutputStream para
entregar datos. Ambos hilos pueden hacer un proceso de la informacion
del flujo correspondiente.
public class ProgressMonitorInputStream extends FilterInputStream
(Paquete: javax.swing)
Vigila el progreso al leer de un InputStream, presentando, en su caso,
ventanas de dialogo.
public class PushBackInputStream extends FilterInputStream
Trabaja sobre un InputStream subyacente y permite desleer un byte.
Este proceso es util cuando estamos buscando, por ejemplo, un byte que
tiene dos funciones: delimitar lo que esta antes y empezar lo nuevo. En
este caso es conveniente desleerlo para el segundo papel que juega.
public class SequenceInputStream extends InputStream
Es capaz de concatenar, para lectura, a varios flujos de entrada como si
fueran uno solo.
public class StringBufferInputStream extends InputStream
Permite crear una aplicacion en la que el flujo proviene de una cadena de
caracteres, en lugar de venir de un dispositivo.

La jerarqua de clases para los flujos de salida de bytes se da en la figura 10.6.

2
Corresponde a deprecated, que indica que no se recomienda su uso porque ya no va a ser
actualizada y soportada
10.4 Entrada y salida de caracteres 328

Con sus marcadas excepciones, por el uso que se le pueda dar, hay una correspon-
dencia entre ambas jerarquas.

Figura 10.6 Jerarqua de clases para OutputStream.

DataOutput

OutputStream ObjectOutput

ObjectOutputStream

ByteArrayOutputStream

PipedOutputStream

FileOutputStream

FilterOutputStream

PrintStream

BufferedOutputStream

DataOutputStream

La unica clase que no tiene contra parte en la jerarqua de entrada de bytes es

PrintStream:

public class PrintStream extends FilterOutputStream

implements Appendable
Agrega funcionalidad a otro OutputStream aportando la habilidad de im-
primir de manera conveniente diversos valores de datos. Adicionalmente,
sus metodos nunca lanzan excepciones y puede construirse de tal manera
que evacue automaticamente.
329 Entrada y salida

10.4 Entrada y salida de caracteres

Cuando hablamos de caracteres en el contexto de Java nos referimos a caracte-

res Unicode, donde cada uno ocupa 2 bytes (16 bits). Tenemos una jerarqua
similar a la que maneja bytes para caracteres Unicode, las superclases Writer y
Reader, cuyas jerarquas se muestra en las figuras 10.7 y 10.8 respectivamente. En
todos los casos las subclases sombreadas se refieren a clases que van a hacer un
proceso intermedio de los datos entre el origen y el destino de los mismos. Un
esquema de que significa esto se encuentra en la figura 10.14. En esta el origen de
los datos puede ser la aplicacion y el destino el dispositivo, en el caso de que se
este efectuando escritura; o bien el origen es el dispositivo que entrega los datos
en crudo y la aplicacion la que los recibe en el destino ya procesados.

Figura 10.7 Jerarqua de clases para Writer.

BufferedWriter

CharArrayWriter

FilterWriter

Writer PrintWriter

PipedWriter

StringWriter

OutputStreamWriter FileWriter
10.4 Entrada y salida de caracteres 330

Figura 10.8 Jerarqua de clases para Reader.

StringReader

CharArrayReader

PipedReader
Reader
BufferedReader LineNumberReader

FilterReader PushbackReader

InputStreamReader FileReader

Figura 10.9 Entrada/Salida con proceso intermedio (filtros)

Filtro

Origen Destino

Tambien estas jerarquas corren paralelas a las que trabajan con bytes, por lo
que no daremos una nueva explicacion de cada una de ellas. Se aplica la misma
331 Entrada y salida

explicacion, excepto que donde dice byte hay que sustituir por caracter. Uni-
camente explicaremos aquellas clases que no tienen contra parte en bytes.

public class StringWriter extends Writer

Escribe su salida en un buffer de tipo String, que puede ser utilizado a su
vez para construir una cadena.
public class OutputStreamWriter extends Writer
Funciona como un puente entre flujos de caracteres y flujos de bytes,
codificados de acuerdo a un conjunto de caracteres especfico.

Vale la pena hacer la aclaracion que en este caso los flujos que leen de y escriben
a archivos en disco extienden a las clases InputStreamReader y OutputStreamWriter
respectivamente, ya que la unidad de trabajo en los archivos es el byte (8 bits) y
no el caracter (16 bits). Por lo demas funcionan igual que sus contra partes en los
flujos de bytes.
Es conveniente mencionar que las versiones actuales de Java indican que las
clases que se deben usar son las que derivan de Reader y Writer y no las que son
subclases de InputStream y OutputStream. Ambas jerarquas (las de bytes y las
de caracteres) definen practicamente los mismos metodos para bytes y caracteres,
pero para fomentar la portabilidad de las aplicaciones se ha optado por soportar
de mejor manera las clases relativas a caracteres.
Sin embargo, como ya mencionamos, la entrada y salida estandar de Java es
a traves de clases que pertenecen a la jerarqua de bytes (System.in, System.out y
System.err).
Lo primero que queremos poder hacer es leer desde el teclado y escribir a
pantalla. Esto lo necesitamos para la clase que maneja el menu y de esta manera
ir abriendo las cajas negras que nos proporcionaba la clase Consola para este fin.

10.4.1. Entrada y salida estandar

La entrada y salida desde teclado y hacia consola se hace a traves de la clase

System. Esta clase ofrece, ademas de los objetos para este tipo de entrada y salida,
muchsimos metodos que van a ser utiles en aplicaciones en general. La clase
System tiene tres atributos que son:
public static f i n a l PrintStream e r r ;
public s t a t i c f i n a l InputStream in ;
public s t a t i c f i n a l PrintStream out ;
10.4 Entrada y salida de caracteres 332

Por ser objetos estaticos de la clase se pueden usar sin construirlos. Todo
programa en ejecucion cuenta con ellos, por lo que los puede usar, simplemente
refiriendose a ellos a traves de la clase System.
El primero de ellos es un archivo al que dirigiremos los mensajes que se refieran
a errores, y que no queramos mezclar con la salida normal. El segundo objeto es
para leer de teclado (con eco en la pantalla) y el tercero para escribir en la pantalla.
Las dos clases mencionadas son clases concretas que aparecen en la jerarqua de
clases que mostramos en las figuras 10.5 en la pagina 325 y 10.6 en la pagina 328.
Si bien la clase PrintStream se va a comportar exactamente igual a Consola,
en cuanto a que interpreta enteros, cadenas, flotantes, etc. para mostrarlos con
formato adecuado, esto no sucede con la clase InputStream que opera de manera
muy primitiva, leyendo byte por byte, y dejandole al usuario la tarea de pegar los
bytes para interpretarlos. Mas adelante revisaremos con cuidado todos los meto-
dos de esta clase. Por el momento unicamente revisaremos los metodos que leen
byte por byte, y que son:

public class InputStream implements Closeable

Constructores:
public InputStream()
Constructor por omision
Metodos:
public int read() throws IOException
Lee el siguiente byte del flujo de entrada. Devuelve un valor entre 0 y 255.
Si se acaba el archivo (o desde el teclado se oprime Ctrl-D) regresa -1.
public int read(byte[] b) throws IOException
Lee un numero de bytes al arreglo. Regresa el numero de bytes ledo.
Bloquea la entrada hasta tener datos de entrada disponibles, se encuentre
el fin de archivo o se lance una excepcion. Se leen, a lo mas, el numero de
bytes dado por el tamano de b.
public int read(byte[] b, int off , int len ) throws IOException
Lee a lo mas len bytes de datos desde el flujo de entrada y los acomoda en el
arreglo de bytes b. Regresa el numero de bytes ledos. El primer byte ledo
se acomoda en b[off]. Lanza una excepcion IndexOutOfBoundsException si
off es negativo, len es negativo o off len  b.length.
333 Entrada y salida

Como podemos ver de los metodos de la clase InputStream, son muy primitivos
y difciles de usar. Por ello, como primer paso en la inclusion de entrada y salida
completa en nuestra aplicacion, para entrada utilizaremos una subclase de Reader,
BufferedReader, mas actual y mejor soportada.

10.5 El manejo del menu de la aplicacion

En el caso de los flujos System.out y System.err no tenemos que hacer abso-

lutamente nada pues existen como atributos estaticos de la clase System, por lo
que los podemos usar directamente. Conviene, sin embargo, listar los metodos y
atributos de la clase PrintStream, que es una subclase de FilterOutputStream, que
es, a su vez, una subclase de OutputStream.

10.5.1. La clase OutputStream

Esta es una clase abstracta que deja sin implementar uno de sus metodos. El
constructor y los metodos se listan a continuacion:

public class OutputStream implements Closeable, Flushable

Constructores:
public OutputStream()
Constructor por omision.
Metodos:
public abstract void write(int b) throws IOException
Toma el entero b y escribe unicamente los 8 bits mas bajos, descartando
los otros 24 bits. El programador de clases que hereden de esta tienen que
definir este metodo.
public void write (byte[] b)
Escribe el contenido de los b.length bytes del arreglo b al flujo de salida.
10.5 El manejo del menu de la aplicacion 334

public void write (byte[] b, int off , int len ) throws IOException
Escribe en el flujo de salida los bytes desde b[off] hasta b[off+len-1]. Si
hay un error en el ndice o si b es null, lanza la excepcion correspondiente
(como son ArithmeticException ambas no hay que vigilarlas). Si hay algun
error de I/O se lanza la excepcion correspondiente.
public void flush () throws IOException
Evacua el flujo, obligando a que los bytes que esten todava en el buffer
sean escritos al medio fsico.
public void close () throws IOException
Cierra el flujo y libera los recursos del sistema asociados al flujo. Una vez
cerrado el flujo, cualquier otro intento de escribir en el va a causar una
excepcion. Lanza una excepcion (IOException) si se intenta reabrir. En
realidad no hace nada, sino que se tiene que reprogramar para que haga
lo que tiene que hacer.

Esta es la superclase de la clase que estamos buscando. De manera intermedia

hereda a la clase FilterOutputStream, que procesa el flujo antes de colocarlo en el
dispositivo de salida. Ademas de los metodos heredados de OutputStream, agrega
los siguientes metodos, ademas de implementar al metodo que lee de un entero.
Tiene la siguiente definicion:

public class FilterOutputStream extends OutputStream

Campo:
protected OutputStream out
El flujo de salida subyacente a ser filtrado.
Constructor:
public FilterOutputStream(OutputStream out)
Crea un filtro para el flujo out.
Metodo:
public void write (int b) throws IOException
Implementa el metodo abstracto write(int) de su superclase.
335 Entrada y salida

El resto de los metodos que hereda de OutputStream simplemente los redefine

a que invoquen al metodo correspondiente de su superclase, por lo que no los
listamos nuevamente. Sin embargo, como mencionamos antes, tanto out como err
se construyen como objetos de la clase PrintStream, que presenta varios metodos,
ademas de los que hereda de FilterOutputStream (hereda, entre otros, el campo que
corresponde al flujo de salida FilterOutputStream out). Listaremos solo algunos de
estos metodos. La lista exhaustiva se puede ver en la documentacion de Java.

public class PrintStream extends FilterOutputStream

implements Appendable
Constructores:
public PrintStream(OutputStream out)
Construye un PrintStream que no auto-evacua.
public PrintStream(OutputStream out, boolean autoFlush)
Construye un nuevo PrintStream. Si autoFlush es verdadero el buffer va
a evacuar cuando se escriba un arreglo de bytes, se invoque un metodo
println o se escriba un caracter de lnea nueva (zn).
public PrintStream(String fileName) throws FileNotFoundException
Busca escribir en un archivo en disco con nombre fileName. Crea el flujo
intermedio OutputStreamWriter necesario.
Metodos:
public void close ()
Cierra el flujo, evacuando y cerrando el flujo de salida subyacente.
public boolean checkError()
Evacua el flujo y verifica su estado de error. Este es verdadero si el flujo
de salida subyacente lanza una IOException distinta de InterruptedIOEx-
ception, y cuando se invoca al metodo setError.
protected void setError()
Establece en verdadero el estado de error del flujo.
public void write (int b)
Sobreescribe el metodo de OutputStream escribiendo el byte mas bajo al
dispositivo.
10.5 El manejo del menu de la aplicacion 336

public void write (byte[] buf, int off , int len )

Hace lo mismo que OutputStream.
public void print (boolean b)
Escribe un valor booleano. Escribe en bytes el valor dado por
String.valueOf(boolean).
public void print (char c)
Escribe un caracter, que se traduce a uno o mas bytes, dependiendo de la
plataforma.
public void print (int i )
Escribe un entero, el valor dado por String.valueOf(int).
public void print ( xtipoy xidentify )
El xtipoy puede ser long, float, double y se escribe lo producido por
String.valueOf(xtipoy).
public void print (char[] s)
Escribe un arreglo de caracteres, convirtiendolos a bytes.
public void print ( String s)
Escribe una cadena, tomando caracter por caracter y convirtiendolo a
byte.
public void print (Object obj)
Usa el metodo String.valueOf(Object) para escribir, en bytes, lo solicitado.
public void println ()
Imprime unicamente un caracter de fin de lnea
public void println ( xtipoy xidentify )
Admite los mismos tipos de argumentos que print; al terminar de escribir
el argumento, escribe un caracter de fin de lnea.
public PrintStream printf ( String format, Object. . . args)
Un metodo para escribir una lista de argumentos con un formato dado
por format.
public PrintStream format( String format, Object ... args)
Metodo equivalente a printf de esta misma clase.
Nota: esta clase presenta muchsimos metodos mas que no veremos por el momento.
Para conocerlos consultar la documentacion de las clases de Java.
337 Entrada y salida

Teniendo ya estas clases, y utilizando la salida estandar System.out y Sys-

tem.err, podemos proceder a reprogramar el menu en cuanto a las partes que
corresponden a la salida. Como la salida a consola en general no lanza excepcio-
nes, lo unico que hay que hacer es sustituir las escrituras en Consola por escrituras
a estos dos archivos estandar. Sustituiremos cada comunicacion normal con el
usuario donde aparezca cons.imprimeln por System.out.println; mientras que donde
sean mensajes de error para el usuario las sustituiremos por System.err.println.
Las lneas que se van a cambiar aparecen a continuacion, primero la original y a
continuacion la que fue cambiada y una breve explicacion, en su caso, de por que.

Antes:
import i c c 1 . i n t e r f a z . C o n s o l a ;
Despues:
import j a v a . i o . ;
Dejamos de importar nuestra clase de entrada y salida e importamos el paquete
io de Java. Si bien no lo necesitamos todava, IOException esta en este paquete
y pudieramos necesitarla.

Antes:
p r i v a t e void r e p o r t a N o ( C o n s o l a cons , S t r i n g nombre ) {
c o n s . i m p r i m e l n ( "El estudiante : z n z t"
+ nombre
+ " z n No esta en el grupo" ) ;
}
Despues:
p r i v a t e void r e p o r t a N o ( P r i n t S t r e a m out ,
S t r i n g nombre ) {
o u t . p r i n t l n ( "El estudiante : z n z t" + nombre
+ " z n no esta en el grupo" ) ;
}
Consola antes se usaba para entrada y salida, pero ahora tenemos que tener un
flujo de entrada y dos de salida. Este metodo unicamente maneja el de salida,
por lo cambiamos su parametros a que sea un flujo de salida del mismo tipo
que son out y err.
10.5 El manejo del menu de la aplicacion 338

Antes:
S t r i n g nombre = c o n s . l e e S t r i n g ( "Dame el nombre del "
+ " estudiante empezando por "
+ " apellido paterno:" ) ;
Despues:
S t r i n g nombre ;
System . o u t . p r i n t ( "Dame el nombre del estudiante ,"
+ " empezando por apellido paterno:" ) ;
// Aca va l a l e c t u r a

Ya no tenemos la posibilidad de escribir un mensaje y leer al final de este.

As que partimos en dos el proceso, escribiendo primero el mensaje, sin dar
cambio de lnea, para que empiece a leer a continuacion del mensaje (todava
falta la lectura de la cadena).

Antes:
c o n s . i m p r i m e l n ( menu ) ;
S t r i n g s o p c i o n = c o n s . l e e S t r i n g ( "Elige una opcion --> " ) ;
Despues:
System . o u t . p r i n t l n ( menu ) ;
System . o u t . p r i n t ( "Elige una opcion --> " ) ;
// Aca v i e n e l o de l a l e c t u r a de l a o p c i o n

Estamos dejando pendiente lo referente a la lectura.

Antes:
case 0 : // S a l i r
c o n s . i m p r i m e l n ( "Espero haberte servido. z n"
+ "Hasta pronto ..." ) ;
Despues:
case 0 : // S a l i r
System . o u t . p r i n t l n ( "Espero haberte servido. z n"
+ "Hasta pronto ..." ) ;
339 Entrada y salida

Antes:
c o n s . i m p r i m e l n ( "El estudiante : z n z t"
+ nombre + " z n Ha sido eliminado " ) ;
}
e l s e r e p o r t a N o ( cons , nombre ) ;
Despues:
System . o u t . p r i n t l n ( "El estudiante : z n z t"
+ nombre + " z n Ha sido eliminado " ) ;
}
e l s e r e p o r t a N o ( System . e r r , nombre ) ;

Antes:
s u b c a d = c o n s . l e e S t r i n g ( "Dame la subcadena a "+
"buscar: " ) ;
do {
s c u a l = c o n s . l e e S t r i n g ( "Ahora dime de cual campo :"
+ "1: Nombre , 2: Cuenta ,"
+ " 3: Carrera , 4: Clave" ) ;
c u a l = "01234" . i n d e x O f ( s c u a l ) ;
i f ( c u a l < 1)
c o n s . i m p r i m e l n ( "Opcion no valida" ) ;
} while ( c u a l < 1 ) ;
Despues:
try {
System . o u t . p r i n t ( "Dame la subcadena a "
+ "buscar: " ) ;
// L e e r s u b c a d e n a
do {
System . o u t . p r i n t ( "Ahora dime de cual campo :"
+ "1: Nombre 2: Cuenta 3: Carrera 4: Clave" ) ;
// L e e r o p c i o n
c u a l = "01234" . i n d e x O f ( s c u a l ) ;
i f ( c u a l < 1)
System . o u t . p r i n t l n ( "Opcion no valida" ) ;
} while ( c u a l < 1 ) ;
10.5 El manejo del menu de la aplicacion 340

donde = ( E s t u d i a n t e ) miCurso . b u s c a S u b c a d ( c u a l , s u b c a d ) ;
i f ( donde != n u l l )
System . o u t . p r i n t l n ( donde . d a R e g i s t r o ( ) ) ;
e l s e r e p o r t a N o ( System . e r r , s u b c a d ) ;
} catch ( I O E x c e p t i o n e ) {
System . e r r . p r i n t l n ( "Error al dar los datos"
+ " para buscar" ) ;
} // end o f t r y
c a t c h
Dejamos sin llenar las lecturas, aunque las colocamos en un bloque try. . . catch
porque las lecturas pueden lanzar excepciones.

Antes:
case 4 : // L i s t a t o d o s
miCurso . l i s t a T o d o s ( c o n s ) ;
Despues:
case 4 : // L i s t a t o d o s
miCurso . l i s t a T o d o s ( System . o u t ) ;
Simplemente pasamos como parametro el archivo de la consola.

Antes:
d e f a u l t : // E r r o r , v u e l v e a p e d i r
c o n s . i m p r i m e l n ( "No diste una opcion valida .\n" +
"Por favor vuelve a elegir." ) ;
return 0;
Despues:
d e f a u l t : // E r r o r , v u e l v e a p e d i r
System . o u t . p r i n t l n ( "No diste una opcion valida .\n"
+ "Por favor vuelve a elegir." ) ;

En cuanto a la clase ListaCurso, se tienen que hacer las siguientes modifica-

ciones:
341 Entrada y salida

Antes:
import i c c 1 . i n t e r f a z . C o n s o l a ;
Despues:
import j a v a . i o . ;

Antes:
p u b l i c void l i s t a T o d o s ( C o n s o l a c o n s ) {
...
cons . imprimeln ( a c t u a l . d a R e g i s t r o ( ) ) ;
...
c o n s . i m p r i m e l n ( "No hay registros en la base de datos" ) ;
Despues:
p u b l i c void l i s t a T o d o s ( P r i n t S t r e a m c o n s ) {
...
cons . p r i n t l n ( a c t u a l . d a R e g i s t r o ( ) ) ;
...
c o n s . p r i n t l n ( "No hay registros en la base de datos" ) ;

Antes:
p u b l i c void losQueCazanCon ( C o n s o l a cons , i n t c u a l ,
S t r i n g subcad ) {
...
cons . imprimeln ( a c t u a l . d a R e g i s t r o ( ) ) ;
...
c o n s . i m p r i m e l n ( "No se encontro ningun registro "
+ "que cazara" ) ;
Despues:
p u b l i c void losQueCazanCon ( P r i n t S t r e a m cons , i n t c u a l ,
S t r i n g subcad ) {
...
cons . p r i n t l n ( a c t u a l . d a R e g i s t r o ( ) ) ;
...
c o n s . p r i n t l n ( "No se encontro ningun registro "
+ "que cazara" ) ;
10.5 El manejo del menu de la aplicacion 342

Tambien en lo que toca a la interfaz implementada por ListaCurso, ParaListas, hay

que modificar los encabezados de estos dos metodos:

Antes:
p u b l i c void l i s t a T o d o s ( C o n s o l a c o n s ) ;
p u b l i c void losQueCazanCon ( C o n s o l a cons , i n t c u a l ,
S t r i n g subcad ) ;
Despues:
p u b l i c void l i s t a T o d o s ( P r i n t S t r e a m c o n s ) ;
p u b l i c void losQueCazanCon ( P r i n t S t r e a m cons , i n t c u a l ,
S t r i n g subcad ) ;

Como se puede ver, y dado que escribir en consola (mediante PrintStream no

lanza excepciones, el uso de esta clase en lugar de Consola para escribir no causa
ningun problema.

10.5.2. Lectura desde teclado

Como ya mencionamos antes, si usamos directamente System.in tendremos que

hacer un uso muy primitivo de la entrada, como convertir caracteres a cadenas,
a enteros, etc. La clase que nos proporciona la conversion desde el teclado es Da-
taInputStream que es la que usamos en Consola excepto por la lectura de una
cadena que se reporta como superada(deprecated. La clase DataInputStream,
como se muestra en la figura 10.5 en la pagina 325, es una subclase de FilterIn-
putStream, que a su vez es una subclase de InputStream. En la documentacion
de la clase io.DataInputStream recomiendan, para leer cadenas, un ejemplar de la
clase BufferedReader, dado que, argumentan, a partir de Java 1.1 ya no pueden
garantizar que la conversion de bytes (externos) a caracteres (internos) se haga
de manera adecuada. Como en el manejo del menu leemos unicamente cadenas,
utilizaremos un ejemplar de esta clase para ello. Como lo hicimos para nuestro
archivo de salida, veamos cual es la lnea hereditaria de esta clase, los metodos
que hereda y los que redefine.
343 Entrada y salida

public class Reader implements Readable, Closeable3

Campos:
protected Object lock
Campo que permite bloquear los accesos al archivo desde otra aplicacion
u otro hilo de ejecucion.
Constructores:
protected Reader()
protected Reader(Object lock)
Ambos constructores entregan un objeto de la clase Reader; el segundo
asigna un cerrojo externo.
Metodos:
public int read() throws IOException
Lee un caracter; se bloquea hasta que se le proporcione uno, haya un error
de I/O o se alcance el final del flujo. Regresa el caracter ledo (0,. . . ,65535)
o -1, si el flujo se acabo.
public int read(char[] cbuf)) throws IOException
Lee caracteres y los acomoda a partir del lugar 0 en el arreglo de caracteres
cbuf; se bloquea hasta que se le proporcione uno, haya un error de I/O o
se alcance el final del flujo. Regresa el numero de caracteres ledos o -1 si
el flujo se acabo.
public int read(char[] cbuf, int off , int len )) throws IOException
Lee a lo mas len caracteres y los acomoda a partir del lugar off en el
arreglo de caracteres cbuf; se bloquea hasta que se le proporcione uno,
haya un error de I/O o se alcance el final del flujo. Regresa el numero de
caracteres ledos o -1 si el flujo se acabo.
public int read(CharBuffer target ) throws IOException
Regresa -1 si el flujo de los caracteres se acabo o el numero de caracteres
agregados al buffer.
public long skip(long n) throws IOException
Salta caracteres (ledos); se bloquea hasta que se le proporcione uno, haya
un error de I/O o se alcance el final del flujo. Puede lanzar tambien la
excepcion IllegalArgumentException que no tiene que ser vigilada si se
le da un argumento negativo. Regresa el numero de caracteres realmente
saltados.

3
Estamos trabajando con JDK Standard Edition 5.0 o posteriores
10.5 El manejo del menu de la aplicacion 344

public boolean ready() throws IOException

Dice si el flujo de entrada tiene caracteres listos (true) o si va a tener
que bloquear la entrada y esperar a que se proporcionen mas caracteres
(false).
public abstract void close () throws IOException
Cierra el flujo y libera los recursos asociados a el. Cualquier accion sobre
el flujo despues de cerrado va a lanzar una excepcion. Si se cierra un flujo
ya cerrado no pasa nada.

Como ya mencionamos, este flujo es sumamente primitivo. Podramos leer a un

arreglo de caracteres y posteriormente convertirlo a cadena, pero preferimos leer
directamente a una cadena. Un amigo nos sugiere la clase DataInputStream, que
aunque hereda de la clase InputStream la revisamos. Esta clase hereda directamente
de FilterInputStream, quien a su vez hereda de InputStream. Esta ultima presenta
los mismos metodos que Reader, excepto que, como ya vimos, trabaja con bytes
en lugar de caracteres (lee a un byte, a un arreglo de bytes, cuenta numero de
bytes,. . . ). El constructor es un constructor por omision, y en lugar del metodo
booleano ready de Reader, tiene el siguiente metodo, que no listamos al presentar
a esta clase:

public abstract class InputStream implements Closeable

Metodo adicional:
public int available () throws IOException
Regresa el numero de bytes que se pueden leer de este flujo sin bloquear
la entrada. A este nivel de la jerarqua siempre regresa 0.

Al igual que en la clase Reader, el metodo read() es abstracto, por lo que no se

pueden construir objetos de esta clase, sino que se tiene que recurrir a alguna de
sus extensiones. Revisemos lo que nos interesa de la clase FilterInputStream, de la
que hereda directamente DataInputStream:

public class FilterInputStream extends InputStream

Campo:
protected InputStream in
El flujo a ser filtrado (manipulado).
345 Entrada y salida

Constructor:
protected FilterInputStream(InputStream in)
Construye el flujo con in como flujo subyacente.
Metodos:
Hereda los metodos ya implementados de InputStream e implementa los
declarados como abstractos en la superclase. Como los encabezados y su
significado se mantiene, no vemos el caso de repetir esta informacion.

Tampoco FilterInputStream nos acerca mas a leer valores, no caracteres. Veamos

que pasa en DataInputStream, que hereda el campo de FilterInputStream y los
metodos de esta clase. Unicamente listaremos algunos de los que nos interesan y
que no estan en las superclases. No daremos una explicacion de cada metodo ya
que los nombres son autodescriptivos.

public class DataInputStream extends FilterInputStream

implements DataInput
Constructores:
public DataInputStream(InputStream in)
Este flujo hereda de FilterInputStream y trabaja como intermediario en-
tre el dispositivo y la aplicacion, por lo que hay que proporcionarle el
dispositivo (in).
Metodos que se agregan:
public final int readUnsignedByte() throws IOException
Regresa un entero entre 0 y 255.
public final short readShort() throws IOException
Lee un short.
public final int readUnsignedShort() throws IOException
public final char readChar() throws IOException
public final int readInt () throws IOException
public final long readLong() throws IOException
public final float readFloat () throws IOException
public final double readDouble() throws IOException
10.5 El manejo del menu de la aplicacion 346

public final String readLine () throws IOException

public final String readUTF() throws IOException
Lee una cadena que ha sido codificada con formato UTF-8.
public final String readUTF(DataInput in) throws IOException
Lee una cadena que ha sido codificada con formato UTF-8 desde un flujo
que implemente a DataInput.

No existe una clase paralela a esta en la jerarqua de Reader. Sin embargo, al re-
visar la documentacion vemos que nuestro metodo favorito, readLine(), esta anun-
ciado como descontinuado (deprecated ), lo que quiere decir que no lo mantienen al
da y lo usaramos arriesgando problemas. Pero tambien en la documentacion vie-
ne la sugerencia de usar BufferedReader, subclase de Reader, por lo que volteamos
hacia ella para resolver nuestros problemas. Presentamos nada mas lo agregado
en esta clase, ya que los metodos que hereda los [presentamos en la clase Reader
antes. Como su nombre lo indica, esta clase trabaja con un buffer de lectura.
No listaremos los metodos que sobreescribe (overrides) ya que tienen los mismos
parametros y el mismo resultado, as que los pensamos como heredados aunque
esten redefinidos en esta clase.

public class BufferedReader extends Reader

Constructores:
public BufferedReader(Reader in)
Construye el flujo con un buffer de tamano por omision (generalmente
suficientemente grande).
public BufferedReader(Reader in , int sz)
Construye el flujo con un buffer de tamano sz. (generalmente suficiente-
mente grande). Puede lanzar la excepcion IllegalArgumentException si el
tamano del buffer es negativo.
Metodos adicionales:
public String readLine () throws IOException
Lee una cadena hasta el fin de linea, pero no guarda el fin de lnea. La
lnea se considera terminada con un fin de lnea (zn), un retorno de carro
o ambos.

Como se puede ver, tampoco esta clase es muy versatil, pero como lo unico que
347 Entrada y salida

queremos, por el momento, es leer cadenas, nos conformamos. Tenemos ya todo lo

que necesitamos para sustituir nuestra clase Consola en el programa. Listaremos
nuevamente la forma anterior de las lecturas y la forma que ahora toman. Notar
que ahora tenemos que colocar cada lectura en un bloque try. . . catch porque todos
los metodos que llevan a cabo lectura pueden lanzar excepciones de entrada/salida.

Antes:
p r i v a t e S t r i n g pideNombre ( C o n s o l a c o n s ) {
S t r i n g nombre ;
System . o u t . p r i n t ( "Dame el nombre del estudiante ,"
+ " empezando por apellido paterno:" ) ;
nombre=c o n s . l e e S t r i n g ( ) ;
r e t u r n nombre ;
}
Despues:
p r i v a t e S t r i n g pideNombre ( B u f f e r e d R e a d e r c o n s )
throws I O E x c e p t i o n {
S t r i n g nombre ;
System . o u t . p r i n t ( "Dame el nombre del estudiante ,"
+ " empezando por apellido paterno:" ) ;
try {
nombre=c o n s . r e a d L i n e ( ) ;
} catch ( I O E x c e p t i o n e ) {
System . e r r . p r i n t l n ( "Error al leer nombre" ) ;
throw e ;
} // end o f t r y
c a t c h
r e t u r n nombre ;
}

El mismo trato se da a los metodos pideCarrera, pideClave y pideCuenta, ya que

todos estos metodos leen cadenas. En el menu los cambios que tenemos que hacer
se listan a continuacion:

Antes:
s o p c i o n = c o n s . l e e S t r i n g ( "Elige una opcion --> " ) ;
10.5 El manejo del menu de la aplicacion 348

Despues:
System . o u t . p r i n t ( "Elige una opcion --> " ) ;
try {
sopcion = cons . readLine ( ) ;
} catch ( I O E x c e p t i o n e ) {
System . e r r . p r i n t l n ( "Error al leer opcion" ) ;
throw new I O E x c e p t i o n ( "Favor de repetir eleccion " ) ;
} // end o f t r y
c a t c h

Antes:
case AGREGA : // Agrega E s t u d i a n t e
nombre = pideNombre ( c o n s ) ;
cuenta = pideCuenta ( cons ) ;
c a r r e r a = p i d e C a r r e r a ( cons ) ;
c l a v e = pide Clave ( cons ) ;
miCurso . a g r e g a E s t O r d e n
(new E s t u d i a n t e ( nombre , c u e n t a , c l a v e , c a r r e r a ) ) ;
Despues:
case AGREGA : // Agrega E s t u d i a n t e
try {
nombre = pideNombre ( c o n s ) ;
cuenta = pideCuenta ( cons ) ;
c a r r e r a = p i d e C a r r e r a ( cons ) ;
c l a v e = pide Clave ( cons ) ;
miCurso . a g r e g a E s t O r d e n
(new E s t u d i a n t e ( nombre , c u e n t a , c l a v e , c a r r e r a ) ) ;
} catch ( I O E x c e p t i o n e ) {
System . o u t . p r i n t l n ( "Error al leer datos del "
+ " estudiante .\ nNo se pudo agregar" ) ;
} // end o f t r y
c a t c h

Antes:
case QUITA : // Q u i t a e s t u d i a n t e
nombre = pideNombre ( c o n s ) ;
donde = ( E s t u d i a n t e ) miCurso . b u s c a S u b c a d
( E s t u d i a n t e .NOMBRE, nombre ) ;
349 Entrada y salida

i f ( donde != n u l l ) {
nombre = donde . daNombre ( ) ;
miCurso . q u i t a E s t ( nombre ) ;
System . o u t . p r i n t l n ( "El estudiante :\n\t"
+ nombre + "\n Ha sido eliminado " ) ;
}
e l s e r e p o r t a N o ( nombre ) ;
Despues:
case QUITA : // Q u i t a e s t u d i a n t e
try {
nombre = pideNombre ( c o n s ) ;
donde = ( E s t u d i a n t e ) miCurso . b u s c a S u b c a d
( E s t u d i a n t e .NOMBRE, nombre ) ;
i f ( donde != n u l l ) {
nombre = donde . daNombre ( ) ;
miCurso . q u i t a E s t ( nombre ) ;
System . o u t . p r i n t l n ( "El estudiante :\n\t"
+ nombre + "\nHa sido eliminado " ) ;
}
e l s e r e p o r t a N o ( nombre ) ;
} catch ( I O E x c e p t i o n e ) {
System . e r r . p r i n t l n ( "No se proporcionaron bien"
+ " los datos .\ nNo se pudo eliminar." ) ;
} // end o f t r y
c a t c h

Antes:
case BUSCA : // Busca s u b c a d e n a
s u b c a d = c o n s . l e e S t r i n g ( "Dame la subcadena a "
+ "buscar: " ) ;
do {
s c u a l = c o n s . l e e S t r i n g ( "Ahora dime de cual "
+ "campo : 1: Nombre 2: Cuenta , 3: Carrera"
+ ", 4: Clave -->" ) ;
c u a l = "01234" . i n d e x O f ( s c u a l ) ;
i f ( c u a l < 1)
System . o u t . p r i n t l n ( "Opcion no valida" ) ;
} while ( c u a l < 1 ) ;
10.5 El manejo del menu de la aplicacion 350

Antes: (continua. . . )
donde = ( E s t u d i a n t e ) miCurso .
buscaSubcad ( cual , subcad ) ;
i f ( donde != n u l l )
System . o u t . p r i n t l n ( donde . d a R e g i s t r o ( ) ) ;
else reportaNo ( subcad ) ;
Despues:
case BUSCA : // Busca s u b c a d e n a
try {
System . o u t . p r i n t ( "Dame la subcadena a "+
"buscar: " ) ;
subcad = cons . r e a d L i n e ( ) ;
do {
System . o u t . p r i n t ( "Ahora dime de cual "
+ "campo : 1: Nombre 2: Cuenta"
+ " 3: Carrera 4: Clave -->" ) ;
s c u a l = cons . readLine ( ) ;
c u a l = "01234" . i n d e x O f ( s c u a l ) ;
i f ( c u a l < 1)
System . o u t . p r i n t l n ( "Opcion no valida" ) ;
} while ( c u a l < 1 ) ;
donde = ( E s t u d i a n t e ) miCurso .
buscaSubcad ( cual , subcad ) ;
i f ( donde != n u l l )
System . o u t . p r i n t l n ( donde . d a R e g i s t r o ( ) ) ;
else reportaNo ( subcad ) ;
} catch ( I O E x c e p t i o n e ) {
System . e r r . p r i n t l n ( "Error al dar los "
+ "datos para buscar" ) ;
} // end o f t r y
c a t c h
Antes:
case LISTAALGUNOS : // L i s t a con c r i t e r i o
s u b c a d = c o n s . l e e S t r i n g ( "Da la subcadena que "
+ " quieres contengan los "
+ " registros :" ) ;
do {
s c u a l = c o n s . l e e S t r i n g ( "Ahora dime de cual campo:"
+ " 1: Nombre 2: Cuenta 3: Carrera 4: Clave -->" ) ;
351 Entrada y salida

Antes: (continua. . . )
c u a l = "01234" . i n d e x O f ( s c u a l ) ;
i f ( c u a l < 1)
System . o u t . p r i n t l n ( "Opcion no valida" ) ;
} while ( c u a l < 1 ) ;
miCurso . losQueCazanCon ( System . out , c u a l , s u b c a d ) ;
Despues:
case LISTAALGUNOS : // L i s t a con c r i t e r i o
try {
System . o u t . p r i n t l n ( "Da la subcadena que " +
" quieres contengan los " +
" registros :" ) ;
subcad = cons . r e a d L i n e ( ) ;
do {
System . o u t . p r i n t ( "Ahora dime de cual campo:"
+ "1: Nombre 2: Cuenta 3: Carrera 4: Clave -->" ) ;
s c u a l = cons . readLine ( ) ;
c u a l = "01234" . i n d e x O f ( s c u a l ) ;
i f ( c u a l < 1)
System . o u t . p r i n t l n ( "Opcion no valida" ) ;
} while ( c u a l < 1 ) ;
miCurso . losQueCazanCon ( System . out , c u a l , s u b c a d ) ;

} catch ( I O E x c e p t i o n e ) {
System . e r r . p r i n t l n ( "Error al dar los datos"
+ "para listar" ) ;
} // end o f t r y
c a t c h

Antes:
p u b l i c s t a t i c void main ( S t r i n g [ ] a r g s ) {
...
C o n s o l a c o n s o l a = new C o n s o l a ( ) ;
Despues:
p u b l i c s t a t i c void main ( S t r i n g [ ] a r g s ) {
...
B u f f e r e d R e a d e r c o n s o l a = new B u f f e r e d R e a d e r
(new I n p u t S t r e a m R e a d e r ( System . i n ) ) ;
10.6 Redireccionamiento de in, out y err 352

Antes:

w h i l e ( ( o p c i o n = miMenu . daMenu ( c o n s o l a , miCurso ) )

!=
1);

Despues:

w h i l e ( o p c i o n !=
1) {
try {
o p c i o n = miMenu . daMenu ( c o n s o l a , miCurso ) ;
} catch ( I O E x c e p t i o n e ) {
System . o u t . p r i n t l n ( "Opcion mal elegida" ) ;
o p c i o n =0;
} // end o f t r y
c a t c h
} // w h i l e

10.6 Redireccionamiento de in, out y err

Muchas veces queremos que los resultados de un programa, o los mensajes de

error, en lugar de ir a los dispositivos estandar (todos a la consola) se graben en
algun archivo en disco para poder examinarlos con calma. Ademas de la manera en
que Unix permite redireccionar la salida, podemos, desde el programa, conseguir
esto. Para ello contamos con metodos en java.lang.System que permiten hacerlo.
Ellos son:

p u b l i c f i n a l s t a t i c v o i d s e t I n ( I n p u t S t r e a m newIn )
p u b l i c f i n a l s t a t i c v o i d s e t O u t ( OutputStream newOut )
p u b l i c f i n a l s t a t i c v o i d s e t E r r ( P r i n t S t r e a m newErr )

A continuacion dos ejemplos:

System . s e t I n ( new F i l e I n p u t S t r e a m ( " misdatos .txt" ) ) ;

System . s e t O u t ( new P r i n t S t r e a m ( new F i l e O u t p u t S t r e a m ( " misdatos .out" ) ) ) ;
353 Entrada y salida

10.7 Persistencia de la base de datos

Hasta ahora unicamente hemos trabajado con la consola o bien con redirec-
cionamiento de la consola, pero no hemos entrado a la motivacion principal de
este captulo y que consiste en lograr guardar el estado de nuestra base de datos
para que pueda ser utilizado posteriormente como punto de partida en la siguiente
ejecucion.
Podemos almacenar, en primera instancia, la base de datos como un conjun-
to de cadenas, y para ello podemos volver a utilizar a los flujos BufferedReader
y BufferedWriter que ya conocemos, pero en esta ocasion queremos que el flujo
subyacente sea un archivo en disco y no un flujo estandar. Revisemos entonces la
clase FileReader y FileWriter que me van a dar esa facilidad. Estos flujos extienden,
respectivamente, a InputStreamReader y OutputStreamWriter, que a su vez here-
dan, respectivamente, de Reader y Writer. De esta jerarqua unicamente hemos
revisado la clase Reader, as que procedemos a ver las otras clases de la jerarqua
que vamos a requerir.

public abstract class Writer implements Appendable,

Closeable, Flushable
Campo:
protected Object lock
Sincroniza el acceso a este flujo.
Constructores:
protected Writer()
Construye un flujo de salida de caracteres a ser sincronizado por el mismo.
protected Writer(Object lock)
Construye un flujo de caracteres que sera sincronizado usando lock.
Metodos:
public Writer append(char c) throws IOException
Agrega el argumento al flujo this.
public Writer append(CharSequence csq) throws IOException
CharSequence es una interfaz de Java que basicamente proporciona meto-
dos para convertir una sucesion de caracteres, codificados en cualquier
codigo de 16 bits en cadenas o subsucesiones. Agrega el argumento al
flujo this.
10.7 Persistencia de la base de datos 354

public Writer append(CharSequence csq, int start , int end)

throws IOException
Agrega al flujo this la subsucesion de csq que empieza en start y termina
en el caracter inmediatamente a la izquierda de end.
public abstract void close () throws IOException
Cierra el flujo vaciandolo primero. Una vez cerrado, cualquier intento de
vaciarlo o escribir en el provocara una excepcion de entrada/salida. No
importa que un flujo se intente cerrar una vez cerrado.
public abstract void flush () throws IOException
Provoca que todas las escrituras pendientes sean vaciadas al flujo pro-
porcionado por el sistema operativo. Sin embargo, el sistema operativo
podra no vaciar su buffer.
public void write (int c) throws IOException
Escribe un unico caracter en el flujo, tomando los 16 bits bajos del entero
proporcionado. Este metodo debera ser sobreescrito por las subclases
correspondientes.
public void write (char[] cbuf) throws IOException
Escribe en el flujo los caracteres presentes en el arreglo cbuf.
public abstract void write(char [], int off , int len )
throws IOException
Escribe en el flujo el contenido del arreglo cbuf a partir del caracter en la
posicion off y un total de len caracteres.
public void write ( String str ) throws IOException
Escribe el contenido de la cadena en el flujo.
public void write ( String str , int off , int len )
throws IOException
Escribe la subcadena de str desde la posicion off un total de len caracteres.

Realmente el unico metodo con el que hay que tener cuidado es el que escribe
un caracter (entero), porque el resto de los metodos se construyen simplemente
invocando a este.
Las clases que heredan directamente de Reader y Writer son, respectivamente,
355 Entrada y salida

InputStreamReader y OutputStreamWriter que pasamos a revisar. Primero revisa-

remos la clase InputStreamReader.

public class InputStreamReader extends Reader

Hereda el campo lock de Reader y los metodos definidos en la superclase.
Listamos los que son redefinidos en esta subclase.
Constructores:
public InputStreamReader(InputStream in)
Construye un flujo de entrada sobre el flujo de bytes que se le proporcione
(y que debe existir como objeto). Basicamente va a traducir bytes en
caracteres.
public InputStreamReader(InputStream in, String charsetName)
throws UnsupportedEncodingException
Construye un flujo de entrada sobre un flujo de bytes. Va a traducir de
acuerdo al codigo nombrado en charsetName. Si el codigo no existe lanza
una excepcion de codigo invalido.
public InputStreamReader(InputStream in, Charset cs)
Construye un flujo sobre in y que va a traducir los bytes de acuerdo al
codigo dado en cs.
Metodos:
public void close () throws IOException
Cierra el flujo correspondiente. Lanza una excepcion si hay algun error de
entrada/salida.
public String getEncoding()
Regresa el nombre del codigo de traduccion de bytes que es el usado por
este flujo.
public int read() throws IOException
Redefine el metodo correspondiente en Reader (recuerdese que en Reader
era un metodo abstracto).
public int read(char[] cbuf, int offset , int length)
throws IOException
Redefine el metodo correspondiente en Reader.
public boolean ready() throws IOException
Redefine el metodo ready en Reader.
10.7 Persistencia de la base de datos 356

Siguiendo en orden en la jerarqua, ahora revisaremos OutputStreamWriter.

public class OutputStreamWriter extends Writer

Hereda el campo lock de la superclase. Listaremos los constructores y los
metodos abstractos de la superclase que se implementan en esta clase.
Constructores:
public OutputStreamWriter(OutputStream out)
Construye un flujo de salida que va a convertir caracteres en bytes. Se
monta sobre un flujo de salida de bytes.
public OutputStreamWriter(OutputStream out, Charset cs)
Construye un flujo de salida de caracteres a bytes, montado sobre un flujo
de salida de bytes, out que usa la codificacion dada por cs.
public OutputStreamWriter(OutputStream out,
CharsetEncoder enc)
Construye un OutputStreamWriter sobre un flujo de bytes out y que usa
la codificacion dada por enc.
Metodos:
public void close () throws IOException
Cierra el flujo vaciando el buffer de salida. Lanza una excepcion si tiene
problemas de entrada/salida.
public void flush () throws IOException
Implementa el metodo correspondiente en Writer.
public String getEncoding()
Regresa el nombre del codigo que se esta usando para escribir los bytes
correspondientes a los caracteres en memoria.
public void write (int c) throws IOException
Implementa el metodo correspondiente en Writer.
public void write (char[] cbuf, int off int len )
throws IOException
Implementa al metodo correspondiente en Writer.
public void write ( String str , int off int len )
throws IOException
Implementa al metodo correspondiente en Writer.
357 Entrada y salida

Ahora s ya podemos pasar a revisar las clases FileReader y FileWriter que here-
dan respectivamente de InputStreamReader y OutputStreamWriter. Empezaremos
por el flujo de entrada. En esta subclase unicamente se definen los constructores,
ya que se heredan precisa y exactamente los metodos implementados en InputS-
treamReader.

public class FileReader extends InputStreamReader

Dado que esta es una subclase de InputStreamReader, va a leer bytes y
convertirlos en caracteres. Al igual que su superclase, tambien trabaja
sobre un InputStream.
Constructores:
public FileReader ( String fileName) throws FileNotFoundException
Crea un flujo para lectura de disco cuyo nombre es fileName. Si no en-
cuentra el flujo lanza una excepcion de archivo no encontrado.
public FileReader ( File file ) throws FileNotFoundException
File es una representacion abstracta de un archivo del sistema operativo
en cuestion, e incluye aspectos como definir el separador y terminador de
archivos, la ruta en el disco, la identificacion del archivo en disco, etc.
(ver la definicion de esta clase en la documentacion de Java). Crea un
flujo para lectura identificado con file. Si no encuentra el flujo lanza una
excepcion de archivo no encontrado.
public FileReader ( FileDescriptor fd)
throws FileNotFoundException
Un FileDescriptor es un objeto que describe a un archivo en disco (ver
documentacion de Java). Crea un flujo de lectura desde disco, donde el
archivo esta asociado al FileDescriptor. Si no lo encuentra, lanza una ex-
cepcion de archivo no encontrado.
Metodos:
Los heredados de Reader y de InputStreamReader, que ya revisamos.

Para los flujos de salida que escriben a disco tenemos una situacion similar a
la de archivos de entrada, pues lo unico que se define para la subclase FileWri-
ter son los constructores. Para el resto de los metodos y campos se heredan las
implementaciones dadas por OutputStreamWriter. Veamos la definicion.
10.7 Persistencia de la base de datos 358

public class FileWriter extends OutputStreamWriter

Enlaza a un flujo de salida de bytes con un archivo en disco. Lo unico que
se implementa a nivel de esta subclase son los constructores.
Constructores:
FileWriter ( File file ) throws IOException
Construye un flujo a disco sobre el flujo file, que podra ser, a su vez, un
FileWriter o cualquier OutputStream o subclases de esta. La excepcion la
lanza si file es un directorio y no un archivo, no existe pero no puede ser
creado o no puede ser abierto por cualquier otra razon.
FileWriter ( File file , boolean append) throws IOException
Construye un flujo a disco sobre el flujo file, que podra ser, a su vez,
un FileWriter o cualquier OutputStream o subclases de esta. La excepcion
la lanza si file es un directorio y no un archivo, no existe pero no puede
ser creado o no puede ser abierto por cualquier otra razon. Si append es
verdadero, la escritura se realiza al final del archivo; si es falsa se realiza
al principio del archivo, como en el constructor sin parametro booleano.
FileWriter ( FileDescriptor fd)
Construye un flujo a disco asociado con el FileDescriptor.
FileWriter ( String fileName) throws IOException
Construye el flujo dado un nombre. Lanza una excepcion de entrada/salida
por las mismas causas que los otros constructores.
FileWriter ( String fileName, boolean append)
throws IOException
Construye el flujo dado un nombre. Si append es verdadera entonces escri-
be al final del archivo; si el archivo no existe lo crea. Lanza una excepcion
de entrada/salida por las mismas causas que los otros constructores.

Hay que recordar que la herencia permite que donde quiera que aparezca una
clase como parametro, los argumentos pueden ser objetos de cualquiera de sus sub-
clases. Con esto en mente pasamos a implementar las opciones en el menu de leer
de un archivo en disco o escribir a un archivo en disco para guardar la informacion
generada en una sesion dada.
359 Entrada y salida

10.7.1. Como guardar datos en un archivo en disco

La informacion en disco se guarda invariablemente en bytes. De hecho, un

archivo en disco es, simplemente, una sucesion muy grande de bytes, que puede
ser interpretado de muy diversas maneras: podemos tomar los bytes de cuatro en
cuatro, e interpretar cada cuatro bytes como un entero; o podemos tomarlos de
seis en seis e interpretar a cada grupo como un doble. En ningun otro caso es mas
cierto el dicho de que todo depende del color del cristal con que se mira que en
la lectura (interpretacion) de archivos en disco. Y esta interpretacion depende del
enunciado con que se tenga acceso al archivo y el tipo de flujo que se utilice para
ello.
Como mencionamos al principio, por lo pronto escribiremos y leeremos (re-
cuperaremos) cadenas, representadas por sucesiones de bytes y separadas entre
s por caracteres de fin de lnea. Dada esta situacion utilizaremos para entrada
objetos de la clase FileReader y para salida objetos de la clase FileWriter.
Agregaremos a nuestro menu tres opciones nuevas, leer registros desde disco,
escribir registros a disco y agregar registros en disco a un archivo que ya tiene
informacion. Que archivo usar debera ser una decision que se toma una vez elegida
alguna de estas opciones. Consideramos que cualquiera de estas acciones puede
llevarse a cabo en cualquier momento del proceso y por lo tanto, la eleccion del
archivo debe hacerse en el momento en que se elige la opcion. La otra opcion
pudiese ser elegir el archivo al entrar al proceso. Pero eso obligara al usuario, ya
sea que quiera o no leer de/guardar en archivos de disco, proporcionar el nombre
para los mismos, algo que no consideramos adecuado. Este curso de accion tambien
evitara que se pudiera leer o escribir, en una misma sesion, mas de un archivo.
Por lo tanto, la definicion del archivo a usar estara situada dentro de la opcion
correspondiente.
Podemos implementar ya esta opcion. Lo primero que hacemos es declarar tres
constantes simbolicas para usarlas en el switch, y que son:
s t a t i c f i n a l i n t AGREGA = 1 ,
...
LEER = 6 ,
GUARDAR = 7 ,
PEGARDISCO = 8 ;
La opcion de guardar lo que llevamos en un archivo en disco debe seguir el
guion dado en la figura 10.10.
Para identificar el archivo que deseamos usar, algo que tendremos que hacer
en los tres casos, construimos un metodo que lea el nombre del archivo de disco
 10.7 Persistencia de la base de datos 360

en consola, y que queda como se ve en el listado 10.1.

Figura 10.10 Algoritmo para guardar la base de datos en disco
$ $
'
' '
' Identificar archivo
'
' '
&
'
' Abrir el archivo
'
' Inicio
'
' '
'
' '
'
Colocarse al principio
'
' %
' de la base de datos
Guardar Base de '
&
Datos en archivo # #
'
'
en disco '
' Procesar registro Escribir registro en disco
'
' Proceso
'
' (mientras haya) Pasar al siguiente
'
'
'
'
'
'
'
' !
%F inal Cerrar el archivo

Codigo 10.1 Metodo que solicita al usuario nombre de archivo (MenuListaIO)

50: /
51: P i d e a l u s u a r i o e l nombre d e l a r c h i v o en e l que d e s e a
52: e s c r i b i r o d e l que d e s e a l e e r .
53: @param c o n s D i s p o s i t i v o d e l que va a l e e r e l nombre
54: @param l e c t u r a True : l e c t u r a , f a l s e : e s c r i t u r a .
55: @return e l archivo s o l i c i t a d o .
56: /
57: p u b l i c S t r i n g pideNombreArch ( B u f f e r e d R e a d e r cons , i n t c a s o )
58: throws I O E x c e p t i o n {
59: S t r i n g m e n s a j e = "Por favor dame el nombre del archivo \n"
60: + ( c a s o == LEER
61: ? "del que vas a leer registros "
62: : ( c a s o == GUARDAR
63: ? "en el que vas a guardar la base de datos "
64: : "en el que vas a agregar registros " ) )
65: + ":\t" ;
66: S t r i n g nombre ;
67: try {
68: System . o u t . p r i n t ( m e n s a j e ) ;
69: nombre = c o n s . r e a d L i n e ( ) ;
70: } catch ( I O E x c e p t i o n e ) {
71: throw e ;
72: } // end o f t r y
c a t c h
73: r e t u r n nombre ;
74: }

Al metodo pideNombreArch le pasamos el flujo que estamos usando para comu-

361 Entrada y salida

nicarnos con el usuario. Queremos que el mensaje sea preciso respecto a que vamos
a hacer con el archivo, pero como usamos el mismo metodo simplemente le pasa-
mos de cual caso se trata caso para que pueda armar el mensaje correspondiente
(lneas 59: a 64:). Despues entramos a un bloque try. . . catch en el que vamos a
leer del usuario el nombre del archivo. El metodo, como lo indica su encabezado,
exporta la excepcion que pudiera lanzarse al leer el nombre del archivo. Estamos
listos ya para programar el algoritmo de la figura 10.10 en la pagina opuesta. El
codigo lo podemos ver en el listado 10.2.

Codigo 10.2 Codigo para guardar la base de datos (MenuListaIO)

200: case GUARDAR:
201: try {
202: s A r c h i v o = pideNombreArch ( cons ,GUARDAR ) ;
203: a r c h i v o O u t = new B u f f e r e d W r i t e r ( new F i l e W r i t e r ( s A r c h i v o ) ) ;
204: System . o u t . p r i n t l n ( "Abr archivo " ) ;
205: E s t u d i a n t e l i s t a = ( ( E s t u d i a n t e ) miCurso . d a L i s t a ( ) ) ;
206: w h i l e ( l i s t a != n u l l ) {
207: a r c h i v o O u t . w r i t e ( l i s t a . daNombre ( ) ) ;
208: archivoOut . newLine ( ) ;
209: a r c h i v o O u t . w r i t e ( l i s t a . daCuenta ( ) ) ;
210: archivoOut . newLine ( ) ;
211: archivoOut . write ( l i s t a . daCarrera ( ) ) ;
212: archivoOut . newLine ( ) ;
213: archivoOut . w r i t e ( l i s t a . daClave ( ) ) ;
214: archivoOut . newLine ( ) ;
215: System . o u t . p r i n t l n ( l i s t a . daNombre ()+"\n" ) ;
216: System . o u t . p r i n t l n ( l i s t a . daCuenta ()+"\n" ) ;
217: System . o u t . p r i n t l n ( l i s t a . d a C a r r e r a ()+"\n" ) ;
218: System . o u t . p r i n t l n ( l i s t a . d a C l a v e ()+"\n" ) ;
219: l i s t a = l i s t a . daSiguiente ();
220: } // end o f w h i l e ( l i s t a != n u l l )
221: archivoOut . f l u s h ( ) ;
222: archivoOut . c lose ( ) ;
223: } catch ( I O E x c e p t i o n e ) {
224: System . e r r . p r i n t l n ( "No pude abrir archivo " ) ;
225: } // end o f t r y
c a t c h
226: finally {
227: try {
228: i f ( a r c h i v o O u t != n u l l ) {
229: archivoOut . c lose ( ) ;
230: }
231: } catch ( I O E x c e p t i o n e ) {
232: System . e r r . p r i n t l n ( No pude c e r r a r a r c h i v o ) ;
233: } // end o f f i n a l l y
234: r e t u r n GUARDAR;
10.7 Persistencia de la base de datos 362

Colocamos toda la opcion en un bloque try. . . catch porque queremos suspender

en cuanto se presente una primera excepcion, ya sea que no podemos abrir el
archivo o que haya algun registro que no podemos escribir. El bloque tiene clausula
finally lneas 226: a 233: para que en caso de que haya algun problema se proceda
a cerrar el archivo. Se verifica antes de intentar cerrarlo que el archivo exista y se
haya logrado abrir.

En las lneas 202: y 203: solicitamos el nombre del archivo a usar y procedemos
a abrir el archivo. En este punto la unica excepcion que pudo haber sido lanzada
es en la interaccion con el usuario, ya que la apertura de un archivo en disco
difcilmente va a lanzar una excepcion.

En la lnea 205: nos colocamos al principio de la lista. Como el metodo mi-

Curso.daLista() regresa un objeto de tipo Object tenemos que hacer un casting.
Una vez que estamos al principio de la lista, procedemos a escribir registro por
registro lneas 207: a 210:. Escribimos campo por campo, en el orden en que
estan en el registro, separando los campos entre s por un caracter de fin de lnea
archivoOut.newLine() propio del sistema operativo en el que este trabajan-
do la aplicacion. En las lneas 212: a 215: simplemente se hace eco de lo que se
escribio en el disco como medida de verificacion.

En seguida se pasa al siguiente registro para procesarlo de la misma manera.

Al terminar simplemente se cierra el archivo, haciendo persistente el contenido de
la lista en memoria.

10.7.2. Como leer registros de un archivo de disco

El algoritmo para leer registros de una archivo en disco es la imagen del proceso
para guardar. Este se puede ver en la figura 10.11.

Para identificar el archivo del que vamos a leer usamos el mismo metodo,
excepto que con un mensaje apropiado. Al abrir el archivo automaticamente nos
encontraremos frente al primer registro. A partir de ah, suponemos que el archivo
esta correcto y que hay cuatro cadenas sucesivas para cada registro que vamos a
leer. El codigo que corresponde a esta opcion se encuentra en el listado 10.3 en la
pagina opuesta.
 363 Entrada y salida

Figura 10.11 Algoritmo para leer registros desde disco

$ $
'
' '
' Identificar archivo
'
' '
&
'
' Abrir el archivo
'
' Inicio
'
' '
'
' '
'
Colocarse al principio
'
' %
'
' del archivo
Leer registros &
a la Base de Datos # #
'
'
desde un archivo en disco '
' Procesar registro Leer registro de disco
'
' P roceso
'
' (mientras haya) Pasar al siguiente
'
'
'
'
'
'
'
' !
%F inal Cerrar el archivo

Codigo 10.3 Opcion para leer registros desde disco (MenuListaIO) 1/2
234: case LEER : // L e e r de d i s c o
235: try {
236: s A r c h i v o = pideNombreArch ( cons , LEER ) ;
237: a r c h i v o I n = new B u f f e r e d R e a d e r ( new F i l e R e a d e r ( s A r c h i v o ) ) ;
238:
239: w h i l e ( ( nombre = a r c h i v o I n . r e a d L i n e ( ) ) != n u l l ) {
240: cuenta = a r c h i v o I n . readLine ( ) ;
241: carrera = archivoIn . readLine ( ) ;
242: clave = archivoIn . readLine ( ) ;
243:
244: miCurso . a g r e g a E s t F i n a l
245: ( new E s t u d i a n t e ( nombre , c u e n t a , c a r r e r a , c l a v e ) ) ;
246: } // end o f w h i l e ( ( nombre = a r c h i v o I n . r e a d L i n e ( ) ) != n u l l )
247: } catch ( F i l e N o t F o u n d E x c e p t i o n e ) {
248: System . o u t . p r i n t l n ( "El archivo " + s A r c h i v o
249: + " no existe ." ) ;
250: throw e ;
251: } catch ( I O E x c e p t i o n e ) {
252: System . e r r . p r i n t l n ( "No pude abrir archivo " ) ;
253: } catch ( E x c e p t i o n e ) {
254: System . o u t . p r i n t l n ( "NO alcanzaron los datos " ) ;
255: i f ( c a r r e r a == n u l l ) {
256: c a r r e r a = "????" ;
257: System . o u t . p r i n t l n ( "No hubo carrera " ) ;
258: } // end o f i f ( c a r r e r a == n u l l )
10.7 Persistencia de la base de datos 364

Codigo 10.3 Opcion para leer registros desde disco (MenuListaIO) 2/2
234: i f ( c u e n t a == n u l l ) {
235: c u e n t a = " 000000000 " ;
236: System . o u t . p r i n t l n ( "No hubo cuenta " ) ;
237: } // end o f i f ( c u e n t a == n u l l )
238: i f ( c l a v e == n u l l ) {
239: c l a v e = "????" ;
240: System . o u t . p r i n t l n ( "No hubo clave " ) ;
241: } // end o f i f ( c l a v e == n u l l )
242: } // end o f c a t c h
243: finally {
244: i f ( a r c h i v o I n != n u l l ) {
245: try {
246: archivoIn . close ();
247: } catch ( I O E x c e p t i o n e ) {
248: System . e r r . p r i n t l n ( "No pude cerrar el"
249: + " archivo de lectura " ) ;
250: } // end o f t r y
c a t c h
251: } // end o f i f ( a r c h i v o I n != n u l l )
252: } // end o f f i n a l l y
253: r e t u r n LEER ;

Nuevamente tenemos que encerrar nuestro proceso en un bloque try. . . catch,

ya que as nos lo exigen los metodos de entrada/salida que estamos utilizando. El
proceso principal, si todo marcha bien, consiste en leer el nombre del archivo en la
lnea 239: y luego proceder a abrirlo. Una vez abierto el archivo se van a leer cuatro
cadenas para considerarlas como los datos para un registro de estudiante, el cual
se agrega a la base de datos en las lneas244: y 245:. Conforme se van leyendo las
cadenas va avanzando el archivo, por lo que no hay necesidad de avanzarlo. Sin
embargo, al leer el nombre s verificamos si se alcanzo el fin de archivo; estamos
suponiendo que los registros vienen completos en grupos de cuatro cadenas y en el
orden en que se intentan leer. En la lnea 239: se verifica que no se haya alcanzado
el fin de archivo; si se alcanzo el fin de archivo, el metodo regresara una referencia
nula.
Podemos encontrarnos con varios errores en este proceso. El primero de ellos es
que pretendamos leer de un archivo que no existe. En este caso se lanza una excep-
cion de la clase FileNotFoundException que manejamos parcialmente: escribimos
un mensaje y exportamos la excepcion, ya que no se va a poder hacer nada.
El siguiente error que podramos tener en nuestro proceso es que los grupos
de cuatro cadenas no esten completos y no haya en el archivo un multiplo de
cuatro en el numero de las cadenas. En este caso, al intentar leer cadenas nos
encontraremos mas alla del fin de archivo lneas 242: a 245: lo que lanzara una
365 Entrada y salida

excepcion de la clase IOException, que es atrapada en la lnea 251: y manejada

simplemente no agregando ese registro incompleto y absorbiendo la excepcion.
La ausencia de suficientes datos tambien puede lanzar una excepcion de ti-
po aritmetico, lo que preveremos en la lnea 253: donde tratamos de averiguar
cuales fueron los datos que no pudimos leer, mandando el mensaje adecuado y
absorbiendo la excepcion.
Sin importar si hubo una excepcion o no trataremos de cerrar el archivo si es
que este se abrio, mediante una clausula finally en las lneas 243: a 252: en la
que, si al cerrar el archivo se lanzo una excepcion, esta se absorbe despues del
mensaje correspondiente.

10.7.3. Como agregar a un archivo ya creado

El algoritmo para agregar registros a un archivo creado previamente es exacta-

mente igual que el que crea un archivo nuevo, excepto que al abrir el archivo hay
que indicar que se busca uno que ya existe; adicionalmente, en lugar de escribir
en el archivo procedemos a agregar (append ). Usando entonces el mismo algorit-
mo que para guardar, con los cambios que acabamos de mencionar, el codigo para
esta opcion queda como se muestra en el listado 10.4.

Codigo 10.4 Opcion de agregar registros a un archivo en disco (MenuListaIO) 1/2

300: case PEGARDISCO :
301: try {
302: s A r c h i v o = pideNombreArch ( cons , PEGARDISCO ) ;
303: a r c h i v o O u t = new B u f f e r e d W r i t e r
304: ( new F i l e W r i t e r ( s A r c h i v o , t r u e ) ) ;
305: E s t u d i a n t e l i s t a = ( ( E s t u d i a n t e ) miCurso . d a L i s t a ( ) ) ;
306: w h i l e ( l i s t a != n u l l ) {
307: a r c h i v o O u t . append ( l i s t a . daNombre ( ) ) ;
308: archivoOut . newLine ( ) ;
309: a r c h i v o O u t . append ( l i s t a . daCuenta ( ) ) ;
310: archivoOut . newLine ( ) ;
311: a r c h i v o O u t . append ( l i s t a . d a C a r r e r a ( ) ) ;
312: archivoOut . newLine ( ) ;
313: a r c h i v o O u t . append ( l i s t a . d a C l a v e ( ) ) ;
314: archivoOut . newLine ( ) ;
10.7 Persistencia de la base de datos 366

Codigo 10.4 Opcion de agregar registros a un archivo en disco (MenuListaIO) 2/2

300: System . o u t . p r i n t l n ( l i s t a . daNombre ()+"\n" ) ;
301: System . o u t . p r i n t l n ( l i s t a . daCuenta ()+"\n" ) ;
302: System . o u t . p r i n t l n ( l i s t a . d a C a r r e r a ()+"\n" ) ;
303: System . o u t . p r i n t l n ( l i s t a . d a C l a v e ()+"\n" ) ;
304: l i s t a = l i s t a . daSiguiente ();
305: } // end o f w h i l e ( l i s t a != n u l l )
306: archivoOut . f l u s h ( ) ;
307: archivoOut . c lose ( ) ;
308: } catch ( F i l e N o t F o u n d E x c e p t i o n e ) {
309: System . e r r . p r i n t l n ( "El archivo " + s A r c h i v o
310: + "no existe !!" ) ;
311: throws e ;
312: } catch ( I O E x c e p t i o n e ) {
313: System . e r r . p r i n t l n ( "No pude abrir archivo " ) ;
314: } // end o f t r y
c a t c h
315: finally {
316: try {
317: i f ( a r c h i v o O u t != n u l l ) {
318: archivoOut . c lose ( ) ;
319: } // end o f i f ( a r c h i v o O u t != n u l l )
320: } catch ( I O E x c e p t i o n e ) {
321: System . e r r . p r i n t l n ( "No pude cerrar el archivo " ) ;
322: } // end o f t r y
c a t c h
323: } // end o f f i n a l l y
324: r e t u r n PEGARDISCO ;

Los unicos cambios en esta opcion son:

En las lneas 303: y 304:, donde se usa otro constructor para el flujo, el que
permite indicar si se usa un archivo ya existente para agregar a el.

En las lneas 307: a 313: se usa el metodo append en lugar del metodo write,
ya que deseamos seguir agregando al final del archivo.

En la lnea 308: se trata de atrapar una excepcion de archivo no encontrado,

ya que en el caso de querer agregar a un archivo este debe existir, mien-
tras que en el contexto de crear un archivo nuevo, esta excepcion no puede
presentarse.

Como se pudo observar, el manejo de flujos en Java tiene un trato uniforme

y, una vez que se manejan las excepciones, no representa mayor problema. Un
punto que hay que vigilar, sin embargo, es la construccion de flujos que se montan
sobre otros flujos. Aca hay que tener cuidado en usar el constructor adecuado
367 Entrada y salida

y proporcionar un flujo que pertenezca a la clase que indica el constructor. La

eleccion del flujo adecuado depende de que es lo que queremos hacer con el y
cuales son las operaciones mas frecuentes que esperamos. Los flujos que hemos
usado hasta ahora manejan de manera idonea lectura y escritura de cadenas, pero
puede suceder que esta no sea la operacion mas frecuente o la que busquemos
facilitar.
Un comentario final: cuando en nuestra aplicacion requerimos de flujos para
montar en ellos al flujo final con el que queramos, los construimos al vuelo, es
decir, de manera anonima sin asignarles un identificador. Todas estas construc-
ciones las podamos haber hecho en dos pasos, primero construir el archivo mas
primitivo (el que tiene contacto con el sistema) asignandole un identificador y
posteriormente construir el flujo de nuestra aplicacion. Como no se utiliza el ar-
chivo base de ninguna otra manera mas que para establecer la conexion no vimos
necesario hacer esto ultimo.

10.8 Escritura y lectura de campos que no son cadenas

Supongamos que queremos tener en el disco una imagen similar a nuestra

primera implementacion de la base de datos, una sucesion de caracteres, donde
sabemos donde empieza un registro y termina el otro porque contamos caracteres
(o bytes). Supongamos tambien que nuestro archivo es, de alguna manera, auto-
descriptivo, esto es que tendra como encabezado del archivo (primera informacion)
el numero de campos y el tamano de cada uno de ellos. De lo anterior, nuestro
archivo se vera como se muestra en la figura 10.12. Mostramos el contenido de
cada uno de los bytes4 en hexadecimal (4 bits para cada smbolo). Por ejemplo,
el encabezado de este archivo nos indica que cada registro consiste de cuatro (4)
campos; el primer campo (nombre) ocupa 40 bytes; el segundo campo (cuenta)
ocupa nueve bytes; el tercer campo (carrera) ocupa cuatro bytes; el cuarto campo
(clave) ocupa 20 bytes. Cabe aclarar que la denominacion entre parentesis esta fue-
ra de la aplicacion; simplemente lo anotamos para tener una idea mas clara de
que es lo que estamos haciendo. Como los enteros que estamos manejando son
relativamente pequenos, los guardaremos en variables tipo short, que ocupa cada
una dos bytes. Las lneas punteadas indican la mascara que estamos aplicando
al archivo (como interpretamos la informacion) y el valor dentro de estas celdas
indica el numero en base 10 que esta grabado. Abajo de cada celda se encuentra
la posicion del byte correspondiente en el archivo, empezando de 0 (cero).
 10.8 Escritura y lectura de campos que no son cadenas 368

Figura 10.12 Formato de un archivo binario autodescrito

Num de tamano tamano tamano tamano Primer campo
campos campo1 campo2 campo3 campo4
hkkkikkkjhkkkikkkjhkkkikkkjhkkkikkkjhkkkikkkjhkkkkkkkkkkkkkkkkkkkkkkkkkikkkkkkkkkkkkkkkkkkkkkkkkkj
short short short short short

410 4010 910 410 2010 A r i z ...

0 0 0 4 0 0 2 8 0 0 0 9 0 0 0 4 0 0 1 4 4 3 7 2 6 9 7A . .... .
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 . . . . . . 49

Lo que conviene es que la clase para cada registro nos entregue el tamano de
cada campo. Podemos suponer que esto es as, agregando a la clase InfoEstudiante
un arreglo con esta informacion:
s h o r t [ ] tamanhos = { 4 , 4 0 , 9 , 4 , 2 0 } ;
quedando en tamanhos[0] el numero de campos, en tamanhos[1] el tamano del primer
campo y as sucesivamente. Agregamos a la clase un metodo
p u b l i c s h o r t getTamanho ( i n t campo ) {
r e t u r n tamanhos [ campo ] ;
}
que simplemente regresa el tamano del campo solicitado.
Podemos pensar en un archivo que es heterogeneo, en el sentido de que lo que
llamamos el encabezado del mismo no tiene la forma que el resto de los elementos;
estos se componen de n campos la n viene en los primeros dos bytes del archivo
con formato binario de un entero corto (short) con un total de k bytes que
corresponde a la suma de los n enteros cortos que aparecen a partir del byte 2 del
archivo. El encabezado del archivo consiste de 2pn 1q bytes. Una vez procesados
estos n 1 enteros cortos, el resto del archivo lo podemos ver como un arreglo
unidimensional de bytes (similarmente a como manejamos la base de datos en
cadenas al principio).
Deseamos insistir en lo que dijimos al principio de esta seccion: todos los
archivos en disco se componen de bytes; la manera de agrupar los bytes para
obtener informacion que tenga sentido depende del software que se use para verlo,
de las mascaras que le apliquemos al archivo. Una vez que terminemos de armar
nuestro archivo con el formato que acabamos de ver, podran observar el archivo
con alguno de los visores de su sistema operativo y veran que tambien los primeros
2pn 1q bytes podran tratar de interpretarlos como caracteres ASCII, no como
variables de Java; por supuesto que si hacen esto la mayora de estos caracteres
no se podran ver en pantalla (por ejemplo, el 0 binario) o apareceran caracteres
que no guardan ninguna relacion con lo que ustedes esperaran ver.
369 Entrada y salida

Como queremos escribir y leer binario (imagenes de variables de Java) para el

encabezado del archivo, usaremos el flujo que nos permite hacer esto directamente
y que es DataOutputStream y DataInputStream respectivamente. Esta ultima ya la
revisamos en la pagina 345, por lo que pasamos a revisar la clase DataOutputS-
tream, aunque van a ver que corre paralela al flujo correspondiente de entrada.

public class DataOutputStream extends FilterOutputStream

implements DataOutput
Campos:
protected int written
Indica el numero de bytes que se han escrito sobre este flujo hasta el
momento.
Constructores:
public DataOutputStream(OutputStream out)
Construye sobre un flujo de salida que este conectado a algun dispositivo.
Este es el unico constructor de este flujo.
Metodos:
public void flush () throws IOException
Vaca el buffer de los bytes almacenados. Usa para ello el metodo dado
por el flujo de salida dado como argumento en el constructor.
public final int size ()
Regresa el valor del campo written.
public void write (byte[] b, int off , int len )throws IOException
Escribe la porcion del arreglo de bytes b que empieza en off y tiene un
tamano maximo de len bytes. Si no se lanza una excepcion, written se
incrementa en len unidades.
void write (int b) throws IOException
Implementa el metodo write de la clase OutputStream.
public final void write XXX (Y Y Y par) throws IOException
Esta denominacion incluye en realidad a varios metodos, que toman la
representacion interna del tipo Y Y Y y lo transfieren tal cual al flujo de
salida. A continuacion damos las combinaciones de XXX y Y Y Y que
tenemos en los distintos metodos:
10.8 Escritura y lectura de campos que no son cadenas 370

XXX YYY Descripcion

Boolean boolean Escribe una booleana como un valor de
1 byte.
Byte int Escribe un byte que corresponde a la par-
te baja del entero
Bytes String Escribe la cadena como una sucesion de
bytes.
Char int Escribe un caracter (los 2 bytes mas ba-
jos del entero), el byte alto primero.
Chars String Escribe la cadena como una sucesion de
caracteres (2 bytes por caracter).
Double double Convierte el double a un long usando
el metodo doubleToLongBits de la clase
Double y luego escribe el valor obtenido
como una sucesion de 8 bytes, el byte alto
primero.
Float float Convierte el valor float a un valor entero
(int) usando el metodo floatToIntBits de
la clase Float para luego escribirlo como
u7n entero de 4 bytes, el byte alto prime-
ro.
Int int Escribe un entero en 4 bytes, byte alto
primero.
Long long Escribe el entero largo en 8 bytes, byte
alto primero.
Short int Escribe el entero corto en 2 bytes (los
dos bytes mas bajos del entero) byte alto
primero.
UTF String Escribe una cadena en el flujo usando
codificacion UTF-8 modificada de manera
que es independiente de la computadora.
Como se puede ver, este flujo sirve para escribir en disco imagenes (copias)
del contenido de variables en memoria, siguiendo el patron de bits dado
para su codificacion binaria. Por esta ultima caracterizacion, a los archivos
creados con este tipo de flujos se les conoce como archivos binarios, esto
es, que los bytes deben interpretarse como si fueran variables en memoria.
371 Entrada y salida

Es en este tipo de archivos donde realmente se puede utilizar el metodo skip,

ya que el numero de bytes que componen un registro logico (que depende de la
manera como lo tratemos de leer) es constante.
Conocemos ya todo lo que requerimos para proponer una nueva opcion en
nuestro menu, la que escribe y lee archivos binarios. Revisemos el codigo agregado
o modificado que se encuentra en los listados 10.5 para lo que tiene que ver con
el proceso de la opcion y el listado 10.6 en la siguiente pagina para lo que tiene
que ver con la opcion misma.

Codigo 10.5 Declaraciones de flujos binarios (MenuListaIO)

6: s t a t i c f i n a l i n t AGREGA = 1 ,

......
15: LEERREGS = 9 ,
16: GUARDARREGS = 1 0 ;

......
128: p u b l i c i n t daMenu ( B u f f e r e d R e a d e r cons , L i s t a C u r s o miCurso )
129: throws I O E x c e p t i o n {

......
141: DataInputStream a r c h i v o R e g s I n = n u l l ;
142: DataOutputStream a r c h i v o R e g s O u t = n u l l ;

......
156: + "(9)\ tLeer de archivo binario \n"
157: + "(A)\ tGuardar en archivo binario \n"

......
170: o p c i o n = " 0123456789 AB" . i n d e x O f ( s o p c i o n ) ;

......

Nuevamente optamos por declarar los flujos necesarios dentro del metodo que
maneja el menu. La razon de esto es que estas opciones se pueden elegir en cual-
quier momento y mas de una vez, en cada ocasion con flujos fsicos distintos, por lo
que hacerlos globales a la clase o, peor aun, al uso de la clase, amarrara a utilizar
unicamente el flujo determinado antes de empezar, cuando existe la posibilidad
de que no se elija esta opcion o que, como ya mencionamos, se desee hacer varias
copias de l;a informacion. En las lneas 15:, 16: 156: a 170: simplemente agrega-
mos dos opciones al menu, y los mecanismos para manejarlas posponemos por el
momento el desarrollo de la opcion correspondiente dentro del switch . La decla-
10.8 Escritura y lectura de campos que no son cadenas 372

racion de los flujos la hacemos en las lneas 141: y 142:. Tanto en este caso como en
el los flujos BufferedReader y BufferedWriter podramos haberlos declarado como
objetos de las superclases correspondiente:
134: Reader a r c h i v o I n = n u l l ;
135: Writer archivoOut = null ;

141: InputStream archivoRegsIn = null ;

142: OutputStream a r c h i v o R e g s O u t = n u l l ;

y determinar la subclase correspondiente en el momento de construirlos. De

haberlo hecho as, para usar los metodos que se agregaron al nivel de Buffered. . .
como readLine y writeLine y Data. . . Stream como readShort y writeShort
hubiesemos tenido que hacer casting para que el compilador los identificara.
Pero, aun cuando requerimos basicamente un flujo de entrada y uno de salida,
no podramos tener nada mas una declaracion por funcion ya que la superclase
comun a Reader e InputStream es Object, y el usar a Object en la declaracion
hubiese requerido de casting practicamente en cada momento de uso de los flujos.
La asignacion de un valor null en la declaracion es para detectar, en su caso, si
el flujo pudo construirse o no. Adicionalmente, dadas las caractersticas de las
excepciones, donde puede haber codigo que no se ejecute, en el bloque catch no
se tiene la seguridad de que a las variables se les haya asignado efectivamente un
valor en el bloque try, por lo que el compilador no va a permitir que las variables
inicien sin valor asignado.
En las lneas 156: y 157: del listado 10.5 simplemente agregamos las opciones
correspondientes al menu que se despliega, mientras que en la lnea 170: del mismo
listado modificamos para que estas opciones sean reconocidas.

Codigo 10.6 Opciones de leer y escribir a archivo binario (MenuListaIOReg) 1/3

379: case LEERREGS :
380: try {
381: s A r c h i v o = pideNombreArch ( cons , LEER ) ;
382: a r c h i v o R e g s I n = new D a t a I n p u t S t r e a m
383: ( new F i l e I n p u t S t r e a m ( s A r c h i v o ) ) ;
384: } catch ( F i l e N o t F o u n d E x c e p t i o n e ) {
385: System . e r r . p r i n t l n ( "el archivo de entrada "
386: + ( s A r c h i v o != n u l l ? s A r c h i v o : "nulo" )
387: + " no existe " ) ;
388: throw e ;
389: } // end o f t r y
c a t c h
373 Entrada y salida

Codigo 10.6 Opciones de leer y escribir a archivo binario (MenuListaIOReg) 2/3

390: try {
391: s h o r t tam = a r c h i v o R e g s I n . r e a d S h o r t ( ) ;
392: tamanhos = new s h o r t [ tam + 1 ] ;
393: tamanhos [ 0 ] = tam ;
394: f o r ( i n t i = 1 ; i <= tam ; i ++)
395: tamanhos [ i ] = a r c h i v o R e g s I n . r e a d S h o r t ( ) ;
396: s h o r t maxt = 0 ;
397: f o r ( i n t i = 0 ; i <= tamanhos [ 0 ] ; i ++)
398: maxt =( s h o r t ) ( Math . max ( maxt , tamanhos [ i ] ) ) ;
399: bCadena = new byte [ maxt ] ;
400: w h i l e ( a r c h i v o R e g s I n . r e a d ( bCadena , 0 , tamanhos [ 1 ] ) > 0 ) {
401: nombre = new S t r i n g ( bCadena , 0 , tamanhos [ 1 ] ) ;
402: f o r ( i n t i = 2 ; i <= tamanhos [ 0 ] ; i ++) {
403: a r c h i v o R e g s I n . r e a d ( bCadena , 0 , tamanhos [ i ] ) ;
404: switch ( i ) {
405: case 2 :
406: c u e n t a = new S t r i n g ( bCadena , 0 , tamanhos [ i ] ) ;
407: break ;
408: case 3 :
409: c a r r e r a = new S t r i n g ( bCadena , 0 , tamanhos [ i ] ) ;
410: break ;
411: case 4 :
412: c l a v e = new S t r i n g ( bCadena , 0 , tamanhos [ i ] ) ;
413: break ;
414: default :
415: break ;
416: } // end o f s w i t c h ( i )
417: } // end o f f o r ( i n t i = 1 ; i <= tamanhos [ 0 ] ; i ++)
418: i f ( miCurso == n u l l ) {
419: System . o u t . p r i n t l n ( "No existe miCurso " ) ;
420: throw new N u l l P o i n t e r E x c e p t i o n ( " Uuups " ) ;
421: } // end o f i f ( miCurso == n u l l )
422: miCurso . a g r e g a E s t F i n a l
423: ( new E s t u d i a n t e ( nombre , c u e n t a , c a r r e r a , c l a v e ) ) ;
424: } // end o f w h i l e ( a r c h i v o R e g s I n . r e a d ( bCadena
425: } catch ( I O E x c e p t i o n e ) {
426: System . e r r . p r i n t l n ( " Error de I/O" ) ;
427: throw e ;
428: } // end o f t r y
c a t c h
429: finally {
430: try {
431: archivoRegsIn . close ();
432: } catch ( I O E x c e p t i o n e ) {
433: System . e r r . p r i n t l n ( "No se pido cerrar el archivo " ) ;
434: } // end o f t r y
c a t c h
435: } // end o f f i n a l l y
436: r e t u r n LEERREGS ;
10.8 Escritura y lectura de campos que no son cadenas 374

Codigo 10.6 Opciones de leer y escribir a archivo binario (MenuListaIOReg) 3/3

437: case GUARDARREGS :
438: try {
439: s A r c h i v o = pideNombreArch ( cons ,GUARDAR ) ;
440: a r c h i v o R e g s O u t = new DataOutputStream
441: ( new F i l e O u t p u t S t r e a m ( s A r c h i v o ) ) ;
442: E s t u d i a n t e l i s t a = ( ( E s t u d i a n t e ) miCurso . d a L i s t a ( ) ) ;
443: i f ( l i s t a != n u l l ) {
444: tamanhos = l i s t a . getTamanhos ( ) ;
445: } // end o f i f ( l i s t a != n u l l )
446: else {
447: System . o u t . p r i n t l n ( "No hay nadie en la base"
448: + " de datos " ) ;
449: throw new I l l e g a l A r g u m e n t E x c e p t i o n ( " Lista vaca " ) ;
450: } // end o f e l s e
451:
452: a r c h i v o R e g s O u t . w r i t e S h o r t ( tamanhos [ 0 ] ) ;
453: f o r ( i n t i = 1 ; i <= tamanhos [ 0 ] ; i ++) {
454: a r c h i v o R e g s O u t . w r i t e S h o r t ( tamanhos [ i ] ) ;
455: } // end o f f o r ( i n t i = 1 ; . . .
456: // Ahora p r o c e d e m o s a v a c i a r l a b a s e de d a t o s
457: w h i l e ( l i s t a != n u l l ) {
458: f o r ( i n t i = 1 ; i <= tamanhos [ 0 ] ; i ++) {
459: nombre = ( l i s t a . daCampo ( i ) + b l a n c o s ) .
460: s u b s t r i n g ( 0 , tamanhos [ i ] ) ;
461: System . o u t . p r i n t l n ( l i s t a . daCampo ( i )+"\t"
462: +i ) ;
463: a r c h i v o R e g s O u t . w r i t e B y t e s ( nombre ) ;
464: } // end o f f o r ( i n t i = 1 ; i <= tamanhos [ 0 ] ; i ++)
465: l i s t a = l i s t a . daSiguiente ();
466: } // end o f w h i l e ( l i s t a != n u l l )
467: archivoRegsOut . f l u s h ( ) ;
468: archivoRegsOut . c l o s e ( ) ;
469: } catch ( I O E x c e p t i o n e ) {
470: System . e r r . p r i n t l n ( "No se que paso" ) ;
471: throw new I O E x c e p t i o n ( "Algo salio mal" ) ;
472: } // end o f t r y
c a t c h
473: r e t u r n GUARDARREGS ;

Como se puede observar, las dos opciones son practicamente paralelas, excepto
que cuando una escribe la otra lee. Pasemos a revisar primero la opcion de escri-
tura, que sera el orden en que programaramos para probar nuestra aplicacion.
 375 Entrada y salida

10.8.1. Escritura en archivos binarios

Figura 10.13 Algoritmo para escribir archivo binario

$ #
'
' Pedir nombre de archivo
'
' Abrir el archivo
'
'
'
'
Construirlo
'
'
'
'
'
' $
'
' '
'
' &
'
'
'
' lista no vaca Obtener descriptor de campos
'
' '
%
'
'
'
'
'
'
'
' #
'
'
'
' Mensaje de lista vaca
'
' lista no vaca
'
'
'
' Lanzar excepcion de argumento invalido
'
'
'
'
'
' $
'
Armar '
& '
'
'
Escribir numero de
'
'
archivo Escribir '
& campos en binario
'
' $
binario '
' descriptor Escribir tamano '
'
' ' &
'
' '
'
'
' de campos '
' de campo Escribir campo i
'
' '
%  '
%
'
' descriptor[0] en binario
'
'
'
'
'
' $
'
'
'
' '
' Escribir nombre ajustado con blancos
'
' '
'
'
' '
'
'
' &Escribir cuenta ajustada con blancos
'
' Procesar registro
'
'  Escribir carrera ajustada con blancos
'
' mientras haya '
'
'
' '
' Escribir clave ajustada con blancos
'
' '
'
'
' %
'
' Pasar al siguiente de la lista
'
'
'
'
'
'
%Cerrar el archivo

El algoritmo que se uso para escribir un archivo binario se encuentra en la figura

10.13 y corresponde a la discusion de la pagina 367 y mostrado en la figura 10.12
en la pagina 368.
En las lneas 440: a 442: del listado 10.6 se implementa la parte correspondiente
a abrir el archivo seleccionado mediante el metodo pideNombreArch. Como este
10.8 Escritura y lectura de campos que no son cadenas 376

enunciado puede lanzar una excepcion de entrada/salida se enmarca en un bloque

try. Sin embargo es difcil que la excepcion sea lanzada y en el caso de que
esto suceda quiere decir que hay problemas que no puede resolver el usuario
no se conforma un bloque try solo para esta operacion. El constructor de la clase
DataOutputStream requiere de un flujo de salida (OutputStream) que realice la
conexion fsica. En este caso le pasamos como argumento un objeto de la clase
FileOutputStream construido al vuelo, y que se construye utilizando el nombre del
archivo deseado. Como FileOutputStream es una subclase de OutputStream no hay
ningun problema ni de compilacion ni de ejecucion.

En las lneas 443: a 450: se verifica que la lista en memoria no este vaca. De
ser as se procede a obtener el descriptor de los campos (el encabezado del archivo
binario) en un arreglo de enteros pequenos (short); si la lista esta vaca se sale del
menu lanzando una excepcion, que es atrapada desde el metodo principal (main)
de la aplicacion.

Se procede a escribir el encabezado del archivo binario en las lneas 452: a 455:
como lo indica el diagrama del algoritmo, utilizando para ello el metodo writeShort
de la clase DataOutputStream ver documentacion de la clase en las paginas 10.8
y 10.8 . Una vez hecho esto se procede a escribir cada uno de los registros de la
base de datos, como un arreglo de bytes, con cada campo ocupando el numero de
bytes que indica el encabezado del archivo en las lneas 459: y 460: se ajusta el
campo a su tamano agregando blancos y en la lnea 463: se escribe utilizando el
metodo writeBytes de la clase DataOutputStream, que convierte una cadena a un
arreglo de bytes . Para escribir toda la lista seguimos nuestro algoritmo usual
que recorre listas.

Finalmente en las lneas 467: y 468: se procede a cerrar el archivo. En el caso

de archivos de disco esto es mucho muy importante, pues si no se hace el archivo
no pasa a formar parte del sistema de archivos y por lo tanto no existira mas
alla de la ejecucion de la aplicacion.

10.8.2. Lectura de archivos binarios

Como ya mencionamos antes, la lectura desde un archivo binario corre practi-

camente paralelo a la escritura, pues se tiene que usar la misma mascara para
leer que la que se utilizo para escribir. En la figura 10.14 mostramos en detalle el
algoritmo para esta operacion.
 377 Entrada y salida

Figura 10.14 Algoritmo para leer de archivo binario

$ $
'
' '
' Pedir nombre de archivo
'
' '
' $ $
'
' '
' '
'
' ' '
' &
' '
' '
'
'
' '
' '
'
' & '
'
Se localizo
' '
& '
%
'
' Abrir el archivo Localizarlo y
'
' '
'
' '
'
'
' ' construirlo '
'
' '
' '
' #
'
' '
' '
'
' ' '
' Salir con
' '
' 'Se localizo
%
'
' %
'
' excepcion
'
'
'
'
'
' $
'
'
'
' '
' Leer numero de campos en tamanhos[0]
$
'
'Leer descriptor '
&
Leer de '
& Leer tamano ' &
archivo de campos '
' de campo Leer de disco tamanhos[i]
'
' '
%  '%
binario '
' tamanhos[0] en binario
'
'
'
'
'
'
'
' $
'
' ' Leer a nombre tamanhos[1] bytes
'
' '
'
'
' '
'
'
' '
' Leer a cuenta tamanhos[2] bytes
'
' '
&
'
' Procesar registro Leer a carrera tamanhos[3] bytes
'
' 
'
' mientras haya ' Leer a clave tamanhos[4] bytes
'
' '
'
'
' '
'
'
' '
' Agregar a la lista el registro
'
' '
%
'
' construido con estos datos
'
'
'
'
'
'
'
% Cerrar el archivo

Comparemos ahora el algoritmo con el codigo del listado 10.6. La parte que
corresponde a abrir el archivo y localizarlo se encuentra en las lneas 380: a 389:.
En esta opcion s procesamos por separado la excepcion que nos pueda dar la
localizacion del archivo binario del que el usuario solicita leer porque es posible que
no exista dicho archivo. Por eso, en lugar de la tradicional excepcion IOException,
aca tratamos de atrapar una excepcion que nos indica que no se encontro el
archivo. Igual que en el caso anterior, sin embargo, salimos con una excepcion del
metodo, pues tenemos que regresar a solicitar otra opcion.
De manera similar a como lo hicimos para escribir, construimos un flujo de la
10.8 Escritura y lectura de campos que no son cadenas 378

clase DataInputStream y le pasamos como argumento un objeto de la clase FileIn-

putStream, que es subclase de InputStream, esto ultimo lo que pide el constructor.
Una vez abierto el flujo si llegamos a la lnea 390: procedemos a adquirir la
descripcion de los campos en el archivo binario.
En la lnea 391: leemos el numero de campos de cada registro almacenado en
el archivo en los primeros dos bytes del mismo, usando para ello formato de short;
y en la lnea 392: construimos un arreglo para almacenar ah los tamanos de cada
campo. En las lneas 393: a 395: leemos con mascara de short cada uno de los
tamanos y los almacenamos en el arreglo de shorts tamanhos.
Una vez que tenemos esto, procedemos a leer del flujo arreglos de k bytes,
donde k esta dado pe la posicion correspondiente de tamanhos. Para poder hacer
esto en una iteracion construimos un arreglo de bytes del maximo tamano de los
campos esto se obtiene en las lneas 396: a 400: utilizando para ello el metodo
read(byte[] b, int off, int len) que me permite ir leyendo pedazos de len bytes. Como
en el caso de la lectura de cadenas, intentamos primero leer el primer campo, y
si esta lectura nos indica que no pudo leer damos por terminado el flujo lnea
401: . En cambio, si pudo leer al primer campo, procedemos a leer tantos campos
como nos indique tamanhos[0], en automatico, esto es, sin la garanta de que se
encuentren en el flujo lneas 403: a 417: dejando en manos del mecanismo de
excepciones si hay algun problema. Para no tener que llamar a cada campo por
su nombre, simplemente usamos un switch lneas 404: a 417: que convierte al
arreglo de bytes en una cadena, que es lo que espera la clase Estudiante.
A continuacion, en las lneas 422: y 423: procedemos a agregar a la base de
datos el registro completo recien ledo, construyendo el registro al vuelo.
Si hay algun error de entrada/salida, la excepcion correspondiente se atrapa
y se sale del metodo, mandando un mensaje alusivo y repitiendo la excepcion.
En esta opcion presentamos una clausula finally, ya que queremos que, aunque
haya un error a la mitad, el flujo se cierre para liberar recursos. Esto se hace en
las lneas 429: a 435:; sin embargo, tenemos que poner el enunciado que cierra el
archivo en un bloque try pues puede lanzar una excepcion. Si sucede esto ultimo,
simplemente absorbemos la excepcion, ya que no importa que haya pasado se va
a salir del metodo.

Avance del flujo sin leer

Como en el archivo que estamos construyendo tenemos tamano fijo de los
registros, sabemos en que byte empieza, digamos, el i-esimo registro. Todo lo que
tenemos que hacer es leer el numero de campos y el tamano de cada campo para
calcular el tamano del registro, y desde ese punto saltar i
1 registros de tamano k,
donde k es el tamano de registro calculado. El unico problema que tenemos aca es
379 Entrada y salida

que el acceso al flujo sigue siendo secuencial, as que los bytes que saltemos en
la lectura ya no los podemos regresar5 . n el listado 10.7 agregamos una opcion al
menu para poder acceder al i-esimo registro, siempre y cuando se haga al principio
del proceso. Esto pudieramos usarlo para descartar un cierto numero de registros
y leer unicamente a partir de cierto punto.

Codigo 10.7 Salto de bytes en lectura secuencial (MenuListaIOReg) 1/3

481: case LEEREGISTROK :
482: // P e d i r e l nombre d e l f l u j o
483: try {
484: s A r c h i v o = pideNombreArch ( cons , LEER ) ;
485: a r c h i v o R e g s I n = new D a t a I n p u t S t r e a m
486: ( new F i l e I n p u t S t r e a m ( s A r c h i v o ) ) ;
487: } catch ( F i l e N o t F o u n d E x c e p t i o n e ) {
488: System . e r r . p r i n t l n ( "el archivo de entrada "
489: + ( s A r c h i v o != n u l l ? s A r c h i v o : "nulo" )
490: + " no existe " ) ;
491: throw e ;
492: } // end o f t r y
c a t c h
493: // C a l c u l a r e l tamanho d e l r e g i s t r o
494: i n t tamR = 0 ;
495: try {
496: s h o r t tam = a r c h i v o R e g s I n . r e a d S h o r t ( ) ;
497: tamanhos = new s h o r t [ tam + 1 ] ;
498: tamanhos [ 0 ] = tam ;
499: tamR = 0 ;
500: f o r ( i n t i = 1 ; i <= tam ; i ++) {
501: tamanhos [ i ] = a r c h i v o R e g s I n . r e a d S h o r t ( ) ;
502: tamR += tamanhos [ i ] ;
503: } // end o f f o r ( i n t i = 1 ; i <= tam ; i ++)
504: } catch ( I O E x c e p t i o n e ) {
505: System . e r r . p r i n t l n ( "No pude leer parametros " ) ;
506: r e t u r n LEEREGISTROK ;
507: } // end o f c a t c h
508: // C a l c u l a r e l numero t o t a l de r e g i s t r o s en e l f l u j o
509: int f i l e S i z e = 0;
510: try {
511: f i l e S i z e = a r c h i v o R e g s I n . a v a i l a b l e ( ) / tamR ;
512:
513: } catch ( I O E x c e p t i o n e ) {
514: System . e r r . p r i n t l n ( " Error al calcular Num bytes " ) ;
515: } // end o f t r y
c a t c h
516: // P e d i r e l r e g i s t r o s o l i c i t a d o que e s t e en r a n g o s
517: i n t numR = 0 ;
10.8 Escritura y lectura de campos que no son cadenas 380

Codigo 10.7 Salto de bytes en lectura secuencial (MenuListaIOReg)2/3

518: try {
519: System . o u t . p r i n t ( " Ahora dime el numero de registro (0.."
520: + ( f i l e S i z e
1 ) + ") -->" ) ;
521: subcad = cons . r e a d L i n e ( ) ;
522: numR = 0 ;
523: f o r ( i n t i = 0 ; i < s u b c a d . l e n g t h ( ) ; i ++) {
524: numR = numR10 + s u b c a d . c h a r A t ( i )
0 ;
525: } // end o f f o r ( i n t i = 0 ; i < s u b c a d . l e n g t h ( ) ; i ++)
526: i f ( numR < 0 | | numR >= f i l e S i z e ) {
527: System . o u t . p r i n t l n ( "Hay menos de " + numR
528: + ". Del 0 al "
529: + ( fileSize
1));
530: r e t u r n LEEREGISTROK ;
531: }
532: } catch ( I O E x c e p t i o n e ) {
533: System . o u t . p r i n t l n ( " Error al leer numero de registro " ) ;
534: } // end o f t r y
c a t c h
535: // S a l t a r e l numero de b y t e s r e q u e r i d o s p a r a u b i c a r s e
536: // en e l r e g i s t r o s o l i c i t a d o .
537: i n t a S a l t a r = (numR
1 ) tamR ;
538: i n t pude = 0 ;
539: try {
540: // S a l t a r b y t e s
541: pude = a r c h i v o R e g s I n . s k i p B y t e s ( a S a l t a r ) ;
542: // S i e s que hubo l o s s u f i c i e n t e s
543: i f ( pude >= a S a l t a r ) {
544: bCadena = new byte [ tamR ] ;
545: // Leemos e l r e g i s t r o s o l i c i t a d o .
546: a r c h i v o R e g s I n . r e a d ( bCadena , 0 , tamanhos [ 1 ] ) ;
547: nombre = new S t r i n g ( bCadena , 0 , tamanhos [ 1 ] ) ;
548: f o r ( i n t i = 2 ; i <= tamanhos [ 0 ] ; i ++) {
549: a r c h i v o R e g s I n . r e a d ( bCadena , 0 , tamanhos [ i ] ) ;
550: switch ( i ) {
551: case 2 :
552: c u e n t a = new S t r i n g ( bCadena , 0 , tamanhos [ i ] ) ;
553: break ;
554: case 3 :
555: c a r r e r a = new S t r i n g ( bCadena , 0 , tamanhos [ i ] ) ;
556: break ;
557: case 4 :
558: c l a v e = new S t r i n g ( bCadena , 0 , tamanhos [ i ] ) ;
559: break ;
560: default :
561: break ;
562: } // end o f s w i t c h ( i )
563: } // end o f f o r ( i n t i = 1 ; i <= tamanhos [ 0 ] ; i ++)
381 Entrada y salida

Codigo 10.7 Salto de bytes en lectura secuencial (MenuListaIOReg) 3/3

554: // Se arma un o b j e t o de l a c l a s e E s t u d i a n t e
555: E s t u d i a n t e nuevo = new E s t u d i a n t e ( nombre , c u e n t a ,
556: carrera , clave );
557: System . o u t . p r i n t l n ( nuevo . d a R e g i s t r o ( ) ) ;
558: } // end o f i f ( pude >= a S a l t a r )
559: } catch ( I O E x c e p t i o n e ) {
560: System . o u t . p r i n t l n ( "Hubo error " ) ;
561: } // end o f t r y
c a t c h
562: r e t u r n LEEREGISTROK ;

10.8.3. Acceso semi directo a archivos binarios

Un archivo binario tiene un tamano fijo de registros; en muchas ocasiones los

registros, o la informacion propiamente dicha, viene precedida de un descriptor
de los registros lo que antes llamamos el encabezado del archivo pero esta
informacion aparece una unica vez y siempre al principio del archivo. Los flujos
que hemos visto hasta ahora, aun los binarios, son secuenciales, esto es, para leer
el registro i hay que leer previamente los i
1 registros que lo preceden, o en
todo caso saltar los bytes correspondientes a i
1 registros. Debemos notar que
incluso con los saltos (skip), estos son siempre hacia el final del archivo: lo que no
podemos hacer es querer leer el registro i y posteriormente el registro j con j i.6
Sin embargo, es muy comun querer un acceso directo7 . Por ejemplo, suponga-
mos que tenemos una base de datos ordenada alfabeticamente y queremos listar
en orden inverso. Con los flujos esto equivaldra a cerrar y abrir el archivo por
cada registro. Lo ideal es que sin costo adicional, pudieramos recorrer el archivo
de atras hacia adelante. Tambien se presenta esta necesidad en las bases de da-
tos, donde se guarda en disco una tabla con alguna llave (key) que identifica a
un registro, y a continuacion la posicion de ese registro en el archivo. Se podra
hacer una busqueda inteligente sobre la tabla (por ejemplo, busqueda binaria) que
requiere la posibilidad de ir hacia adelante o hacia atras en la lectura del archivo.
En Java tenemos una clase que nos da esta facilidad y que es la clase Ran-
6
Para poder hacer esto en archivos secuenciales tenemos que cerrar y volver a abrir el archivo
para que se vuelva a colocar al principio del mismo y poder saltar hacia el final del archivo. Otra
opcion es que el archivo tenga implementado los metodos mark y reset.
7
Llamamos directo a lo que en ingles se conoce tambien como random aleatorio , porque
consideramos que aquel es un termino mas adecuado. Aleatorio tiene un sentido de no determinis-
mo y lo que se hace con este tipo de acceso es poder llegar directamente (no secuencialmente)
a un cierto registro.
10.8 Escritura y lectura de campos que no son cadenas 382

domAccessFile. Hay que tener presente que aunque esta clase maneja archivos en
disco no hereda de ningun flujo (stream) o de lector/escritor (Reader/Writer), sino
que hereda directamente de Object, aunque s se encuentra en el paquete java.io.
Los ejemplares de esta clase proveen tanto lectura como escritura en el mis-
mo objeto. en general podemos pensar en un archivo de acceso directo como un
arreglo en disco, donde cada elemento del arreglo es un registro y al cual quere-
mos tener acceso directamente a cualquiera de los registros sin seguir un orden
predeterminado.
Con un archivo de este tipo tenemos siempre asociado un apuntador de archivo
(en adelante simplemente apuntador), que se encarga de indicar en cada momento
a partir de donde se va a realizar la siguiente lectura/escritura. Si el apuntador
esta al final del archivo y viene una orden de escritura, el archivo simplemente
se extiende (el arreglo crece); si estando al final del archivo viene una orden de
lectura, la maquina virtual lanzara una excepcion EOFException. Si se intenta
realizar alguna operacion despues de que el archivo fue cerrado, se lanzara una
IOException. Se tiene un metodo que se encarga de mover al apuntador, lo que
consigue que la siguen te lectura/escritura se lleve a cabo a partir de la posicion a
la que se movio el apuntador. Estas posiciones son absolutas en terminos de bytes.
Este tipo de archivos se pueden usar para lectura, escritura o lectura/escritura,
dependiendo de que se indique al construir los ejemplares.
Si bien no hereda de ninguna de las clases Stream, como ya dijimos, implemen-
ta a las interfaces DataOutput, DataInput y Closeable. Como se pueden imaginar,
las dos primeras tambien son implementadas por DataOutputStream y DataInputS-
tream, por lo que tendremos practicamente los mismos metodos que ya conocemos
de estas dos ultimas clases, todos en una unica clase. Revisaremos unicamente
aquellos metodos que no conocemos todava, dando por sentado que contamos
con los metodos para leer y escribir de DataInputStream y DataOutputStream.

public class RandomAccessFile implements DataOutput,

DataInput, Closeable
Constructores:
public RandomAccesFile(File file , String mode)
throws FileNotFoundException
Nuevamente tenemos que File representa a un archivo fsico, ya sea que
ya ha sido construido a traves de un flujo o que se le de la identificacion
completa de un archivo en disco. La cadena mode representa el tipo de
uso que se le va a dar al archivo y puede ser:
383 Entrada y salida

class RandomAccessFile (continua. . . )

r Abre el archivo solo para lectura. Si con un archivo abierto en
este modo se intenta escribir, se lanzara una IOException1.
rw El archivo se abre para lectura/escritura. Si el archivo no existe,
se intenta crear nuevo.
rws Igual que rw, excepto que exige que todo cambio al archivo o
al descriptor (meta-datos) del archivo se refleje inmediatamente
en el dispositivo, que se haga sincronizado con el enunciado.
rwd Igual que rws, excepto que los meta-datos no tienen que ac-
tualizarse de manera sincronizada.
Estos dos ultimos modos son muy utiles para garantizar que si hay algun
problema con el sistema, todo lo que se escribio desde la aplicacion en
efecto se vea reflejado en el dispositivo local. Si el dispositivo no es local,
no hay garanta de que esto suceda.
Las excepciones que pueden ser lanzadas (aunque no es necesario anun-
ciarlas a todas) son:

IllegalArgumentException Si el modo del constructor no es uno de los

especificados.
FileNotFoundException Si no se encontro el archivo solicitado y se in-
tento abrir solo para lectura.
SecurityException Si se intento abrir un archivo para lectura o para lec-
tura/escritura que el manejador de la seguridad no permita leer, o
para lectura/escritura que el manejador de seguridad no permita
escribir.
public RandomAccesFile(String name, String mode)
throws FileNotFoundException
En este caso la primera cadena da una identificacion en disco del vuelve
a ser el modo en que vamos a usar el archivo. Se comporta exactamente
igual que el primer constructor que mostramos.

Metodos adicionales a los de DataInput y DataOutput

En el caso de los archivos de acceso directo siempre existe el problema de
que se trate de leer mas alla del fin de archivo. Por ello, practicamente
todos los metodos que intentan leer mas de un caracter incondicionalmente
llegando al final del archivo sin haber ledo todos los bytes y que son
redefinidos lanzan la excepcion EOFException.
10.8 Escritura y lectura de campos que no son cadenas 384

class RandomAccessFile (continua. . . )

Como esta es una subclase de IOException no hay necesidad de modificar el
encabezado que por otro lado no se puede para que avise que tambien
puede lanzar una EOFException, que se refiere a tratar de leer mas alla del
fin de archivo.

public long length () throws IOException

Regresa el tamano del archivo en bytes.

void setLength(long newLength) throws IOException

Establece un nuevo tamano para el archivo. Si el tamano anterior era
mayor, se trunca el archivo al nuevo tamano, perdiendose lo que haba
mas alla del nuevo tamano. Si el tamano anterior era menos, se reserva
espacio para agrandar el archivo; sin embargo hay que tener en cuenta que
el contenido del espacio agregado no estara definido. En el caso de que el
archivo sea truncado y que el filePointer este mas alla del nuevo final del
archivo, el apuntador se colocara al final del archivo.

public void seek(long pos) throws IOException

Coloca el apuntador del archivo (filePointer) en la posicion dada por pos,
contado en bytes a partir del principio del archivo. Esta posicion puede
estar mas alla del fin de archivo sin que se lance una excepcion de fin de
archivo (EOFException), pero sin que cambie tampoco el tamano del ar-
chivo. Sin embargo, si una vez colocado el apuntador mas alla del final, se
lleva a cabo una escritura, esta accion si modificara el tamano del archivo.
La excepcion se lanza si pos 0 u ocurre un error de entrada/salida.
public long getFilePointer () throws IOException
Regresa la distancia al principio del archivo, en bytes, de la posicion actual
del archivo (el proximo byte que va a ser ledo o escrito).

Con esto ya tenemos las herramientas necesarias para acceder al disco con
acceso directo.

10.8.4. Lectura directa de registros

Como ya mencionamos, cualquier archivo en disco (o algun otro dispositivo de

almacenamiento en bytes) puede ser ledo o escrito bajo cualquier tipo de flujo;
el tipo de flujo nos indica unicamente como interpretar los bytes: no describe el
 385 Entrada y salida

contenido del archivo.

Figura 10.15 Algoritmo para agregar registros desde archivo de acceso directo
$
'
' Pedir nombre de archivo
'
'
'
' Abrir archivo para#lectura
'
'
'
'
'
'
'
Leer numero de tamanhos[0] Primer short
'
'
'
' campos del archivo
'
'
'
'
'
' $ $
'
' ' '
'
' & &Leer siguiente
'
' Calcular tamano Sumar tamanhos[i]
'
'  short
'
' de registro '
% i=1,. . . , tamanhos[0] ' %
'
' Sumarlo
'
'
'
'
'
'
'
' $ $
'
' ' 'Leer cadena de
'
' '
' Obtener del usuario el ' '
'
' '
' &
'
' '
' consola
'
' '
' numero del registro
'
' '
' '
' Procesar dgito
'
' '
' solicitado '
% 
Agregar registros '
' '
' mientras haya
& '
'
'
'
desde archivo de '
'
'
' '
' $
acceso directo ' '
'
'
'
'
'
'
'
&pos
'
'
'
'
'
'
'
'
'
'
Calcular posicion en
'
tamR numR
'
'
'
'
'
'
'
'
'
'
bytes %
|
encabezado|
'
' &
'
'
Procesar registro Colocar el apuntador en esa posicion
'
'
'
' (mientras se den) ''
'
'
' ' $
'
' '
' ' Leer nombre
'
' '
' '
'
'
' '
' &
'
' 'Leer registro desde
' Leer cuenta
'
' '
'
'
' '
' disco '
' Leer carrera
'
' '
' '
%
'
' '
'
'
' '
' Leer clave
'
' '
'
'
' '
'
'
' '
' $
'
' '
' '
'
' '
'Agregar a lista &Construir registro
'
' '
'
'
' '
' nuevo
'
% '
% registro ledo '
%
Agregar a lista
10.8 Escritura y lectura de campos que no son cadenas 386

El unico problema que enfrentamos es si suponemos un flujo en el que queramos

leer cadenas y no tenemos caracteres de fin de lnea en el archivo; en este caso
una unica lectura nos dara todo el contenido del archivo, terminando la cadena
con un fin de archivo. En este sentido, s hay que distinguir (desde la aplicacion)
cuando estamos trabajando con un archivo de cadenas o de registros de tamano
fijo.
La lectura directa nos permite brincar dentro del archivo, hacia adelante y
hacia atras, buscando un byte en una posicion determinada. Lo que quisieramos
hacer con nuestra base de datos, guardada en un archivo en disco, es poder leer y
agregar en desorden a los registros que se encuentran en el disco. Tambien debe
ser posible agregar unicamente a un subconjunto de estos registros. El algoritmo
para este caso se encuentra en la figura 10.15 en la pagina anterior.
Podemos revisar cada uno de estos subprocesos en terminos del diagrama. Por
ejemplo, pedir el nombre del archivo consiste de exactamente el mismo proceso
que en el caso del acceso al k-esimo registro. La implementacion se puede ver en
el listado 10.8. La parte correspondiente a la lectura y apertura del archivo tienen
que estar en un bloque try, ya que ambas operaciones pueden lanzar excepciones
lneas 605: a 612:. Lo primero que hacemos es solicitar del usuario el nombre del
archivo en disco que vamos a utilizar lnea 606: y a continuacion lo tratamos
de abrir exclusivamente para lectura, lo que que hacemos poniendo como segundo
argumento del constructor "r" en la lnea 607:.
Si se lanza la excepcion de archivo no encontrado, simplemente emitimos un
mensaje acorde y salimos a mostrar nuevamente el menu lneas 608: a 612: ,

mientras que si lo que tenemos es un error de entrada/salida realmente ya no

podemos hacer nada y exportamos la excepcion lneas 613: y 614:.
Lo siguiente que queremos hacer es leer el encabezado del archivo para calcular
el tamano del registro. Tambien esto se lleva a cabo de la misma manera que lo
hicimos en la lectura de archivos binarios, por lo que ya no es necesaria una
explicacion. El codigo se encuentra en el listado 10.9.

Codigo 10.8 Lectura del nombre del archivo y apertura del mismo (case LEERDIRECTO) 1/2
603: case LEERDIRECTO :
604: // P e d i r e l nombre d e l f l u j o
605: try {
606: s A r c h i v o = pideNombreArch ( cons , o p c i o n ) ;
607: archivoRndm = new R a n d o m A c c e s s F i l e ( s A r c h i v o , "r" ) ;
608: } catch ( F i l e N o t F o u n d E x c e p t i o n e ) {
387 Entrada y salida

Codigo 10.8 Lectura del nombre del archivo y apertura del mismo (case LEERDIRECTO) 2/2
609: System . e r r . p r i n t l n ( "el archivo de entrada "
610: + ( s A r c h i v o != n u l l ? s A r c h i v o : "nulo" )
611: + " no existe " ) ;
612: r e t u r n LEERDIRECTO ;
613: } catch ( I O E x c e p t i o n e ) {
614: throw e ;
615: } // end o f t r y
c a t c h

Codigo 10.9 Calculo del tamano del registro (case LEERDIRECTO)

616: // C a l c u l a r e l tamano d e l r e g i s t r o
617: tamR = 0 ;
618: numBytes = 0 ;
619: try {
620: s h o r t tam = 0 ;
621: tam = archivoRndm . r e a d S h o r t ( ) ;
622: numBytes = 2 ;
623: tamanhos = new s h o r t [ tam + 1 ] ;
624: tamanhos [ 0 ] = tam ;
625: tamR = 0 ;
626: f o r ( i n t i = 1 ; i <= tam ; i ++) {
627: tamanhos [ i ] = archivoRndm . r e a d S h o r t ( ) ;
628: numBytes+=2; tamR += tamanhos [ i ] ;
629: } // end o f f o r ( i n t i = 1 ; i <= tam ; i ++)
630: } catch ( I O E x c e p t i o n e ) {
631: System . e r r . p r i n t l n ( "No pude leer parametros " ) ;
632: return opcion ;
633: } // end o f c a t c h
634: // C a l c u l a r e l numero t o t a l de r e g i s t r o s en e l f l u j o
635: // p a r a d e t e c t a r p o s i c i o n e s e r r o n e a s de r e g i s t r o s
636: f i l e S i z e = 0;
637: try {
638: f i l e S i z e = archivoRndm . l e n g t h ( ) / tamR ;
639: } catch ( I O E x c e p t i o n e ) {
640: System . e r r . p r i n t l n ( " Error al calcular Num bytes " ) ;
641: } // end o f t r y
c a t c h

Una vez que calculamos el tamano del encabezado (numBytes), el tamano del
registro (tamR) y el numero de registros logicos en el archivo (fileSize) procedemos
a iterar, pidiendole al usuario el numero de registro, tantos como desee, del registro
que desea leer y agregar a la lista en memoria. Esto se lleva a cabo en las lneas
642: a 667: en el listado 10.10 en la siguiente pagina.
10.8 Escritura y lectura de campos que no son cadenas 388

Codigo 10.10 Peticion del numero de registro al usuario (case LEERDIRECTO)

642: w h i l e (numR >= 0 ) {
643: // P e d i r e l r e g i s t r o s o l i c i t a d o que e s t e en r a n g o s
644: numR = 0 ;
645: try {
646: System . o u t . p r i n t ( " Ahora dime el numero de registro "
647: + "(0.." + ( f i l e S i z e
1 )
648: + ", -1 para terminar )"
649: + " a agregar -->" ) ;
650: subcad = cons . r e a d L i n e ( ) ;
651: i f ( s u b c a d . c h a r A t ( 0 ) < 0 | | s u b c a d . c h a r A t ( 0 ) >= 9 ) {
652: numR =
1;
653: continue ;
654: } // end o f i f
655: numR = 0 ;
656: f o r ( i n t i = 0 ; i < s u b c a d . l e n g t h ( ) ; i ++) {
657: numR = numR10 + s u b c a d . c h a r A t ( i )
0 ;
658: } // end o f f o r
659: i f ( numR < 0 | | numR >= f i l e S i z e ) {
660: System . o u t . p r i n t l n ( "Hay menos de " + numR
661: + ". Del 0 al "
662: + ( fileSize
1));
663: return opcion ;
664: }
665: } catch ( I O E x c e p t i o n e ) {
666: System . o u t . p r i n t l n ( " Error al leer numero de registro " ) ;
667: } // end o f t r y
c a t c h

Elegimos leer del usuario una cadena, para evitar errores de lectura en caso
de que el usuario no proporcione un entero lnea 650:. Calculamos el entero
correspondiente usando la regla de Horner, que proporciona una manera sencilla,
de izquierda a derecha, de calcular un polinomio. Supongamos que tenemos un
polinomio
cn xn cn
1 xn
1 . . . c0
Podemos pensar en un numero en base b como un polinomio donde x  b y
tenemos la restriccion de que 0 ci b. En este caso para saber el valor en base
10 evaluamos el polinomio. La manera facil y costosa de hacerlo es calculando
cada una de las potencias de b para proceder despues a multiplicar ci por bi .

n
P pxq  ci xi

i 0

Pero como acabamos de mencionar, esta es una manera costosa y poco elegante
389 Entrada y salida

de hacerlo. La regla de Horner nos dice:

P pxq  c0 xpc1 xpc2 xp. . .qq . . .q

lo que nos permite evaluar el polinomio sin calcular previamente las potencias de
b. Por ejemplo, el numero base 10 8725 lo podemos expresar como el polinomio

8  103 7  102 2  101 5  100  8000 700 20 5  8725

Si usamos la regla de Horner lo calculamos de la siguiente manera:

5 10p2 10p7 10p8qqq

Pero como tenemos que calcular de adentro hacia afuera, el orden de las opera-
ciones es el siguiente:

ppp8  10q 7q  10 2q  10 5

que resulta en la siguiente sucesion de operaciones:

8  10 80 7
87  10 870 2
872  10 8720 5
 8725
lo que permite leer los dgitos de izquierda a derecha e ir realizando las multipli-
caciones y sumas necesarias. La ventaja de esta regla es que cuando leemos el 8,
por ejemplo, no tenemos que saber la posicion que ocupa, sino simplemente que
es el que esta mas a la izquierda. Dependiendo de cuantos dgitos se encuentren a
su derecha va a ser el numero de veces que multipliquemos por 10, y por lo tanto
la potencia de 10 que le corresponde. Este algoritmo se encuentra codificado en
las lneas 655: a 658:.
En las lneas 651: a 654: verificamos que el usuario no este proporcionando un
numero negativo (que empieza con -). Si es as, damos por terminada la sucesion
de enteros para elegir registros.
Quisieramos insistir en que no importa si el flujo es secuencial o de acceso
directo, una lectura se hace siempre a partir de la posicion en la que se encuentra
el flujo. Si se acaba de abrir esta posicion es la primera la cero (0) . Conforme se
hacen lecturas o escrituras el flujo o archivo va avanzando; en los flujos secuenciales
de entrada, mediante el metodo skip se puede avanzar sin usar los bytes saltados,
pero siempre hacia adelante. En cambio, en los archivos de acceso directo se cuenta
10.8 Escritura y lectura de campos que no son cadenas 390

con el comando seek que es capaz de ubicar la siguiente lectura o escritura a partir
de la posicion dada como argumento, colocando el apuntador de archivo en esa
posicion.
En el listado 10.11 se encuentra el codigo que corresponde a la ubicacion del
apuntador del archivo, frente al primer byte del registro solicitado por el usuario
en la iteracion actual.

Codigo 10.11 Posicionamiento del apuntador del archivo y lectura (case LEERDIRECTO)
687: try {
688: // S a l t a r e l numero de b y t e s r e q u e r i d o s p a r a u b i c a r s e
689: // en e l r e g i s t r o s o l i c i t a d o .
690: a S a l t a r = numRtamR + numBytes ;
691: archivoRndm . s e e k ( a S a l t a r ) ;
692: bCadena = new byte [ tamR ] ;
693: // Leemos e l r e g i s t r o s o l i c i t a d o .
694: archivoRndm . r e a d ( bCadena , 0 , tamanhos [ 1 ] ) ;
695: nombre = new S t r i n g ( bCadena , 0 , tamanhos [ 1 ] ) ;
696: f o r ( i n t i = 2 ; i <= tamanhos [ 0 ] ; i ++) {
697: archivoRndm . r e a d ( bCadena , 0 , tamanhos [ i ] ) ;
698: switch ( i ) {
699: case 2 :
700: c u e n t a = new S t r i n g ( bCadena , 0 , tamanhos [ i ] ) ;
701: break ;
702: case 3 :
703: c a r r e r a = new S t r i n g ( bCadena , 0 , tamanhos [ i ] ) ;
704: break ;
705: case 4 :
706: c l a v e = new S t r i n g ( bCadena , 0 , tamanhos [ i ] ) ;
707: break ;
708: default :
709: break ;
710: } // end o f s w i t c h ( i )
711: } // end o f f o r ( i n t i = 1 ;
712: // Se arma un o b j e t o de l a c l a s e E s t u d i a n t e
713: E s t u d i a n t e nuevo = new E s t u d i a n t e
714: ( nombre , c u e n t a , c a r r e r a , c l a v e ) ;
715: i f ( miCurso == n u l l ) {
716: System . o u t . p r i n t l n ( "No existe Curso " ) ;
717: throw new N u l l P o i n t e r E x c e p t i o n ( " Uuups " ) ;
718: } // end o f i f ( miCurso == n u l l )
719: miCurso . a g r e g a E s t F i n a l
720: ( new E s t u d i a n t e ( nombre , c u e n t a , c a r r e r a , c l a v e ) ) ;
721: } catch ( I O E x c e p t i o n e ) {
722: System . o u t . p r i n t l n ( "Hubo error en LEERDIRECTO " ) ;
723: } // end o f t r y
c a t c h
724: } // end w h i l e s e p i d a n r e g i s t r o s
391 Entrada y salida

En la lnea 690: calculamos la posicion que corresponde al entero dado en esta

iteracion y en la lnea 691: colocamos al apuntador del archivo frente al siguiente
registro a leer. Como los registros estan numerados del 0 en adelante, el numero
de registros que se tienen que saltar son precisamente el entero proporcionado
por el usuario. Una vez colocados frente al registro deseado procedemos a leer el
registro desde disco lneas 692: a 711: . Una vez ledo el registro procedemos a
agregarlo a la lista que se esta construyendo lneas 713: a 720: . En este bloque
hay varias operaciones que pueden lanzar una excepcion, por lo que se colocan en
un bloque try. En caso de que haya algun problema, simplemente descarta esta
escritura y procede a pedir el siguiente numero de registro.

10.8.5. Escritura directa de registros

En un archivo de acceso directo podemos tener varias situaciones:

1. Queremos guardar en un archivo de acceso directo a los registros de la lista
en memoria.
2. Queremos agregar registros al final del archivo.
3. Deseamos sustituir un registro en el archivo por otro proporcionado por el
usuario.
Las primeras dos situaciones no guardan ninguna diferencia con la de estar
trabajando con archivos binarios; insistimos en que las opciones que vamos a
tener con un archivo en disco depende del color del cristal con el que lo veamos.
En general, si tenemos el encabezado del archivo y registros de tamano uniforme,
podemos verlo como un archivo binario o como uno de acceso directo. Por esta
razon nos concentraremos en la tercera situacion, aclarando que la posicion que se
de para escribir el registro puede estar mas alla del fin de archivo, lo que resultara,
en este tipo de archivos, en que se extienda el archivo, dejando como indefinidos
los bytes que se encuentren entre el final anterior y el actual. El algoritmo para
esta opcion se encuentra en la figura 10.16.
Por supuesto que en otras aplicaciones puede ser la misma aplicacion la que
modifique un registro y lo reescriba. En el contexto de nuestra aplicacion pensa-
remos que el usuario nos da la posicion del registro y el registro a escribir en esa
posicion esto para poder seguir trabajando en este contexto. El algoritmo para
esta opcion corre paralelo al que dimos para lectura de archivo de acceso directo,
excepto que ademas de pedir numero de registro, la aplicacion tiene que pedir el
registro a escribir. Por lo anterior, esta opcion es una combinacion de la opcion
que agrega un registro y de la que lee de un archivo de acceso directo. El codigo
correspondiente se encuentra en al listado 10.12.
 10.8 Escritura y lectura de campos que no son cadenas 392

Figura 10.16 Algoritmo para sobrescribir registros en archivo de acceso directo

$
'
'Pedir nombre de archivo
'
'
'
' Abrir archivo para#lectura y escritura
'
'
'
'
'
'
'
Leer numero tamanhos[0] Primer short
'
'
'
' de campos del archivo
'
'
'
'
'
' $ $
'
'
'
' '
' '
&Leer siguiente
'
' '
& Sumar tamanhos[i]
'
' Calcular tamano  short
'
' i=1,. . . , tamanhos[0] '
'
' ' %
'
' de registro '
'
Sumarlo
'
' %
'
'
'
' $ $
'
' '
'
' '
' '
' Leer de consola
'
' '
' '
&
'
' '
' Obtener la posicion cadena
'
' '
'
'
' '
' del registro a escribir ' Procesar dgito
'
' '
' '
' 
'
' '
' %
'
' '
' mientras haya
Modificar registros '
& '
'
'
'
en archivo de '
' $
' '
'
acceso directo '
' '
' '
' Pedir nombre
'
' '
' '
&
'
' '
' Obtener del usuario Pedir cuenta
'
' '
'
'
' '
' el registro a escribir ' Pedir carrera
'
' '
' '
'
'
' '
' %
'
' '
& Pedir clave
'
' Procesar registro
'
'
'
' (mientras se den) ' $
'
'
'
'
'
'
'
'
'
'
'
&pos
'
'
'
'
'
'
'
'
'
'
Calcular posicion
'

tamR numR
'
'
'
'
'
'
'
'
'
en bytes %
| |
encabezado
'
' '
'
' 'Colocar el apuntador
'
'
' '
'
'
' '
' en esa posicion
'
' '
' $
'
' '
'
'
' '
' '
' Escribir nombre
'
' '
' '
&
'
' '
' Escribir campos Escribir cuenta
'
' '
'
'
' '
' '
'
' '
' en el disco '
'
Escribir carrera
'
% '
% %
Escribir clave
393 Entrada y salida

Codigo 10.12 Opcion de modificar registros (case GUARDARDIRECTO)1/2

742: case GUARDARDIRECTO :
743: E s t u d i a n t e nuevo = n u l l ;
744: // P e d i r e l nombre d e l f l u j o
745: try {
746: s A r c h i v o = pideNombreArch ( cons , o p c i o n ) ;
747: archivoRndm = new R a n d o m A c c e s s F i l e
748: ( s A r c h i v o , "rw" ) ;
749: } catch ( F i l e N o t F o u n d E x c e p t i o n e ) {
750: System . e r r . p r i n t l n ( "el archivo de entrada "
751: + ( s A r c h i v o != n u l l ? s A r c h i v o : "nulo" )
752: + " no existe " ) ;
753: return opcion ;
754: } catch ( I O E x c e p t i o n e ) {
755: throw e ;
756: } // end o f t r y
c a t c h
757: // C a l c u l a r e l tamano d e l r e g i s t r o
758: tamR = 0 ;
759: numBytes = 0 ;
760: try {
761: s h o r t tam = 0 ;
762: tam = archivoRndm . r e a d S h o r t ( ) ;
763: numBytes = 2 ;
764: tamanhos = new s h o r t [ tam + 1 ] ;
765: tamanhos [ 0 ] = tam ;
766: tamR = 0 ;
767: f o r ( i n t i = 1 ; i <= tam ; i ++) {
768: tamanhos [ i ] = archivoRndm . r e a d S h o r t ( ) ;
769: numBytes+=2;
770: tamR += tamanhos [ i ] ;
771: } // end o f f o r ( i n t i = 1 ; i <= tam ; i ++)
772: } catch ( I O E x c e p t i o n e ) {
773: System . e r r . p r i n t l n ( "No pude leer parametros " ) ;
774: return opcion ;
775: } // end o f c a t c h
776: // C a l c u l a r e l numero t o t a l de r e g i s t r o s en e l f l u j o
777: f i l e S i z e = 0;
778: try {
779: f i l e S i z e = archivoRndm . l e n g t h ( ) / tamR ;
780: } catch ( I O E x c e p t i o n e ) {
781: System . e r r . p r i n t l n ( " Error al calcular Num bytes " ) ;
782: } // end o f t r y
c a t c h ( i n t i = 1 ; i <= tamanhos [ 0 ] ; i ++)
783: w h i l e (numR >= 0 ) {
784: // P e d i r e l r e g i s t r o s o l i c i t a d o que e s t e en r a n g o s
785: try {
10.8 Escritura y lectura de campos que no son cadenas 394

Codigo 10.12 Opcion de modificar registros (case GUARDARDISCO)2/2

786: System . o u t . p r i n t ( " Ahora dime el numero de registro (0.."
787: + ", -1 para terminar )"
788: + " a escribir -->" ) ;
789: subcad = cons . r e a d L i n e ( ) ;
790: char c u a l = s u b c a d . c h a r A t ( 0 ) ;
791: i f ( c u a l < 0 | | c u a l >= 9 ) {
792: numR =
1;
793: continue ;
794: } // end o f i f
795: numR = 0 ;
796: f o r ( i n t i = 0 ; i < s u b c a d . l e n g t h ( ) ; i ++)
797: numR = numR10 + s u b c a d . c h a r A t ( i )
0 ;
798: } catch ( I O E x c e p t i o n e ) {
799: System . o u t . p r i n t l n ( " Error al leer numero de registro " ) ;
800: } // end o f t r y
c a t c h
801: // P e d i r l o s campos a e s c r i b i r
802: try {
803: nombre = pideNombre ( c o n s ) ;
804: cuenta = pideCuenta ( cons ) ;
805: c a r r e r a = p i d e C a r r e r a ( cons ) ;
806: c l a v e = pideClave ( cons ) ;
807: nuevo = new E s t u d i a n t e ( nombre , c u e n t a , c a r r e r a , c l a v e ) ;
808: } catch ( I O E x c e p t i o n e ) {
809: System . o u t . p r i n t l n ( " Error al leer datos del "
810: + " estudiante .\ nNo se pudo escribir " ) ;
811: } // end o f t r y
c a t c h
812: try {
813: // S a l t a r e l numero de b y t e s r e q u e r i d o s p a r a u b i c a r s e
814: // en e l r e g i s t r o s o l i c i t a d o .
815: a S a l t a r = numRtamR + numBytes ;
816: archivoRndm . s e e k ( a S a l t a r ) ;
817: // E s c r i b o e l r e g i s t r o c o n s t r u i d o en nuevo
818: f o r ( i n t i = 1 ; i <= tamanhos [ 0 ] ; i ++) {
819: nombre = ( nuevo . daCampo ( i ) + b l a n c o s ) .
820: s u b s t r i n g ( 0 , tamanhos [ i ] ) ;
821: archivoRndm . w r i t e B y t e s ( nombre ) ;
822: } // end o f f o r ( i n t i = 1 ; i <= tamanhos [ 0 ] ; i ++)
823: } catch ( I O E x c e p t i o n e ) {
824: System . o u t . p r i n t l n ( "Hubo error en GUARDARDIRECTO " ) ;
825: } // end o f t r y
c a t c h
826: } // end w h i l e s e p i d a n r e g i s t r o s
827: try {
828: archivoRndm . c l o s e ( ) ;
829: } catch ( I O E x c e p t i o n e ) {
830: System . e r r . p r i n t l n ( "No pude cerrar archivo directo " ) ;
831: } // end o f t r y
c a t c h
832: r e t u r n GUARDARDIRECTO ;
395 Entrada y salida

Realmente ya no hay mucho que explicar en esta opcion, pues practicamente

todo lo interesante ya se vio y los comentarios del codigo explican el orden. Sin
embargo es necesario insistir en un punto. Supongamos que leemos un registro (en
modo directo), lo modificamos y lo reescribimos; esto quiere decir que leemos y
escribimos de la misma posicion. Por lo tanto, tendremos que colocar el apuntador
del archivo en la posicion correspondiente; leemos el registro; lo modificamos;
volvemos a colocar el apuntador de archivo en la posicion anterior; y escribimos.
Si no regresamos al apuntador a la posicion donde empieza el registro, vamos
a sobreescribir en el siguiente registro, no en el que lemos. Esto se debe a que
cada lectura (o escritura) avanza al apuntador tantos bytes como se hayan ledo
(o escrito); al final de la lectura el apuntador va a estar posicionado un byte mas
alla del final del registro ledo, por lo que es necesario regresarlo a que apunte al
principio del registro ledo.

10.9 Lectura y escritura de objetos

Siendo Java un lenguaje orientado a objetos, uno se hace la pregunta de por

que se usan mecanismos anticuados como la transformacion de y a bytes
para lectura y escritura del ingrediente fundamental del lenguaje. Una respuesta,
aunque no del todo precisa, es que el almacenamiento en dispositivos externos si-
gue siendo todava en terminos de bytes. Pero no es del todo precisa esta respuesta
pues lo que intentamos con el uso de un lenguaje orientado a objetos es elevar
el nivel de abstraccion de nuestras aplicaciones; esto es, independientemente de
cual sea la representacion subyacente de la informacion el lenguaje de maquina
que corresponde as la representacion de la informacion deseamos, al nivel de la
aplicacion, pensar en que tenemos almacenados objetos, independientemente de
como esten codificados estos objetos.
La caracterstica que buscamos escribiendo y leyendo objetos es el autoconoci-
miento que tienen de s mismos los objetos: buscamos que tanto en el dispositivo
externo como en la memoria durante la ejecucion el objeto pueda describirse a
s mismo; que la lectura, escritura, y por lo tanto la interpretacion, no dependa de
la aplicacion, sino que dependa de lo que esta almacenado (o se este almacenan-
do). En resumen, deseamos que los objetos se almacenen con una descripcion de
s mismos; y que esta descripcion sea manejada automaticamente por el lenguaje,
descargando de esta tarea a la aplicacion.
Para ello cuenta Java con dos flujos, uno de entrada y otro de salida, que
contempla la lectura y escritura de objetos, ObjectInputStream y ObjectOutputS-
10.9 Lectura y escritura de objetos 396

tream respectivamente. Las lecturas y escrituras se llevan a cabo como acabamos

de mencionar, por lo que los archivos presentan un tamano mayor al que espe-
raramos. Tambien hay que tomar en cuenta que este modo de entrada/salida no
es muy eficiente, sobre todo si los objetos son grandes o tenemos una cantidad
grande de los mismos. En este ultimo caso se recomienda vaciar el objeto como
lo hicimos antes y dejar que sea la aplicacion la que lo interprete. Se conoce como
serializacion a la conversion que se realiza de un objeto a un flujo de bytes y
deserializacion la accion inversa: construir el estado de un objeto a partir de su
imagen en bytes.
Un aspecto muy importante e interesante es que al serializar un objeto estamos
guardando su estado, que es lo que lo distingue de otros objetos de la misma clase.
Al deserializarlo recuperamos precisamente el estado del objeto en el momento en
que fue serializado. De esta manera se puede recuperar facilmente el estado de
una aplicacion utilizando estos mecanismos. El contexto principal en el que estos
mecanismos se requieren es cuando se ejecuta una aplicacion distribuida en varias
plataformas o de manera remota.
Regresando a los mecanismos de Java para leer/escribir objetos, llama la aten-
cion que ObjectInputStream y ObjectOutputStream no heredan de FilexxxputStream
sino que heredan directamente de xxxputStream, donde xxx corresponde a in o
out. Pero veamos parte de la definicion de estas clases y los metodos que nos
aportan.
No es trivial guardar el estado de un objeto, pues algunos de los campos pueden
depender de la maquina virtual en la que se esta ejecutando o del contexto. Por
ejemplo, si tenemos una lista ligada con objetos, la referencia al siguiente elemento
de la lista depende de la secuencia de ejecucion y de la localidad asignada por
la maquina virtual: no es probable que en otra ejecucion, posiblemente hasta
en otra maquina o con distinto sistema operativo, la lista quede armada en las
mismas posiciones que las dadas por el estado de los objetos. Otro ejemplo es
el de un objeto que guarda la posicion de un cierto flujo donde se encuentra el
apuntador del archivo en el momento en que quedo definido su estado: en una
ejecucion posterior o distinta puede suceder que el archivo ya haya cambiado y
esa posicion no corresponda; o que al momento de leer el objeto el archivo ni
siquiera este disponible. Por lo tanto, hay campos en un objeto serializado que
no tiene sentido guardar o leer porque se encuentran fuera de contexto. A este
tipo de campos los marcamos con el calificativo de transient para indicarle a la
aplicacion que no los incluya en la serializacion del objeto.
Otros campos que no vale la pena tampoco guardar son los campos estaticos
(static) de la clase. Tambien en este caso, dado que esos campos pueden ser mo-
dificados por cualquiera de los objetos de esa clase, el valor que tienen cuando se
serializa al objeto no tiene por que ser el mismo que cuando se le deserializa. Por
397 Entrada y salida

lo tanto, tampoco los campos estaticos van a ser incluidos en la serializacion de

un objeto.
Si tenemos una clase que contiene campos que corresponden a otra(s) clase(s),
los objetos de la primera van a poder ser serializados si y solo si cada una de
los campos que corresponden a clases contenidos en el objeto son tambien seria-
lizables. Asimismo, si una superclase no es serializable, ninguna subclase de ella
puede ser serializable, ya que si serializamos a la subclase le damos la vuelta a la
seguridad de la superclase que no desea ser serializada.
Cada objeto en el flujo consiste de un bloque de datos, en el que primero se
encuentra la descripcion de los datos y despues los datos propiamente dichos.
Como se puede ver de estos breves comentarios, la serializacion y deserializa-
cion de objetos tiene muchsimos puntos finos que hay que observar. Haremos una
lista mas precisa de estos puntos hacia el final de esta seccion. Pasemos a revisar
los flujos de objetos.

public class ObjectInputStream extends InputStream

implements ObjectInput, ObjectStreamConstants
Un flujo de entrada de objetos que deserializa datos primitivas que
fueron previamente escritos usando un flujo de salida de objetos
(ObjectOutputStream). Solo los objetos que implementan la interfaz Se-
rializable son sujetos a ser serializados.
La interfaz ObjectInput hereda de la interfaz DataInput todos los metodos
que interpretan valores primitivas y agrega metodos para leer objetos y
bytes en crudo, sin interpretacion.
La interfaz ObjectStreamConstants simplemente proporciona constantes
simbolicas para evitar el uso de numeros magicos. Ademas de implementar
los metodos de DataInput (que no listaremos) provee metodos especficos
para trabajar con objetos.
Clase anidada:
public abstract static class ObjectInputStream.GetField
Provee acceso para los campos persistentes ledos del flujo de entrada.
Campos:
Los heredados de ObjectStreamConstants.
Constructores:
protected ObjectInputStream() throws IOException,
SecurityException
10.9 Lectura y escritura de objetos 398

La excepcion de I/O es la usual. La excepcion relativa a la seguridad tiene

que ver con el administrador de seguridad, si es que se violan los permisos
dados para la serializacion.
public ObjectInputStream(InputStream in) throws IOException
Crea un ObjectInputStream que se asocia al flujo dado por in.
Metodos: (ademas de los de DataInput)
public void defaultReadObject() throws IOException,
ClassNotFoundException
Lee los datos no-estaticos y no-transeuntes de la clase asociada a este
flujo. Solo puede ser invocada desde el metodo readObject. Si el flujo no
esta activo, lanza la excepcion NotActiveException. Si no encuentra en
su entorno la clase a la que pertenecen los objetos serializados, lanza la
excepcion ClassNotFoundException.
protected boolean enableResolveObject( boolean enable)
Habilita al flujo para permitir que los objetos que son ledos del flujo pue-
dan ser reemplazados. Regresa el valor anterior antes de esta invocacion.
Lanza la excepcion si el manejador de seguridad no permite que se rees-
criba en este flujo.
public Object readObject()
throws IOException, ClassNotFoundException
Permite leer un objeto de un flujo serializado.
Ademas de las excepciones mencionadas en el encabezado, puede lanzar
una de las siguientes excepciones:

InvalidClassException Lanza esta excepcion cuando la clase descrita en

la serializacion no coincide con la que se encuentra declarada, no
reconoce el tipo de alguno de los campos o bien no cuenta con el
constructor requerido.

StreamCorruptedException La descripcion del objeto viola la consisten-

cia del sistema y no lo puede leer.

OptionalDataException En el flujo no hay objetos, sino datos primitivos;

no esta la descripcion del objeto.
protected ObjectStreamClass readClassDescriptor ()
399 Entrada y salida

throws IOException, ClassNotFoundException

Lee un descriptor de clase del flujo serializado. Se utiliza cuando la apli-
cacion espera un descriptor de clase como siguiente elemento en el flujo.
protected Object resolveObject(Object obj)
throws IOException
Permite a subclases en las que se confa sustituir a un objeto por otro
durante la deserializacion. Este metodo se llama despues de invocar a
readObject pero antes de regresar de esta ultima invocacion.

La lista que acabamos de dar dista mucho de ser exhaustiva, pero contiene la
suficiente informacion para poder cumplir con nuestro objetivo, que consiste en
serializar y deserializar la base de datos. Terminemos de reunir las herramientas
que requerimos mostrando la definicion de la clase ObjectOutputStream.

public class ObjectOutputStream extends OutputStream

implements ObjectOutput, ObjectStreamConstants
Escribe al objeto serializado en un flujo de bytes. Unicamente los objetos
de clases que declaran ser Serializable pueden ser serializadas. Tanto la
superclase como todos los campos de la clase que a su vez sean objetos
deben ser serializables.
Clase anidada:
public abstract static class ObjectOutputStream.PutField
Aporta acceso de programacion a los campos persistentes a escribirse e la
salida de objetos (ObjectOutput).
Campos:
Los heredados de ObjectStreamConstants.
Constructores:
public ObjectOutputStream(OutputStream out)
throws IOException
Crea un flujo ObjectOutputStream que escribe sobre el flujo de salida es-
pecificado (out). Escribe el encabezado de la serializacion en el flujo de
salida. Ademas de la excepcion IOException puede lanzar una excepcion
de seguridad (SecurityException) si hubiese clases que pasen por encima
de las medidas de seguridad de acceso; y finalmente tambien puede lanzar
una excepcion NullPointerException si out es nulo.
10.9 Lectura y escritura de objetos 400

protected ObjectOutputStream() throws IOException,

SecurityException
Sirve para construir subclases que redefinan el flujo para no tener que
asignar espacio para datos privados que se usan unicamente en esta imple-
mentacion de ObjectOutputStream. Realiza las verificaciones de seguridad
necesarias.
protected void annotateClass(Class<?> cl) throws IOException
Permite escribir en el flujo datos que corresponden a la clase. Corresponde
al metodo resolveClass de ObjectInputStream. Lo escrito por este metodo
debe ser ledo por resolveClass.
public void defaultWriteObject () throws IOException
Escribe los campos no estaticos y no transeuntes al flujo. Solo puede ser
invocado desde writeObject. So no se hace as lanza una excepcion del tipo
NotActiveException.
protected void drain() throws IOException
Vaca cualquier informacion acumulada en el flujo que no ha sido escrita
en el dispositivo. Similar a flush pero no se encadena con el dispositivo.
protected boolean enableReplaceObject (boolean enable)
throws SecurityException
Cuando es verdadera, permite el reemplazo de objetos en el flujo. Si
esta habilitada, se invoca al metodoreplaceObject cada vez que se serializa
un objeto.
public ObjectOutputStream.PutField putFields ()
throws IOException
Obtiene el objeto que se usa para almacenar campos persistentes que van a
ser escritos en el flujo. Los campos se escriben cuando se invoca al metodo
writeFields.
protected Object replaceObject(Object obj)
throws IOException
Permite que clases confiables sustituyan un objeto por otro durante la
serializacion. El objeto que reemplaza (obj) puede no ser serializable. El
objeto debe ser de la clase que esta descrita en el flujo, o de una subclase
de esta. De otra manera lanza una excepcion.
public void reset () throws IOException
Ignora el estado de los objetos que ya fueron escritos en el flujo. El estado
del flujo se establece igual al de haberlo creado (new ObjectInputStream).
401 Entrada y salida

public void write ( args ) throws IOException

La especificacion de args puede ser cualquiera de las especificadas en
las interfaces DataOutput. Los argumentos son, como en otros flujos, un
arreglo de bytes (con, opcionalmente, la primera posicion y el tamano) o
un valor entero.
Ademas de aquellos metodos que escriben enteros, bytes, flotantes, etc., tenemos
metodos que provienen de la interfaz ObjectOutput. Unicamente mencionaremos
los que provienen de la segunda interfaz, ya que el resto funciona exactamente de
la misma manera que en todos los flujos que implementa DataOutput y que ya
revisamos.
public void writeFields () throws IOException
Escribe los campos que se encuentren en el buffer al flujo de objetos.
protected void writeStreamHeader() throws IOException
Se proporciona para que las subclases puedan pegar su propio encabezado
al flujo.
protected void writeClassDescriptor ( ObjectStreamClass desc)
throws IOException
Se utiliza para que las subclases puedan determinar la manera como van
a codificar la descripcion de la clase.
public final void writeObject(Object obj) throws IOException
Escribe el objeto indicado en el flujo, incluyendo a la clase y la firma de
la clase a la que pertenece el objeto, los valores de las variables de estado
que no sean transeuntes y todos los supertipos de la clase. Se usa para
brincar la serializacion y hacerla mas ad-hoc para el objeto dado. Si se
reimplementa este metodo se tiene que hacer lo mismo con readObject de
ObjectInputStream. Las excepciones que puede lanzar son:

InvalidClassException Algo esta mal con la clase utilizada por la serializa-

cion.
NotSerializableException Alguno de los objetos que forman parte del ob-
jeto que se desea escribir no implementa la interfaz Serializable.
IOException Excepciones lanzadas por el flujo subyacente.
protected void writeObject(Object obj) throws IOException
Lo usan las subclases para redefinir el metodo writeObject.
public void writeUnshared(Object obj) throws IOException
Escribe el objeto como unico, sin referencias hacia objetos anteriores en
el mismo flujo.
10.9 Lectura y escritura de objetos 402

Como se puede ver de la descripcion de los metodos (y nos faltaron algunos)

la escritura y lectura en flujos de objetos es muy sofisticada, ya que permite
transferir objetos de una aplicacion a otra, conservando cada uno su estado, de
manera transparente y muy efectiva. Cuando se estan ejecutando aplicaciones
donde los datos (en este caso objetos) tiene que transitar por la red, tal vez el
tiempo adicional de escribir/leer en un flujo de objetos no es muy significativo. Sin
embargo, hay que tener presente que la lectura/escritura de objetos es un proceso
lento y que no debiera utilizarse en aplicaciones locales que manejen un numero
grande de datos.
Regresemos a nuestro objetivo de esta seccion que es la de escribir y leer a
flujos con formato de objetos. Nuevamente permitiremos en cualquier momento
de las ejecucion de nuestra aplicacion cargar o descargar objetos a y desde la base
de datos. Pero lo primero que tenemos que hacer es permitir que cada uno de los
objetos que pretendemos escribir implementen a la interfaz Serializable. Lo mas
sencillo sera simplemente agregar este aspecto a nuestra clase Estudiante, y como
esta extiende a InfoEstudiante, ambas tenemos que corregirlas para que implemen-
ten a la interfaz8 . Como InfoEstudiante originalmente implementa interfaces, a las
que no hay que ponerles el calificativo de ser serializables, con estas dos clases ya
cubrimos el requisito de que todas las superclases sean serializables. Tambien hay
que notar que el registro consiste de cadenas y 7un referencia; como las cadenas
son serializables y la referencia tambien lo es, se cubre ampliamente el requisito
de ser serializable. Los cambios hechos a InfoEstudiante y Estudiante se pueden ver
en los listados 10.13 y 10.14 en la pagina opuesta respectivamente.

Codigo 10.13 Cambios a InfoEstudiante (InfoEstudianteSerial) 1/2

1: import j a v a . i o . ;
2: /
3: Base de d a t o s , a b a s e de l i s t a s de r e g i s t r o s , que emula
4: l a l i s t a de un c u r s o de l i c e n c i a t u r a . T i e n e l a s o p c i o n e s
5: n o r m a l e s de una b a s e de d a t o s y f u n c i o n a m e d i a n t e un Menu
6: /
7: c l a s s I n f o E s t u d i a n t e S e r i a l implements D a E s t u d i a n t e , S e r i a l i z a b l e {
......
16: /
17: C o n s t r u c t o r s i n p a r a m e t r o s
18: /

8
Reescribimos estas dos clases agregando al nombre Serial para mantener intacto el trabajo
que realizamos con anterioridad.
403 Entrada y salida

Codigo 10.13 Cambios a InfoEstudiante (InfoEstudianteSerial) 2/2

19: public I n f o E s t u d i a n t e S e r i a l () {
20: nombre = c a r r e r a = c u e n t a = n u l l ;
21: }
22: / C o n s t r u c t o r a p a r t i r de d a t o s de un e s t u d i a n t e .
23: l o s campos v i e n e n s e p a r a d o s e n t r e s p o r comas ,
24: m i e n t r a s que l o s r e g i s t r o s v i e n e n s e p a r a d o s e n t r e s
25: p o r punto y coma .
26: @param S t r i n g , S t r i n g , S t r i n g , S t r i n g l o s v a l o r e s p a r a
27: cada uno de l o s campos que s e van a l l e n a r .
28: @ r e t u r n I n f o E s t u d i a n t e una r e f e r e n c i a a una l i s t a
29: /
30: p u b l i c I n f o E s t u d i a n t e S e r i a l ( S t r i n g nmbre , S t r i n g c nta ,
31: String crrera ) {
32: nombre = nmbre . t r i m ( ) ;
33: cuenta = cnta . trim ( ) ;
34: carrera = c r r e r a . trim ( ) ;
35: }
......

Como ya habamos mencionado, en la lnea 7: le cambiamos el nombre a la

clase y agregamos el que implementa la interfaz Serializable. Por este cambio de
nombre, tambien tuvimos que cambiar el nombre a los constructores lneas 19:
y 30: . De similar manera tenemos que modificar a la clase Estudiante.

Codigo 10.14 Modificaciones a la clase Estudiante (EstudianteSerial) 1/2

1: import j a v a . i o . ;
2:
3: // i m p o r t i c c 1 . i n t e r f a z . C o n s o l a ;
4: /
5: Base de d a t o s , a b a s e de l i s t a s de r e g i s t r o s , que emula l a l i s t a de un
6: c u r s o de l i c e n c i a t u r a . T i e n e l a s o p c i o n e s n o r m a l e s de una b a s e de
7: d a t o s y f u n c i o n a m e d i a n t e un Menu
8: /
9: c l a s s E s t u d i a n t e S e r i a l extends I n f o E s t u d i a n t e S e r i a l
10: implements S e r i a l i z a b l e {
......
13: / C o n s t r u c t o r s i n p a r a m e t r o s /
14: public E s t u d i an t e S e ri al () {
15: super ( ) ;
16: clave = null ;
17: siguiente = null ;
18: s h o r t [ ] tam = { ( s h o r t ) ( tamanhos [ 0 ] + 1 ) ,
19: tamanhos [ 1 ] , tamanhos [ 2 ] , tamanhos [ 3 ] , 2 0 } ;
10.9 Lectura y escritura de objetos 404

Codigo 10.14 Modificaciones a la clase Estudiante (EstudianteSerial) 2/2

20: tamanhos = tam ;
21: }
22: / C o n s t r u c t o r a p a r t i r de d a t o s de un e s t u d i a n t e .
23: l o s campos v i e n e n s e p a r a d o s e n t r e s p o r comas ,
24: m i e n t r a s que l o s r e g i s t r o s v i e n e n s e p a r a d o s e n t r e s
25: p o r punto y coma .
26: @param S t r i n g , S t r i n g , S t r i n g , S t r i n g l o s v a l o r e s p a r a
27: cada uno de l o s campos que s e van a l l e n a r .
28: @ r e t u r n E s t u d i a n t e una r e f e r e n c i a a una l i s t a
29: /
30: p u b l i c E s t u d i a n t e S e r i a l ( S t r i n g nmbre , S t r i n g c nt a ,
31: String crrera , String clve ) {
50: public E s t udi a n t e S e r i a l daSiguiente () {
51: return s i g u i e n t e ;
52: }
53: / A c t u a l i z a e l campo s i g u i e n t e .
54: @params E s t u d i a n t e l a r e f e r e n c i a que s e va a a s i g n a r .
55: /
56: public void p o n S i g u i e n t e ( E s t u d i a n t e S e r i a l s i g ) {
57: siguiente = sig ;
58: }

......

En las lneas 9:, 13:, 30:, 50: y 56: se encuentran las consecuencias de haber
cambiado el nombre a ambas clases de las que hablamos. En la lnea 10: se en-
cuentra la declaracion de que esta clase implementa a la interfaz Serializable, lo
que la hace susceptible de ser escrita o leda de un flujo de objetos.
Dado que la base de datos esta compuesta por objetos de la clase Estudiante
y eso no lo queremos modificar, tenemos que dar metodos que conviertan de
EstudianteSerial a Estudiante y viceversa en la clase EstudianteSerial. Son metodos
sencillos que unicamente copian los campos. El codigo se puede ver en el listado
10.15.

Codigo 10.15 Conversion de Estudiante a EstudianteSerial y viceversa (EstudianteSerial) 1/2

99: /
100: C o n v i e r t e a un e s t u d i a n t e en un e s t u d i a n t e s e r i a l , s i m p l e m e n t e
101: c o p i a n d o l o s campos c o r r e s p o n d i e n t e s .
102: @param nuevo e l E s t u d i a n t e .
103: @ r e t u r n s Un E s t u d i a n t e S e r i a l con e l mismo c o n t e n i d o que nuevo .
104: /
405 Entrada y salida

Codigo 10.15 Conversion de Estudiante a EstudianteSerial y viceversa (EstudianteSerial) 2/2

105: p u b l i c v o i d d a E s t u d i a n t e S e r i a l ( E s t u d i a n t e nuevo ) {
106: nombre = nuevo . daNombre ( ) ;
107: c u e n t a = nuevo . daCuenta ( ) ;
108: c a r r e r a = nuevo . d a C a r r e r a ( ) ;
109: c l a v e = nuevo . d a C l a v e ( ) ;
110: }
111: /
112: C o n v i e r t e a un E s t u d i a n t e S e r i a l en un E s t u d i a n t e c o n s t r u y e n d o
113: uno de e s t o s .
114: @param e l e s t u d i a n t e s e r i a l .
115: @ r e t u r n s un E s t u d i a n t e .
116: /
117: public Estudiante daEstudiante () {
118: S t r i n g nmbre = t h i s . daNombre ( ) ;
119: S t r i n g c n t a = t h i s . daCuenta ( ) ;
120: String c rrera = this . daCarrera ( ) ;
121: S t r i n g c l v e = this . daClave ( ) ;
122: r e t u r n new E s t u d i a n t e ( nmbre , c nt a , c r r e r a , c l v e ) ;
123: }

Habiendo hecho estos cambios, nos avocamos a la clase ListaCursoIO a la

que identificaremos como ListaCursoIOObj para ver los cambios necesarios en el
manejo de nuestra base de datos, que se localizan en la clase MenuListaIOObj.
Lo primero que tenemos que hacer es agregarle al metodo que pide el nombre
del archivo la opcion para que pida un archivo del que se van a leer (o escribir)
objetos, lo que se encuentra en el listado 10.16.

Codigo 10.16 Solicitud de nombre de archivo para flujo de objetos (MenuListaIOObj)

182: p u b l i c S t r i n g pideNombreArch ( B u f f e r e d R e a d e r cons , i n t c a s o )
183: throws I O E x c e p t i o n {
184: S t r i n g m e n s a j e = "Por favor dame el nombre del archivo \n" ;
185: switch ( caso ) {

......
219: case LEEROBJETOS :
220: m e n s a j e += "de donde vas a leer objetos " ;
221: break ;
222: case GUARDAROBJETOS :
223: m e n s a j e += "en donde vas a escribir objetos " ;
224: break ;
......
 10.9 Lectura y escritura de objetos 406

Necesitamos tambien declarar un flujo de objetos, al principio del metodo

daMenu, lo que se encuentra en el listado 10.17.

Codigo 10.17 Declaracion de flujo de objetos (MenuListaIOObj)

267: ObjectInputStream archvoObjetosIn = null ;
268: ObjectOutputStream archvoObjetosOut = n u l l ;

Con esto ya estamos listos para llenar los casos que nos ocupan. El algoritmo
para la lectura de los registros se muestra en la figura 10.17 y como se puede ob-
servar es practicamente identico al de leer registros de un archivo directo, excepto
que por el hecho de leer objetos la maquina virtual se encarga de interpretarlos.

Figura 10.17 Algoritmo para la lectura de objetos

$
'
' Abrir el archivo
'
' $
'
' '
& &Leer el registro actual
Cargar registros
Lectura de Objetos
'
' (mientras haya) '%
'
' Ingresarlo a la base de datos
'
'
%
Cerrar el archivo

En este diagrama no pusimos el manejo de excepciones porque no forman parte

de la logica general del algoritmo. En la figura 10.18 mostramos el diagrama para
la escritura a flujos de objetos, que es sumamente similar al de la lectura.

Figura 10.18 Escritura a un flujo de objetos

$ #
'
' Abrir el archivo
'
' Inicio
'
' Colocarse al principio de la lista
'
'
'
'
'
'
'
& $
'
' Convertir al estudiante actual
Escritura de Objetos '
&
'
' Tomar registro en estudiante serial
'
'
'
' (mientras haya) ' Escribirlo al flujo de objetos
'
' '
'
'
' %
'
' Tomar como actual al siguiente
'
%
Cerrar el archivo
407 Entrada y salida

Antes de proceder con la codificacion de estos esquemas debemos nuevamente

declarar los flujos correspondientes y una variable para almacenamiento temporal
de objetos de la clase EstudianteSerial, as como modificar el menu y el manejo de
las opciones. El codigo correspondiente a esto se encuentra en el listado 10.18.

Codigo 10.18 Caso de lectura de objetos (declaraciones) (MenuListaIOObj)

......
267: ObjectInputStream archvoObjetosIn = null ;
268: ObjectOutputStream archvoObjetosOut = n u l l ;
......
272: EstudianteSerial nuevoSrl = null ;
......
293: + "(F)\ tLeer objetos de flujo \n"
294: + "(G)\ tEscribir objetos en flujo \n"
......
308: o p c i o n = " 0123456789 ABCDEFGZ " . i n d e x O f ( s o p c i o n ) ;

En el listado 10.19 se encuentra el codigo que corresponde al manejo de estos

dos casos en el menu.

Codigo 10.19 Caso de lectura de objetos (MenuListaIOObj) 1/3

......
966: case LEEROBJETOS :
967: try {
968: archvoObjetosIn = null ;
969: s A r c h i v o = pideNombreArch ( cons , LEEROBJETOS ) ;
970: a r c h v o O b j e t o s I n = new O b j e c t I n p u t S t r e a m
971: ( new F i l e I n p u t S t r e a m ( s A r c h i v o ) ) ;
972: i f ( a r c h v o O b j e t o s I n == n u l l ) {
973: System . o u t . p r i n t l n ( "el archivo NO quedo abierto " ) ;
974: } // end o f i f ( a r c h v o O b j e t o s I n == n u l l )
975: boolean yaNoHay = f a l s e ;
976: w h i l e ( ! yaNoHay ) {
977: nuevoSrl = null ;
978: / Cuando s e ac ab a un a r c h i v o de o b j e t o s y s e
979: t r a t a de l e e r s i m p l e m e n t e l a n z a una e x c e p c i o n
980: /
981: try {
982: nuevoSrl =
983: ( EstudianteSerial ) archvoObjetosIn . readObject ( ) ;
10.9 Lectura y escritura de objetos 408

Codigo 10.19 Caso de lectura de objetos (MenuListaIOObj) 2/3

984: } catch ( I O E x c e p t i o n e ) {
985: yaNoHay = t r u e ;
986: } // end o f t r y
c a t c h
987: i f ( yaNoHay ) {
988: continue ;
989: } // end o f i f ( a r c h v o O b j e t o s I n . a v a i l a b l e > 0 )
990: nuevo = n u e v o S r l . d a E s t u d i a n t e ( ) ;
991: miCurso . a g r e g a E s t O r d e n ( nuevo ) ;
992: } // end o f w h i l e ( ( nombre = a r c h i v o I n . r e a d L i n e ( ) . . .
993: } // end o f t r y
994: catch ( C l a s s N o t F o u n d E x c e p t i o n e ) {
995: System . o u t . p r i n t l n ( "Se esta leyendo el archivo equivocado " ) ;
996: } // end o f c a t c h
997: catch ( I n v a l i d C l a s s E x c e p t i o n e ) {
998: System . o u t . p r i n t l n ( "La clase no permite ser serializada " ) ;
999: } // end o f c a t c h
1000: catch ( S t r e a m C o r r u p t e d E x c e p t i o n e ) {
1001: System . o u t . p r i n t l n ( "La descripcion del objeto "
1002: + "es inconsistente " ) ;
1003: } // end o f c a t c h
1004: catch ( O p t i o n a l D a t a E x c e p t i o n e ) {
1005: System . o u t . p r i n t l n ( "No se encontraron objetos sino "
1006: + " datos directos " ) ;
1007: } // end o f c a t c h
1008: catch ( I O E x c e p t i o n e ) {
1009: System . e r r . p r i n t l n ( "No pude abrir archivo " ) ;
1010: } // end o f t r y
c a t c h
1011: catch ( E x c e p t i o n e ) {
1012: System . o u t . p r i n t l n ( "No alcanzaron los datos " ) ;
1013: } // end o f c a t c h
1014: finally {
1015: i f ( a r c h v o O b j e t o s I n != n u l l ) {
1016: try {
1017: archvoObjetosIn . close ( ) ;
1018: } catch ( I O E x c e p t i o n e ) {
1019: System . e r r . p r i n t l n ( "No pude cerrar el"
1020: + " archivo de lectura " ) ;
1021: } // end o f t r y
c a t c h
1022: } // end o f i f ( a r c h i v o I n != n u l l )
1023: } // end o f f i n a l l y
1024: r e t u r n LEEROBJETOS ;
1025:
1026: case GUARDAROBJETOS :
1027: try {
1028: s A r c h i v o = pideNombreArch ( cons , GUARDAROBJETOS ) ;
1029: archvoObjetosOut = null ;
409 Entrada y salida

Codigo 10.20 Caso de lectura de objetos (MenuListaIOObj) 3/3

1030: a r c h v o O b j e t o s O u t = new O b j e c t O u t p u t S t r e a m
1031: ( new F i l e O u t p u t S t r e a m ( s A r c h i v o ) ) ;
1032: System . o u t . p r i n t l n ( "Abr el archivo " ) ;
1033: i f ( a r c h v o O b j e t o s O u t == n u l l ) {
1034: System . o u t . p r i n t l n ( "el archivo NO esta abierto !" ) ;
1035: } // end o f i f ( a r c h v o O b j e t o s O u t == n u l l )
1036: l i s t a = ( ( E s t u d i a n t e ) miCurso . d a L i s t a ( ) ) ;
1037: int contador = 0;
1038: w h i l e ( l i s t a != n u l l ) {
1039: n u e v o S r l = new E s t u d i a n t e S e r i a l ( ) ;
1040: nuevoSrl . daEstudianteSerial ( l i s t a ) ;
1041: archvoObjetosOut . writeObject ( nuevoSrl ) ;
1042: l i s t a = l i s t a . daSiguiente ();
1043: } // end o f w h i l e ( l i s t a != n u l l )
1044: } catch ( S e c u r i t y E x c e p t i o n e ) {
1045: System . o u t . p r i n t l n ( "Se violaron condiciones de seguridad " ) ;
1046: } // end o f c a t c h
1047: catch ( I O E x c e p t i o n e ) {
1048: System . e r r . p r i n t l n ( "No pude abrir archivo " ) ;
1049: } // end o f t r y
c a t c h
1050: finally {
1051: try {
1052: i f ( a r c h v o O b j e t o s O u t != n u l l ) {
1053: archvoObjetosOut . c l o s e ( ) ;
1054: } // end o f i f ( a r c h i v o O u t != n u l l )
1055: } catch ( I O E x c e p t i o n e ) {
1056: System . e r r . p r i n t l n ( "No pude cerrar el archivo " ) ;
1057: } // end o f t r y
c a t c h
1058: } // end o f f i n a l l y
1059: r e t u r n GUARDAROBJETOS ;

Como hasta ahora, la lectura es un poco mas compleja que la escritura, ya

que sabemos lo que estamos escribiendo, pero al tratar de leer pueden venir mal
los datos, no existir el archivo, leer de mas, etc.. Pasamos a explicar unicamente
aquellas lneas de codigo que no sean del todo claras.
Para abrir el archivo de entrada o de salida se construye un flujo de objetos
sobre un flujo de bytes lneas 970:971: y 1030: 1031: ya que esa es la
definicion del constructor de un flujo de objetos.
Se lee el registro a un EstudianteSerial lnea 982: 983: , pero como la lista
que tenemos es de objetos de la clase Estudiante, lo tendremos que convertir antes
de agregarlo a la lista. En el caso de flujos de objetos no tenemos un indicador
adecuado de cuando se acabo el archivo y lo unico que podemos usar es la excep-
10.10 Colofon 410

cion de entrada y salida que se va a alcanzar cuando ya no pueda leer del flujo.
Por ello, colocamos estas lneas en un bloque trycatch 981: a 986: que atrape
la excepcion y simplemente prenda una variable para avisar que ya no hay datos.
En las lneas 987: a 989: se detecta que ya se alcanzo el fin de archivo (o que no
se pudo leer) y se regresa al encabezado del while, para evitar tratar de procesar
datos erroneos.
Finalmente, en las lneas 990: y 991: se obtiene un objeto Estudiante a partir
del que se leyo y se agrega a la lista.
Las clausulas catch externas a la lectura y que corresponden unicamente al caso
de lectura lneas 994: a 1013: simplemente proporcionan un mensaje de error
de que es lo que sucedio, lo mismo que las clausulas catch del caso de escritura a
flujo de objetos lneas 1044: a 1049: .
En ambos casos que nos ocupan tenemos una clausula finally que se encarga de
cerrar el archivo, preguntando antes si es que el archivo fue abierto adecuadamente
lneas 1015: a 1022: en lectura y 1050: a 1058: en escritura que ademas tiene
que estar, nuevamente, en un bloque try-catch para el caso en que se lance una
excepcion.
Es interesante ver con un visor de texto en ASCII un archivo creado como
flujo de objetos ya que se ve, de alguna manera, la gran cantidad de informacion
que se encuentra adicional a los datos mismos. Esto se debe a que con cada
objeto se tiene que describir al mismo, lo que sucede ya que en un mismo flujo de
objetos podemos escribir objetos de distintas clases y al leerlos, automaticamente
se carga la descripcion que trae consigo el objeto. Es por eso que la lectura siempre
es de un Object y se tiene que hacer un cast para obtener el objeto que creemos
estamos leyendo. Para decodificar un objeto de un flujo del que no sabemos a
que clase pertenece, podemos utilizar la clase Class que proporciona toda clase de
herramientas para ello.

10.10 Colofon

Revisamos varias clases de flujos de entrada y salida, pero de ninguna manera

fuimos exhaustivos. Sin embargo, los conceptos vertidos en este captulo deber
servir de plataforma para poder revisar (y utilizar adecuadamente) flujos de otras
clases que no hayan sido tratados. Una revision completa de toda la entrada y
salida que ofrece Java esta mas alla del alcance de este material.
 Hilos de ejecucion
11
11.1 Que es un hilo de ejecucion?

Hasta ahora, cada vez que ejecutamos un programa estamos trabajando de

solamente sobre el programa. Sin embargo, cualquier sistema operativo moderno
tiene mas de un programa trabajando al mismo tiempo: el servidor de impresion,
el shell, los demonios para correo electronico, etc. Cada uno de estos programas
constituyen un hilo de ejecucion thread, proceso, tarea que trabaja indepen-
diente de otros procesos y que usan un juego comun de datos.

Un ejemplo mas sencillo y mas usual es el manejo de las cuentas de cheques

de un banco. El banco cuenta con su base de datos y tenemos a miles de cajeros
teniendo acceso a la base de datos, cada cajero en su propio hilo de ejecucion. No
sera pensable que fuera un unico proceso el que se encargara de todos los accesos.
Decimos entonces que tenemos procesos o hilos de ejecucion concurrentes, ya que
concurren a un mismo conjunto de datos o recursos.
11.2 La clase Thread 412

11.2 La clase Thread

En Java tenemos la posibilidad de que un proceso lance, a su vez, a otros

procesos. En principio, los procesos lanzados pueden o no mantener comunicacion
con el proceso padre que los lanzo. Asimismo, los procesos lanzados, a diferencia
de los metodos invocados, no regresan al lugar desde el que se les lanzo. Pero
tienen acceso a todos los recursos y atributos con que cuenta el metodo que los
haya lanzado.
La clase Thread es la encargada de iniciar hilos de ejecucion independientes.
Es una clase muy extensa que tiene muchsimos metodos y atributos. En este
momento nos interesan dos metodos: el que define al hilo de ejecucion, run(), y el
que lo inicia, start().
Si deseamos que de una clase se puedan crear hilos de ejecucion independientes
hacemos que extienda a Thread y que tenga un metodo run(). Veamos el ejemplo
de una clase que lanza dos hilos de ejecucion independientes en el listado 11.1.

Codigo 11.1 Objeto que lanza dos hilos de ejecucion 1/2

1: p u b l i c c l a s s PingPong extends Thread {

2: p r i v a t e S t r i n g word ;
3: private int delay ;
4:
5: p u b l i c PingPong ( S t r i n g whatToSay , i n t d e l a y T i m e ) {
6: word = whatToSay ;
7: d e l a y = delayTime ;
8: }
9:
10: public void run ( ) {
11: System . e r r . p r i n t l n ( " Empezo :"+Thread . c u r r e n t T h r e a d ( ) . getName ( ) ) ;
12: try {
13: while ( true ) {
14: System . o u t . p r i n t ( word + " " ) ;
15: Thread . s l e e p ( d e l a y ) ;
16: }
17: } catch ( I n t e r r u p t e d E x c e p t i o n e ) {
18: return ; // Termina e s t e h i l o de e j e c u c i o n
19: }
20: }
413 Hilos de ejecucion

Codigo 11.1 Objeto que lanza dos hilos de ejecucion 2/2

21: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
22: System . o u t . p r i n t l n ( " Nombre : " + c u r r e n t T h r e a d ( ) . getName ( ) ) ;
23: new PingPong ( "ping" , 3 3 ) . s t a r t ( ) ; // 1/30 de s e g u n d o
24: new PingPong ( "pong" , 1 0 0 ) . s t a r t ( ) ; // 1/10 de s e g u n d o
25: }
26: }

En el listado 11.1 en la pagina opuesta la clase PingPong extiende a la clase

Thread, por lo que tendra que redefinir su propio metodo run() el de Thread no
hace nada lo que hace en las lneas 10: a 20:. Esto es lo que va a hacer el hilo
de ejecucion, cuando sea lanzado. Se inicia un nuevo hilo de ejecucion cuando se
invoca al metodo start() de un objeto, cuya clase extiende a Thread lneas 23:2
y 24: del listado 11.1 en la pagina opuesta.
En la lnea 11: aparecen dos invocaciones a dos metodos de Thread. El metodo
currentThread() es un metodo estatico de la clase Thread y regresa un objeto de
tipo Thread poda haber sido llamada sin precederlo del nombre de la clase. El
metodo getName() regresa una cadena, que es el nombre del hilo de ejecucion que
se lanzo. El nombre del hilo de ejecucion es un atributo del mismo. Tambien en la
lnea 15: se encuentra un metodo estatico de la clase Thread, el metodo sleep(delay).
Este metodo suspende la ejecucion del hilo durante el tiempo estipulado.

Figura 11.1 Salida de PingPong.

java PingPong
Nombre: main
Empezo:Thread-0
ping Empezo:Thread-1
pong ping ping pong ping ping pong ping ping ping pong ping ping
pong ping ping pong ping ping pong ping ping pong ping ping ping
pong ping ping pong ping ping pong ping ping pong ping ping pong
ping ping ping pong ping ping pong ping ping pong ping ping pong
ping ping pong ping ping ping pong ping ping pong ping ping pong
ping ping pong ping ping pong ping ping ping pong ping ping pong
ping ping pong ping ping pong ping ping pong ping ping ping pong
ping ping pong ping ping pong ping ping pong ping ping pong ping
ping ping pong ping ping pong ping

La clase PingPong podra no tener metodo main. Lo ponemos para hacer una
demostracion de esta clase. En la lnea 22: nuevamente invocamos a los metodos
11.2 La clase Thread 414

currentThread y getName para que nos indiquen el nombre del hilo donde aparece
esa solicitud. A continuacion creamos dos objetos anonimos y les solicitamos que
cada uno de ellos inicie su hilo de ejecucion con el metodo start().
La ejecucion del metodo main de esta clase produce la salida que se observa
en la figura 11.1 en la pagina anterior.
Como se puede observar en la figura 11.1 en la pagina anterior, mientras que
el nombre del proceso que esta ejecutandose inmediatamente antes de lanzar los
hilos de ejecucion se llama main, que es el que tiene, los hilos de ejecucion lanzados
tienen nombres asignados por el sistema. Podamos haberles asignado nosotros un
nombre al construir a los objetos. Para eso debemos modificar al constructor de la
clase PingPong e invocar a un constructor de Thread que acepte como argumento
a una cadena, para que esta sea el nombre del hilo de ejecucion. Los cambios a
realizar se pueden observar en el listado 11.2. La salida que produce se puede ver
en la figura 11.2 en la pagina opuesta.

Codigo 11.2 Asignacion de nombres a los hilos de ejecucion

1: p u b l i c c l a s s NombrePingPong extends Thread {
2: p r i v a t e S t r i n g word ;
3: private int delay ;
4:
5: p u b l i c NombrePingPong ( S t r i n g whatToSay , i n t de l a y Ti m e ,
6: S t r i n g name ) {
7: super ( name ) ;
8: word = whatToSay ;
9: d e l a y = delayTime ;
10: }

. . . // El metodo run() queda exactamente igual

20: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
21: System . o u t . p r i n t l n ( " Nombre : "+ c u r r e n t T h r e a d ( ) . getName ( ) ) ;
22: / 1/30 de s e g u n d o : /
23: new NombrePingPong ( "ping" , 3 3 , "Ping" ) . s t a r t ( ) ;
24: / 1/10 de s e g u n d o : /
25: new NombrePingPong ( "pong" , 1 0 0 , "Pong" ) . s t a r t ( ) ;
26: }
27: }

Ejecucion del metodo run()

Una vez iniciado el hilo de ejecucion, el metodo run() va a proseguir su ejecucion
hasta que una de tres cosas sucedan:
i. El metodo se encuentra un return, en cuyo caso simplemente termina su
415 Hilos de ejecucion

ejecucion.

ii. El metodo llega al final de su definicion.

iii. Se presenta una excepcion en el metodo.

Debe quedar claro que en el caso de hilos de ejecucion, cuando uno termina su
ejecucion no es que regrese al lugar desde el que se le lanzo, sino que simplemente
se acaba. El hilo de ejecucion, una vez lanzado, adquiere una vida independiente,
con acceso a los recursos del objeto desde el cual fue lanzado.

Figura 11.2 Salida con asignacion de nombres.

java NombrePingPong
Nombre: main
Empezo:Ping
ping Empezo:Pong
pong ping ping pong ping ping pong ping ping ping pong
ping ping pong ping ping pong ping ping pong ping ping
pong ping ping ping pong ping ping pong ping ping pong
ping ping pong ping ping pong ping ping ping pong ping
ping pong ping ping pong ping ping pong ping ping pong
ping ping ping pong ping ping pong ping ping pong ping
ping pong ping ping pong ping ping ping pong ping ping
pong ping ping pong ping ping pong ping ping pong ping
ping ping pong ping ping pong ping ping pong ping ping
pong ping ping pong ping

11.3 La interfaz Runnable

Java proporciona otra manera de lanzar hilos de ejecucion, que es median-

te clases que implementan a la interfaz Runnable. Esta interfaz solo declara un
metodo, run(), por lo que una clase que implemente a esta interfaz, sus obje-
tos tambien pueden lanzar hilos de ejecucion independientes. Veamos la clase del
PingPong programada implementando a la interfaz Runnable en el listado 11.3 en
la siguiente pagina.
11.3 La interfaz Runnable 416

Codigo 11.3 Hilos de ejecucion con la interfaz Runnable

1: c l a s s RunPingPong implements R u n n a b l e {
2: p r i v a t e S t r i n g word ;
3: private int delay ;
4:
5: RunPingPong ( S t r i n g whatToSay , i n t d e l a y T i m e ) {
6: word = whatToSay ;
7: d e l a y = delayTime ;
8: }
9:
10: public void run ( ) {
11: System . o u t . p r i n t l n ( "El nombre del hilo de ejecucion es: " +
12: Thread . c u r r e n t T h r e a d ( ) . getName ( ) ) ;
13: try {
14: for ( ; ; ) {
15: System . o u t . p r i n t ( word + " " ) ;
16: Thread . s l e e p ( d e l a y ) ;
17: }
18: } catch ( I n t e r r u p t e d E x c e p t i o n e ) {
19: return ;
20: }
21: }
22:
23: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
24: R u n n a b l e p i n g = new RunPingPong ( "ping" , 3 3 ) ;
25: R u n n a b l e pong = new RunPingPong ( "pong" , 1 0 0 ) ;
26: new Thread ( p i n g , "Ping" ) . s t a r t ( ) ;
27: new Thread ( pong , "Pong" ) . s t a r t ( ) ;
28: }
29: }

La clase RunPingPong se declara implementando Runnable. Al igual que cuando

se extiende a la clase Thread, RunPingPong debe definir su propio metodo run(),
que es lo que va a hacer el hilo de ejecucion una vez lanzado. Basicamente hace
lo mismo que haca la clase PingPong, que era una extension de Thread. Donde
cambia un poco el asunto es al crear los hilos de ejecucion. Si vemos las lneas que
corresponden a main, primero se crean objetos de tipo Runnable se pueden crear
objetos de este tipo, ya que Runnable esta implementada en RunPingPong y se
asignan en esas referencias a objetos tipo RunPingPong. Una vez hecho esto, se
construyen hilos de ejecucion lneas 24: y 25: para cada uno de los objetos y se
lanzan mediante el metodo start. En esta ocasion, al construir el hilo de ejecucion
le estamos asignando un nombre, mediante el segundo argumento al constructor
de la clase Thread.
417 Hilos de ejecucion

Una ejecucion de este programa produce lo que se ve en la figura 11.3. Es

importante aclarar que dos ejecuciones de RunPingPong pueden o no dar la misma
salida. La maquina virtual de Java (JVM) no puede garantizar el orden en que
llegan los procesos a la pantalla. Notese tambien que no se mezclan las palabras
ping y pong en la misma. Esto es porque una vez que System.out empieza
a escribir desde uno de los hilos de ejecucion, no suelta la pantalla hasta que
termina.

Figura 11.3 Salida de RunPingPong.

java RunPingPong
El nombre del hilo de ejecucion es: Ping
ping El nombre del hilo de ejecucion es: Pong
pong ping ping pong ping ping pong ping ping pong ping ping ping
pong ping ping pong ping ping pong ping ping pong ping ping pong
ping ping ping pong ping ping pong ping ping pong ping ping pong
ping ping pong ping ping ping pong ping ping pong ping ping pong
ping ping pong ping ping pong ping ping ping pong ping ping pong
ping ping pong ping ping pong ping ping pong ping ping ping pong
ping ping pong ping ping pong ping ping pong ping ping pong ping
ping ping pong ping ping pong ping ping pong ping ping pong ping
ping pong ping ping ping pong ping ping pong ping ping pong ping
ping pong ping ping pong ping ping ping pong ping ping pong ping
ping pong ping ping pong ping

11.3.1. Constructores de la clase Thread

Hasta ahora hemos visto cuatro constructores para objetos de la clase Thread:
public Thread()
Es el constructor por omision. Construye un hilo de ejecucion anonimo, al
que el sistema le asignara nombre. Cuando una clase que extiende a Thread
no invoca a ningun constructor de la superclase, este es el constructor que
se ejecuta.
public Thread(String name)
Este construye un hilo de ejecucion y la asigna el nombre dado como argu-
mento.
11.4 Sincronizacion de hilos de ejecucion 418

public Thread(Runnable target)

Usa el metodo run() de la clase que implementa a Runnable para ejecutarse.
public Thread(Runnable target, String name)
Construye un Thread con el nombre especificado y usa el metodo run() de
la clase que implementa a Runnable.
El problema con implementar a traves de Runnable es que el metodo run() es
publico y entonces lo podra ejecutar cualquiera que tuviera acceso a la clase. Una
manera de evitar esto es declarando una clase interna anonima para que no se
tenga acceso al metodo run().
Cuando hay mas de un hilo de ejecucion en un programa se corre el riesgo de
que uno de ellos corrompa la informacion del otro. A los puntos en los que esto
puede suceder se les llama regiones crticas y se evita la interferencia sincronizando
las actividades de esas regiones crticas.
Se sincroniza el acceso a datos comunes a traves de candados (lock s). El proceso
que quiere trabajar sobre algun dato comun, adquiere el candado de los objetos
sobre los que va a trabajar. Todo objeto tiene un candado. Para trabajar con ese
objeto, cualquier hilo de ejecucion debe encontrar el candado disponible. Se usa
el termino codigo sincronizado para aquel codigo que se encuentra en un metodo
o enunciado sincronizado.

11.4 Sincronizacion de hilos de ejecucion

11.4.1. Metodos sincronizados

Un objeto que va a ser usado simultaneamente por mas de un hilo de ejecucion

declara a los metodos peligrosos como sincronizados (synchronized). Cuando
se solicita la ejecucion de un metodo sincronizado, el hilo de ejecucion primero
adquiere el candado sobre el objeto. Realiza la ejecucion solicitada, y al terminar
el metodo libera el candado del objeto. Si otro hilo de ejecucion intenta ejecutar
cualquiera de los metodos sincronizados del objeto, se bloqueara y esperara hasta
que el candado del objeto este disponible. Si los metodos no son sincronizados
podran trabajar sobre el objeto independientemente del estado del candado.
Para evitar que algun hilo de ejecucion se bloquee a s mismo, el dueno del
candado es el hilo de ejecucion mismo. Por lo tanto, si se encuentra ejecutando
algun metodo sincronizado sobre cierto objeto, la ejecucion de mas metodos, sin-
419 Hilos de ejecucion

cronizados o no, sobre el mismo objeto procedera sin problemas, ya que el hilo
de ejecucion posee el candado respectivo. El candado se libera cuando el hilo de
ejecucion termina de ejecutar el primer metodo sincronizado que invoco, que es el
que le proporciono el candado. Si esto no se hiciera as, cualquier metodo recursivo
o de herencia, por ejemplo, bloqueara la ejecucion llegando a una situacion en la
que el hilo de ejecucion no puede continuar porque el candado esta comprometi-
do (aunque sea consigo mismo), y no puede liberar el candado porque no puede
continuar.
El candado se libera automaticamente en cualquiera de estos tres casos:

El metodo termina normalmente porque se encuentra un enunciado return.

El metodo termina normalmente porque llego al final de su cuerpo.

El metodo termina anormalmente lanzando una excepcion.

El hecho de que la liberacion del candado sea automatica libera al programador

de la responsabilidad de adquirir y liberar el candado, evitando as que algun
objeto quede congelado porque se olvidaron de liberar su candado.
Para manejar una cuenta de cheques desde varias posibles terminales, el codigo
se hara como se muestra en el listado 11.4.

Codigo 11.4 Manejo sincronizado de una cuenta de cheques 1/2

1: c l a s s S o b r e g i r a d o E x c e p t i o n extends E x c e p t i o n {
2: p u b l i c S o b r e g i r a d o E x c e p t i o n ( S t r i n g msg ) {
3: super ( msg ) ;
4: }
5: }
6:
7: c l a s s Cuenta {
8: p r i v a t e double b a l a n c e ;
9:
10: p u b l i c Cuenta ( double d e p o s i t o I n i c i a l ) {
11: balance = d e p o s i t o I n i c i a l ;
12: }
13:
14: p u b l i c s y n c h r o n i z e d double g e t B a l a n c e ( ) {
15: return balance ;
16: }
17:
18: p u b l i c s y n c h r o n i z e d v o i d d e p o s i t o ( double c a n t i d a d ) {
19: b a l a n c e += c a n t i d a d ;
20: }
11.4 Sincronizacion de hilos de ejecucion 420

Codigo 11.4 Manejo sincronizado de una cuenta de cheques 2/2

21: p u b l i c s y n c h r o n i z e d v o i d c h e q u e ( double c a n t i d a d )
22: throws S o b r e g i r a d o E x c e p t i o n {
23: i f ( b a l a n c e >= c a n t i d a d ) {
24: b a l a n c e
= c a n t i d a d ;
25: }
26: else {
27: throw new S o b r e g i r a d o E x c e p t i o n ( " Cuenta sobregirada " ) ;
28: }
29: }
30: }

Revisemos con cuidado la sincronizacion que pedimos en la clase Cuenta. El

constructor no esta sincronizado, porque la creacion de una nueva cuenta puede
hacerse unicamente desde un solo hilo. Ademas, los constructores no pueden estar
sincronizados. Pero debemos proteger al atributo balance, ya que no puede suceder
al mismo tiempo que sea modificado y se solicite su valor. Tampoco puede suceder
que sea modificado en direcciones opuestas.
En estos momentos debe quedar claro por que se ha elegido declarar los campos
de datos como privados (o en el mejor de los casos, protegidos) y definir metodos
de acceso y modificacion. Si los campos fueran declarados publicos o de paquete,
no habra manera de protegerlos de accesos invalidos desde multiples hilos de
ejecucion.
Con la declaracion de synchronized se garantiza que dos o mas hilos de eje-
cucion no van a interferirse entre s. Lo que no se puede garantizar es el orden
en que se van a ejecutar los distintos hilos de ejecucion. Si dos hilos presentan
solicitudes simultaneas, es impredecible cual de ellas va a ser atendida primero.
Para garantizar el orden de ejecucion frente a procesos simultaneos, los hilos de
ejecucion tienen que coordinarse entre s de alguna manera que va a depender de
la aplicacion.

11.4.2. Sincronizacion de metodos y la herencia

Cuando el metodo sincronizado de una superclase se extiende mediante he-

rencia, el metodo de la subclase puede o no estar sincronizado. El programador
podra programar la subclase de tal manera que ya no hubiera la posibilidad de
interferir o ser interferido por algun otro hilo de ejecucion. Sin embargo, si el
metodo no sincronizado de la subclase invoca al metodo sincronizado de la su-
421 Hilos de ejecucion

perclase, esta invocacion debera estar sincronizada. A la inversa tambien puede

suceder: un metodo no sincronizado en la superclase puede extenderse a un metodo
sincronizado en la subclase.

11.4.3. Metodos estaticos sincronizados

Tambien los datos estaticos de las clases se pueden sincronizar, utilizando

para ello metodos estaticos. Cuando algun hilo de control ejecuta alguno de estos
metodos, ningun otro hilo de control podra invocarlos, exactamente de la misma
manera que con los metodos que pertenecen a objetos. Sin embargo, los objetos
de la clase si podran ser usados por otros hilos de control, ya que el candado se
referira unicamente al objeto que representa a la clase, no a los objetos de ese
tipo.

11.4.4. Enunciados sincronizados

Puede suceder que queramos sincronizar el acceso no unicamente al objeto

vigente (this), sino de cualquier otro objeto involucrado en nuestro codigo, y no
queremos que la sincronizacion dure todo el metodo, sino unicamente mientras se
ejecutan ciertos enunciados. Podemos entonces sincronizar un pedazo de codigo
con la siguiente sintaxis:

Sintaxis:
xenunciado de sincronizaciony::= synchronized( xexpry) {
xenunciadosy
}
Semantica:
La xexpry tiene que regresar una referencia a un objeto. Mientras se ejecu-
tan los xenunciadosy, el objeto referido en la xexpry queda sincronizado. Si
se desea sincronizar mas de un objeto, se recurrira a enunciados de estos
anidados. El candado quedara liberado cuando se alcance el final de los
enunciados, o si se lanza alguna excepcion dentro del grupo de enunciados.

Veamos un ejemplo de sincronizacion de un grupo de enunciados en el lista-

do 11.5 en la siguiente pagina.
11.4 Sincronizacion de hilos de ejecucion 422

Codigo 11.5 Sincronizacion selectiva sobre objetos

1: //




Cambiar a l o s e l e m e n t o s de un a r r e g l o
2: //




p o r s u v a l o r a b s o l u t o






3: public s t a t i c void abs ( i n t [ ] v a l o r e s ) {
4: synchronized ( v a l o r e s ) {
5: f o r ( i n t i = 0 ; i < v a l o r e s . l e n g t h ; i ++)
6: i f ( v a l o r e s [ i ] < 0)
7: v a l o r e s [ i ] =
v a l o r e s [ i ] ;
8: }
9: }

A este tipo de sincronizacion se le conoce como sincronizacion del cliente,

porque son los usuarios del objeto los que se ponen de acuerdo para sincronizar su
uso. Por ejemplo, en el caso de los arreglos, no hay otra manera de sincronizarlos,
ya que no tenemos acceso a los metodos para sincronizarlos desde el servidor.
Los enunciados de sincronizacion permiten:
Mantener con candado a un objeto el menor tiempo posible (unicamente el
indispensable).
Adquirir el candado de otros objetos diferentes de this.
Veamos un ejemplo de sincronizacion con objetos distintos de this en el lista-
do 11.6.

Codigo 11.6 Sincronizacion de variables primitivas en enunciados 1/2

1: c l a s s G r u p o s S e p a r a d o s {
2: p r i v a t e double a V a l = 0 . 0 ;
3: p r i v a t e double bVal = 1 . 1 ;
4: p r o t e c t e d O b j e c t l o c k A = new O b j e c t ( ) ;
5: p r o t e c t e d O b j e c t l o c k B = new O b j e c t ( ) ;
6:
7: p u b l i c double getA ( ) {
8: synchronized ( lockA ) {
9: return aVal ;
10: }
11: }
12:
13: p u b l i c v o i d s e t A ( double v a l ) {
14: synchronized ( lockA ) {
15: aVal = v a l ;
16: }
17: }
423 Hilos de ejecucion

Codigo 11.6 Sincronizacion de variables primitivas en enunciados 2/2

18: p u b l i c double getB ( ) {
19: synchronized ( lockB ) {
20: r e t u r n bVal ;
21: }
22: }
23:
24: p u b l i c v o i d s e t B ( double v a l ) {
25: synchronized ( lockB ) {
26: bVal = v a l ;
27: }
28: }
29:
30: public void r e s e t ( ) {
31: synchronized ( lockA ) {
32: synchronized ( lockB ) {
33: a V a l = bVal = 0 . 0 ;
34: }
35: }
36: }
37: }

Este tipo de sincronizacion la hace el servidor. Elige sincronizar unicamente a

los datos primitivos del objeto, y cada uno de estos datos independiente del otro.
Lo consigue restringiendo el acceso a los mismos unicamente a traves de metodos
de la clase, donde asocia a un objeto arbitrario para que maneje el candado de cada
uno de los datos. De esta manera, como el hilo de ejecucion que llega al proceso
adquiere el candado del objeto, ningun otro hilo de ejecucion puede entrar a la
region crtica hasta que el primero que llego libere el candado. En el metodo
reset() se adquieren ambos candados antes de entrar a la region crtica, que es la
que modifica el valor de los datos primitivos. Como ya habamos mencionado, si
queremos sincronizar con mas de un objeto simplemente anidamos los enunciados
de sincronizacion. Cualquier hilo de ejecucion que intente ejecutar la region crtica
tendra que librar ambos obstaculos.
Lo que se pretende con la sincronizacion es que un metodo (o grupo de enuncia-
dos) se ejecuten como si fueran atomicos, esto es, que nada los interrumpa desde
que empiezan a ejecutarse hasta que llegan al final. Por supuesto que estamos
hablando de la ejecucion del bytecode en la JVM, donde cada enunciado escrito en
Java se traduce a varios enunciados del lenguaje de maquina. Por lo tanto, algun
otro proceso concurrente podra ejecutarse antes de que se termine de ejecutar el
enunciado peligroso.
11.5 Comunicacion entre hilos de ejecucion 424

11.4.5. Modelos de sincronizacion

Regresemos al esquema de cliente-servidor en el cual el objeto que da el servicio

es el servidor mientras que el que lo solicita es el cliente. La pregunta importante
en la sincronizacion es quien debera ser el responsable de la misma? Trataremos
de dar algunas ideas al respecto.
En general en la orientacion a objetos, como cada objeto se conoce a s mismo
debe encargarse de su propia sincronizacion, esto es, de protegerse en regiones
crticas de manera adecuada. Esto respondera a que sea el servidor, el proveedor
de servicios, el encargado de manejar la sincrona. Pero pudiera suceder que el
disenador de la clase que va a dar los servicios no penso en que sus objetos fue-
ran usados concurrentemente. En ese caso, sera la responsabilidad del cliente el
manejar la sincronizacion entre los distintos procesos que quieran trabajar sobre
algun objeto.
El problema de sincronizacion es complejo y en algunos casos puede llevar a lo
que se conoce como un abrazo mortal deadlock en el que un proceso esta espe-
rando adquirir un candado que no es soltado por otro procesa que espera adquirir
el candado que tiene el primer proceso. De esta manera, ambos procesos estan
esperando a que el otro proceso libere el candado que necesitan para proseguir.

11.5 Comunicacion entre hilos de ejecucion

Si bien el mecanismo de sincronizacion evita que los procesos interfieran unos

con otros, no tenemos hasta el momento ninguna manera de que los hilos de eje-
cucion se comuniquen entre s. Por ejemplo, en el caso del servidor de impresora
debe suceder que cuando la cola de impresion este vaca, el servidor de impre-
sora libere el recurso y espere hasta que algun trabajo de impresion ingrese a la
misma. Si no es as, el servidor esta trabajando inutilmente, revisando la cola
continuamente hasta que haya algo, pero manteniendo en su poder el candado, lo
que no permitira que ningun objeto ingresara a la cola. Asimismo, para que esto
funcione adecuadamente, se requiere que el proceso que coloca elementos en la
cola avise a los procesos que estan esperando que ya hay algo que sacar. Tenemos,
entonces, dos aspectos en este tipo de comunicacion: por un lado, el proceso que
esta dispuesto a esperar a que algo suceda, y por el otro el proceso que logra que
algo suceda y lo notifica.
425 Hilos de ejecucion

La forma general para que un proceso espere a que una condicion se cumpla es
s y n c h r o n i z e d v o i d doWhenCondition ( ) {
while ( ! c o n d i c i o n )
wait ( ) ;
// . . . Se h a c e l o que s e t i e n e que h a c e r cuando l a
// c o n d i c i o n e s v e r d a d e r a
}
Cuando se usa el enunciado wait se deben considerar los siguientes puntos:
Como hay varios hilos de ejecucion, la condicion puede cambiar de estado
aun cuando este hilo de ejecucion no este haciendo nada. Sin embargo, es
importante que estos enunciados esten sincronizados. Si estos enunciados no
estan sincronizados, pudiera suceder que el estado de la condicion se hiciera
verdadero, pero entre que este codigo sigue adelante, algun otro proceso hace
que vuelva a cambiar el estado de la condicion. Esto hara que este proceso
trabajara sin que la condicion sea verdadera.
La definicion de wait pide que la suspension del hilo de ejecucion y la libera-
cion del candado sea una operacion atomica, esto es, que nada pueda suceder
ni ejecutarse entre estas dos operaciones. Si no fuera as podra suceder que
hubiera un cambio de estado entre que se libera el candado y se suspende
el proceso, pero como el proceso ya no tiene el candado, la notificacion se
podra perder.
La condicion que se esta probando debe estar siempre en una iteracion, para
no correr el riesgo de que entre que se prueba la condicion una unica vez y
se decide que hacer, la condicion podra cambiar otra vez.
Por otro lado, la notificacion de que se cambio el estado para una condicion
generalmente toma la siguiente forma:
synchronized v o i f changeCondition ( ) {
// . . . Cambia a l g u n v a l o r que s e u s a en l a p r u e b a
// de l a c o n d i c i o n
notifyAll (); // o b i e n n o t i f y ( )
}
Si se usa notifyAll() todos los procesos que estan en estado de espera que eje-
cutaron un wait() se van a despertar, mientras que notify() unicamente despierta
a un hilo de ejecucion. Si los procesos estan esperando distintas condiciones se
debe usar notifyAll(), ya que si se usa notify() se corre el riesgo de que despierte un
proceso que esta esperando otra condicion. En cambio, si todos los procesos estan
esperando la misma condicion y solo uno de ellos puede reiniciar su ejecucion, no
es importante cual de ellos se despierta.
11.5 Comunicacion entre hilos de ejecucion 426

Volvamos al ejemplo del servidor de impresora, pero incluyendo ahora un hilo

de ejecucion que produce trabajos de impresion.

11.5.1. Ejemplo: un servidor de impresora

Como sabemos a estas alturas, en los sistemas Unix las impresoras estan conec-
tadas a los usuarios a traves de un servidor de impresion. Cada vez que un usuario
solicita la impresion de algun trabajo, lo que en realidad sucede es que se arma la
solicitud del usuario y se forma en una cola de impresion, que es atendida uno a la
vez. En una estructura de datos tipo cola, el primero que llega es el primero que
es atendido. Por supuesto que el manejo de la cola de impresion se tiene que hacer
en al menos dos hilos de ejecucion: uno que forma a los trabajos que solicitan ser
impresos y otra que los toma de la cola y los imprime. En el listado 11.7 vemos
la implementacion de una cola generica o abstracta (sus elementos son del tipo
Object) usando para ello listas ligadas. Como los elementos son objetos, se puede
meter a la cola cualquier tipo de objeto, ya que todos heredan de Object. Se usa
para la implementacion listas ligadas, ya que siendo generica no hay una idea de
cuantos elementos podran introducirse a la cola. Cuando se introduce algun ele-
mento a la cola en el metodo add, se notifica que la cola ya no esta vaca. Cuando
se intenta sacar a un elemento de la cola, si la cola esta vaca, el metodo take entra
a una espera, que rompe hasta que es notificado de que la cola ya no esta vaca.

Codigo 11.7 Cola generica con operaciones sincronizadas 1/2

1: c l a s s Queue {
2: / P r i m e r o y u l t i m o e l e m e n t o s de l a c o l a /
3: p r i v a t e C e l l head , t a i l ;
4:
5: p u b l i c s y n c h r o n i z e d v o i d add ( O b j e c t o ) {
6: C e l l p = new C e l l ( o ) ; // E n v o l v e r a o en una C e l l
7:
8: i f ( t a i l == n u l l ) {
9: head = p ;
10: }
11: else {
12: t a i l . setNext (p ) ;
13: }
14: p . setNext ( null ) ;
427 Hilos de ejecucion

Codigo 11.7 Cola generica con operaciones sincronizadas 2/2

15: tail = p;
16: notifyAll (); // A v s a l e a l o s que e s p e r a n ,
17: // e l o b j e t o f u e a n a d i d o
18: }
19: public synchronized Object take ( )
20: throws I n t e r r u p t e d E x c e p t i o n {
21: w h i l e ( head == n u l l )
22: wait ( ) ; // E s p e r a un o b j e t o en l a c o l a
23: C e l l p = head ; // R e c u e r d a a l p r i m e r o b j e t o
24: head = head . g e t N e x t ( ) ; // Q u t a l o de l a c o l a
25: i f ( head == n u l l )
26: t a i l = null ;
27: return p . getElement ( ) ;
28: }
29: }

La definicion de cada uno de los elementos de la cola se encuentra en el lista-

do 11.8.

Codigo 11.8 Definicion de elementos de la cola

1: c l a s s C e l l {
2: private C e l l next ;
3: private Object element ;
4: public C e l l ( Object element ) {
5: this . element = element ;
6: }
7: public C e l l ( Object element , C e l l next ) {
8: this . element = element ;
9: this . next = next ;
10: }
11: public Object getElement () {
12: return element ;
13: }
14: p u b l i c v o i d s e t E l e m e n t ( O b j e c t E l e m e nt ) {
15: this . element = element ;
16: }
17: public C e l l getNext () {
18: return next ;
19: }
20: public void setNext ( C e l l next ) {
21: this . next = next ;
22: }
23: }
11.5 Comunicacion entre hilos de ejecucion 428

En el listado 11.9 tenemos la definicion concreta de lo que es un trabajo de

impresion. Se redefine el metodo toString() de Object para poder escribir el trabajo
directamente en la impresora.

Codigo 11.9 PrintJob: trabajo de impresion

1: p u b l i c c l a s s P r i n t J o b {
2: p r i v a t e i n t numLines ;
3: p r i v a t e S t r i n g name ;
4: p u b l i c P r i n t J o b ( S t r i n g name , i n t numLines ) {
5: t h i s . name = name ;
6: t h i s . numLines = numLines ;
7: }
8: public String toString () {
9: r e t u r n name . t r i m ( ) + " " + numLines + " lines printed " ;
10: }
11: }

Con todas las clases que usa el servidor de impresion ya definidas, en el lista-
do 11.10 mostramos el servidor de impresion propiamente dicho.
Codigo 11.10 Servidor de impresion que corre en un hilo propio de ejecucion
1: import j a v a . u t i l . ;
2:
3: c l a s s P r i n t S e r v e r implements R u n n a b l e {
4: p r i v a t e Queue r e q u e s t s = new Queue ( ) ;
5: public PrintServer () {
6: new Thread ( t h i s ) . s t a r t ( ) ;
7: }
8: public void p r i n t ( PrintJob job ) {
9: r e q u e s t s . add ( j o b ) ;
10: }
11: public void run ( ) {
12: try {
13: for ( ; ; )
14: r e a l P r i n t (( PrintJob ) requests . take ( ) ) ;
15: } catch ( I n t e r r u p t e d E x c e p t i o n e ) {
16: System . o u t . p r i n t l n ( "La impresora quedo fuera de lnea " ) ;
17: System . e x i t ( 0 ) ;
18: }
19: }
20: private void r e a l P r i n t ( PrintJob job ) {
21: System . o u t . p r i n t l n ( " Imprimiendo " + j o b ) ;
22: }
23: }
429 Hilos de ejecucion

Finalmente, para simular un servidor de impresion que recibe y procesa traba-

jos de impresion construimos la clase SistOperativo, que proporciona un entorno
en el cual el servidor de impresion se arranca para que empiece a funcionar. Esta
clase se muestra en el listado 11.11.

Codigo 11.11 Entorno en el que funciona un servidor de impresion

1: c l a s s S i s t O p e r a t i v o extends Thread {
2: p r i v a t e P r i n t S e r v e r p r = new P r i n t S e r v e r ( ) ;
3: p r i v a t e i n t numJob =0;
4: public void run ( ) {
5: try {
6: while ( true ) {
7: numJob++;
8: // Se g e n e r a n t r a b a j o s con un numero a r b i t r a r i o
9: // de l n e a s p o r i m p r i m i r
10: p r . p r i n t ( new P r i n t J o b ( "Job \#" + numJob + ", " ,
11: ( ( i n t ) Math . f l o o r ( Math . random ( )
12: 10000)) + 1 ) ) ;
13: sleep (300);
14: }
15: } catch ( I n t e r r u p t e d E x c e p t i o n e ) {
16: System . o u t . p r i n t l n ( " Termino el trabajo " ) ;
17: System . e x i t ( 0 ) ;
18: }
19: }
20: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
21: new S i s t O p e r a t i v o ( ) . s t a r t ( ) ;
22: }
23: }

Una ejecucion breve de este programa produce se puede ver en la figura 11.4
en la siguiente pagina.

11.5.2. Mas detalles sobre la espera y la notificacion

Los metodos wait que tienen tres variantes y los metodos que corresponden
a la notificacion notify() y notifyAll son metodos de la clase Object y por lo
tanto todas las clases los pueden invocar. Todos estos metodos estan declarados
final por lo que no pueden ser modificados. Veamos las variantes que presentan:
Metodos de espera:
p u b l i c f i n a l v o i d w a i t ( long t i m e o u t ) throws I n t e r r u p t e d E x c e p t i o n

El hilo de control en el que aparece el wait se duerme hasta que sucede una
de cuatro cosas:
11.5 Comunicacion entre hilos de ejecucion 430

Figura 11.4 Salida que produce el servidor de impresion.

% java SistOperativo
Imprimiendo Job#1, 920 lines printed
Imprimiendo Job#2, 8714 lines printed
Imprimiendo Job#3, 2297 lines printed
Imprimiendo Job#4, 799 lines printed
Imprimiendo Job#5, 1966 lines printed
Imprimiendo Job#6, 2439 lines printed
Imprimiendo Job#7, 6808 lines printed
Imprimiendo Job#8, 8270 lines printed
Imprimiendo Job#9, 7093 lines printed
Imprimiendo Job#10, 63 lines printed
Imprimiendo Job#11, 2904 lines printed
Imprimiendo Job#12, 5396 lines printed
Imprimiendo Job#13, 8980 lines printed
Imprimiendo Job#14, 6519 lines printed
Imprimiendo Job#15, 4359 lines printed
Imprimiendo Job#16, 2179 lines printed
Imprimiendo Job#17, 9404 lines printed
Imprimiendo Job#18, 8575 lines printed
Imprimiendo Job#19, 2095 lines printed
Imprimiendo Job#20, 6245 lines printed
Imprimiendo Job#21, 4016 lines printed
Imprimiendo Job#22, 9531 lines printed

Metodos de espera: (continua. . . )

i. Se invoca notify sobre este objeto y se selecciona al hilo de ejecucion
como ejecutable.
ii. Se invoca notifyAll sobre este objeto.
iii. El tiempo especificado para esperar expira.
iv. Se invoca al metodo interrupt despues veremos con mas detalle este
metodo del hilo de ejecucion.
Si timeout es cero, el proceso esperara indefinidamente hasta que sea notifica-
do que puede continuar. Durante la espera, se libera el candado del objeto,
y este es readquirido antes de que termine wait, no importa como o por
que termine. Si wait termina porque el hilo de ejecucion fue interrumpido,
431 Hilos de ejecucion

el metodo lanza una excepcion de InterruptedException.

p u b l i c f i n a l v o i d w a i t ( long t i m e o u t , i n t n a n o s )

Da la posibilidad de esperar tiempo en nanosegundos tambien. El proceso

dormira el numero de timeout de milisegundos mas nanos nanosegundos.
p u b l i c f i n a l v o i d w a i t ( ) throws I n t e r r u p t e d E x c e p t i o n

Equivalente a wait(0).

Metodos de notificacion:
public f i n a l void n o t i f y A l l ( )

Notifica a todos los procesos que estan en estado de espera que alguna con-
dicion cambio. Despertaran los procesos que puedan readquirir el candado
que estan esperando.
public f i n a l void n o t i f y ( )
Notifica a lo mas a un hilo esperando notificacion, pero pudiera suceder que
el hilo notificado no estuviera esperando por la condicion que cambio de
estado. Esta forma de notificacion solo se debe usar cuando hay seguridad
de quien esta esperando notificacion y por que.

Los metodos de notificacion lo que hacen, de hecho, es ofrecer el candado

que poseen a los metodos que estan esperando. Si ningun metodo esta esperando,
o el que recibio la notificacion no esta esperando ese candado en particular, la
notificacion se pierde.
Tanto los metodos de espera como los de notificacion tienen que invocarse desde
codigo sincronizado, usando el candado del objeto sobre el cual son invocados. La
invocacion se puede hacer directamente desde el codigo sincronizado, o bien desde
metodos invocados desde el codigo sincronizado. Si se intenta invocar a cualquiera
de estos dos metodos cuando no se posee el candado del objeto, se presentara una
excepcion IllegalMonitorStateException.
No hay manera de saber el porque un objeto despierta, si es porque trans-
currio el tiempo especificado, o porque fue notificado de un cambio de estado.
Esto se puede averiguar si se obtiene el tiempo transcurrido durante la espera.
Esto ultimo se puede lograr con el metodo estatico currentTimeMillis() de la clase
System, como mostramos en el listado 11.12 en la siguiente pagina.
11.6 Alternativas para la programacion de procesos 432

Codigo 11.12 Para verificar tiempo transcurrido.

......
1: p u b l i c s y n c h r o n i z e d O b j e c t t a k e ( )
2: throws I n t e r r u p t e d E x c e p t i o n {
3: w h i l e ( head == n u l l ) {
4: long t i e m p o = System . c u r r e n t T i m e M i l l i s ( ) ;
5: wait (300); // E s p e r a un o b j e t o en l a c o l a
6: long t r a n s c u r r i d o = System . c u r r e n t T i m e M i l l i s ( )
t i e m p o ;
7: i f ( t r a n s c u r r i d o > 300)
8: System . e r r . p r i n t l n ( "Se desperto sin que hubiera cambios " ) ;
9: }

......

11.6 Alternativas para la programacion de procesos

Hasta ahora, si hay varios procesos esperando para reanudar su ejecucion, es

impredecible el orden en que van a reanudar su ejecucion, ya que es la JVM la
que decide a cual proceso atender. Pero dentro de nuestros programas, algunas
tareas van a ser mas importantes que otras, o vamos a desear influir, aunque sea
un poco, en que esas tareas entren a ejecucion antes que otras.
Se puede pensar en varios procesos ejecutandose simultaneamente aun cuando
la maquina tenga un solo procesador. Para ello, el sistema operativo (o en nues-
tro caso, la JVM) tiene polticas de distribucion del tiempo de procesador. Cada
proceso tiene una prioridad asociada, que da una indicacion de la importancia del
mismo. La poltica del sistema puede ser que va a llevar a ejecucion a los procesos
con mas altas prioridad de entre los que estan en posibilidades de ejecutarse. El
proceso seleccionado seguira ejecutandose hasta que desee ejecutar una operacion
que bloque la ejecucion (un wait, sleep o alguna operacion de entrada y salida). En
ese momento se le quita el uso del procesador y se le da a otro proceso, poniendolo
a esperar. El sistema tambien pudiera tener la poltica de repartir el tiempo de
procesador de manera equitativa, permitiendo a cada proceso ejecutarse un cierto
lapso. En este caso, los procesos son desalojados del procesador aun cuando estan
en estado ejecutable, y simplemente esperaran hasta que les vuelva a tocar otro
lapso de ejecucion.
El que el sistema desaloje a un proceso depende mas de las polticas del sis-
433 Hilos de ejecucion

tema que del tipo de proceso. En general es aceptable asumir que el sistema le
dara preferencia a los procesos con mas alta prioridad y que esten en estado de
poder ser ejecutados, pero no hay ninguna garanta al respecto. La unica manera
de modificar estas polticas de desalojo es mediante la comunicacion de procesos.
La prioridad de un hilo de ejecucion es, en principio, la misma que la del
proceso que lo creo. Esta prioridad se puede cambiar con el metodo public final
void setPriority(int newPriority) que asigna una nueva prioridad al hilo de ejecucion.
Esta prioridad es un valor entero tal que cumple
MIN PRIORITY newPriority MAX PRIORITY
La prioridad de un hilo que se esta ejecutando puede cambiarse en cualquier
momento. En general, aquellas partes que se ejecutan continuamente en un sistema
deben correr con prioridad menor que los que detectan situaciones mas raras,
como la alimentacion de datos. Por ejemplo, cuando un usuario oprime el boton
de cancelar para un proceso, quiere que este termine lo antes posible. Sin embargo,
si se estan ejecutando con la misma prioridad, puede pasar mucho tiempo antes
de que el proceso que se encarga de cancelar tome el control.
En general es preferible usar prioridades cercanas a NORM PRIORITY para
evitar comportamientos extremos en un sistema. Si un proceso tiene la prioridad
mas alta posible, puede suceder que evite que cualquier otro proceso se ejecute,
una situacion que se conoce como hambruna (starvation).

11.6.1. Desalojo voluntario

Hay varios metodos mediante los cuales un programa puede desalojarse a

s mismo del procesador. Todos estos metodos de la clase Thread son estaticos.
Veamos cuales son.
public static void sleep(long millis) throws InterruptedException
Pone a dormir al hilo de ejecucion en cuestion al menos por el tiempo especi-
ficado. Sin embargo, no hay garanta de que sea exactamente este tiempo, ya
que las polticas de programacion pudieran no permitir que el proceso regre-
se al procesador en cuando despierta. Si el proceso es interrumpido mientras
esta durmiendo, se termina y lanza una excepcion InterruptedException.

public static void sleep(long millis, int nanos) throws InterruptedException

Lo mismo que el anterior, pero se pueden agregar nanosegundos, que estaran
en el rango 0-999999.
11.6 Alternativas para la programacion de procesos 434

public static void yield()

Le indica al programador de procesos que esta dispuesto a ser desalojado,
ya que la tarea que esta realizando no tiene que continuar en este momento.
El programador de procesos decide si lo desaloja o no.

Ya hemos utilizado el metodo sleep. En la clase del listado 11.13 mostramos

un ejemplo de yield. Esta clase se ejecuta dandole en la lnea de comandos varios
argumentos.

Codigo 11.13 Desalojo voluntario

1: c l a s s B a b b l e extends Thread {
2: s t a t i c boolean d e c l i n a ; // D e c l i n a r a o t r o s p r o c e s o s ?
3: s t a t i c i n t howOften ; // c u a n t a s v e c e s i m p r i m i r
4: p r i v a t e S t r i n g word ;
5:
6: B a b b l e ( S t r i n g whatToSay ) {
7: word = whatToSay ;
8: }
9:
10: public void run ( ) {
11: f o r ( i n t i = 0 ; i < howOften ; i ++) {
12: System . o u t . p r i n t l n ( word ) ;
13: if ( declina )
14: Thread . y i e l d ( ) ; // Deja que o t r o s p r o c e s o s
15: // s e e j e c u t e n
16: }
17: }
18:
19: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
20: d e c l i n a = new B o o l e a n ( a r g s [ 0 ] ) . b o o l e a n V a l u e ( ) ;
21: howOften = I n t e g e r . p a r s e I n t ( a r g s [ 1 ] ) ;
22:
23: // Crea un h i l o de e j e c u c i o n p a r a cada p a l a b r a
24: f o r ( i n t i = 2 ; i < a r g s . l e n g t h ; i ++)
25: new B a b b l e ( a r g s [ i ] ) . s t a r t ( ) ;
26: }
27: }

Podemos ver dos ejecuciones con lneas de comandos distintas, una que provoca
el desalojo y la otra no. Sin embargo, en el sistema en que probamos este pequeno
programa, el resultado es el mismo. Deberamos ejecutarlo en varios sistemas para
ver si el resultado cambia de alguna manera. Veamos los resultados en la figura 11.5
en la pagina opuesta.
435 Hilos de ejecucion

Figura 11.5 Ejecucion con desalojo voluntario.

% java Babble false 2 Did DidNot
Did
Did
DidNot
DidNot
% java Babble true 2 Did DidNot
Did
Did
DidNot
DidNot

11.7 Abrazo mortal (deadlock)

Siempre que se tienen dos hilos de ejecucion y dos objetos con candados se
puede llegar a una situacion conocida como abrazo mortal, en la cual cada proceso
posee el candado de uno de los objetos y esta esperando adquirir el candado del
otro proceso. Si el objeto X tiene un metodo sincronizado que invoca a un metodo
sincronizado del objeto Y, quien a su vez tiene a un metodo sincronizado invocando
a un metodo sincronizado de X, cada proceso se encontrara esperando a que el
otro termine para poder continuar, y ninguno de los dos va a poder hacerlo.
En el listado 11.14 mostramos una clase Apapachosa en la cual un amigo, al
ser apapachado, insiste en apapachar de regreso a su companero.
Codigo 11.14 Posibilidad de abrazo mortal 1/2
1: c l a s s Apapachosa {
2: p r i v a t e Apapachosa amigo ;
3: p r i v a t e S t r i n g nombre ;
4: p u b l i c Apapachosa ( S t r i n g nombre ) {
5: t h i s . nombre = nombre ;
6: }
7: p u b l i c s y n c h r o n i z e d v o i d apapacha ( ) {
8: System . o u t . p r i n t l n ( Thread . c u r r e n t T h r e a d ( ) . getName ( ) +
9: " en " + nombre + ". apapacha () tratando de " +
10: " invocar a " + amigo . nombre + ". reApapacha ()" ) ;
11: amigo . r e A p a p a c h a ( ) ;
12: }
11.7 Abrazo mortal (deadlock ) 436

Codigo 11.14 Posibilidad de abrazo mortal 2/2

13:
14: p r i v a t e synchronized void reApapacha ( ) {
15: System . o u t . p r i n t l n ( Thread . c u r r e n t T h r e a d ( ) . getName ()+
16: " en " + nombre + ". reApapacha ()" ) ;
17: }
18:
19: p u b l i c v o i d seAmigo ( Apapachosa amiga ) {
20: t h i s . amigo = amiga ;
21: }
22:
23: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
24: f i n a l Apapachosa l u p e = new Apapachosa ( "Lupe" ) ;
25: f i n a l Apapachosa j u a n a = new Apapachosa ( " Juana " ) ;
26: l u p e . seAmigo ( j u a n a ) ;
27: j u a n a . seAmigo ( l u p e ) ;
28:
29: new Thread ( new R u n n a b l e ( ) {
30: p u b l i c v o i d r u n ( ) { l u p e . apapacha ( ) ; }
31: } , " Hilo1 " ) . s t a r t ( ) ;
32: new Thread ( new R u n n a b l e ( ) {
33: public void run ( ) { j u a n a . apapacha ( ) ; }
34: } , " Hilo2 " ) . s t a r t ( ) ;
35: }
36: }

Dependiendo del encargado de la programacion, pudiera suceder que lupe ter-

mine antes que empiece juana. Pero esto no lo podemos garantizar. Una ejecucion
en nuestra maquina logro lo que acabamos de mencionar, y produjo la salida que
se muestra en la figura 11.6.

Figura 11.6 Ejecucion con la posibilidad de abrazo mortal.

% java Apapachosa
Hilo1 en Lupe.apapacha() tratando de invocar a Juana.reApapacha()
Hilo1 en Juana.reApapacha()
Hilo2 en Juana.apapacha() tratando de invocar a Lupe.reApapacha()
Hilo2 en Lupe.reApapacha()

En las corridas que hicimos en nuestra maquina siempre pudo Lupe terminar
su intercambio antes de que Juana intentara el suyo. Sin embargo, pudiera suceder
437 Hilos de ejecucion

que en otro sistema, o si la JVM tuviera que atender a mas hilos de ejecucion, ese
programita bloqueara el sistema cayendo en abrazo mortal.
Introduciendo un enunciado wait dentro del metodo reaApapacha conseguimos
que el proceso caiga en un abrazo mortal. Se lanza el hilo de ejecucion con lupe,
pero como tiene que esperar cuando llega a reApapacha(), esto permite que tambien
el hilo de ejecucion con juana se inicie. Esto hace que ambos procesos se queden
esperando a que el otro libere el candado del objeto, pero para liberarlo tienen
que terminar la ejecucion de reApapacha, lo ninguno de los dos puede hacer cada
uno esta esperando a que termine el otro. La aplicacion modificada se muestra
en el listado 11.15 y en la figura 11.7 en la siguiente pagina se muestra como se
queda pasmado el programa, sin avanzar ni terminar, hasta que se teclea un C.

Codigo 11.15 Abrazo mortal entre hilos de ejecucion 1/2

1: c l a s s Apapachosa2 {
2: p r i v a t e Apapachosa2 amigo ;
3: p r i v a t e S t r i n g nombre ;
4: p r i v a t e O b j e c t candado = new O b j e c t ( ) ;
5:
6: p u b l i c Apapachosa2 ( S t r i n g nombre ) {
7: t h i s . nombre = nombre ;
8: }
9:
10: p u b l i c s y n c h r o n i z e d v o i d apapacha ( ) {
11: System . o u t . p r i n t l n ( Thread . c u r r e n t T h r e a d ( ) . getName ( ) +
12: + " en " + nombre
13: + ". apapacha () tratando "
14: + " de invocar " + amigo . nombre
15: + ". reApapacha ()" ) ;
16: amigo . r e A p a p a c h a ( ) ;
17: }
18:
19: p r i v a t e synchronized void reApapacha ( ) {
20: try {
21: wait(3);
22: System . o u t . p r i n t l n ( Thread . c u r r e n t T h r e a d ( ) . getName ( )
23: + " en " + nombre + ". reApapacha ()" ) ;
24: } catch(InterruptedException e) { }
25: }
26:
27: p u b l i c v o i d hazteAmigo ( Apapachosa2 amigo ) {
28: t h i s . amigo = amigo ;
29: }
11.7 Abrazo mortal (deadlock ) 438

Codigo 11.15 Abrazo mortal entre hilos de ejecucion 2/2

30:
31: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
32: f i n a l Apapachosa2 l u p e = new Apapachosa2 ( "Lupe" ) ;
33: f i n a l Apapachosa2 j u a n a = new Apapachosa2 ( " Juana " ) ;
34: l u p e . hazteAmigo ( j u a n a ) ;
35: j u a n a . hazteAmigo ( l u p e ) ;
36: new Thread ( new R u n n a b l e ( ) {
37: public void run ( ) { l u p e . apapacha ( ) ; }
38: } , " Hilo1 " ) . s t a r t ( ) ;
39: new Thread ( new R u n n a b l e ( ) {
40: p u b l i c v o i d r u n ( ) { j u a n a . apapacha ( ) ; }
41: } , " Hilo2 " ) . s t a r t ( ) ;
42: }
43: }

Como se puede ver en las lneas 22, 23 y 26, lo unico que se le agrego a esta clase
es que una vez dentro del metodo reApapacha espere 3 milisegundos, liberando el
candado. Este es un tiempo suficiente para que el otro hilo de ejecucion se apodere
del candado. Aca es cuando se da el abrazo mortal, porque el primer hilo no puede
terminar ya que esta esperando a que se libere el candado, pero el segundo hilo
tampoco puede continuar porque el primero no ha terminado.

Figura 11.7 Ejecucion de Apapachosa2 con abrazo mortal

elisa@lambda ...ICC1/progs/threads % java Apapachosa2
Hilo1 en Lupe.apapacha() tratando de invocar Juana.reApapacha()
Hilo2 en Juana.apapacha() tratando de invocar Lupe.reApapacha()

elisa@lambda ...ICC1/progs/threads %

Si bien nos costo trabajo lograr el abrazo mortal, en un entorno donde se estan
ejecutando multiples aplicaciones a la vez no podramos predecir que el segundo
hilo de ejecucion no se apoderara del candado del objeto antes de que el primer
hilo lograra llegar a ejecutar el metodo reApapacha, por lo que tendramos que
hacer algo al respecto.
Es responsabilidad del cliente evitar que haya abrazos mortales, asegurandose
del orden en que se ejecutan los distintos metodos y procesos. Esto lo conseguira el
programador usando enunciados wait, yield, notify, notifyAll y sincronizando alre-
dedor de uno o mas objetos, para conseguir que un proceso espere siempre a otro.
439 Hilos de ejecucion

El tema de abrazos mortales es de gran importancia e interes, y proporciona

un campo de estudio e investigacion muy fertil. Siendo este un curso introductorio
no creemos necesario verlo mas a fondo y nos conformamos con haber creado la
conciencia de situaciones anomalas que se pueden presentar.

11.8 Como se termina la ejecucion de un proceso

Un proceso en general puede presentar los siguientes estados:

vivo: Un metodo esta vivo desde el momento que es iniciado con start() y hasta
que termina su ejecucion.

activo: Un metodo esta activo si esta siendo ejecutado por el procesador.

ejecutable: Na hay ningun obstaculo para que sea ejecutado, pero el procesador
no lo ha atendido.

esperando: Se encuentra esperando a que alguna condicion se cumpla o se le

notifique de algun evento, por lo que el procesador no lo puede ejecutar.

Un metodo deja de estar vivo, como ya dijimos, por cualquiera de las causas
que siguen:

El metodo run ejecuta un return o llega al final de su definicion.

El metodo run termina abruptamente.

Se invoca al metodo destroy sobre ese proceso.

Es posible que se detecte que algo mal esta sucediendo en cierto proceso y se
desee terminar su ejecucion. Sin embargo, destroy debera ser un ultimo recurso, ya
que si bien se consigue que el proceso termine, pudiera suceder que no se liberen
los candados que posee el proceso en cuestion y se queden en el sistema otros
procesos bloqueados para siempre esperando candados que ya nunca van a poder
ser liberados. Es tan drastico y peligroso este metodo para el sistema en general
que muchas maquinas virtuales han decidido no implementarlo y simplemente
lanzan una excepcion NoSuchMethodError, que termina la ejecucion del hilo. Esto
sucede si modificamos el metodo apapacha como se muestra en el listado 11.16 en
la siguiente pagina.
11.8 Como se termina la ejecucion de un proceso 440

Codigo 11.16 Uso de destroy para terminar un hilo de ejecucion

1: p u b l i c s y n c h r o n i z e d v o i d apapacha ( ) {
2: System . o u t . p r i n t l n ( Thread . c u r r e n t T h r e a d ( ) . getName ( )
3: + " en " + nombre + ". apapacha () tratando "
4: + " de invocar " + amigo . nombre
5: + ". reApapacha ()" ) ;
6: i f ( Thread . c u r r e n t T h r e a d ( ) . getName ( ) . e q u a l s ( " Hilo2 " ) ) {
7: System . o u t . p r i n t l n ( " Entre a destroy " ) ;
8: Thread . c u r r e n t T h r e a d ( ) . d e s t r o y ( ) ;
9: }
10: amigo . r e A p a p a c h a ( ) ;
11: }

Figura 11.8 Implementacion de destroy en la maquina virtual de Java.

elisa@lambda ...ICC1/progs/threads % java Apapachosa2
Hilo1 en Lupe.apapacha() tratando de invocar Juana.reApapacha()
Hilo2 en Juana.apapacha() tratando de invocar Lupe.reApapacha()
Entre a destroy
java.lang.NoSuchMethodErrorHilo1 en Juana.reApapacha()
at java.lang.Thread.destroy(Thread.java:709)
at Apapachosa2.apapacha(Apapachosa2.java:20)
at Apapachosa2$2.run(Apapachosa2.java:49)
at java.lang.Thread.run(Thread.java:484)

La ejecucion de Apapachosa2 con la redefinicion de este metodo produce la

salida que se observa en la figura 11.8.
Cuando un programa termina por cualquier razon, en ese momento terminan
todos los procesos lanzados por este programa.

11.8.1. Cancelacion de un proceso

En ocasiones es deseable poder cancelar un proceso que esta trabajando. Por

ejemplo, si estamos trabajando con interfaces graficas y el usuario oprime el boton
de cancelar deseamos poder terminar el proceso de una manera adecuada. Para
poder pedir la cancelacion de un proceso debemos poder interrumpirlo para que
escuche la orden de terminacion.
La clase Thread tiene dos metodos asociados a la interrupcion de un proceso, la
solicitud de interrupcion y la consulta de si el proceso ha sido o no interrumpido.
441 Hilos de ejecucion

La solicitud de interrupcion se hace mediante el enunciado

// En e l h i l o 1
thread2 . i n t e r r u p t ()

desde un metodo distinto que el que se desea interrumpir. En el metodo por in-
terrumpir deberemos tener una iteracion que en cada vuelta este preguntando si
ha sido o no interrumpido:

// En e l h i l o 2
while ( ! i n t e r r u p t e d ( ) ) {
// haz e l t r a b a j o p l a n e a d o
}

Si tenemos mas de un proceso ejecutandose y se le enva una senal de interrup-

cion a uno de los procesos, el otro proceso proseguira, aduenandose del procesador.
Al interrumpir a un proceso, los candados que posea el objeto se liberan, por lo
que este puede ser un mecanismo necesario para terminar con un abrazo mortal,
aun a costa de uno de los procesos.
Veamos una aplicacion de dos hilos de ejecucion encargados de escribir un
punto en la pantalla cada determinado tiempo. En un momento dado el programa
principal decide interrumpir a uno de las procesos, y en ese momento el otro
continua su ejecucion ya sin ceder el procesador a nadie mas. Podemos ver este
programa en el listado 11.17.

Codigo 11.17 Interrupcion de procesos 1/2

1: c l a s s T i c k extends Thread {
2: i n t count ;
3: long p a u s e ;
4:
5: p u b l i c T i c k ( i n t count , long pauseTime , S t r i n g name ) {
6: super ( name ) ;
7: t h i s . count = count ;
8: p a u s e = pauseTime ;
9: }
10:
11: public void run ( ) {
12: t i c k ( count , p a u s e ) ;
13: }
11.8 Como se termina la ejecucion de un proceso 442

Codigo 11.17 Interrupcion de procesos 2/2

14: s y n c h r o n i z e d v o i d t i c k ( i n t count , long pauseTime ) {
15: System . o u t . p r i n t l n ( Thread . c u r r e n t T h r e a d ( ) ) ;
16: try {
17: f o r ( i n t i = 0 ; i < c o u n t ; i ++) {
18: System . o u t . p r i n t l n ( c u r r e n t T h r e a d ( ) . getName ( )
19: + " >." ) ;
20: System . o u t . f l u s h ( ) ;
21: Thread . s l e e p ( pauseTime ) ;
22: }
23: } catch ( I n t e r r u p t e d E x c e p t i o n e ) {
24: System . o u t . p r i n t l n ( "Se interrumpio " +
25: c u r r e n t T h r e a d ( ) . getName ( ) ) ;
26: }
27: }
28:
29: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
30: T i c k h i l o 1 = new T i c k ( 2 0 , 1 0 0 , "Hilo 1" ) ;
31: T i c k h i l o 2 = new T i c k ( 1 0 , 1 0 0 , " Hilo2 " ) ;
32: hilo1 . start ();
33: hilo2 . start ();
34: System . o u t . p r i n t l n ( " Desde el programa principal " ) ;
35: try {
36: s l e e p ( 3 0 0 ) ; // Deja que t r a b a j e n un r a t o
37: } catch ( I n t e r r u p t e d E x c e p t i o n e ) {
38: hilo1 . interrupt ();
39: }
40: }
41: }

La diferencia principal entre este metodo de interrupcion o interrumpir con un

C, por ejemplo, es que en este ultimo caso estamos interrumpiendo al programa
principal, por lo que todos los procesos que fueron lanzados desde el se dan por
aludidos, mientras que si mandamos un mensaje de interrupcion a un solo proceso,
este es el unico que cachara la excepcion y suspendera su ejecucion. La salida que
produce esta aplicacion se puede ver en la figura 11.9 en la pagina opuesta.
La ejecucion del proceso hilo 1 se interrumpe porque al estar dormido (ejecu-
tando un sleep) el proceso sale de este estado al recibir la senal de interrupcion.
Entonces, el proceso terminara.
Un enunciado interrupt no va a tener ningun efecto si el proceso correspondiente
no esta en un estado de espera (wait o sleep). Tiene efecto en estos estados porque
estos metodos lanzan la excepcion InterruptedException, pero no porque de hecho
se suspenda inmediatamente el mismo.
443 Hilos de ejecucion

Figura 11.9 Interrupcion de un hilo de ejecucion desde el programa principal.

elisa@lambda ...ICC1/progs/threads % java Tick
Thread[Hilo 1,5,main]
Hilo 1>.
Desde el programa principal
Thread[Hilo2,5,main]
Hilo2>.
Hilo 1>.
Hilo2>.
Hilo 1>.
Hilo2>.
Se interrumpio Hilo 1
Hilo2>.
Hilo2>.
Hilo2>.
Hilo2>.
Hilo2>.
Hilo2>.
Hilo2>.
elisa@lambda ...ICC1/progs/threads %

Si el programa solicita la interrupcion de un proceso es muy peligroso hacer

caso omiso de esta solicitud, cachando la excepcion y no haciendo nada al res-
pecto. En algunas ocasiones se usa interrupt() para desbloquear a un proceso que
esta esperando algo, y al no responder en ninguna forma a la excepcion de hecho
el proceso no se interrumpe.

Codigo 11.18 Significado de la interrupcion en un proceso

1: s y n c h r o n i z e d v o i d t i c k ( i n t count , long pauseTime ) {
2: System . o u t . p r i n t l n ( c u r r e n t T h r e a d ( ) ) ;
3: f o r ( i n t i = 0 ; i c o u n t ; i ++) {
4: try {
5: System . o u t . p r i n t l n ( c u r r e n t T h r e a d ( ) . getName ( ) +" >." ) ;
6: System . o u t . f l u s h ( ) ;
7: s l e e p ( pauseTime ) ;
8: } catch ( I n t e r r u p t e d E x c e p t i o n e ) {
9: System . o u t . p r i n t l n ( "Se interrumpio "
10: + c u r r e n t T h r e a d ( ) . getName ( ) ) ;
11: }
12: }
13: }
11.8 Como se termina la ejecucion de un proceso 444

Si en el metodo tick del ejemplo que estamos manejando intercambiamos el

try con la iteracion, como se muestra en el listado 11.18 en la pagina anterior,
el proceso recibe la senal de interrupcion en una de las iteraciones, pero como
no hace nada al momento de cacharla respecto al hilo de ejecucion, al regresar
una vez mas a la iteracion resulta que el hilo supuestamente suspendido no fue
suspendido y sigue compartiendo el procesador con el otro hilo.

11.8.2. Terminacion de la ejecucion de un proceso

Una de las razones que puede tener un programa para lanzar un proceso para-
lelo es la necesidad de hacer calculos complejos, que pudieran hacerse simultanea-
mente. Sin embargo, muchas veces no se sabe cual de los dos calculos se va a
tardar mas, por lo que el proceso principal tendra que esperar a que termine, en
su caso, el proceso que lanzo antes de poder utilizar los resultados del mismo.
Java tiene el metodo join() de la clase Thread que espera a que el proceso con
el que se invoca el metodo termine antes de que se proceda a ejecutar la siguiente
lnea del programa. Veamos en los listados 11.19 y 11.20 en la pagina opuesta un
ejemplo en el quesupuestamente se desean hacer dos calculos que pueden llevarse
a cabo de manera simultanea. El metodo principal (main) crea un proceso paralelo
para que se efectue uno de los calculos mientras el ejecuta el otro. Una vez que
termina de ejecutar su propio calculo, se sienta a esperar hasta que el proceso
que lanzo termine.

Codigo 11.19 Espera para la terminacion de un coproceso

1: c l a s s C a l c T h r e a d extends Thread {
2: p r i v a t e double r e s u l t ;
3: public void run ( ) {
4: result = calculate ();
5: }
6: p u b l i c double g e t R e s u l t ( ) {
7: return r e s u l t ;
8: }
9: p u b l i c double c a l c u l a t e ( ) {
10: i n t t o p e =(( i n t ) Math . f l o o r ( Math . random ( ) 1 0 0 0 0 0 ) ) ;
11: f o r ( i n t i = 0 ; i < t o p e ; i ++);
12: r e t u r n ( ( double ) System . c u r r e n t T i m e M i l l i s ( ) ) ;
13: }
14: }

En el programa principal, desde el que se lanza el coproceso del calculo, una

445 Hilos de ejecucion

vez hecha la tarea que se poda realizar de manera simultanea, se espera para
garantizar que el coproceso termino. Si esto no se hace as pudiera suceder que
el valor que se desea calcule el coproceso no estuviera listo al terminar el proceso
principal con su propio trabajo.

Codigo 11.20 Programa principal para ejemplificar la espera

1: c l a s s S h o w J o i n s {
2: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
3: long a n t e s , d e s p u e s ;
4: C a l c T h r e a d c a l c = new C a l c T h r e a d ( ) ;
5: calc . start ();
6: i n t t o p e =(( i n t ) Math . f l o o r ( Math . random ( ) 1 0 0 0 0 ) ) ;
7: f o r ( i n t i =0; i < t o p e ; i ++);
8: try {
9: a n t e s = System . c u r r e n t T i m e M i l l i s ( ) ;
10: calc . join ();
11: d e s p u e s = System . c u r r e n t T i m e M i l l i s ( ) ;
12: System . o u t . p r i n t l n ( " Espere "+( d e s p u e s
a n t e s ) +
13: " milisegundos " ) ;
14: System . o u t . p r i n t l n ( " result vale " +
15: calc . getResult ());
16: } catch ( I n t e r r u p t e d E x c e p t i o n e ) {
17: System . o u t . p r i n t l n ( "No hay respuesta : fue interrumpido " ) ;
18: }
19: }
20: }

Otra manera de esperar a que un proceso termine antes de continuar con un

cierto hilo de ejecucion es mediante el metodo isAlive() de la clase Thread, que nos
indica si el metodo todava no ha llegado a su final, ya sea porque fue interrumpido
o porque termino su tarea. Si eligieramos usar esta forma de sincronizacion, el
programa del listado 11.20 se vera como se muestra en el listado 11.21 en la
siguiente pagina, con la parte que cambio en negritas.
En la lnea 11 del listado 11.21 en la siguiente pagina todo lo que hace el
programa es estar en un ciclo hasta que la condicion del ciclo se vuelva falsa. Como
la condicion es que el hilo de ejecucion calc este vivo, el programa podra salir del
ciclo cuando el proceso calc deje de estar vivo, o sea cuando termine.
11.9 Terminacion de la aplicacion 446

Codigo 11.21 Verificacion de terminacion con isAlive()

1: c l a s s S h o w A l i v e {
2: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
3: long a n t e s , d e s p u e s ;
4: C a l c T h r e a d c a l c = new C a l c T h r e a d ( ) ;
5: calc . start ();
6: i n t t o p e =(( i n t ) Math . f l o o r ( Math . random ( ) 1 0 0 0 0 ) ) ;
7: f o r ( i n t i =0; i < t o p e ; i ++); // e s p e r a
8: a n t e s = System . c u r r e n t T i m e M i l l i s ( ) ;
9: while (calc.isAlive());
10: d e s p u e s = System . c u r r e n t T i m e M i l l i s ( ) ;
11: System . o u t . p r i n t l n ( " Espere "+( d e s p u e s
a n t e s )
12: + " milisegundos " ) ;
13: System . o u t . p r i n t l n ( " result vale " + c a l c . g e t R e s u l t ( ) ) ;
14: }
15: }

Que un proceso no este ejecutandose no quiere decir que el proceso no este vivo.
Un proceso esta vivo si esta en espera, ya sea de alguna notificacion, de que
transcurra algun tiempo, o de que la JVM continue ejecutandolo. Por lo tanto, aun
cuando un proceso sea interrumpido por alguna de las condiciones que acabamos
de mencionar, el proceso seguira vivo mientras no termine su ejecucion.

11.9 Terminacion de la aplicacion

Nos surge una pregunta natural respecto a la relacion que existe entre los
procesos lanzados desde una aplicacion, y el proceso que corresponde a la aplica-
cion misma: que pasa si el proceso principal termina antes de que terminen los
procesos que fueron lanzados por el?
La respuesta es mas simple de lo que se piensa: el proceso principal no termina
hasta que hayan terminado todos los procesos que fueron lanzados por el. Bajo
terminar nos referimos a dejar de estar vivo, no forzosamente a estar ejecutando
algo. Esta situacion, pensandolo bien, es lo natural. El proceso principal es aquel
cuyo metodo main se invoco. El resto de los procesos fueron invocados utilizando
start(). Esa es la unica diferencia que hay entre ellos. Al lanzar procesos se genera
una estructura como de cacto, donde cada proceso tiene su stack de ejecucion, que
es una continuacion del stack de ejecucion del proceso que lo lanzo. Por lo tanto,
447 Hilos de ejecucion

no puede terminar un proceso hasta en tanto todos los procesos que dependen de
el (que montaron su stack de ejecucion encima) hayan terminado.
En Java hay otro tipo de procesos llamados demonios. Un demonio es un
proceso lanzado desde otro y cuya tarea es realizar acciones que no forzosamente
tienen mucho que ver con el proceso que los lanzo. En el caso de los demonios,
cuando termina el proceso que los lanzo, en ese momento y abruptamente se
interrumpen todos los demonios lanzados por ese proceso. Es como si aplicaramos
un destroy() a todos los demonios lanzados por el proceso que termina.
Resumiendo, hay dos tipos de procesos que se pueden lanzar desde otro proceso
cualquiera: los hilos de ejecucion normales y los demonios. El proceso lanzador
no puede terminar hasta en tanto los hilos de ejecucion iniciados por el no ter-
minen, mientras que los demonios se suspenden abruptamente cuando el proceso
que los lanzo termina.
Un proceso se puede hacer demonio simplemente aplicandole el metodo setDae-
mon(true) al hilo de ejecucion antes de que este inicie su ejecucion. Los procesos
iniciados por un demonio son, a su vez, demonios. Veamos un ejemplo de la dife-
rencia entre procesos normales y demonios en el listado 11.22.

Codigo 11.22 Diferencia entre procesos normales y demonios 1/2

1: import j a v a . i o . ;
2:
3: c l a s s Daemon extends Thread {
4: p r i v a t e s t a t i c f i n a l i n t SIZE = 1 0 ;
5: p r i v a t e Thread [ ] t = new Thread [ SIZE ] ;
6:
7: p u b l i c Daemon ( ) {
8: setDaemon ( t r u e ) ;
9: start ();
10: }
11:
12: public void run ( ) {
13: f o r ( i n t i = 0 ; i < SIZE ; i ++)
14: t [ i ] = new DaemonSpawn ( i ) ;
15: f o r ( i n t i = 0 ; i < SIZE ; i ++)
16: System . o u t . p r i n t l n ( "t[" + i +"]. isDaemon () = " +
17: t [ i ] . isDaemon ( ) ) ;
18: while ( true )
19: yield ();
20: }
21: }
11.9 Terminacion de la aplicacion 448

Codigo 11.22 Diferencia entre procesos normales y demonios 2/2

22: c l a s s DaemonSpawn extends Thread {

23: p u b l i c DaemonSpawn ( i n t i ) {
24: System . o u t . p r i n t l n ( " DaemonSpawn " + i + " lanzado " ) ;
25: start ();
26: }
27:
28: public void run ( ) {
29: while ( true ) y i e l d ( ) ;
30: }
31: }
32:
33:
34: p u b l i c c l a s s Daemons {
35: p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) }
36: throws I O E x c e p t i o n {
37: Thread d = new Daemon ( ) ;
38: System . o u t . p r i n t l n ( "d. isDaemon () = " + d . isDaemon ( ) ) ;
39: }
40: }

Para ver los distintos efectos que tiene el que los procesos lanzados sean o
no demonios, vamos a ejecutar la clase Daemon como esta. La teora es que al
terminar de ejecutarse el metodo main de esta clase, los demonios suspenderan
tambien su funcionamiento. Y en efecto as es. La ejecucion la podemos ver en la
figura 11.10 en la pagina opuesta.
Mostramos dos ejecuciones de la misma aplicacion. En la primera ejecucion,
se alcanzo a lanzar 5 demonios antes de que el proceso principal terminara. En la
segunda ejecucion, unicamente se alcanzaron a lanzar 2 demonios. El numero de
demonios que se logre lanzar dependera de las polticas de atencion de la JVM.
Como el proceso Daemon es, a su vez, un demonio, en cuanto llega el proceso
principal al final, se suspende abruptamente la ejecucion de todos los demonios
que se hayan iniciado desde el, o desde procesos o demonios iniciados por el.
Si cambiamos la lnea 8: de esta aplicacion para que Daemon sea un proceso
comun y corriente con la lnea

8: setDaemon ( f a l s e ) ;

obtenemos la salida que se muestra en la figura 11.10 en la pagina opuesta.

 449 Hilos de ejecucion

Figura 11.10 Terminacion de procesos que son demonios

elisa@lambda ...ICC1/progs/threads % java Daemons
d.isDaemon() = true
DaemonSpawn 0 iniciado
DaemonSpawn 1 iniciado
DaemonSpawn 2 iniciado
DaemonSpawn 3 iniciado
DaemonSpawn 4 iniciado
elisa@lambda ...ICC1/progs/threads % java Daemons
d.isDaemon() = true
DaemonSpawn 0 iniciado
DaemonSpawn 1 iniciado
elisa@lambda ...ICC1/progs/threads %

Si ademas agregamos la lnea que sigue

setDaemon ( t r u e ) ;

entre las lneas 37: y 38: de la clase DaemonSpawn, la ejecucion de Daemon tiene
que terminar antes de que la aplicacion pueda hacerlo, por lo que se alcanzan a
lanzar todos los demonios. Como no hay ninguna manera de que termine el proceso
Daemon, tambien el proceso principal nunca termina, hasta que tecleamos ctrl-C.
Si en las lneas 18: y 19: de la clase Daemon quitamos el ciclo y unicamente tenemos
yield(), el proceso termina normalmente en el momento en que termina el proceso
de la clase Daemon. Veamos la salida en la figura 11.11 en la siguiente pagina.
Dependiendo de la programacion particular que de la JVM, podra suceder
que alguno de los hilos de ejecucion causara una excepcion, o que al suspenderse
alguno de los demonios abruptamente lanzara una excepcion. Esto resulta en
que ejecuciones de la misma aplicacion puedan dar distintos resultados cuando
estamos trabajando con hilos de ejecucion, sobre todo si no se ejerce ninguna
sincronizacion, como es el caso del ejemplo con el que estamos trabajando.

11.10 Depuracion en hilos de ejecucion

Java proporciona dos metodos a utilizar cuando hay problemas con la ejecucion
de coprocesos. Estos son:
 11.11 Otros temas relacionados con hilos de ejecucion 450

public String toString

Regresa la representacion en cadena del hilo de ejecucion. Esta representa-
cion tiene el nombre del hilo de ejecucion, su prioridad y el grupo al que
pertenece.

public static void dumpStack()

Imprime el stack de ejecucion para el coproceso en cuestion. Manda la salida
a System.out.

Figura 11.11 Terminacion de procesos

elisa@lambda ...ICC1/progs/threads % java Daemons

d.isDaemon() = false
DaemonSpawn 0 iniciado
DaemonSpawn 1 iniciado
DaemonSpawn 2 iniciado
DaemonSpawn 3 iniciado
DaemonSpawn 4 iniciado
DaemonSpawn 5 iniciado
DaemonSpawn 6 iniciado
DaemonSpawn 7 iniciado
DaemonSpawn 8 iniciado
DaemonSpawn 9 iniciado
t[0].isDaemon() = true
t[1].isDaemon() = true
t[2].isDaemon() = true
t[3].isDaemon() = true
t[4].isDaemon() = true
t[5].isDaemon() = true
t[6].isDaemon() = true
t[7].isDaemon() = true
t[8].isDaemon() = true
t[9].isDaemon() = true
elisa@lambda ...ICC1/progs/threads
451 Hilos de ejecucion

11.11 Otros temas relacionados con hilos de ejecucion

Entre los temas que ya no veremos en este captulo por considerarlos mas
apropiados para cursos posteriores, podemos mencionar:

Grupos: Cada hilo de ejecucion pertenece a un grupo de hilos de ejecucion con

sus caractersticas particulares. Java proporciona casi un metodo para el
trabajo en grupo por cada metodo para el trabajo con un hilo de ejecucion.
Los grupos pueden modificar la prioridad con la que se ejecuta un proceso,
a que otros hilos de ejecucion tiene acceso, etc.

Excepciones en hilos de ejecucion: Al igual que en una aplicacion comun y

corriente, se pueden dar excepciones dentro de un hilo de ejecucion. Si la
excepcion no es manejada a ese nivel, se propagara a niveles superiores.
La gran diferencia es que una vez que hay una excepcion en un hilo de
ejecucion, ese hilo se aborta y no se va a poder obtener informacion sobre
el desde fuera, ya que ya no va a existir. Bajo este tema se revisan bien los
mecanismos para poder saber con mas certeza que esta pasando y el por
que de las excepciones.

variables volatile: Esto se refiere a variables que para el compilador pudieran

parecer como que no se modifican de un enunciado a otro, pero con la exis-
tencia de hilos de ejecucion paralelos, pudieran ser modificadas por otros
procesos. Se marcan las variables como volatile para obligar al compilador
a consultar el valor de la variable, y no asumir que no ha cambiado desde
la ultima vez que la vio; el efecto es que no permite al compilador hacer
optimizaciones que pudieran falsear el verdadero valor de una variable en
un momento dado.

Esperamos haber proporcionado una vision del potencial que tienen los hilos
de ejecucion en Java. Una vez que esten realizando programacion en serio, y en el
ambiente actual de procesos en red, tendran que usarlos.
Bibliografa

[1] Ken Arnold and James Gosling. The Java Programming Language Third Edi-
tion. Addison-Wesley, 2001.

[2] Jose Galaviz Casas. Elogio a la pereza. Vnculos Matematicos, Num. 8, 2001.

[3] Sun Corporation. The source for java technology. web page.

[4] Elliotte Rusty Harold. Java I/O. OReilly, 1999.

[5] Henry F. Ledgard. The Little Book of Object-Oriented Programming. Prentice

Hall, 1996.

[6] Canek Pelaez and Elisa Viso. Practicas para el curso de Introduccion a Cien-
cias de la Computacion I. Vnculos Matematicos, por publicarse, 2002.

[7] Danny C. C. Poo and Dereck B. K. Kiong. Object-Oriented Programming and

Java. Springer, 1998.

[8] Phil Sully. Modeling the world with objects. Prentice hall, 1993.