Programación en Java. Estructuras de control

JAVA TIENE TRES ESTRUCTURAS DE CONTROL para realizar bucles: la while, la do y la for. Y dos estructuras para realizar desvíos: La instrucción if y la instrucción switch. Esta sección, explica el funcionamiento de estas instrucciones.

El bucle do

Anteriormente, hemos visto la instrucción while, y como el ordenador comprueba la condición antes de empezar el bucle, para determinar si lo realiza o no.

while ( expresión-boleana )
 instrucción

La diferencia entre el bucle while y el do, reside en que en este ultimo, la comprobación se realiza al final. El formato es el siguiente:

do
 instrucción
while ( expresión-boleana );

o si como es normal la  instrucción es un bloque (block),

          do {
              instrucciones
          } while ( expresión-boleana );

(Observe el ‘;’ final. Este ‘;’ forma parte de la instrucción, es mas, el punto y coma que aparece al final de cada instrucción de asignación, o al final de una declaración, forma parte de la instrucción. Generalizando, debemos indicar que todas las instrucciones de Java terminan con ‘;’ o con la llave derecha’}’)

Para ejecutar el bucle do  el ordenador, en primer lugar, ejecuta el cuerpo del bucle — nos referimos a la instrucción o instrucciones que están dentro del bucle — y después, evalúa la expresión boleana. Si el valor de la expresión es true, el ordenador volverá al principio y repetirá el proceso, si el valor es false, el bucle finalizara y se continuara con la siguiente instrucción del programa

Como hemos visto la principal diferencia, entre el bucle do y el while, es que en el do el cuerpo del bucle se ejecuta al menos una vez antes de evaluar la expresión boleana, mientras que en el while, al empezar evaluando la expresión, si esta es falsa, el cuerpo del bucle no se ejecuta ninguna vez.

Por ejemplo, consideremos el siguiente pseudocódigo para un programa de juego.

do {
    juegue;
    preguntar al usuario si quiere seguir jugando;
} while(el usuario conteste si);

El bucle for

El bucle for existe como una simplificación del bucle while. Muchos bucles while, tienen un formato semejante a este:

inicialización
while ( condición de continuación ) {
    instrucciones
    actualización
}

Por ejemplo. considere

            int years = 0;  // inicializar la variable years
            while ( years < 5 ) {   // condición para continuar en el bucle
                interest = principal * rate; // algunas instrucciones
                principal += interest;
                System.out.println(principal);
                years++;   // Actualizar el valor de la variable years
            }

Este bucle, se hubiera podido escribir así:

for ( int years = 0; years < 5; years++ ) {
   interest = principal * rate;
   principal += interest;
   System.out.println(principal);
}

La inicialización, la condición de continuación y la actualización, se combinan en la primera línea del bucle, lo que nos permite realizar todo el control en un solo sitio. Esto hace que sea mas fácil tanto de entender como de leer. En general, el bucle for toma esta forma:

for (inicialización;condición de continuación; actualización)
    instrucción

o empleando un bloque de instrucciones:

for (inicialización;condición de continuación; actualización){
    instrucciones
}

La condición de continuación es una expresión boleana, mientras que la inicialización y la actualización pueden ser cualquier expresión. De las tres partes, ninguna puede quedar vacía. Normalmente, la inicialización es una asignación o declaración y la actualización es una asignación o una operación de  decremento o incremento. La sintaxis oficial, permite que tanto la actualización como la inicialización, puedan ser varias instrucciones separadas por comas (,). Si declara la variable en la inicialización, el ámbito de la variable queda reducido a la instrucción for, esto es: cuando la instrucción for finaliza, la variable deja de existir.

A continuación tiene algunos ejemplos de instrucción for:

// imprimir el alfabeto en una línea
for ( char ch='A'; ch <= 'Z'; ch++ )
   console.put(ch);
console.putln();
// cuenta de 1 a 10 y de 10 a 1 a la vez
for ( int i=0,j=10; i < 10; i++,j-- ) {
  console.put(i,5); // saca i una columna de 5 caracteres
  console.putln(j,5);
}
// calcular el numero 1 * 2 * 3 * ... * 20
long factorial = 1;
for (int num=2; num <= 20; num++)
  factorial *= num;
System.out.println("20! = " + factorial);

La instrucción break

En los bucles do, for, y while,  la comprobación para continuar con el bucle, se puede realizar al principio o al final, pero a veces puede necesitar realizar la comprobación en el medio del bucle, o hacer varias comprobaciones a lo largo del bucle. Para todo ello, Java provee una instrucción que puede romper la continuidad del bucle; esta es la instrucción break, que tiene el siguiente formato:

break;

Cuando el ordenador ejecuta una instrucción break, salta inmediatamente al final de bucle ( o de la estructura de control) que contiene el break. Pasando a ejecutar las instrucciones que estén a continuación del bucle. Considere el siguiente ejemplo:

while (true) { // Atención, bucle infinito!
   console.put("Entre un número positivo: ");
    N = console.getlnt();
    if (N > 0) // La entrada es correcta
       break;
    console.putln("El numero debe ser > 0.");
 }
 // continuar aquí después del break

La instrucción break hace que finalice inmediatamente el bucle en el que se encuentra. Es posible anidar bucles, haciendo que dentro de un bucle haya otro; si la instrucción break se encuentra en el bucle interior, al ejecutarse, solo se romperá este bucle, pero se continuara ejecutando el bucle exterior. Existe también una instrucción llamada labeled break que permite especificar que bucle quiere romper. Aquí no vamos a verlo, si piensa que lo puede necesitar, ya lo buscará.


Mas sobre la instrucción if

En el articulo anterior, estuvimos hablando sobre la instrucción if. Tiene esta forma:

if (expresión-boleana)
    instrucción-1
else
    instrucción-2

Lo normal es que dentro de una instrucción if se monte un bloque de instrucciones. Una instrucción if, representa un desvío de dos ramas. También es posible omitir la parte else –formada por la palabra else y su bloque de instrucciones–.

Estamos hablando de la instrucción if, esto es , de una instrucción. Entonces vamos a poder incluirla en instrucción-1 o en instrucción-2.(Nota: Si instrucción-1 en una instrucción if, significa que puede tener una parte else, y si no la tiene, cuando el ordenador encuentre la cláusula else de if de nivel superior, puede considerarla de este if. Para evitar este problema, lo mas sencillo es que forme un bloque con el nuevo if, esto es lo encierre entre llaves'{}’ )

Una instrucción if en donde la parte else sea otra instrucción if, podría quedar así(quizás sin la parte else final):

if (expresión-boleana-1)
   instrucción-1
else
   if (expresión-boleana-2)
       instrucción-2
   else
       instrucción-3

Ahora bien, ya que al ordenador no le preocupa como se presenta el programa sobre el papel, normalmente se escribirá así:

             if (expresión-boleana-1)
                  instrucción-1
             else if (expresión-boleana-2)
                  instrucción-2
             else
                  instrucción-3

Supongo que una sencilla instrucción, representa un desvío de tres vías. Cuando el ordenador ejecute esta instrucción, solo leerá una de las tres instrucciones: instrucción-1, instrucción-2   y instrucción-3 El ordenador evaluara expresión-boleana-1 . Si es true, ejecutara instrucción-1 y saltara al final de toda la instrucción if   saltando las otras dos instrucciones. Si el resultado de la primera evaluación fuera false, entonces saltara  instrucción-1 y ejecutara la segunda instrucción if. Comprobara el valor de expresión-boleana-2 y lo usara para decidir entre ejecutar instrucción-2 o instrucción-3.

Aquí tenemos un ejemplo de cómo presentar tres mensajes distintos en función del valor de una variable llamada temperature.

if (temperature < 20)
   System.out.println("Hace frío.");
else if (temperature < 30)
    System.out.println("Se esta bien.");
else System.out.println("Hace calor.");

Si temperatura tiene un valor (vale) de 18, el ordenador imprimirá el mensaje “Hace frío” y saltara el resto de instrucciones, sin ni siquiera evaluarlas.

Es posible ir enlazando cualquier numero de if’s para conseguir desvíos de ‘n’ vías:

if (expresión-boleana-1)
    instrucción-1
else if (expresión-boleana-2)
    instrucción-2
else if (expresión-boleana-3)
    instrucción-3
.
. // (more cases)
.
else if (expresión-boleana-N)
    instrucción-N
else
    instrucción-(N+1)

Recuerde que solo se ejecutara una instrucción, y que el ordenador solo ira comprobando hasta encontrar la primera expresión boleana que sea true. Recuerde también que puede omitir la parte else del ultimo if, y que cualquier instrucción, puede ser sustituida por un bloque de instrucciones encerradas entre llaves ‘{}’ (Admita que todo esto es demasiada sintaxis para verla junta, estúdiela y practique un poco, después se sentirá mas cómodo)


La instrucción switch

Java también dispone de una instrucción que permite realizar multidesvio en un caso concreto: la instrucción switch. Esta instrucción, permite comprobar el valor de una expresión y en función del mismo saltar a un numero determinado de direcciones dentro de la instrucción switch. Las posiciones a las que se puede saltar se marcan con las etiquetas case que tienen la forma: “case constante“. El funcionamiento de la instrucción es el siguiente: se evalúa la expresión, y con el valor obtenido, se busca una etiqueta case en donde se haya indicado ese valoren la constante. Al final de la instrucción, puede utilizar una etiqueta “default” que será seleccionada en caso de que no se cumpla ninguno de los casos previos( ósea que el valor de la expresión no aparezca en ninguna etiqueta case).

Una instrucción switch tiene la siguiente forma:

switch (expresión-int) {
   case constante-int-1:
      instrucción-1
      break;
   case constante-int-2:
      instrucción-2
      break;
   .
   . // (mas case's)
   .
   case constante-int-N:
      instrucción-N
      break;
   default: // opcional
      instrucción-(N+1)
} // final de la instrucción switch

Técnicamente, la instrucción break, es opcional. Su efecto, es hacer que el ordenador salte al final de la instrucción case,; si no lo pone, el ordenador ejecutara todas las instrucciones que están a continuación, falseando el resultado, ya que no es lo que normalmente querrá que haga. (Aquí  vera, aunque no es fácil que lo entienda hasta que haya leído el siguiente capítulo, que dentro de una subrutina a veces se sustituye  la instrucción break por la return )

También puede ahorrarse un grupo completo de instrucciones, incluida break. Puede dejar varias etiquetas case una debajo de la otra, cada una son su constante. Esto hará que el ordenador salte al mismo sitio y realice las mismas acciones para todos esos valores.

aquí tenemos un ejemplo de una instrucción switch. No es una aplicación habitual, pero le va a permitir entenderlo. Hemos alterado voluntariamente el orden de las constantes, para que vea que sigue siendo correcto, aunque para la legibilidad del programa, puede que no lo sea tanto.

switch (N) {
// suponga que N es una variable entera
   case 1:
      System.out.println("El número es 1.");
      break;
   case 2:
   case 4: 
   case 8:
      System.out.println("El número es 2, 4, u 8.");
      System.out.println("(Potencias de 2.)");
      break;
   case 3:
   case 6:
   case 9:
     System.out.println("El número es 3, 6, o 9.");
     System.out.println("(Múltiplo de  3.)");
     break;
   case 5:
     System.out.println("El número es 5.");
     break;
   default:
     System.out.println("El número es 7,");
     System.out.println(" o fuera de rango de 1 a 9.");
 }

La instrucción switch pertenece a las estructuras de control mas antiguas y, con su uso, es fácil cometer errores. Java tomó las estructuras de control directamente de los anteriores lenguajes de programación como C y C++. La instrucción switch, es uno de los sitios en donde los diseñadores de Java hubieran podido realizar alguna mejora.


La instrucción vacía

Hemos llegado al final de la sección y quiero mencionar una instrucción mas del lenguaje Java: la instrucción vacía. Esta instrucción consiste simplemente en un punto y coma (;).  La existencia de esta instrucción, nos permite que aparezca un ; después de la llave de cierre, sin que el ordenador lo señale como error, ya que lo ve como una instrucción mas (vacía, pero instrucción).

if (x < 0) {
    x = -x;
};

También puede necesitar la instrucción vacía cuando no quiera hacer nada dentro de un bucle. Aunque en esos casos  prefiero utilizar un bloque vacío consistente en dos llaves {} sin nada entre ellas


Lista de los tipos de instrucciones Java

Hemos mencionado aquí la instrucción vacía para completar la lista.Hasta ahora conoce todos los tipos de instrucciones Java. Mas abajo tiene la lista completa como referencia.Las únicas instrucciones nuevas que aparecen en la lista son try...catch y synchronized que están relacionadas con aspectos avanzados de la programación Java como el manejo de las excepciones y la multitarea.

Otra posible sorpresa es la aparición en la lista de “instrucciones con expresiones” que refleja el hecho de que cualquier expresión seguida por punto y coma (;) puede considerarse instrucción. Para ejecutar estas instrucciones, el ordenador se limita a evaluar la expresión e ignora el valor; esto solo tiene sentido cuando la evaluación tiene como efecto el modificar el valor de una variable o provocar algún cambio en la situación del ordenador. Un ejemplo de esto es la expresión “x++” que tiene como efecto secundario el sumar 1 al valor de x. Observe que las instrucciones de asignación y las llamadas a subrutinas se consideran también instrucciones de expresión.

Tipos de instrucciones Java

  • declarativas (instrucciones de declaración)
  • Instrucciones de asignación
  • Instrucciones de llamada a subrutina (incluyendo las rutinas de entrada/salida)
  • otras instrucciones de expresiones (como “x++”)
  • Instrucción vacía
  • Instrucción de bloque
  • instrucción while
  • instrucción do..while
  • instrucción if
  • instrucción for
  • instrucción switch
  • instrucción try…catch
  • instrucción synchronized

 

Acerca de Miguel Garcia

Programador, Desarrollador web, Formador en distintas areas de informatica y director de equipos multidisciplinares.
Esta entrada fue publicada en Formacion, Java. Guarda el enlace permanente.

Una respuesta a Programación en Java. Estructuras de control

  1. Pingback: Java - Un resumen organizado....o no.Recursos para formacion

Deja un comentario