Estructuras repetitivas. While, Do, For.
La explicación de esas estructuras
fue mostrada en su momento, durante los capítulos 9, 10 y 11, por lo que
solamente mostraré su sintaxis, con la finalidad de avanzar rápidamente para llegar a estudiar lo nuevo que nos
ofrece este lenguaje y ver sus
posibilidades.
1.- WHILE
La sintaxis es:
while(condicion verdadera){
instrucciones;
}
Como se
puede ver, su construcción es similar a la instrucción IF. La condición va
entre paréntesis y el bloque de instrucciones va entre llaves { }
Ejemplo:
import java.util.Scanner;
public class Saludo{
public static void main(String[]args){
int num = 0;
Scanner ingreso = new Scanner(System.in);
while(num != 5){
System.out.print("Ingresa un 5 para
continuar...");
num = ingreso.nextInt();
if(num != 5){
System.out.println("Debes
ingresar 5 para continuar");
}
}//fin while
System.out.print("Numero 5 ingresado,
gracias!!!");
}//fin main
}//fin class
Otro
ejemplo:
import java.util.Scanner;
public class Saludo{
public static void main(String[]args){
int continuar = 1;
int edad;
Scanner ingreso = new Scanner(System.in);
while(continuar == 1){
System.out.print("Ingresa tu edad:
");
edad = ingreso.nextInt();
if(edad >= 18){
System.out.println("Eres
mayor de edad");
}
else{
System.out.println("Eres menor de
edad");
}
System.out.println("Otro ingreso?\n1
= Si\nOtro numero = No");
continuar = ingreso.nextInt();
}//fin while
System.out.println("Programa
finalizado!!!");
}//fin main
}//fin class
2.- DO
La sintaxis
es:
do {
instrucciones;
}while(condicion verdadera);
Como se puede ver, la condición a evaluar se
encuentra al final del bloque, por lo que esta estructura siempre se ejecutará
al menos una vez (la primera) y dependiendo de la condición, se volverá a
ejecutar o finalizará el ciclo.
Ejemplo:
Utilizaré el mismo ejemplo anterior pero adaptado a esta instrucción,
después de todo, el resultado es el mismo.
import java.util.Scanner;
public class Saludo{
public static void main(String[]args){
int num;
Scanner ingreso = new Scanner(System.in);
do{
System.out.print("Ingresa un 5 para
continuar...");
num = ingreso.nextInt();
if(num != 5){
System.out.println("Debes
ingresar 5 para continuar");
}
}while(num != 5);//fin do
System.out.print("Numero 5 ingresado,
gracias!!!");
}//fin main
}//fin class
Si hacen lo mismo ¿cuál es la diferencia o cuando escoger uno u otro?
Bueno, en el caso de DO yo lo escogería siempre que necesite que algo se
ejecute al menos 1 vez y si no consigo el resultado que quiero, entonces que se
vuelva a repetir. En cambio, en el caso de WHILE, yo lo escogería solamente si
necesito que algo se ejecute bajo ciertas condiciones y no siempre, como ocurre
en el caso de DO. Aquí colocaré un ejemplo de ambos casos.
//La
maldicion del 13
import java.util.Scanner;
public class Saludo{
public static void main(String[]args){
int num, maldad;
Scanner ingreso = new Scanner(System.in);
do{
System.out.println("Si ingresas un 13,
algo malo puede ocurrir");
System.out.print("Yo recomiendo
ingresar cualquier otro numero: ");
num = ingreso.nextInt();
if(num != 13){
System.out.println("Estamos a salvo del 13");
}
if(num == 13){
while(num ==
13){
System.out.println("Has caido en
la trampa Ja ja ja!!!");
}//fin while
}//fin if
System.out.println("\nHas salido sano y
salvo de la maldicion del 13!!!");
System.out.println("Quieres
continuar??\n1 = Si\nOtro = No ");
num = ingreso.nextInt();
}while(num == 1);//fin do
}//fin main
}//fin class
Este programa integra ambas estructuras, pero aquí se
puede comprobar que en el caso de la estructura DO, SIEMPRE se ejecuta como
mínimo 1 vez. En el caso de la estructura WHILE, ésta solamente se ejecutará
bajo condiciones específicas, en este caso, si el usuario ingresa el número 13,
donde caerá en un ciclo infinito XD, pero aquí la gran diferencia. Puede que el
usuario jamás ingrese el número 13 y por lo tanto, esa estructura nunca se
ejecute.
La sintaxis es:
for(variable inicio ; variable
final ; incremento/decremento){
instrucciones;
}
Al igual que en small basic y lo que se explicó en el
capítulo 9, esta instrucción ejecuta las instrucciones que se encuentran en su
bloque, la cantidad de veces según se lo indiquemos. La variable inicio, es la
que indica el valor inicial del ciclo, la variable final es la que indica el
final de éste y el incremento o decremento, corresponde al valor por el cual se
irá incrementando o disminuyendo la variable en cuestión.
Ejemplo, sencillo y barato. Se mostrará una secuencia
del 1 al 10
public class Saludo{
public static void main(String[]args){
int num;
for(num = 1; num <= 10; num++){
System.out.println(num);
}//fin for
}//fin main
}//fin class
El primer término "num = 1" indica el
inicio del valor de la variable. El segundo término indica el valor final de la
variable, es en este lugar donde se indica cuando finalizará el ciclo. En este
caso, el ciclo finalizará cuando la variable tenga un valor de 10. El tercer
término es el incremento, en este caso está indicado como "num++" el
++ indica que se irá incrementando uno en uno. Esto es equivalente a escribir
"num = num + 1" Se utiliza ++ simplemente para abreviar lo anterior.
Si se quisiera hacer un decremento de uno en uno, en vez de escribir
"variable = variable - 1" se puede escribir "variable--" y
sería lo mismo. Si quisiera aumentar con otro valor distinto a 1, no me sirve
el ++ ahí tendría que usar por ejemplo "var = var + 2" si quisiera
por ejemplo mostrar los múltiplos de 2
El siguiente ejemplo, muestra una tabla de multiplicar según el numero
que ingrese el usuario:
import
java.util.Scanner;
public class Saludo{
public static void main(String[]args){
int num1, tabla;
Scanner ingreso = new Scanner(System.in);
System.out.print("Ingresa un numero: ");
num1 = ingreso.nextInt();
for(tabla = 1; tabla <= 10;
tabla++){
System.out.printf("%d x %d = %d\n", num1, tabla, num1 *
tabla);
}//fin for
}//fin main
}//fin class
Gustavo J. Cerda Nilo
No hay comentarios:
Publicar un comentario