248 Capítulo 7 Arreglos y objetos ArrayList

1 // Fig. 7.2: InicArreglo.java

2 // Inicialización de los elementos de un arreglo con valores predeterminados de
cero.
3
4 public class InicArreglo
5 {
6 public static void main(String[] args)
7 {
8 // declara la variable arreglo y la inicializa con un objeto arreglo
9 int[] arreglo = new int[10]; // crea el objeto arreglo
10
11 System.out.printf(“%s%8s%n”, “Indice”, “Valor”); // encabezados de columnas
12
13 // imprime el valor de cada elemento del arreglo
14 for (int contador = 0; contador < arreglo.length; contador++)
15 System.out.printf(“%5d%8d%n”, contador, arreglo[contador]);
16 }
17
7 } // fin de la clase InicArreglo

Indice Valor
0 0
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
9 0

Fig. 7.2 冷 Inicialización de los elementos de un arreglo con valores predeterminados de cero.

La instrucción for (líneas 14 y 15) imprime el índice (representado por contador) y el valor de cada ele-
mento del arreglo (representado por arreglo[contador]). Al principio la variable de control contador es 0.
Los valores de los índices empiezan en 0, por lo que al utilizar un conteo con base cero se permite al ciclo
acceder a todos los elementos del arreglo. La condición de continuación de ciclo de la instrucción for
utiliza la expresión arreglo.length (línea 14) para determinar la longitud del arreglo. En este ejemplo la
longitud del arreglo es de 10, por lo que el ciclo continúa ejecutándose mientras el valor de la variable de
control contador sea menor que 10. El valor más alto para el índice de un arreglo de 10 elementos es 9,
por lo que al utilizar el operador “menor que” en la condición de continuación de ciclo se garantiza que
el ciclo no trate de acceder a un elemento que esté más alláá del final del arreglo (es decir, durante la itera-
ción final del ciclo, contador es 9). Pronto veremos lo que hace Java cuando encuentra un índice fuera de
rango en tiempo de ejecución.

7.4.2 Uso de un inicializador de arreglos

Usted puede crear un arreglo e inicializar sus elementos con un inicializador de arreglo, que es una lista
de expresiones separadas por comas (la cual se conoce también como lista inicializadora) a y que está ence-
rrada entre llaves. En este caso, la longitud del arreglo se determina con base en el número de elementos en
la lista inicializadora. Por ejemplo, la declaración
int[] n = { 10, 20, 30, 40, 50 };

crea un arreglo de cinco elementos con los valores de índices 0 a 4. El elemento n[0] se inicializa con 10,
n[1] se inicializa con 20, y así en lo sucesivo. Cuando el compilador encuentra la declaración de un arreglo

M07_DEITEL_COMO-PROGRAMAR-EN-JAVA_SE_10ED_C7_243-314_3802-1.indd 248 5/4/16 11:30 AM

 7.4 Ejemplos sobre el uso de los arreglos 249

que incluye una lista inicializadora, cuentaa el número de inicializadores en la lista para determinar el tama-
ño del arreglo y después establece la operación new apropiada “tras bambalinas”.
La aplicación de la figura 7.3 inicializa un arreglo de enteros con 10 valores (línea 9) y muestra el arre-
glo en formato tabular. El código para mostrar los elementos del arreglo (líneas 14 y 15) es idéntico al de la
figura 7.2 (líneas 15 y 16).

1 // Fig. 7.3: InicArreglo.java

2 // Inicialización de los elementos de un arreglo con un inicializador de arreglo.
3
4 public class InicArreglo
5 {
6 public static void main(String[] args)
7 {
8 // la lista inicializadora especifica el valor para cada elemento
9 int[] arreglo = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };
10
11 System.out.printf(“%s%8s%n”, “Indice”, “Valor”); // encabezados de
columnas
12
13 // imprime el valor de cada elemento del arreglo
14 for (int contador = 0; contador < arreglo.length; contador++)
15 System.out.printf(“%5d%8d%n”, contador, arreglo[contador]);
16 }
17
7 } // fin de la clase InicArreglo

Indice Valor
0 32
1 27
2 64
3 18
4 95
5 14
6 90
7 70
8 60
9 37

Fig. 7.3 冷 Inicialización de los elementos de un arreglo con un inicializador de arreglo.

7.4.3 Cálculo de los valores a almacenar en un arreglo

La aplicación de la figura 7.4 crea un arreglo de 10 elementos y asigna a cada elemento uno de los enteros
pares del 2 al 20 (2, 4, 6, …, 20). Después, la aplicación muestra el arreglo en formato tabular. La instruc-
ción for en las líneas 12 y 13 calcula el valor de un elemento del arreglo, multiplicando el valor actual de
la variable de control contador por 2, y después le suma 2.

1 // Fig. 7.4: InicArreglo.java

2 // Cálculo de los valores a colocar en los elementos de un arreglo.
3
4 public class InicArreglo
5 {

Fig. 7.4 冷 Cálculo de los valores a colocar en los elementos de un arreglo (parte 1 de 2).

M07_DEITEL_COMO-PROGRAMAR-EN-JAVA_SE_10ED_C7_243-314_3802-1.indd 249 5/4/16 11:30 AM

 250 Capítulo 7 Arreglos y objetos ArrayList

6 public static void main(String[] args)

7 {
8 final int LONGITUD_ARREGLO = 10; // declara la constante
9 int[] arreglo = new int[LONGITUD_ARREGLO]; // crea el arreglo
10
11 // calcula el valor para cada elemento del arreglo
12 for (int contador = 0; contador < arreglo.length; contador++)
13 arreglo[contador] = 2 + 2 * contador;
14
15 System.out.printf(“%s%8s%n”, “Indice”, “Valor”); // encabezados de columnas
16
17
7 // imprime el valor de cada elemento del arreglo
18 for (int contador = 0; contador < arreglo.length; contador++)
19 System.out.printf(“%5d%8d%n”, contador, arreglo[contador]);
20 }
21 } // fin de la clase InicArreglo

Indice Valor
0 2
1 4
2 6
3 8
4 10
5 12
6 14
7 16
8 18
9 20

Fig. 7.4 冷 Cálculo de los valores a colocar en los elementos de un arreglo (parte 2 de 2).

La línea 8 utiliza el modificador final para declarar la variable constante LONGITUD_ARREGLO con el
valor 10. Las variables constantes deben inicializarse antess de usarlas, y no pueden modificarse de ahí en
adelante. Si trata de modificarr una variable final después de inicializarla en su declaración, el compilador
genera el siguiente mensaje de error:

cannot assign a value to final variable nombreVariable

Buena práctica de programación 7.2

Las variables constantes también se conocen como constantes con nombre. Con frecuencia mejoran la
legibilidad de un programa, en comparación con los programas que utilizan valores literales (por ejemplo, 100);
una constante con nombre como LONGITUD_ARREGLOO indica sin duda su propósito, mientras que un valor
literal podría tener distintos significados, según su contexto.

Buena práctica de programación 7.3

Las constantes con nombres compuestos por varias palabras deben tener cada palabra separada, una de la
otra, por un guion bajo (__), como en LONGITUD_ARREGLO.

Error común de programación 7.4

Asignar un valor a una variable final después de inicializarla es un error de compilación. De igual forma,
al tratar de acceder al valor de una variable final antes de inicializarla se produce un error de compilación
como: “variable nombreVariablee might not have been initialized”.

M07_DEITEL_COMO-PROGRAMAR-EN-JAVA_SE_10ED_C7_243-314_3802-1.indd 250 5/4/16 11:30 AM

 7.4 Ejemplos sobre el uso de los arreglos 251

7.4.4 Suma de los elementos de un arreglo

A menudo, los elementos de un arreglo representan una serie de valores que se emplearán en un cálculo.
Por ejemplo, si los elementos del arreglo representan las calificaciones de un examen, es probable que el
profesor desee sumar el total de los elementos del arreglo y utilizar esa suma para calcular el promedio de
la clase para el examen. Los ejemplos de la clase LibroCalificaciones en las figuras 7.14 y 7.18 utilizan
esta técnica.
La figura 7.5 suma los valores contenidos en un arreglo entero de 10 elementos. El programa declara,
crea e inicializa el arreglo en la línea 8. La instrucción for realiza los cálculos. [Nota: los valores suministra-
dos como inicializadores de arreglos generalmente se introducen en un programa, en vez de especificarse
en una lista inicializadora. Por ejemplo, una aplicación podría recibir los valores del usuario o de un archi-
vo en disco (como veremos en el capítulo 15, Archivos, flujos y serialización de objetos). Al hacer que los
datos se introduzcan como entrada en un programa (en vez de “codificarlos a mano” en el mismo) éste se
hace más reutilizable, ya que puede utilizarse con distintoss conjuntos de datos].

1 // Fig. 7.5: SumaArreglo.java

2 // Cálculo de la suma de los elementos de un arreglo.
3
4 public class SumaArreglo
5 {
6 public static void main(String[] args)
7 {
8 int[] arreglo = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
9 int total = 0;
10
11 // suma el valor de cada elemento al total
12 for (int contador = 0; contador < arreglo.length; contador++)
13 total += arreglo[contador];
14
15 System.out.printf(“Total de los elementos del arreglo: %d%n”, total);
16 }
17
7 } // fin de la clase SumaArreglo

Total de los elementos del arreglo: 849

Fig. 7.5 冷 Cálculo de la suma de los elementos de un arreglo.

7.4.5 Uso de gráficos de barra para mostrar en forma gráfica los datos de un arreglo
Muchos programas presentan datos a los usuarios en forma gráfica. Por ejemplo, con frecuencia los valores
numéricos se muestran como barras en un gráfico de barras. En dicho gráfico, las barras más largas repre-
sentan proporcionalmente los valores numéricos más grandes. Una manera sencilla de mostrar los datos
numéricos en forma gráfica es mediante un gráfico de barras que muestre cada valor numérico como una
barra de asteriscos (*).
A los profesores a menudo les gusta analizar la distribución de las calificaciones en un examen. Un
profesor podría graficar el número de calificaciones en cada una de las distintas categorías, para visualizar
la distribución de las calificaciones. Suponga que las calificaciones en un examen fueron 87, 68, 94, 100,
83, 78, 85, 91, 76 y 87. Se incluye una calificación de 100, dos calificaciones en el rango de 90 a 99, cuatro
calificaciones en el rango de 80 a 89, dos en el rango de 70 a 79, una en el rango de 60 a 69 y ninguna por
debajo de 60. Nuestra siguiente aplicación (figura 7.6) almacena estos datos de distribución de las califica-
ciones en un arreglo de 11 elementos, cada uno de los cuales corresponde a una categoría de calificaciones.
Por ejemplo, arreglo[0] indica el número de calificaciones en el rango de 0 a 9, arreglo[7] indica el

M07_DEITEL_COMO-PROGRAMAR-EN-JAVA_SE_10ED_C7_243-314_3802-1.indd 251 5/4/16 11:30 AM

 252 Capítulo 7 Arreglos y objetos ArrayList

número de calificaciones en el rango de 70 a 79 y arreglo[10] indica el número de calificaciones de 100.

Las clases LibroCalificaciones que veremos más adelante en este capítulo (figuras 7.14 y 7.18) contienen
código para calcular estas frecuencias de calificaciones, con base en un conjunto de calificaciones. Por
ahora crearemos el arreglo en forma manual con las frecuencias de las calificaciones dadas.

1 // Fig. 7.6: GraficoBarras.java

2 // Programa para imprimir gráficos de barras.
3
4 public class GraficoBarras
5 {
6 public static void main(String[] args)
7 {
8 int[] arreglo = { 0, 0, 0, 0, 0, 0, 1, 2, 4, 2, 1 };
9
10 System.out.println(“Distribucion de calificaciones:”);
11
12 // para cada elemento del arreglo, imprime una barra del gráfico
13 for (int contador = 0; contador < arreglo.length; contador++)
14 {
15 // imprime etiqueta de la barra (“00-09: ”, ..., “90-99: ”, “100: ”)
16 if (contador == 10)
17
7 System.out.printf(“%5d: ”, 100);
18 else
19 System.out.printf(“%02d-%02d: ”,
20 contador * 10, contador * 10 + 9);
21
22 // imprime barra de asteriscos
23 for (int estrellas = 0; estrellas < arreglo[contador]; estrellas++)
24 System.out.print(“*”);
25
26 System.out.println();
27
7 }
28 }
29 } // fin de la clase GraficoBarras

Distribucion de calificaciones:
00-09:
10-19:
20-29:
30-39:
40-49:
50-59:
60-69: *
70-79: **
80-89: ****
90-99: **
100: *

Fig. 7.6 冷 Programa para imprimir gráficos de barras.

La aplicación lee los números del arreglo y grafica la información en forma de un gráfico de barras. Muestraa
cada rango de calificaciones seguido de una barra de asteriscos, que indican el número de calificaciones en
ese rango. Para etiquetar cada barra, las líneas 16 a 20 imprimen un rango de notas (por ejemplo, “70-79:”)
con base en el valor actual de contador. Cuando contador es 10, la línea 17 imprime 100 con una anchuraa
de campo de 5, seguida de dos puntos y un espacio, para alinear la etiqueta “100:” con las otras etiquetas de

M07_DEITEL_COMO-PROGRAMAR-EN-JAVA_SE_10ED_C7_243-314_3802-1.indd 252 5/4/16 11:30 AM

 7.4 Ejemplos sobre el uso de los arreglos 253

las barras. La instrucción for anidada (líneas 23 y 24) imprime las barras en pantalla. Observe la condición
de continuación de ciclo en la línea 23 (estrellas < arreglo[contador]). Cada vez que el programa
llega al for interno, el ciclo cuenta desde 0 hasta arreglo[contador], con lo cual utiliza un valor en arre-
glo para determinar el número de asteriscos a mostrar en pantalla. En este ejemplo, ningún estudiante re-
cibió una calificación menor de 60, por lo que los valores de arreglo[0] hasta arreglo[5] son ceros, y no
se muestran asteriscos enseguida de los primeros seis rangos de calificaciones. En la línea 19, el especificador
de formato %02d indica que se debe dar formato a un valor int como un campo de dos dígitos. La bande-
ra 0 en el especificador de formato muestra un 0 a la izquierda para los valores con menos dígitos que la
anchura de campo (2).

7.4.6 Uso de los elementos de un arreglo como contadores

En ocasiones, los programas utilizan variables tipo contador para sintetizar datos, como los resultados de
una encuesta. En la figura 6.7 utilizamos contadores independientes en nuestro programa para tirar dados,
para rastrear el número de veces que aparecía cada una de las caras de un dado con seis lados, al tiempo que
la aplicación tiraba el dado 6,000,000 de veces. En la figura 7.7 se muestra una versión de esta aplicación
con un arreglo.

1 // Fig. 7.7: TirarDado.java

2 // Programa para tirar dados que utiliza arreglos en vez de switch.
3 import java.security.SecureRandom;
4
5 public class TirarDado
6 {
7 public static void main(String[] args)
8 {
9 SecureRandom numerosAleatorios = new SecureRandom();
10 int[] frecuencia = new int[ 7 ]; // arreglo de contadores de frecuencia
11
12 // tira el dado 6,000,000 veces; usa el valor del dado como índice de
frecuencia
13 for (int tiro = 1; tiro <= 6000000; tiro++)
14 ++frecuencia[1 + numerosAleatorios.nextInt(6)];
15
16 System.out.printf( “%s%10s%n”, “Cara”, “Frecuencia”);
17
18 // imprime el valor de cada elemento del arreglo
19 for (int cara = 1; cara < frecuencia.length; cara++)
20 System.out.printf(“%4d%10d%n”, cara, frecuencia[cara]);
21 }
22 } // fin de la clase TirarDado

Cara Frecuencia
1 999690
2 999512
3 1000575
4 999815
5 999781
6 1000627

Fig. 7.7 冷 Programa para tirar dados que utiliza arreglos en vez de switch.

La figura 7.7 utiliza el arreglo frecuencia (línea 10) para contar las ocurrencias de cada lado del dado.
La instrucción individual en la línea 14 de este programa sustituye las líneas 22 a 45 de la figura 6.7
7. La líneaa
14 utiliza el valor aleatorio para determinar qué elemento de frecuencia debe incrementar durante cada

M07_DEITEL_COMO-PROGRAMAR-EN-JAVA_SE_10ED_C7_243-314_3802-1.indd 253 5/4/16 11:30 AM

 254 Capítulo 7 Arreglos y objetos ArrayList

iteración del ciclo. El cálculo en la línea 14 produce números aleatorios del 1 al 6, por lo que el arreglo
frecuencia debe ser lo bastante grande como para poder almacenar seis contadores. Sin embargo, utiliza-
mos un arreglo de siete elementos, en el cual ignoramos frecuencia[0]; es más lógico que el valor de cara
1 incremente a frecuencia[1] que a frecuencia[0]. Por ende, cada valor de cara se utiliza como subín-
dice para el arreglo frecuencia. En la línea 14, se evalúa primero el cálculo dentro de los corchetes para
determinar qué elemento del arreglo se debe incrementar, y después el operador ++ suma uno a ese elemen-
to. También sustituimos las líneas 49 a 51 de la figura 6.7 por un ciclo a través del arreglo frecuencia para
imprimir los resultados en pantalla (líneas 19 a 20). Cuando estudiemos las nuevas capacidades de progra-
mación funcional de Java SE 8 en el capítulo 17, le mostraremos cómo reemplazar las líneas 13-14 y 19-20
¡con una sola instrucción!

7.4.7 Uso de arreglos para analizar los resultados de una encuesta

Nuestro siguiente ejemplo utiliza arreglos para sintetizar los resultados de los datos recolectados en una
encuesta. Considere la siguiente declaración de un problema:
Se pidió a veinte estudiantes que calificaran la calidad de la comida en la cafetería estudiantil en una
escala del 1 al 5, en donde 1 significa “pésimo” y 5 significa “excelente”. Coloque las 20 respuestas en
un arreglo entero y determine la frecuencia de cada calificación.
Ésta es una típica aplicación de procesamiento de arreglos (figura 7.8). Deseamos resumir el número de
respuestas de cada tipo (es decir, del 1 al 5). El arreglo respuestas (líneas 9 a 10) es un arreglo entero
de 20 elementos que contiene las respuestas de los estudiantes a la encuesta. El último valor en el arreglo es,
intencionalmente, una respuesta incorrecta (14). Cuando se ejecuta un programa en Java, se verifica la validez
de los índices de los elementos del arreglo; todos los índices deben ser mayores o iguales a 0 y menores que
la longitud del arreglo. Cualquier intento de acceder a un elemento fuera de ese rango de índices produce un
error en tiempo de ejecución, el cual se conoce como ArrayIndexOutOfBoundsException. Al final de esta
sección, hablaremos sobre el valor de respuesta inválido, demostraremos la comprobación de límites de un
arreglo e introduciremos el mecanismo de manejo de excepcioness de Java, el cual se puede utilizar para detectar
y manejar una excepción ArrayIndexOutOfBoundsException.

1 // Fig. 7.8: EncuestaEstudiantes.java

2 // Programa de análisis de una encuesta.
3
4 public class EncuestaEstudiantes
5 {
6 public static void main(String[] args)
7 {
8 // arreglo de respuestas de estudiantes (lo más común es que se
introduzcan en tiempo de ejecución)
9 int[] respuestas = { 1, 2, 5, 4, 3, 5, 2, 1, 3, 3, 1, 4, 3, 3, 3,
10 2, 3, 3, 2, 14 };
11 int[] frecuencia = new int[6]; // arreglo de contadores de frecuencia
12
13 // para cada respuesta, selecciona el elemento de respuestas y usa ese
valor
14 // como índice de frecuencia para determinar el elemento a incrementar
15 for (int respuesta = 0; respuesta < respuestas.length; respuesta++)
16 {
17
7 try
18 {
19 ++frecuencia[respuestas[respuesta]];

Fig. 7.8 冷 Programa de análisis de una encuesta (parte 1 de 2).

M07_DEITEL_COMO-PROGRAMAR-EN-JAVA_SE_10ED_C7_243-314_3802-1.indd 254 5/4/16 11:30 AM

 7.4 Ejemplos sobre el uso de los arreglos 255

20 }
21 catch (ArrayIndexOutOfBoundsException e)
22 {
23 System.out.println(e); // invoca el método toString
24 System.out.printf( " respuestas[%d] = %d%n%n",
25 respuesta, respuestas[respuesta]);
26 }
27
7 }
28
29 System.out.printf(“%s%10s%n”, “Calificacion”, “Frecuencia”);
30
31 // imprime el valor de cada elemento del arreglo
32 for (int calificacion = 1; calificacion < frecuencia.length; calificacion++)
33 System.out.printf(“%6d%10d%n”, calificacion, frecuencia[calificacion]);
34 }
35 } // fin de la clase EncuestaEstudiantes

java.lang.ArrayIndexOutOfBoundsException: 14
respuestas[19] = 14

Calificacion Frecuencia
1 3
2 4
3 8
4 2
5 2

Fig. 7.8 冷 Programa de análisis de una encuesta (parte 2 de 2).

El arreglo frecuencia
Utilizamos el arreglo de seis elementoss llamado frecuencia (línea 11) para contar el número de ocurrencias
de cada respuesta. Cada elemento del arreglo se utiliza como un contadorr para uno de los posibles tipos de
respuestas de la encuesta, de tal forma que frecuencia[1] cuenta el número de estudiantes que calificaron
la comida como 1, frecuencia[2] cuenta el número de estudiantes que calificaron la comida como 2, y así
en lo sucesivo.

Síntesis de los resultados

El ciclo for (líneas 15 a 27) recibe las respuestas del arreglo respuestas una a la vez, e incrementa uno
de los contadores frecuencia[1] a frecuencia[5]; ignoramos frecuencia[0] ya que las respuestas de la
encuesta se limitan al rango de 1 a 5. La instrucción clave en el ciclo aparece en la línea 19. Esta instrucción
incrementa el contador de frecuencia apropiado, dependiendo del valor de respuestas[respuesta].
Vamos a recorrer las primeras iteraciones de la instrucción for:
• Cuando el contador respuesta es 0, el valor de respuestas[respuesta] es el valor de
respuestas[0] (es decir, 1; vea la línea 9). En este caso, frecuencia[respuestas[respuesta]]
se interpreta como frecuencia[1], y el contador frecuencia[1] se incrementa en uno. Para
evaluar la expresión, empezamos con el valor en el conjunto más interno de corchetes (respuesta,
actualmente 0). El valor de respuesta se inserta en la expresión y se evalúa el siguiente conjun-
to de corchetes (respuestas[respuesta]). Ese valor se utiliza como subíndice del arreglo
frecuencia, para determinar cuál contador se incrementará (en este caso, frecuencia[1]).

M07_DEITEL_COMO-PROGRAMAR-EN-JAVA_SE_10ED_C7_243-314_3802-1.indd 255 5/4/16 11:30 AM

 256 Capítulo 7 Arreglos y objetos ArrayList

• En la siguiente iteración del ciclo, respuesta es 1, por lo que respuestas[respuesta] es el valor

de respuestas[1] (es decir, 2; vea la línea 9). Por lo tanto, frecuencia[respuestas[respues-
ta]] se interpreta como frecuencia[2], lo cual provoca que se incremente frecuencia[2].

• Cuando respuesta es 2, respuestas[respuesta] es el valor de respuestas[2] (es decir, 5;

vea la línea 9). Por lo tanto, frecuencia[respuestas[respuesta]] se interpreta como frecuen-
cia[5], lo cual provoca que se incremente frecuencia[5], y así en lo sucesivo.

Sin importar el número de respuestas procesadas en la encuesta, el programa sólo requiere un arreglo de
seis elementos (en el cual se ignora el elemento cero) para resumir los resultados, ya que todos los valores
de las respuestas se encuentran entre 1 y 5, y los valores de subíndice para un arreglo de seis elementos
son del 0 al 5. En la salida del programa, la columna Frecuencia sintetiza sólo 19 de los 20 valores en el
arreglo respuestas; el último elemento del arreglo respuestas contiene una respuesta (intencional-
mente) incorrecta que no se contó. En la sección 7.5 hablaremos sobre lo que ocurre cuando el programa
de la figura 7.8 encuentra la respuesta inválida (14) en el último elemento del arreglo respuestas.

7.5 Manejo de excepciones: procesamiento de la respuesta

incorrecta
Una excepción indica un problema que ocurre mientras se ejecuta un programa. El nombre “excepción”
sugiere que el problema no ocurre con frecuencia; si la “regla” es que una instrucción por lo general se
ejecuta en forma correcta, entonces el problema representa la “excepción a la regla”. El manejo de ex-
cepciones nos permite crear programas tolerantes a fallas que pueden resolver (o manejar) las excep-
ciones. En muchos casos, esto permite a un programa continuar su ejecución como si no hubiera encon-
trado ningún problema. Por ejemplo, la aplicación EncuestaEstudiantes sigue mostrando resultados
(figura 7.8), aun cuando una de las respuestas esté fuera del rango. Los problemas más severos podrían
evitar que un programa continuara su ejecución normal, en vez de requerir que el programa notifique al
usuario sobre el problema y luego termine. Cuando la JVM o un método detecta un problema, como un
índice de arreglo inválido o el argumento de un método inválido, lanza una excepción; es decir, ocurre
una excepción. Los métodos en sus propias clases también lanzan excepciones, como veremos en el ca-
pítulo 8.

7.5.1 La instrucción try

Para manejar una excepción, hay que colocar el código que podría lanzar una excepción en una instruc-
ción try (líneas 17 a 26). El bloque try (líneas 17 a 20) contiene el código que podría lanzar una ex-
cepción, y el bloque catch (líneas 21 a 26) contiene el código que maneja la excepción, si ocurre una.
Puede tener muchoss bloques catch para manejar distintos tiposs de excepciones que podrían lanzarse en
el bloque try correspondiente. Cuando la línea 19 incrementa en forma correcta un elemento del arre-
glo frecuencia, se ignoran las líneas 21 a 26. Se requieren las llaves que delimitan los cuerpos de los
bloques try y catch.

7.5.2 Ejecución del bloque catch

Cuando el programa encuentra el valor inválido 14 en el arreglo respuestas, intenta sumar 1 a frecuen-
cia[14], que está fuera a de los límites del arreglo, debido a que frecuencia sólo tiene seis elementos (con
los índices 0 a 5). Como la comprobación de los límites de un arreglo se realiza en tiempo de ejecución, la
JVM genera una excepción; en específico, la línea 19 lanza una excepción ArrayIndexOutOfBoundsExcep-
tion para notificar al programa sobre este problema. En este punto, el bloque try termina y el bloque
catch comienza a ejecutarse. Si usted declaró variables locales en el bloque try, ahora se encuentran fuera
de alcancee (y ya no existen), por lo que no son accesibles en el bloque catch.

M07_DEITEL_COMO-PROGRAMAR-EN-JAVA_SE_10ED_C7_243-314_3802-1.indd 256 5/4/16 11:30 AM

 7.6 Ejemplo práctico: simulación para barajar y repartir cartas 257

El bloque catch declara un parámetro de excepción (e) de tipo (IndexOutOfRangeException). El

bloque catch puede manejar excepciones del tipo especificado. Dentro del bloque catch, usted puede usar
el identificador del parámetro para interactuar con un objeto excepción atrapada.

Tip para prevenir errores 7.1

Al escribir código para acceder al elemento de un arreglo, hay que asegurar que el índice del arreglo siempre
sea mayor o igual a 0 y menor que la longitud del arreglo. Esto le ayudará a evitar excepciones del tipo
ArrayIndexOutOfBoundsException si su programa es correcto.

Observación de ingeniería de software 7.1

Los sistemas en la industria que han pasado por pruebas exhaustivas aún tienen probabilidades de contener
errores. Nuestra preferencia por los sistemas de calidad industrial es atrapar y lidiar las excepciones en tiempo
de ejecución, como las excepciones ArrayIndexOutOfBoundsException, para asegurar que un sistema
permanezca funcionando o se degrade de manera elegante, e informar a los desarrolladores del sistema sobre
el problema.

7.5.3 El método toString del parámetro de excepción

Cuando las líneas 21 a 26 atrapan la excepción, el programa muestra un mensaje para indicar el problema
que ocurrió. La línea 23 realiza una llamada implícita al método toString del objeto excepción para obte-
ner el mensaje de error almacenado en el objeto excepción y mostrarlo. Una vez que se muestra el mensaje
en este ejemplo, el programa considera que se manejóó la excepción y continúa con la siguiente instrucción
después de la llave de cierre del bloque catch. En este ejemplo se llega al fin de la instrucción for (línea 27),
por lo que el programa continúa con el incremento de la variable de control en la línea 15. En el capítulo 8
hablaremos sobre el manejo de excepciones de nuevo, y en el capítulo 11 presentaremos un análisis más
detallado.

7.6 Ejemplo práctico: simulación para barajar y repartir cartas

Hasta ahora, en los ejemplos en este capítulo hemos utilizado arreglos que contienen elementos de tipos
primitivos. En la sección 7.2 vimos que los elementos de un arreglo pueden ser de tipos primitivos o de
tipos por referencia. En esta sección utilizaremos la generación de números aleatorios y un arreglo de ele-
mentos de tipo por referencia (objetos que representan cartas de juego) para desarrollar una clase que si-
mule los procesos de barajar y repartir cartas. Después podremos utilizar esta clase para implementar
aplicaciones que ejecuten juegos específicos de cartas. Los ejercicios al final del capítulo utilizan las clases
que desarrollaremos aquí para crear una aplicación simple de póquer.
Primero desarrollaremos la clase Carta (figura 7.9), la cual representa una carta de juego que tiene
una cara (“As”, “Dos”, “Tres”, … “Joker”, “Reina”, “Rey”) y un palo (“Corazones”, “Diamantes”,
“Treboles”, “Espadas”). Después desarrollaremos la clase PaqueteDeCartas (figura 7.10), la cual crea
un paquete de 52 cartas en las que cada elemento es un objeto Carta. Luego construiremos una aplica-
ción de prueba (figura 7.11) para demostrar las capacidades de barajar y repartir cartas de la clase
PaqueteDeCartas.

La clase Carta
La clase Carta (figura 7.9) contiene dos variables de instancia String (cara y palo) que se utilizan para
almacenar referencias al nombre de la cara y al del palo para una Carta específica. El constructor de
la clase (líneas 10 a 14) recibe dos objetos String que utiliza para inicializar cara y palo. El método
toString (líneas 17 a 20) crea un objeto String que consiste en la cara de la carta, el objeto String

M07_DEITEL_COMO-PROGRAMAR-EN-JAVA_SE_10ED_C7_243-314_3802-1.indd 257 5/4/16 11:30 AM

 258 Capítulo 7 Arreglos y objetos ArrayList

“de ” y el palo de la carta. El método toString de Carta puede invocarse en forma explícita para obtener
la representación de cadena de un objeto Carta (por ejemplo, “As de Espadas”). El método toString de
un objeto se llama en forma implícita cuando el objeto se utiliza en donde se espera un objeto String
(por ejemplo, cuando printf imprime en pantalla el objeto como un String, usando el especificador
de formato %s, o cuando el objeto se concatena con un objeto String mediante el operador +). Para que
ocurra este comportamiento, toString debe declararse con el encabezado que se muestra en la figura 7.9.

1 // Fig. 7.9: Carta.java

2 // La clase Carta representa una carta de juego.
3
4 public class Carta
5 {
6 private final String cara; // cara de la carta (“As”, “Dos”, ...)
7 private final String palo; // palo de la carta (“Corazones”, “Diamantes”, ...)
8
9 // el constructor de dos argumentos inicializa la cara y el palo de la carta
10 public Carta(String caraCarta, String paloCarta)
11 {
12 this.cara = caraCarta; // inicializa la cara de la carta
13 this.palo = paloCarta; // inicializa el palo de la carta
14 }
15
16 // devuelve representación String de Carta
17
7 public String toString()
18 {
19 return cara + “ de ” + palo;
20 }
21 } // fin de la clase Carta

Fig. 7.9 冷 La clase Carta representa una carta de juego.

La clase PaqueteDeCartas
La clase PaqueteDeCartas (figura 7.10) declara como variable de instancia un arreglo Carta llamado
paquete (línea 7). Un arreglo de tipo por referencia a se declara igual que cualquier otro arreglo. La
clase PaqueteDeCartas también declara la variable de instancia entera llamada cartaActual (línea 8), que
representa el número de secuencia (0 a 51) de la siguiente Carta a repartir del arreglo paquete, así como
una constante con nombre NUMERO_DE_CARTAS (línea 9), que indica el número de objetos Carta en el
paquete (52).

1 // Fig. 7.10: PaqueteDeCartas.java

2 // La clase PaqueteDeCartas representa un paquete de cartas de juego.
3 import java.util.SecureRandom;
4
5 public class PaqueteDeCartas
6 {

Fig. 7.10 冷 La clase PaqueteDeCartas representa un paquete de cartas de juego (parte 1 de 2).

M07_DEITEL_COMO-PROGRAMAR-EN-JAVA_SE_10ED_C7_243-314_3802-1.indd 258 5/4/16 11:30 AM