Cursos gratuitos de programacion de ordenadores, en español

AnteriorPosterior

6. Bucles (partes del programa que se repiten)

  Curso: Introducción a Java

6. Bucles: Partes del programa que se repiten

(Nota: al igual que ocurría con los dos apartados anteriores, los bucles en Java son muy parecidos a los de C y C++: quien conozca alguno de esos dos lenguajes, podrá avanzar rápido en este tema)

Con frecuencia tendremos que hacer que una parte de nuestro programa se repita (es lo que llamaremos un "bucle"). Este trozo de programa se puede repetir mientras se cumpla una condición o bien un cierto número prefijado de veces.

6.1. while

Java incopora varias formas de conseguirlo. La primera que veremos es la orden "while", que hace que una parte del programa se repita mientras se cumpla una cierta condición. Su formato será:

 
while (condición)
    sentencia;

Es decir, la sintaxis es similar a la de "if", con la diferencia de que aquella orden realizaba la sentencia indicada una vez como máximo (si se cumplía la condición), pero "while" puede repetir la sentencia más de una vez (mientras la condición sea cierta). Al igual que ocurría con "if", podemos realizar varias sentencias seguidas (dar "más de un paso") si las encerramos entre llaves:

// While1.java
// Comprobación repetitiva de condiciones con "while"
// Introducción a Java, Nacho Cabanes
 
class While1 { 
 
    public static void main( String args[] ) { 
 
        int x = 10;
 
        while (x > 5) {
            System.out.println( "x aún es mayor que 5" );
            x--;
        #125;
    }
}
 

Esta estructuras repetitivas se pueden usar para hacer "contadores". Por ejemplo, un programa que contase del 1 al 5 (y escribiese todos esos números) podría ser:

// While2.java
// Contar del 1 al 5 con "while"
// Introducción a Java, Nacho Cabanes
 
class While2 { 
 
    public static void main( String args[] ) { 
 
        int x = 1;
 
        while (x <= 5) {
            System.out.println( x );
            x++;
        }
    }
}
 

Ejercicio propuesto 6.1.1: Crea un programa que muestre los números del 1 al 10, usando "while"

Ejercicio propuesto 6.1.2: Crea un programa que muestre los números pares del 20 al 2, decreciendo, usando "while"

Ejercicio propuesto 6.1.3: Crea un programa que muestre la "tabla de multiplicar del 5", usando "while"

Ejercicio propuesto 6.1.4: Crea un programa que pida al usuario un número entero y muestre su cuadrado. Se repetirá mientras el usuario introduzca un número distinto de cero.

Ejercicio propuesto 6.1.5: Crea un programa que pida al usuario su login (un número entero) y su contraseña (otro número entero). Se repetirá mientras el usuario introduzca un login distinto de "1809" o una contraseña distinta de "1234".

Ejercicio propuesto 6.1.6: Crea un programa que escriba en pantalla tantos asteriscos como el usuario indique, todos ellos en la misma línea.

6.2. do-while

Existe una variante de este tipo de bucle. Es el conjunto do..while, cuyo formato es:

 
do {
    sentencia;
} while (condición)

En este caso, la condición se comprueba al final, lo que quiere decir que las "sentencias" intermedias se realizarán al menos una vez, cosa que no ocurría en la construcción anterior (un único "while" antes de las sentencias), porque con "while", si la condición era falsa desde un principio, los pasos que se indicaban a continuación de "while" no llegaban a darse ni una sola vez.

Un ejemplo típico de esta construcción "do..while" es cuando queremos que el usuario introduzca una contraseña que le permitirá acceder a una cierta información:

// DoWhile1.java
// Comprobación repetitiva de condiciones con "do-while"
// Introducción a Java, Nacho Cabanes
 
import java.util.Scanner;
 
class DoWhile1 { 
 
    public static void main( String args[] ) { 
 
        int password;
 
        Scanner teclado = new Scanner(System.in);
 
        do {
 
            System.out.print( "Introduzca su password numérica: " );
            password = teclado.nextInt();    
 
            if (password != 1234)
                System.out.println( "No es válida." );
        }        
        while (password != 1234);
    }
}
 

Por supuesto, también podemos contar con un do..while, siempre y cuando tengamos en cuenta que la condición se comprueba al final, lo que puede hacer que la lógica sea un poco distinta en algunos casos:

// DoWhile2.java
// Contador con "do-while"
// Introducción a Java, Nacho Cabanes
 
import java.util.Scanner;
 
class DoWhile2 { 
 
    public static void main( String args[] ) { 
 
        int n = 0;
 
        do {
 
            n++;
            System.out.print( n + " " );
        }        
        while (n < 5);
    }
}
 

Ejercicio propuesto 6.2.1: Crea un programa que muestre los números del 1 al 10, usando "do-while"

Ejercicio propuesto 6.2.2: Crea un programa que muestre los números pares del 20 al 2, decreciendo, usando "do-while"

Ejercicio propuesto 6.2.3: Crea un programa que muestre la "tabla de multiplicar del 5", usando "do-while"

Ejercicio propuesto 6.2.4: Crea un programa que pida al usuario dos números enteros y muestre su suma. Se repetirá hasta que los dos sean 0. Emplea do-while.

Ejercicio propuesto 6.2.5: Crea un programa que pida al usuario su login (un número entero) y su contraseña (otro número entero). Se repetirá hasta que el usuario introduzca como login "1809" y como contraseña "1234". En esta ocasión, hazlo con do-while.

Ejercicio propuesto 6.2.6: Crea un programa que pida un número de tipo byte al usuario y escriba en pantalla un cuadrado formado por asteriscos, que tendrá como alto y ancho la cantidad introducida por el usuario.

6.3. for

Una tercera forma de conseguir que parte de nuestro programa se repita es la orden "for". La emplearemos sobre todo para conseguir un número concreto de repeticiones. En lenguajes como BASIC su formato es muy simple: "FOR x = 1 TO 10" irá recorriendo todos los valores de x, desde uno hasta 10. En Java y otros lenguajes que derivan de C, su sintaxis es más enrevesada:

for ( valor_inicial ; condicion_continuacion ; incremento ) {
sentencias
}

Es decir, indicamos entre paréntesis, y separadas por puntos y coma, tres órdenes:

  • La primera orden dará el valor inicial a una variable que sirva de control.
  • La segunda órden será la condición que se debe cumplir mientras que se repitan las sentencias.
  • La tercera orden será la que se encargue de aumentar -o disminuir- el valor de la variable, para que cada vez quede un paso menos por dar.

Esto se se verá mejor con un ejemplo. Podríamos repetir 10 veces un bloque de órdenes haciendo:

// For1.java
// Repetición con "for" 1: contar de 1 a 10
// Introducción a Java, Nacho Cabanes
 
class For1 { 
 
    public static void main( String args[] ) { 
 
        int i;
 
        for ( i=1 ; i<=10 ; i++ ) { 
            System.out.println( "El contador vale "+i );
        }
    }
}
 

(inicialmente i vale 1, hay que repetir mientras sea menor o igual que 10, y en cada paso hay que aumentar su valor una unidad),

O bien podríamos contar descendiendo desde el 10 hasta el 2, con saltos de 2 unidades en 2 unidades, así:

// For3.java
// Variable declarada dentro de un "for"
// Introducción a Java, Nacho Cabanes
 
class For3 { 
 
    public static void main( String args[] ) { 
 
        int i;
 
        for ( i=10 ; i>=0 ; i-=2 ) { 
            System.out.println( "El contador vale "+i );
        }
 
    }
}
 

Nota: se puede observar una equivalencia casi inmediata entre la orden "for" y la orden "while". Así, el ejemplo anterior se podría reescribir empleando "while", de esta manera:

// While3.java
// Repetición con "while": descontar de 10 a 0, de 2 en 2
// Programa equivalente a "For2.java"
// Introducción a Java, Nacho Cabanes
 
class While3 { 
 
    public static void main( String args[] ) { 
 
        int i;
 
        i=10 ; 
        while ( i>=0 ) { 
            System.out.println( "El contador vale "+i );
            i-=2;
        }
 
    }
}
 

No hay obligación de declarar las variables justo al principio del programa. También se pueden declarar en puntos posteriores del fuente. Por eso, un sitio habitual para declarar la variable que actúa de contador de un "for" es dentro del propio "for", así:

// For3.java
// Variable declarada dentro de un "for"
// Introducción a Java, Nacho Cabanes
 
class For3 { 
 
    public static void main( String args[] ) { 
 
        for (int i=10 ; i>=0 ; i-=2 ) { 
            System.out.println( "El contador vale "+i );
        }
 
    }
}
 

Esto tiene la ventaja de que no podemos reutilizar esa variable "i" después de salir del "for", porque "se destruye" automáticamente y obtendríamos un mensaje de error si tratamos de usarla. Así evitamos efectos indeseados de que cambios en una parte del programa afecten a otra parte del programa porque estemos reutilizando una variable sin darnos cuenta.

Ejercicio propuesto 6.3.1: Crea un programa que muestre los números del 1 al 15, usando "for"

Ejercicio propuesto 6.3.2: Crea un programa que muestre los números pares del 20 al 2, decreciendo, usando "for"

Ejercicio propuesto 6.3.3: Crea un programa que muestre la "tabla de multiplicar del 5", usando "for"

Ejercicio propuesto 6.3.4: Crea un programa que muestre los números enteros del 0 al 100 que son múltiplos de 6 (el resto al dividir por 6 sea 0).

Ejercicio propuesto 6.3.5: Crea un programa que muestre los números enteros entre 0 y el que introduzca el usuario que sean múltiplos de 3 (el resto al dividir por 3 es 0) y a la vez múltiplos de 7 (ídem).

Ejercicio propuesto 6.3.6: Crea un programa que pida dos números de tipo byte al usuario y escriba en pantalla un cuadrado formado por asteriscos, que tendrá como alto el primer número y como ancho el segundo número.

Ejercicio propuesto 6.3.7: Crea un programa que pida un número de tipo byte al usuario y escriba en pantalla un cuadrado hueco, que tendrá un borde formado por asteriscos y su interior serán espacios en blanco. Por ejemplo, para un tamaño de 4 sería:

****
*  *
*  *
****

Ejercicio propuesto 6.3.8: Crea un programa que pida al usuario un número entero largo y muestre cuáles son sus divisores (aquellos entre los que se puede dividir, obteniendo como resto 0).

Ejercicio propuesto 6.3.9: Crea un programa que pida al usuario un número entero largo y diga si es primo (si sólo es divisible entre 1 y él mismo).

Ejercicio propuesto 6.3.10: Crea un programa que pida al usuario dos números enteros largos y diga cuántos números primos hay entre ellos (ambos incluidos).

Precaución con los bucles: Casi siempre, nos interesará que una parte de nuestro programa se repita varias veces (o muchas veces), pero no indefinidamente. Si planteamos mal la condición de salida, nuestro programa se puede quedar "colgado", repitiendo sin fin los mismos pasos.

6.4. break y continue

Se puede modificar un poco el comportamiento de estos bucles con las órdenes "break" y "continue".

La sentencia "break" hace que se salten las instrucciones del bucle que quedan por realizar, y se salga del bucle inmediatamente. Como ejemplo:

// Break1.java
// Ejemplo de uso de "break"
// Introducción a Java, Nacho Cabanes
 
class Break1 { 
 
    public static void main( String args[] ) { 
 
        int i;
        System.out.println( "Empezamos..." );
        for ( i=1 ; i<=10 ; i++ ) {
             System.out.println( "Comenzada la vuelta" );
             System.out.println( i );
             if (i==8) 
                 break;
             System.out.println( "Terminada esta vuelta" );
        }
        System.out.println( "Terminado" );
    }
}
 

En este caso, no se mostraría el texto "Terminada esta vuelta" para la pasada con i=8, ni se darían las pasadas de i=9 e i=10, porque ya se ha abandonado el bucle.

La sentencia "continue" hace que se salten las instrucciones del bucle que quedan por realizar, pero no se sale del bucle sino que se pasa a la siguiente iteración (la siguiente "vuelta" o "pasada"). Como ejemplo:

// Continue1.java
// Ejemplo de uso de "continue"
// Introducción a Java, Nacho Cabanes
 
class Continue1 { 
 
    public static void main( String args[] ) { 
 
        int i;
        System.out.println( "Empezamos..." );
        for ( i=1 ; i<=10 ; i++ ) {
             System.out.println( "Comenzada la vuelta" );
             System.out.println( i );
             if (i==8) 
                 continue;
             System.out.println( "Terminada esta vuelta" );
        }
        System.out.println( "Terminado" );
    }
}
 

En este caso, no se mostraría el texto "Terminada esta vuelta" para la pasada con i=8, pero sí se darían la pasada de i=9 y la de i=10.

Ejercicio propuesto 6.4.1: Crea un programa que muestre los números del 1 al 20, excepto el 15, usando "for" y "continue"

Ejercicio propuesto 6.4.2: Crea un programa que muestre los números del 1 al 10, usando "for" que vaya del 1 al 20 y "break"

6.5. Etiquetas

También existe la posibilidad de usar una "etiqueta" para indicar dónde se quiere saltar con break o continue. Sólo se debería utilizar cuando tengamos un bucle que a su vez está dentro de otro bucle, y queramos salir de golpe de ambos. Es ese caso (muy poco frecuente), deberemos crear una etiqueta justo antes de la orden que queremos que se interrumpa, y luego usar "break" seguido del nombre de esa etiqueta, así

// BreakEtiqueta.java
// Ejemplo de uso de "break" con etiqueta de salto
// Introducción a Java, Nacho Cabanes
 
class BreakEtiqueta { 
    public static void main( String args[] ) {
        int i; 
        bucleAInterrumpir:
        for ( i=1 ; i<=10 ; i++ ) {
            System.out.println( "Comenzada la vuelta" );
            System.out.println( i );
            if (i==8) break bucleAInterrumpir;
            System.out.println( "Terminada esta vuelta" );
        }
        System.out.println( "Terminado" );  
    }
}
 

En este caso, a mitad de la pasada 8 se interrumpiria el bloque que hemos etiquetado como "bucleAInterrumpir" (una etiqueta se define como se ve en el ejemplo, con su nombre terminado con el símbolo de "dos puntos").

Ejercicio propuesto 6.5.1: Crea un programa que muestre los números del 1 al 10, usando "for" que vaya del 1 al 20 y un "break" con etiqueta.

Actualizado el: 23-01-2015 12:27

AnteriorPosterior