INDICE

INTRODUCCION ................................................................................................................................... 2
ESCTRUCTURAS DE SELECCIÓN Y DE REPETICIÓN ......................................................... 3
Estructuras de selección ............................................................................................................. 6
Estructura if ................................................................................................................................... 6
Estructura if else ........................................................................................................................... 7
Estructura if else if ........................................................................................................................ 9
CUADRO COMPARATIVO ................................................................................................................... 13

1
INTRODUCCION

Las estructuras de repetición, permiten la ejecución de una lista o secuencia de

instrucciones (<Bloque de instrucciones>) en varias ocasiones. El número de veces
que el bloque de instrucciones se ejecutará se puede especificar de manera
explícita, o a través de una condición lógica que indica cuándo se ejecuta de nuevo
y cuándo no. A cada ejecución del bloque de instrucciones se le conoce como una
iteración.
Las estructuras de selección o condicionales controlan si una o varias
instrucciones que se ejecutan en función del cumplimiento o no de una condición.
Las sentencia if - else evalúa una expresión lógica y si se cumple ejecuta ciertas
instrucciones, en caso contrario ejecuta otras. Los bucles o ciclos permiten la
ejecución de una o varias instrucciones, nitas, oin, nitas, dependiendo de las
necesidades que se tengan.

2
ESCTRUCTURAS DE SELECCIÓN Y DE REPETICIÓN

Una estructura de repetición o bucle nos permite ejecutar un número de veces

determinado una serie de instrucciones. La mayor utilidad es evitar la repetición de
líneas de código iguales. Para salir del bucle, se indica una condición, si esa
condición no se cumple se sale del bucle.

Las estructuras de repetición son:

 while: indicamos una condición que se ejecutara hasta que la condición sea
falsa, es importante que la variable que este en la condición, varíe para que
no se produzca un bucle infinito. Su sintaxis es:

1while (condición){
2 instrucciones
3}

Veamos un ejemplo:

1 public class PruebaApp {

2
3 public static void main(String[] args) {
4
5 int num=1;
6
7 while (num<=5){
8 System.out.println(num);
9 num++;
10 }
11 }
12}

Como vemos, num vale 1 al principio, se comprueba la condición, como 1 es

menor o igual que 5, entra en el bucle y ejecuta las instrucciones, y así
sucesivamente hasta que num vale 6, ya que 6 no es menor o igual que 5. Si num
no fuera modificado, nunca saldría del bucle.

 for: este tipo de bucle, es como el anterior pero ademas de la condición,

incluye una inicialización de una variable y un incremento o decremento de
esa variable, en principio, no es necesario que incluya las 3 partes, se pueden
inicializar o incrementar varias separadas por comas. Cada parte se separa
con un; NOTA: cuando salimos del bucle, la variable inicializada no existe. Su
sintaxis:

3
1for(inicializacion;condicion;incremento){
2 instrucciones
3}

Si nos fijamos, es como en while pero todo se define en el bucle. Veamos un

ejemplo:

1public class PruebaApp {

2
3 public static void main(String[] args) {
4
5 for (int num=1; num<=5; num++){
6 System.out.println(num);
7 }
8 }
9}

Es el mismo ejemplo de antes pero más reducido.

 do-while: esta estructura repetitiva, tiene algo especial y es que

como mínimo las instrucciones dentro de la estructura repetitiva al menos
una vez, mientras que el while sus instrucciones pueden ejecutarse 0 o N
veces. Se sale del bucle cuando la condición del while no se cumple, si esto
pasa empieza desde el do. Se utiliza para la validación de datos. Su sintaxis
es:

1do{
2 instrucciones
3}while(condición);

Veamos un ejemplo:

import javax.swing.JOptionPane;
1
public class PruebaApp {
2
3
public static void main(String[] args) {
4
int num;
5
do{
6
String texto=JOptionPane.showInputDialog("Introduce un numero entre
7
0 y 10");
8
num=Integer.parseInt(texto);
9
}while(num>=10 || num<0);
10
System.out.println("El numero introducido es "+num);
11
}
12
}

4
Tenemos que pensar bien la condición de salida. En nuestro caso, si insertamos
un 5 (5>=10 or 5<0) devolvería falso, si insertáramos un -1 (-1>=10 or 5<o)
devolvería verdadero, haciendo que vuelva a pedir un número

El cuerpo de un programa se compone de un conjunto de sentencias que

especifican las acciones que se realizan durante su ejecución. Dentro de cualquier
programa, se escriben sentencias que definen la secuencia de acciones a ejecutar.
Estas sentencias incluyen acciones de cálculo, entrada y salida de datos,
almacenamiento de datos, etc. Las sentencias se ejecutan una a una en el orden
en el que han sido escritas.

Se denomina flujo de un programa al orden de ejecución de las sentencias que

forman parte del cuerpo de un programa. Las estructuras de control son una
característica básica de los lenguajes que se utiliza para modificar el flujo de un
programa.

Hay casos en los que el flujo de un programa debe ejecutar determinadas

instrucciones solo cuando se cumple una condición. En otras ocasiones, debe
repetir un conjunto de sentencias un número determinado de veces.
Las estructuras de control permiten condicionar el flujo de ejecución dependiendo
del estado de las variables de un programa.

Las estructuras de control básicas se pueden clasificar en estructuras de selección,

de repetición y de salto.

 Selección. Permiten decidir si se ejecuta un bloque de sentencias o no.

 Repetición. Permiten ejecutar un bloque de sentencias muchas veces.
 Salto. Permiten dar un salto y continuar la ejecución de un programa en un
punto distinto de la siguiente sentencia en el orden natural de ejecución.

Las estructuras de control se pueden combinar sin ningún tipo de limitación.

Cualquier nuevo bloque de sentencias puede incluir estructuras de control a
continuación de otras. Cuando se incluyen varias estructuras seguidas unas de
otras, se dice que son estructuras de control apiladas.

Por otra parte, dentro de un bloque de una estructura de control se puede incluir
otra estructura de control y dentro de este nuevo bloque se puede incluir otra
estructura de control y así sucesivamente. Cuando una estructura contiene otra
estructura, se dice que son estructuras de control anidadas.

Es importante destacar que no existe limitación en cuanto al número de estructuras

de control apiladas o anidadas que se pueden utilizar en un programa Java. La única
restricción a tener en cuenta es la claridad y la legibilidad del programa.

5
Estructuras de selección

Las estructur as de selección permiten modificar el flujo de un programa. La decisión

de ejecutar un bloque de sentencias queda condicionada por el valor de una
expresión lógica definida utilizando variables del programa.

Estructura if

La estructura if se denomina estructura de selección única porque ejecuta un bloque

de sentencias solo cuando se cumple la condición del if. Si la condición es verdadera
se ejecuta el bloque de sentencias. Si la condición es falsa, el flujo del programa
continúa en la sentencia inmediatamente posterior al if.

Una sentencia if tiene la siguiente sintaxis:

?
1if (condicion) {
2bloque-de-sentencias
3}

La condición es una expresión que evalúa un valor lógico, por lo que el resultado
solo puede ser true o false. La condición siempre se escribe entre paréntesis. La
selección se produce sobre el bloque de sentencias delimitado por llaves. Si el
bloque de sentencias solo tiene una sentencia, entonces se puede escribir sin las
llaves, como se muestra a continuación.

?
1if (condicion)
2sentencia;

Cuando el flujo de un programa llega a una estructura if, se evalúa la condición y el

bloque de instrucciones se ejecuta si el valor de la condición es true. Si la condición
es false, entonces se ejecuta la sentencia inmediatamente posterior al if.

Por ejemplo, si la calificación de un alumno es 10, entonces se debe mostrar por la

consola un mensaje indicando que tiene una Matrícula de Honor.

La sentencia if considerando que calificación es una variable de tipo int:

?
1if (calificación == 10) {

6
2System.out.println("Matrícula de Honor");
3}

En este ejemplo el mensaje “Matrícula de Honor” solo se muestra cuando el valor

de la calificación es igual a 10.

Estructura if else

La estructura if-else se denomina de selección doble porque selecciona entre dos

bloques de sentencias mutuamente excluyentes. Si se cumple la condición, se
ejecuta el bloque de sentencias asociado al if. Si la condición no se cumple,
entonces se ejecuta el bloque de sentencias asociado al else.

Una sentencia if-else tiene la siguiente sintaxis:

?
1if (condicion) {
2bloque-de-sentencias-if
3}
4else {
5bloque-de-sentencias-else
6}

Al igual que en el if, la condición se debe escribir entre paréntesis. La selección

depende del resultado de evaluar la condición. Si el resultado es true, se ejecuta el
bloque de sentencias del if, en cualquier otro caso se ejecuta el bloque de
instrucciones del else. Después de ejecutar el bloque de sentencias se ejecuta la
sentencia inmediatamente posterior al if-else.

Por ejemplo, si se desea mostrar un mensaje por la consola para indicar si un

número es par o impar, basta con calcular el resto de la división del número entre 2
con el operador %. Si el resto es igual a cero, entonces el número es par, en caso
contrario el número es impar.

La sentencia if-else:

?
1if (numero % 2 == 0)
2System.out.println("El número es par");
3else
4System.out.println("El número es impar");

Como se ha comentado antes, los bloques de sentencias son mutuamente

excluyentes. Si se cumple la condición se ejecuta un bloque de sentencias, en caso
contrario se ejecuta el otro bloque de sentencias. Teniendo en cuenta esto, se

7
podría escribir una sentencia if-else con la condición contraria y con los bloques de
sentencias intercambiados.

?
1if (numero % 2 != 0)
2System.out.println("El número es impar");
3else
4System.out.println("El número es par");

Si fuera necesario evaluar más de una condición, entonces se deben utilizar varias
estructuras de selección anidadas. Por ejemplo, para mostrar la calificación de un
alumno, es necesario evaluar las condiciones que se indican en la siguiente tabla.

De la tabla anterior, se puede ver que las condiciones son excluyentes entre sí. Si
la calificación es 10 se muestra “Matrícula de Honor”. En caso contrario la
calificación es menor de 10 y es necesario seleccionar entre “Sobresaliente”,
“Notable”, “Bien”, “Aprobado” y “Suspenso”. Si la calificación es 9 se muestra
“Sobresaliente”. En caso contrario, la calificación es menor de 9 y se debe
seleccionar entre “Notable”, “Bien”, “Aprobado” y “Suspenso”. Si la calificación es
mayor o igual a 7 se muestra “Notable”. En caso contrario la calificación es menor
de 7 y se debe seleccionar entre “Bien”, “Aprobado” y “Suspenso”. Si la calificación
es 6 se muestra “Bien”. En caso contrario la calificación es menor o igual a 6 y se
debe seleccionar entre “Aprobado” y “Suspenso”. Si la calificación es 5 se muestra
“Aprobado”, en caso contrario “Suspenso”.

La sentencia if-else:

?
1 int calificación = 7;
2 if (calificación == 10)
3 System.out.println("Matrícula de Honor");
4 else
5 if (calificación == 9)
8
6 System.out.println("Sobresaliente");
7 else
8 if (calificación >= 7)
9 System.out.println("Notable");
10else
11if (calificación == 6)
12System.out.println("Bien");
13else
14if (calificación == 5)
15System.out.println("Aprobado");
16else
17System.out.println("Suspenso");

Estructura if else if

La estructura if-else-if se puede aplicar en los mismos casos en que se utiliza un if-
else anidado. Esta estructura permite escribir de forma abreviada las condiciones
de un if-else anidado.

Una sentencia if-else-if tiene la siguiente sintaxis:

?
1if (condicion-1) {
2bloque-de-sentencias-condicion-1
3} else if (condicion-2) {
4bloque-de-sentencias-condicion-2
5} else {
6bloque-de-sentencias-else
7}

La sentencia if-else-if para el ejemplo de las calificaciones:

?
1 int calificación = 7;
2 if (calificación == 10) {
3 System.out.println("Matrícula de Honor");
4 } else if (calificación == 9) {
5 System.out.println("Sobresaliente");
6 } else if (calificación >= 7) {
7 System.out.println("Notable");
8 } else if (calificación == 6) {
9 System.out.println("Bien");
10} else if (calificación == 5) {
11System.out.println("Aprobado");
12} else {

9
13System.out.println("Suspenso");
14}

ESTRUCTURA SELECTIVA
Las estructuras selectivas se utilizan para tomar decisiones lógicas; de ahí que se
suelan denominar también estructuras de decision o alternativas y son utilizadas
en todos los lenguajes de programacion.
Las estructuras selectivas múltiples o anidadas están
compuesta múltiples selectivas simples’ que están unidas
por el comando elsif el resultado que se obtiene con una
selectiva múltiple se puede obtener con varias selectivas
simples.

if (condición)

acción (si la condición entre paréntesis es verdadera se

ejecutara la acción o acciones, porque, puede estar
conformado por varias líneas)

elsif (condición)

acción (si la condición entre paréntesis es verdadera se

ejecutara la acción o acciones, porque, puede estar
MULTIPLE conformado por varias líneas)

elsif (condición)

acción (si la condición entre paréntesis es verdadera se

ejecutara la acción o acciones, porque, puede estar
conformado por varias líneas)

end

SIMPLE Las estructuras selectivas simples o condicionales están

compuesta únicamente de una sola condición si es
verdadera ejecutara la acción o acciones si la condición es
falsa no hará nada.

if (condición) entre paréntesis esta la condición que se debe

evaluar

10
 acción (si la condición entre paréntesis es verdadera se
ejecutara la acción o acciones, porque, puede estar
conformado por varias acciones)

end

Antes de mostrar el ejemplo vamos a explicar algunos

comandos que vamos a utilizar:

# => este comando nos permite poner un comentario, puede

ser a principio de línea o en cualquier posición de ella.

puts => este comando nos permite imprimir cualquier texto

en pantalla, puede ser el resultado de una operación o un
texto escrito entre comillas.
DOBLE Las estructuras selectivas dobles están compuestas
únicamente de una sola condición, si es verdadera ejecutara
la acción o acciones y si la condición es falsa ejecutara las
acciones para la condición falsa. Esta estructura selectiva
solo se debe utilizar únicamente cuando existen dos
condiciones, si hubieran más de dos condiciones se puede
utilizar varias selectivas simples’ o una selectiva múltiple.

if (condición)

acción (si la condición entre paréntesis es verdadera se

ejecutara la acción o acciones, porque, puede estar
conformado por varias líneas)

else

acción (si la condición entre paréntesis es falsa se ejecutara

la acción o acciones, porque, puede estar conformado por
varias líneas)

end

ESTRUCTURA DE REPETICIÓN
Las estructuras repetitivas se utilizan cuando se quiere que un conjunto de
instrucciones se ejecuten un cierto número finito de veces, por ejemplo,
escribir algo en pantalla cierta cantidad de veces, mover un objeto de un
punto a otro cierta cantidad de pasos, o hacer una operación matemática
cierta cantidad de veces. Se les llama bucle o ciclo a todo proceso que se
repite cierto número de veces dentro de un pseudocódigo o un programa y
las estructuras repetitivas nos permiten hacerlo de forma sencilla.

11
 Repite el cuerpo del bucle mientras se cumpla una
determinada condición.

Mientras condición
MIENTRAS
Acción_1

Acción_2

Acción_3

Acción_n

Fin_mientras
Esta estructura ejecuta las acciones del cuerpo del bucle un
número especificado de veces, y de modo automático
controla el número de iteraciones o pasos.
Desde i=0 hasta 100

DESDE O PARA Acción_1

Acción_2

Acción_3

Acción_n

Fin_desde
REPETIR La estructura repetir cumple la misma función que la
estructura mientras. La diferencia está en que la estructura
mientras comprueba la condición al inicio y repetir lo hace al
final. Es por ello que la estructura repetir se ejecuta por lo
menos una vez.

Hacer

Acción_1

Acción_2

Acción_3

Acción_n

Mientras condición

12
CUADRO COMPARATIVO

13