Manual de Java

Volver a índice

Capítulo 3. Control del flujo.

• Ramificación
  • if-else
  • break
  • switch
  • return
• Bucles
  • while
  • do-while
  • for
  • Sentencias separadas por comas
  • continue
• Excepciones

El control del flujo es la manera que tiene un lenguaje de programación de provocar que el flujo de la ejecución avance y se ramifique en función de los cambios de estado de los datos. La ramificación, iteración, selección y llamadas a subrutina son formas de control de flujo.

Ramificación

En los programas se necesitará que algunas sentencias se ejecuten condicionalmente y se omitan otras. Java proporciona varios mecanismos para conseguir este control y decidir qué partes del código ejecutar, mediante sus sentencias de ramificación.

if-else

La construcción if-else provoca que la ejecución atraviese un conjunto de estados boolean que determinan que se ejecuten distintos fragmentos de código.

if ( expresión-booleana ) sentencia1; [ else sentencia2; ]

La cláusula else es opcional. Cada una de las sentencias puede ser una sentencia compuesta encerrada entre llaves, { }. Una expresión-booleana es cualquier expresión que devuelve un valor boolean. Podría ser una variable simple declarada como boolean.

boolean datosdisponibles;	int bytesdisponibles;
// ...				// ...
if (datosdisponibles)			if (bytesdisponibles > 0)
	ProcesarDatos();			ProcesarDatos();
else                          		else
	esperarAMasDatos();                	esperarAMasDatos();

Si se desea incluir más sentencias después del if o else, hay que utilizar las llaves como en este código ejemplo.

int bytesDisponibles;
// ...
if (bytesDisponibles > 0) {
	ProcesarDatos();
	bytesDisponibles -= n;
} else
	esperarAMasDatos();

break

La sentencia break de Java está diseņada para cubrir aquellos casos en los que saltar arbitrariamente a una porción de código es una constucción valiosa y legítima para el control del flujo. El término break se refiere al acto de salirse de un bloque de código. Le dice al intérprete que retome la ejecución pasado el final del bloque.

switch

La sentencia switch proporciona una forma limpia de dirigir la ejecución a partes diferentes del código en base al valor de una variable o expresión. Esta es la forma general de la sentencia switch:

switch ( expresión ) {
	case valor1:
		break;
	case valor2:
		break;
	case valorN:
		break;
	default:
}

El valor de expresión se compara con cada uno de los valores literales de las sentencias case. Si coincide con alguno, se ejecuta el código que sigue a la sentencia case. Si no coincide con ninguno de ellos, entonces se ejecuta la sentencia default (por defecto). La sentencia default es opcional. La sentencia break, comentada anteriormente, hace, en este caso, que la ejecución salte al final del switch. Si no se pone el break, la ejecución continuará en el siguiente case.

return

Como se explicará en el siguiente capítulo, Java utiliza una forma de subrutina llamada método para implementar una interfaz de procedimiento a las clases de objetos. En cualquier momento dentro de un método, se puede utilizar la sentencia return para que la ejecución salte y vuelva al punto donde se llamó al método.

Bucles

Un bucle es lo que llamamos ejecutar repetidamente el mismo bloque de código hasta que cumpla una condición de terminación. Hay cuatro partes en cualquier bucle, inicialización, cuerpo, iteración y terminación . La inicialización es el código que establece las condiciones iniciales de un bucle. El cuerpo es la sentencia que queremos repetir. La iteración es el código que queremos ejecutar después de cuerpo, pero antes de entrar de nuevo en el bucle. Se utiliza a menudo para incrementar o decrementar contadores e índices. La terminación es la expresión booleana que comprueba cada vez a lo largo de un bucle para ver si ha llegado el momento de parar de iterar. Java tiene tres construcciones para bucles: while, do-while y for.

while

Ejecuta una sentencia repetidamente mientras una expresión booleana sea verdadera. Esta es su forma general:

[ inicialización; ]
while ( terminación ) {
	cuerpo;
	[ iteración; ]
}

Las partes inicialización e iteración son opcionales, y mientras la expresión terminación devuelva un valor true, la sentencia cuerpo continuará ejecutándose.

do-while

La contrucción do-while se utiliza cuando se desea ejecutar el cuerpo de un bucle while al menos una vez, incluso si la expresión booleana tiene el valor false la primera vez. Es decir si se desea evaluar la expresión de terminación al final del bucle en vez de al principio como en el while.

[ inicialización; ]
do { cuerpo; [ iteración; ] } while ( terminación );

for

La sentencia for es una forma compacta de expresar un bucle.

for ( inicalización; terminación; iteración ) cuerpo;

Si las condiciones iniciales no provocan que la terminación devuelva true la primera vez, entonces la sentencia cuerpo e iteración no se ejecutarán nunca. Ejemplo de un bucle for:

for (int i = 1; i <= 10; i++)
	System.out.println("i = " + i);

Aunque no hemos estudiado todavía las clases de Java, comentar brevemente que este bucle imprime en pantalla desde 1 hasta 10 el índice ( i ) del bucle mediante el método println.

Sentencias separadas por comas

A veces se podría desear incluir más de un sentencia en las sentencias de inicialización y de iteración. Java proporciona una manera de expresar sentencias múltiples mediante la utilización de comas ( , ) en el interior de los paréntesis de un bucle for. Por lo tanto puede ponerse tantas sentencias como se desee, siempre y cuando estén separadas por comas.

int a, b;
for (a = 1, b = 4, a < b, a++, b--) {
	System.out.println("a = " + a);
	System.out.println("b = " + b);
}

El bucle anterior sólo se ejecuta dos veces y su salida es la siguiente:

a = 1
b = 4
a = 2
b = 3

continue

Del mismo modo que se desea salir prematuramente de un bucle, se podría desear continuar en el bucle, pero dejar de procesar el resto de código en esta interación en concreto. La sentencia continue de Java salta del cuerpo de bucle, pero permaneciendo en el bucle.

for (int i = 0; i < 10; i++) {
	System.out.print(i + " ");
	if (i % 2 == 0)
		continue;
	System.out.println("");
}

Este bucle utiliza continue para provocar que se impriman dos números en cada línea.

Excepciones

La última manera de provocar un salto en el flujo de un código es utilizando el mecanismo de gestión de excepciones de Java. Las sentencias try, catch, throw y finally se utilizan para expresar este modelo potente para ramificación no local. La gestión de excepciones se utiliza muy a menudo en las clases de Java fundamentales y le dedicaremos más adelante un capítulo completo a su estudio.