Aprendiendo JAVA (III)

En esta nueva entrega vamos a tratar el control de flujo de un programa informático. Controlar el flujo es determinar el orden en el que se ejecutarán las instrucciones en nuestros programas, en base a una toma de decisiones.

Las sentencias más usuales son If, Switch, for, do y while.

Bloque IF y su sintaxis es:

1. if (condición if)
2. {
3. Acciones del if;
4. }
5. else if (condición else if)
6. {
7. Acciones del else if;
8. }
9. else
10. {
11. Acciones del else;
12. }

En pocas palabras viene a significar que: Si se cumple la condición if se ejecutaran las acciones del if, si no se cumple esa condición y existe el punto else if y se cumple la condición del else if se ejecutaran las acciones del else if, en caso de que no se cumpla ninguna condición se ejecutarían las acciones del else.
En el momento que se cumple una condición ya no se evalúa ninguna más.

Bloque SWITCH:
Cuando nos vemos obligados a anidar múltiples sentencias if, por ejemplo:

1. if (condición primera)
2. {
3. if (condición segunda)
4. {
5. if (condición tercera)
6. {
7. }
8. }
9. }

aspecto que sucede bastante a menudo, quiere decir que, probablemente sea más adecuado utilizar un switch.
En un switch se evalúa una variable y en función del valor de esa variable se ejecuta un bloque Case. Si el valor de la variable no es igual a ningún Case y el bloque switch tiene un Default se ejecutaran las sentencias que se encuentren después de esta etiqueta.

La sintaxis general del switch es:

1. switch (variable)
2. {
3. case valor:
4. Acciones;
5. break;
6. case valor2:
7. Acciones;
8. break;
9. case valorn:
10. Acciones;
11. break;
12. default:
13. Acciones;
14. }

En pocas palabras viene a significar que si la variable que se evalúa en la primera línea del switch vale 4 se ejecutaran las acciones que se encuentren en el case cuya valor sea 4. Una vez ejecutadas las acciones el programa llega a la sentencia break, que obligara al programa a salir del bloque switch y continuar en la primera sentencia después de la llave de cierre del mismo }.

Bloque FOR:

Una de las acciones que mejor realiza un ordenador es el repetir operaciones. El bloque for es precisamente eso: un bloque de repetición.
Se ira haciendo una y otra vez una serie de sentencias hasta que se cumpla una condición. La sintaxis general de este bloque es:

1. for (Inicio contador; condición a cumplir; incremento contador)
2. {
3. Acciones;
4. }

Usaremos un contador for cuando sepamos las iteraciones que queremos realizar.

Existe otra versión del bloque for denominado for-each que resulta idóneo para recorrer arrays y colecciones.

Bloque DO:

El bloque do se ejecuta y después comprueba una condición. Si esa condición se cumple se volverá a ejecutar. Esto significa que por lo menos el bloque se ejecutara una vez. Es ideal para realizar menús por consola. La sintaxis general de este bloque es:

1. do
2. {
3. Acciones;
4. } while (condición)

Bloque WHILE:

El bloque while es igual que el bloque do salvo que la condición se comprueba antes de ejecutarse. Por tanto el bloque puede que no llegue a ejecutarse nunca.

1. while (condición)
2. {
3. Acciones;
4. }

Veamos unos cuantos ejemplos para comprender mejor estos conceptos. Aunque antes de pasar a ellos explicaremos un último concepto.
Para capturar los datos que un usuario nos pasaría por teclado usaremos la clase Scanner, esta clase es exclusiva de la versión de JAVA J2SE5 y para utilizarla tendremos que importar java.util.*, pasemos a los ejemplos.
Dependiendo del valor que solicitemos o esperamos utilizaremos una sentencia diferente para recogerlo: nextShort, nextInt, nextLong, nextLine (valores String), nextDouble.

Abriremos nuestra aplicación Eclipse y crearemos un nuevo proyecto al que llamaremos Segundo y le añadiremos una clase a la que llamaremos Condicional y antes de aceptarla marcaremos la casilla public static void main(String [] args).

En esta ocasión no vamos a crear ningún objeto, sencillamente trabajaremos directamente sobre el método main.
Comenzaremos con el siguiente ejercicio:
Realiza un programa que averigüe si el año introducido por el teclado es bisiesto. Teniendo en cuenta que para ser bisiesto debe ser divisible por 4 y no por 100. Y que también son bisiestos los años divisibles por 400.
Si quieres puedes realizarlo tú antes de ver la solución o hacer simplemente un pseudocódigo en un papel.
Nuestro código será el siguiente:

1. import java.util.*;
2. public class Condicional {
3. public static void main(String[] args) {
4. Scanner sc=new Scanner(System.in);
5. //creamos un objeto scanner
6. System.out.println(”Introduce el año que desea” +
7. ” comprobar”);
8. /*con el signo + concatenamos (unimos) dos frases
9. para no salirnos del margen derecho. Comentario de mas de una linea*/
10. short anyo=sc.nextShort();
11. if((anyo%4==0 && anyo%100!=0) || (anyo%400==0)){
12. System.out.println(anyo + ” es bisiesto”);
13. }
14. else{
15. System.out.println(anyo + ” no es bisiesto”);
16. }
17. }
18. }

Puntualizaciones sobre este código:
Para introducir comentarios en un código utilizaremos // cuando esos comentarios no sobrepasen una línea. Utilizaremos /* - - - */ cuando el comentario sea de mas de una línea.
El funcionamiento del programa será el siguiente: En la consola aparecerá Introduce el año que desea comprobar. Puedes escribir el año que desees y pulsar intro, acto seguido se mostrar el mensaje correspondiente a año bisiesto o no, según el año indicado.

En este código aparecen algunos conceptos de los que no hemos hablado como por ejemplo:
anyo%4==0 Se utiliza el operador aritmético % para conocer el resto de una división, en otros lenguajes se utiliza mod. Esta operación significa que el resto de dividir anyo entre 4 debe ser igual a 0.
El operador lógico && significa and (Y)
El operador != significa no es igual, es decir el resto de dividir anyo entre 100 es diferente de 0.
El operador || es el operador or (O).

Nuestro código quedara tal y como sigue:

Para comprobar el funcionamiento del bloque switch crearemos un programa que nos informe de cuantos días tiene cualquier mes del año. Comenzaremos con una nueva clase a la que llamaremos diasdelmes y marcaremos la casilla public static void main(String [] args).
Nuestro código será el siguiente:

1. import java.util.*;
2. public class diasdelmes {
3. public static void main(String[] args) {
4. Scanner sc = new Scanner(System.in);
5. System.out.println(”Introduce el numero del mes”);
6. short mes = sc.nextShort();
7. switch(mes) {
8. case 1: case 3: case 5: case 7: case 10: case 12:
9. case 8:
10. System.out.println(”El mes numero “+ mes +
11. ” tiene 31 días”);
12. break;
13. case 2:
14. System.out.println(”El mes numero “+ mes +
15. ” tiene 28 días”);
16. System.out.println(”excepto bisiestos 29 días”);
17. break;
18. case 4: case 6: case 9: case 11:
19. System.out.println(”El mes numero “+
20. mes +” tiene 30 días”);
21. break;
22. default:
23. System.out.println(”Mes no contemplado”);
24. }
25. }
26. }

Puntualizaciones sobre este código:
Podemos comprobar que se pueden anunciar varios cases en una sola línea y si la variable que validamos, en este caso mes, es igual a cualquier de los cases declarados en línea se ejecutar el código de ese bloque.
También podemos observar que todos los cases incluyen la sentencia break menos el caso de default. Incluimos la sentencia break en cada bloque para que una vez ejecutado el código de dicho bloque ya no continúe evaluando ningún bloque mas. En el caso de default como es el último bloque da igual el poner break o no ponerlo.
El funcionamiento del programa será el siguiente:
Al arrancar el programa aparecerá en la consola: Introduce el número del mes, nosotros podemos poner un número del 1 al 12 y pulsar intro y el programa nos devolverá los días del mes indicado. Si colocamos un valor superior 12 o inferior de 1 el programa nos devolverá el valor del bloque default.

El código quedara tal y como sigue:

En el siguiente post abordaremos los bloques repetitivos.

Enlaces interesantes

• Eclipse
• Página oficial de Java en español