Cuales son los Ciclos Revisión de las sentencias de control

Tema 5: Sentencias de control (1)

En el Tema 3 (apartado 3.1) indicábamos los distintos tipos de sentencias de un programa. Ya hemos visto las sentencias relativas a las llamadas a métodos, así como las sentencias de asignación (ver Tema 3). A continuación estudiaremos los tipos de sentencias que permiten alterar el flujo secuencial de ejecución de un programa: las sentencias de control. Concretamente analizaremos las sentencias de repetición: bucles FOR y WHILE.  

1. Revisión de las sentencias de control

Las sentencias de un algoritmo se ejecutan según el orden en el se han escrito, es decir, de forma secuencial. Para alterar dicho orden secuencial se utilizan las denominadas sentencias de control (ver Tabla 5.1), y que podemos agrupar en tres tipos distintos:

• Sentencias de repetición: como su propio nombre indica permiten que un conjunto de sentencias sean ejecutadas un cierto número de veces.
• Sentencias condicionales: necesarias cuando se quiere que se lleven a cabo acciones diferentes dependiendo del resultado de una expresión booleana.
• Excepciones: permiten alterar el flujo secuencial de ejecución cuando se produce alguna situación anómala, que causa que el programa ejecute un conjunto de sentencias determinadas.

Tabla 5.1. Revisión de las sentencias de control.

El uso de sentencias de control es importante, puesto que permiten reducir el número de líneas de código a escribir (en el caso de sentencias de repetición), así como crear distintos "caminos" posibles de ejecución (en el caso de sentencias condicionales y excepciones). En cualquier caso, dichas sentencias constituyen una práctica habitual por lo que es necesario comprender bien la semántica (significado) de dichas sentencias para poder implementar algoritmos correctos y eficientes.

2. Expresiones booleanas

Las expresiones booleanas^[1] son aquellas que devuelven un valor verdadero o falso. Éstas permiten controlar las decisiones que se toman en un programa en cuanto a caminos lógicos alternativos a seguir.

En Java, se pueden utilizar seis operadores de comparación, cuyo resultado es un valor booleano:

• == igual a
• != distinto de
• > mayor que
• < menor que
• >= mayor o igual que
• <= menor o igual que

Así, por ejemplo, mostramos algunas expresiones y el valor booleano asociado:

5*10 ==4*10+10;         Devuelve el valor cierto

5/6 > 6/5;                   Devuelve el valor falso 35*100 - 27 != 0;         Devuelve el valor falso

75 mod 26 >= 1;          Devuelve el valor cierto

El resultado de una expresión booleana puede almacenarse en una variable booleana (de tipo booleano). Por ejemplo podemos declarar: boolean esMenorDeEdad; que indica que la variable esMenorDeEdad puede tomar únicamente dos valores: cierto o falso.

Los valores cierto y falso se corresponden con las palabras reservadas true y false respectivamente. Así, podemos realizar asignaciones del tipo: esMenorDeEdad = true.

Java dispone también de los operadores booleanos:

• &  operador lógico and  
• | operador lógico or
• ^ operador lógico xor
• ¡ operador lógico not

En las Tablas 5.2... 5.5 aparecen reflejados los resultados de aplicar dichos operadores.

        Tabla 5.2. Operador AND.                                             Tabla 5.2. Operador OR.

        Tabla 5.2. Operador XOR.                                             Tabla 5.2. Operador NOT.

La operación AND devuelve cierto si y sólo si los dos operadores son ciertos, mientras que la operación OR devuelve falso cuando los dos operadores tienen valor falso. La operación XOR devuelve cierto cuando únicamente uno de los dos operandos toma el valor cierto. Finalmente la operación NOT devuelve la negación del valor del operador.

Así, por ejemplo, la expresión:

(17> (45-12))  false) & (8/3 > 1) tiene el valor TRUE

Java tiene también una versión adicional de los operadores AND y OR, y que son && y || respectivamente. El operador && no evalúa el valor del segundo operando si el primero tiene un valor false. Mientras que el operador ||no evalúa el valor del segundo operando si el primero tiene un valor true.  

Supongamos las siguientes expresiones:  

(4+8 < 0) & (3 != (1+2)) ;  

(4+8 < 0) && (3 != (1+2)) ;  

En el primer caso, se realizará la evaluación de las dos expresiones, y el resultado será false. Mientras que en el segundo caso solamente se evaluará la expresión (4+8 < 0), y puesto que el valor es false, no se continúa con el segundo operador, puesto que, independientemente de su valor, el resultado de la expresión será false. Por lo tanto, la versión &&  del operador AND es más eficiente que &. Lo mismo ocurre con el operador OR.

3. Repetición con bucles FOR

Un bucle FOR permite repetir la ejecución de una o varias sentencias un cierto número conocido de veces. Cada una de las repeticiones de las sentencias del bucle se denominan iteraciones. Los bucles FOR utilizan una variable contador, que se incrementa en uno en cada iteración, y se compara con el valor límite correspondiente al número de repeticiones que se debe realizar. Cuando la variable contador alcanza dicho valor límite, entonces concluye la sentencia FOR y se continúa la ejecución con la siguiente sentencia del programa. Esta situación se ilustra en la Figura 5.1

[pic 2]

Figura 5.1. Ejecución de un bucle FOR con valor límite 3.

La sintaxis en Java para un bucle FOR es la siguiente:

Sentencia FOR

for (inicio; prueba; actualizacion) {   sentencias_bucle

}; 

La parte de inicio introduce una o más variables de bucle (contadores), que se prueban y actualizan. Si hay más de una variable de bucle, sus instrucciones de inicio se separan con comas. Las variables de bucle deben ser números, y por convención suelen ser enteros. Es posible, pero se considera un mal hábito, utilizar un número real como variable de bucle. La razón es que una comparación sobre números reales es inexacta en los límites, y se podría ejecutar el bucle una vez más o menos de las esperadas.

...