LA HABILIDAD DEL ORDENADOR para ejecutar complejas tares, justamente, esta generada por la habilidad de combinar comandos sencillos dentro de estructuras de control. En Java, hay 6 de esas estructura y, de hecho, con tres de ellas nos bastaría para poder escribir programas que realizaran tareas. Las seis estructuras de control son: el bloque, el bucle while, el bucle do, el bucle for, la instrucción if, y la instrucción switch. Cada una de estas estructuras, se consideran instrucciones, pero de hecho, hay instrucciones de control que dentro de ellas contienen uno o mas de estas instrucciones.


El bloque es el tipo de instrucción mas simple, su propósito es únicamente el agrupar varias instrucciones como si fuera una sola instrucción. El formato del bloque es:

{
instrucciones
}

Esto es: consiste en una secuencia de instrucciones encerradas entre dos llaves { y }.(De hecho, es posible que un bloque no contenga ninguna instrucción, entonces al bloque se le llamaría bloque vacío, y a veces resulta útil).

La instrucción bloque aparece normalmente dentro de otras instrucciones, siendo su propósito el mantener juntas varias instrucciones como si fueran un unidad. De esta forma, el bloque puede emplearse allí donde se pueda utilizar una instrucción.

Hay un sitio donde es obligatorio el empleo de bloque , ya habíamos hablado de ello: la definición de un método.


Probablemente, debo explicar en este punto, porque Java ha sido llamado como el lenguaje de formato libre.:

No hay reglas de sintaxis sobre como se ha de distribuir el lenguaje en la pagina. Por ejemplo, puede llegar a escribir un bloque entero en una sola línea, si quiere, pero es importante un buen estilo de programación; debería ordenar su programa en la pagina, de tal forma que su estructura fuera lo mas clara posible.

En general, se acostumbra a escribir una instrucción por línea, empleando la identación para indicar las instrucciones incluidas en una estructura de control. Este es el formato que normalmente empleare en mis ejemplos.

Aquí hay dos ejemplos de bloques:
{
   System.out.print("La respuesta es ");
   System.out.println(ans);
   }

{ // Este bloque intercambia valores entre x e y
int temp = x;  // declara temp y almacena x 
x = y;         // copia el valor de y a x
y = temp;      // copia el valor de temp a y
}

En el segundo ejemplo, la variable temp, se define dentro del bloque. Esto ilustra una propiedad del bloque muy importante:

las variables declaradas dentro del bloque son completamente invisibles e inaccesibles desde fuera de él.

Se dice de la variable que es local del bloque. Esto es un concepto general llamado «ámbito» de un identificador.

El ámbito de un identificador, es la parte del programa en donde ese identificador es valido.

Ya hemos visto que el ámbito de una variable esta limitado por el bloque en el que se la declara. El uso de variables locales, es sencillo por que evita confusión y ayuda a hacer mas legible el programa.

Esto es un objetivo importante, y deberemos usar las variables locales allí donde hagan falta.


La instrucción bloque por si sola, no afecta al flujo del programa. Las cinco estructuras restantes, si lo hacen. Debemos dividirlas en dos tipos:

  • instrucciones de bucle e
  • instrucciones de salto o de desvío.

Realmente, para poder tener un lenguaje de propósito general, es preciso disponer de una estructura de cada tipo. El tener mas, solo es conveniente. Hablare únicamente del bucle while y de la instrucción if. El resto de las instrucciones, lo veremos mas adelante

El bucle while se emplea para repetir un conjunto de instrucciones una y otra vez.

Naturalmente, no es probable que quiera que se repitan por siempre. Eso seria un bucle infinito, y normalmente es un error. (Hay una vieja historia sobre la pionera de los ordenadores Grace Murray Hopper, que estaba leyendo en un bote de champú las siguientes instrucciones «enjabonar, aclarar, repetir» La historia cuenta que presento una demanda porque intento seguir las instrucciones, pero el champú dejo de salir.(En este caso, no se lo tome en serio, es una broma acerca de la forma tan descuidada en que un ordenador sigue las instrucciones.)

Para ser mas exacto, el bucle while repite las instrucciones una y otra vez, solo mientras sea cierta una condición especifica. El bucle while tiene el siguiente formato:

while (expresión boleana)
      instrucción

Aveces la instrucción puede ser, y usualmente es, un bloque; entonces el formato será:

while (expresión boleana) {
     instrucciones
}

La semántica de esta instrucción es la siguiente:

Cuando el ordenador encuentra una instrucción while,

  • evalúa la expresión boleana que produce un resultado de cierto o falso (true o false)
  • Si el valor es falso, el ordenador, salta el resto del bucle while, y continua con la siguiente instrucción en el programa.
  • Si el valor de la instrucción es cierto, el ordenador ejecuta las instrucciones que están dentro del bucle.
  • A continuación, vuelve al principio del bucle para reiniciar el proceso. Esto es , volver a evaluar la expresión boleana, finalizando el bucle cuando la expresión es falsa o continuando en él, mientras sea cierta.

Esto continuara una y otra vez, hasta que el valor de la expresión sea falso, si no pasa nunca, entonces estaremos ante un bucle infinito.

Aquí hay un ejemplo muy sencillo que imprime los numero 1,2,3,4:

   int number = 1;
                while ( number < 5 ) {
                         System.out.println(number);
                        number = number + 1;
                 }
                 System.out.println("Hecho!");
  • La variable number se inicializa al valor 1,
  • por lo que la primera vez que pasa por el bucle while, cuando el ordenador evalúa la expresión «number<5» esta preguntando si 1 es menor que 5, lo que es cierto.
  • El ordenador procede ha ejecutar las dos instrucciones que están dentro del bucle;
    • la primera instrucción imprime «1»,
    • la segunda instrucción, le suma 1 a number y vuelve a almacenar el resultado dentro de la variable number, por lo cual su valor cambia a 2.
  • El ordenador encuentra el final del bucle , por lo que lo reinicia preguntando otra vez si number es menor de 5.
  • Otra vez es cierto por lo que el ordenador ejecuta el bucle otra vez e
    • imprime el numero 2 y
    • a continuación cambia el valor de number dejando el numero 3.

Y continua de esta forma, hasta que casualmente number sea igual a 5. En ese momento, la expresión «number<5″ se evalúa como falsa. Entonces el ordenador salta hasta pasar el final del bucle e imprime el mensaje «Hecho!».

Por esto, puede recordar que nunca vera el bucle while como un programa real. Siempre deberá estar dentro de un método que a su vez defina una clase. Como en el ejemplo que viene a continuación, donde el bucle while esta dentro de un programa completo. Aquí tenemos un pequeño programa que calcula el interés de una inversión durante varios años:

public class Interest2
         /*Esta clase implementa un programa que calcula
              el importe del interés generado por una inversión
          de 17.000 dólares a un interés de 0,07 por 5 años
           se imprimirá el valor de la inversión al final 
           de cada año.
          */

            public static void main(String[] args) {

                double principal = 17000;  // El valor de la inversión
                double rate = 0.07;        // El porcentaje de interés anual

                int years = 0;  // cuenta el numero de años que han pasado

                while (years < 5) {
                   double interest = principal * rate;   // calcula intereses año
                   principal = principal + interest;     //  lo suma al capital
                   years = years + 1;    // cuenta el año
                   System.out.print("El valor de la inversión después de ");
                   System.out.print(years);
                   System.out.print(" año es $");
                   System.out.println(principal);
                } // Final del bucle while                               
            } // fin del bucle main()

         } // fin de la clase nterest2
          
        

Aplets desactivados

Si quiere ser el resultado, puede ejecutar el applet equivalente que esta a continuación:

[_htmlBox filename=Interest2Console.html]

Debe estudiar el programa y estar seguro de comprender como realiza el ordenador el bucle, siguiendo el programa paso a paso.


La instrucción if, le dice al ordenador que tiene que tomar uno de los dos posibles cursos de acción, dependiendo de que el valor que tome la expresión boleana sea cierto o falso.

If (expresión boleana)
   instrucción
else
   instrucción

Cuando el ordenador ejecuta la instrucción if, evalúa la expresión boleana. Si el valor es cierto (true) el ordenador ejecuta la primera instrucción y salta la instrucción que se encuentra a continuación del else. Si el valor de la expresión es falso, el ordenador salta la primera instrucción y ejecuta la segunda. Dese cuenta que en cualquier caso una y solo una de las dos instrucciones se ejecutara. Las dos instrucciones, representan cursos de acción alternativos; el ordenador decide entre los dos caminos, basándose en el valor de la expresión boleana.

En según que casos, querrá que el ordenador escoja entre hacer algo y no hacerlo. Puede conseguirlo con una instrucción if, omitiendo la parte else .

if (expresión boleana)
     instrucción

 

Para ejecutar esta instrucción, el ordenador evalúa la expresión. Si el valor es cierto, el ordenador ejecuta la instrucción contenida dentro del propio if; si el valor es falso, el ordenado salta la instrucción.

Como es normal, cada una de las instrucciones en una instrucción if, pueden ser un bloque, entonces una instrucción if tendrá a menudo esta apariencia:

if (expresión boleana) {
        instrucciones
   } else {
    instrucciones
   }

o :

if  (expresión boleana) {
                    instrucciones
}

En el ejemplo, tenemos una instrucción if que intercambia los valores entre x e y , pero solo si x es mayor que y al inicio. Después de que la instrucción if se ejecute, podemos estar totalmente seguro que el valor de x es definitivamente menor o igual que el valor de y:

if (x>y) {
    int temp = x;  // declara temp y almacena x 
    x = y;         // copia el valor de y a x
    y = temp;      // copia el valor de temp a y
}

 Finalmente, a continuación un ejemplo de instrucción if que incluye la parte else Vea si puede imaginarse que hace, y para que sirve:

if ( years > 1 ) {  // rutina para el caso de 2 o mas años
   System.out.print("El valor de la inversión después de  ");
    System.out.print(years);
    System.out.print(" años es $");
}
  else {  // rutina para el caso del primer año
    System.out.print("El valor de la inversión después de un año es $");
}  // fin de la instrucción if
System.out.println(principal);  //esto se realizara siempre

Seguiremos viendo mas cosas sobre la instrucción if mas adelante, en este mismo capítulo. Pero ya conoce lo esencial. Si quiere aprender algo mas sobre las estructuras de control, ya sabe bastante para realizar algún trabajo con el ordenador.

3 comentarios sobre “Programacion en Java.Bucles y desvíos”

Deja un comentario

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.