1.4. Estructuras de control de flujo.

Objetivo del tema 1.4.

Unidad:
Tema:
Objetivo:

I - Introduccin a Java utilizando el IDE NetBeans.

1.4. Estructuras de control.
Explicar y demostrar las extructuras de control de Java.

Introduccin.
Frecuentemente en programacin es necesario cambiar el flujo normal de control - esto es,
el orden en el cual son ejecutadas las sentencias. Existen tres tcnicas bsicas para cambiar
el flujo de control de un programa:
1. Invocar un mtodo: esto implica que el flujo de control deja el mtodo actual y se
desplaza hacia el mtodo que est siendo invocado.
2. Toma de decisin: esto se efecta cuando un criterio determina cul camino toma el
flujo de control. Java tiene dos mecanismos para tomar decisiones: la sentencia if
- else y la sentencia switch (el operador ternario tambin puede ser usado para la
toma de decisiones, pero es bsicamente una versin abreviada de la sentencia if else).
3. Repeticin: la repeticin ocurre cuando una tarea necesita ser repetida un cierto
nmero de veces, y a menudo es referida como un lazo. Java tiene tres mecanismos
de repeticin: el ciclo for, el ciclo while y el ciclo do - while.
Las sentencias de toma de decisin y de repeticin son conocidas como estructuras de
control porque se usan para controlar el flujo de un programa. Todas las estructuras de
control involucran algn tipo de decisin booleana, de modo que necesitar un buen
entendimiento de la lgica booleana y de las tablas de verdad.
.

Lgica booleana.
La lgica booleana se refiere a la combinacin de dos o ms expresiones booleanas en una
sola expresin booleana. Hay cuatro operaciones lgicas cuando se trabajan con las
sentencias booleanas combinadas:

1. AND: la expresin combinada es verdadera slo si ambas partes son verdaderas. Se

representa con el smbolo &.
2. OR: la expresin combinada es verdadera si al menos una de las partes es
verdadera. Se representa con el smbolo |.
3. OR exclusivo (XOR): la expresin combinada es verdadera slo si una parte es
verdadera y la otra es falsa. Se representa con el smbolo ^.
4. NOT: niega una expresin booleana. Se representa con el smbolo !.
....
....
....
....
....
....
....

X
F
F
V
V
.

....
....
....
....
....
....

X
F
F
V
V

Tabla de verdad
del operador AND
Y
x&Y
F
F
V
F
F
F
V
V
.
.
Tabla de verdad
del operador XOR
Y
x^Y
F
F
V
V
F
V
V
F

........
........
........
........
........
........

X
F
F
V
V
.

........
........
........
........
........

.
.

Tabla de verdad
del operador OR
Y
X|Y
F
F
V
V
F
V
V
V
.
.
Tabla de verdad
del operador NOT
X
!X
F
V
V
F
.
.
.
.

Cuadro Resumen de los Operadores Booleanos.

....
....
....
....

Operador
AND
OR
XOR

Sintaxis
&
|
^

........
........
........
........

Operador
Cortocircuito AND
Cortocircuito OR
NOT

Sintaxis
&&
||
!

.
Ejemplos:

1. int x = 10;
boolean b = ((x > 0) || (x-- != 10));

Qu hacen estos fragmentos de cdigo?

.
Cul es la diferencia operativa entre ambos?
(Ver marcacin en color verde).

2. int x = 10;
boolean b = ((x > 0) | (x-- != 10));

1. int x = 10;
boolean b = ((x != 0) && (x++ > 10));
.

Qu hacen estos fragmentos de cdigo?

Cul es la diferencia operativa entre ambos?
(Ver marcacin en color verde).

2. int x = 10;
boolean b = ((x != 0) & (x++ > 10));

int x = 5, y = 6, z = -3;
boolean b = ((x + 3 > y) ^ (z >= y)) && !(x == 5 | ++x ==
0);

Anlisis 1: (true ^false) && !(true |

true)
Anlisis 2: true && !(true)
Anlisis 3: true && false
Resultado: false

Sentencia IF.
Consiste en una estructura que evala la validez de una expresin booleana, y dependiendo
del resultado realiza una operacin.

if (Expresin booleana) {
if (expresin booleana)
// Conjunto de sentencias a ejecutar
// Sentencia a ejecutar
}

if (expresin booleana)
// Sentencia a ejecutar
else

if (expresin booleana) {
// Conjunto de sentencias a ejecutar
} else {

// Conjunto de sentencias a ejecutar

// Sentencia a ejecutar
}

if (expresin booleana) {
if (expresin booleana) {

if (expresin booleana) {

// Conjunto de sentencias a ejecutar

} else {

// Conjunto de sentencias a ejecutar

} else if (expresin booleana) {

// Conjunto de sentencias a ejecutar

}

// Conjunto de sentencias a ejecutar

} else if (expresin booleana) {

} else {

// Conjunto de sentencias a ejecutar

if (expresin booleana) {

} else if (expresin booleana) {

// Conjunto de sentencias a ejecutar

} else {

// Conjunto de sentencias a ejecutar

} else {

// Conjunto de sentencias a ejecutar

}

// Conjunto de sentencias a ejecutar

}

Sentencia SWITCH.
Permite probar una variable contra una lista de valores, donde cada valor es llamado un
caso (case) y la variable se prueba para cada caso. Su sintaxis es la siguiente:
switch (variable) {
case valor1:
// Conjunto de sentencias a ejecutar

break; // Opcional
case valor2:
// Conjunto de sentencias a ejecutar
break: // Opcional
default; // Opcionar
// Conjunto de sentencias a ejecutar
}
Las siguientes reglas aplican para una sentencia switch:

La variable usada slo puede ser un valor entero de 32 bits o ms pequeo. Esto
significa que los nicos tipos de datos que pueden ser evaluados son byte, short, int
y char.

Puede usar cualquier nmero de sentencias dentro de una estructura switch. Cada
caso es seguido por el valor con el que ser comprado y dos puntos.

El valor de un caso debe ser del mismo tipo de datos que la variable en la
estructura switch y debe ser una constante o un literal.

Cuando una variable que est siendo evaluada es igual a un caso, las sentencias que
le siguen a ese caso sern ejecutadas hasta llegar a un break.

Cuando un break es alcanzado, la sentencia switch termina y el flujo de control

salta hacia la lnea siguiente despus de la sentencia switch.

Los casos no necesitan contener un break. Si ningn break aparece, el flujo de

control "caer" hacia todos los case siguientes hasta encontrar un break o hasta el
final de la estructura.

Una sentencia switch puede tener un caso default, el cual debe aparecer al final de
la sentencia switch. El caso por defecto puede ser usado para realizar tareas cuando
ninguno de los casos es verdadero.

No es necesario el uso de break en las opciones case.

Sentencia WHILE.

Permite repetir una tarea mientras la expresin booleana definida se cumpla. Su sintaxis es
la siguiente:
while (expresin booleana) {
// Conjunto de sentencias a ejecutar
}
A continuacin se muestra un ejemplo sencillo:
int x = 1;
while (x <= 10) { // Existe riesgo
System.out.println(x);
x++; // Existe riesgo
}

NOTAS:
1. En la lnea marcada con amarillo existe la posibilidad de que nunca se ejecute el
ciclo si no se redacta adecuadamente la condicin dentro del parntesis o de que el
ciclo sea infinito si la condicin no vara (siempre se cumple), como se ampla en el
numeral tres.
2. En la lnea marcada con azul existe riesgo de crear un ciclo infinito si no se define,
porque la variable de color nunca cambiara de valor y siempre se cumplira la
condicin booleana.
3. Tambin puede darse un incumplimiento en ambas lneas, por ejemplo:
int x = 0;
while (x != 9) {
System.out.println(x);
x += 2;
}

Se convierte en un ciclo infinito debido a que x nunca toma el valor de 9.

Sentencia DO WHILE.
Similar a la sentencia while con la diferencia que esta estructura tiene la garanta de
ejecutarse al menos una vez debido a que la evaluacin de la condicin se encuentra al final
de la estructura. Su sintaxis es la siguiente:
do {
// Conjunto de sentencias a ejecutar
} while (expresin booleana);
A continuacin se muestra un ejemplo sencillo:
int x = 10:
do {
System.out.println(x);
x += 10; // Existe riesgo
} while (x <= 100); // Existe riesgo

NOTAS:
1. En la lnea marcada con amarillo existe riesgo de crear un ciclo infinito si no se
define, porque la variable de control nunca cambiara de valor y siempre se
cumplira la condicin booleana en caso de ser evaluada como verdadera. Recuerde
que este ciclo puede ser ejecutado al menos una vez aunque la condicin no se
cumpla, debido a que la evaluacin de su condicin se encuentra al final de la
estructura.
2. En la lnea marcada con azul existe la posibilidad de que la condicin dentro del
parntesis nunca se cumpla por haber sido redactada de forma tal que el ciclo sea
infinito, como se ampla en el numeral tres.

3. Tambinse puede darse un incumplimiento en ambas lneas, por ejemplo:

int x = 0;
do {
System.out.println(x);
x += 2;
} while (x != 9);
Se convierte en un ciclo infinito debido a que x nunca toma el valor de 9.

Sentencia FOR.
Permite escribir un lazo que ser ejecutado un nmero especfico de veces. Su sintaxis es la
siguiente:
for (inicio; expresin booleana; incremento) {
// Conjunto de sentencias
}
A continuacin se muestra un ejemplo sencillo:
for (int j = 1; j <= 1024; j * 2) {
System.out.println(j);
}
Analice este caso:
for (int a = 1, b = 100; a < b; a = a + 2, b = b - 4)
System.out.println("a = " + a + " y b = " + b);
La salida es:

a = 1 y b = 100
a = 3 y b = 96
...
a = 31 y b = 40
a = 33 y b = 36 // Esta es la ltima lnea que cumple la condicin definida en el ciclo.
NOTA: Las tres estructuras (WHILE, DO.. WHILE y FOR) anteriores pueden anidarse
.

La palabra reservada BREAK.

Esta palabra puede ser usada en cualquiera de las estructuras de ciclo para hacer que el
ciclo finalice inmediatamente. Cuando ocurre un break, el flujo de control salta
inmediatamente a la siguiente sentencia despus del ciclo sin importar el valor que en ese
momento tenga el contador.
public class BreakDemo {
public static void main (String [] args) {
int k = 1;
while (k <= 10) {
System.out.println(k);
if (k == 4)
break;
k++;
}
System.out.println("El valor final de k es " + k);
}
}

}
.

La palabra reservada CONTINUE.

Esta palabra puede ser usada en cualquiera de las estructuras de control de ciclo para hacer
que el ciclo salte inmediatamente a la siguiente iteracin. En un ciclo for, el flujo de control
salta a la parte de incremento. En un ciclo while o do while el flujo salta hacia la expresin
booleana. Por ejemplo:
public class ContinueDemo {
public static void main (String [] args) {
System.out.println("El ciclo FOR");
for (int i = 10; i > 0; i--) {
if (i % 2 == 0)
continue;
System.out.println(i);
}
System.out.println("El ciclo DO WHILE");
int j = 20;
do {
if (j % 3 != 0)
continue;
System.out.println(j);
} while (j-- > 0);
}
}
.

Ciclo anidado.
Es un ciclo que aparece en el cuerpo de otro ciclo.
public class Alfabeto {
public static void main (String [] args) {
char = 'a';
for (int fila = 0; fila < 3; fila++) {
for (int columna = 0; columna < 10; columna++) {
System.out.println(actual + " ");
actual++;
}
System.out.println();
}
}
}
.

Estructura TRY CATCH.

En Java se usa la excepcin para manejar los errores o fallas inesperadas que se pueden dar
en tiempo de ejecucin. Una excepcin es un evento que se da cuando el flujo normal de un
programa se interrumpe abruptamente durante su ejecucin. Por ejemplo, mientras se lee un
archivo y encuentra un sector daado en el disco.
Para construir un manejador de excepciones es necesario encerrar en un bloque try las
sentencias que puedan emitir una excepcin. Las sentencias encerradas en el try se ejecutan
hasta donde se d una excepcin.
A continuacin se agrega un bloque catch por cada tipo de excepcin que se quiera
capturar. Slo se ejecutar si se produce esa excepcin.

Opcionalmente, puede incluir un bloque finally que se ejecutar siempre, sin importar que
se d o no una excepcin.
La estructura bsica de try catch es la siguiente:
try {
// Conjunto de sentencias que podran generar una excepcin
} catch (Exception1 e) {
// Sentencia(s) para manejar la excepcin 1
} catch (Exception2 e) {
// Sentencia(s) para manejar la excepcin 2
} catch (Exception N) {
// Sentencia(s) para manejar la excepcin N
} finally
// Sentencia(s) a ejecutar sin importar si se gener una excepcin o no