Los bucles se utilizan para ejecutar un conjunto de instrucciones varias veces basándose siempre en una condición que decidirá si se sigue repitiendo o no. Veamos los tipos que hay.

Bucle While

while (expresion) {sentencias}

Las instrucciones dentro de las llaves se ejecutan mientras la expresión sea verdadera.

i=5;
while ( i > 0 ) {i --;}
// las llaves aquí se podían haber omitido, puesto
// que solo hay una sentencia.
System.out.println("Ahora i vale 0");

Bucle For

Es un bucle más "fijo", permite ejecutar el conjunto de sentencias un numero determinado de veces fijado al principio del bucle y funciona por tanto como un contador. Su expresión general seria como la que sigue:

for (inicialización, expresionBooleana, incremento) {conjuntoDeSentencias;}

for (int i= 0; i <10; i++){     System.out.println("el valor de i es: " + i); }

Este ejemplo nos mostraría por la pantalla diez líneas diciéndonos el valor creciente de 'i' de cero a nueve.

Bucle do while

Es igual al bucle while anteriormente visto, solo que ahora se evalúa la expresión al final del bucle, por lo que ese conjunto de sentencias se ejecuta al menos una vez:

i=5;
do
{i --;} // las llaves aquí se pueden omitir puesto
while ( i > 0 ) // que solo hay una sentencia.

Este ejemplo similar al anterior para el bucle while se diferencia en que ejecuta una vez mas las sentencias en su cuerpo puesto que comprueba la condición posteriormente.

Sentencias Break, Continue y Return

Antes hemos hablado de la sentencia Break con las bifurcaciones switch. Pues bien, esta sentencia tiene un valor mas amplio. La sentencia break nos permite salirnos del bloque de sentencias (encerrado entre llaves) o el bucle que estamos ejecutando, sin ejecutar las sentencias que resten para el final o las restantes iteraciones del bucle. Por ejemplo:

i=5;
do{
   i --;
   if (i == 3) break;
} while ( i > 0 )
// En este ejemplo cuando i tenga el valor 3
// se abandonará el bucle.

La sentencia Continue solo es válida para bucles, sirve para no ejecutar las sentencias que restan para la finalización de una iteración de ese bucle, continuando después con las siguientes iteraciones del bucle. Por ejemplo:

i=5;
do{
    if (i == 3) continue;     i --;
}while ( i > 0 ) // En este ejemplo cuando i tenga el valor 3
// se abandonará la iteración y por tanto el
// bucle no tendrá fin puesto que no se
// ejecutaría la sentencia de decremento.

Tanto la sentencia continue como break se pueden utilizar con etiquetas para poder discriminar los bucles que quieren afectar en caso de que se encuentren en un bucle anidado. Por ejemplo:

Bucle1:
for (int i=0; i<10; i++){
    bucle2:
    for (int j=0; i<10; j++){
       if (j==5) {break bucle2;}
    }
} // cuando j llega a 5 el bucle2 deja de
// ejecutarse hasta la siguiente iteracion
// del bloque1

Por último vemos la sentencia return. Esta sentencia nos permite finalizar también un conjunto de sentencias, con la peculiaridad esta vez de que también finaliza el método o función que en el que se encuentre. En el caso de que queramos devolver un valor desde esa función o método lo debemos poner a continuación de return. Por ejemplo:

void funcionEjemplo(){
    int i=0;
    while (i < 100){ //esta absurda función nos devuelve
       i++; //al llamarla el valor 100 como has
    } //podido comprobar
    return i;
}

Bloque Try – Catch – Finally

Se trata de unas sentencias de control relacionadas con el tratamiento de excepciones, no tiene nada que ver con las estructuras de control de bucle, vistas en este artículo, salvo porque es también una estructura de control. La comentamos a continuación, aunque se verá con ejemplos más adelante.

El tratamiento de excepciones se utiliza para detectar errores cuando se ejecutan nuestros programas y tratarlos del modo que nosotros queramos. Los errores cazados por un sistema de tratamiento de excepciones no bloquean el programa y el manejo de excepciones nos permite hacer cosas cuando esos errores ocurren.

Por ahora solo es bueno que sepas que existen, ya las veremos en otro momento.