Estructuras de control en Java
Las estructuras de control determinan la secuencia de ejecución
de las sentencias de un programa.
Las estructuras de control se dividen en tres
categorías:
·
Secuencial
·
Condicional o Selectiva
·
Iterativa o Repetitiva.
1.- ESTRUCTURA
SECUENCIAL
El orden en que se ejecutan por defecto las
sentencias de un programa es secuencial. Esto significa que las sentencias se
ejecutan en secuencia, una después de otra, en el orden en que aparecen
escritas dentro del programa.
La estructura secuencial está formada por una
sucesión de instrucciones que se ejecutan en orden una a continuación de la
otra.
Cada una de las instrucciones están separadas
por el carácter punto y coma (;).
Las instrucciones se suelen agrupar en
bloques.
El bloque de sentencias se define por el
carácter llave de apertura ({) para marcar el inicio del mismo, y el carácter
llave de cierre (}) para marcar el final.
Ejemplo:
{
instrucción 1;
instrucción 2;
instrucción 3;
}
En Java si el bloque de sentencias está constituido
por una única sentencia no es obligatorio el uso de las llaves de apertura y
cierre ({ }), aunque sí recomendable.
Ejemplo de programa Java con
estructura secuencial: Programa que lee dos números por teclado y los
muestra por pantalla.
/* Programa
que lea dos números por teclado y los muestre por pantalla.
*/
importjava.util.*;
public class Main {
public static void main(String[]
args){
//declaración de variables
int n1, n2;
Scanner leer = new
Scanner(System.in);
//leer el primer número
System.out.println("Introduce un número entero: ");
n1 = leer.nextInt(); //lee un entero por teclado
//leer el segundo número
System.out.println("Introduce otro número entero: ");
n2 = leer.nextInt(); //lee un entero por teclado
//mostrar resultado
System.out.println("Ha introducido los números: " + n1 + " y
" + 2);
}
}
2.- ESTRUCTURA
CONDICIONAL, ALTERNATIVA O SELECTIVA
La estructura condicional determina si se ejecutan unas instrucciones u otras
según se cumpla o no una determinada condición.
En java la estructura condicional se
implementa mediante:
- Instrucción if.
- Instrucción switch.-
2.1.1 INSTRUCCION if
Puede ser del tipo:
-
Condicional simple: if
-
Condicional doble: if ... else ...
-
Condicional múltiple: if ..else if ..
La condición debe ser una expresión booleana es decir debe dar como
resultado un valor booleano (true ó false).
Condicional simple: se evalúa la condición y si ésta se cumple se ejecuta una
determinada acción o grupo de acciones. En caso contrario se saltan dicho grupo
de acciones.
if(expresión_booleana){
instrucción 1
instrucción 2
.......
}
Si el
bloque de instrucciones tiene una sola instrucción no es necesario escribir las llaves { } aunque para evitar
confusiones se recomienda escribir las llaves siempre.
Ejemplo de programa Java con
estructura condicional simple: Programa que pide por teclado la nota
obtenida por un alumno y muestra un mensaje si el alumno ha aprobado.
/*
* Programa que pide una nota por teclado y
muestra un mensaje si la nota es
* mayor o igual que 5
*/
importjava.util.*;
public class
Ejemplo0If {
public static void main( String[] args
){
Scanner leer = new Scanner( System.in );
System.out.print("Ingres Nota: ");
int nota = leer.nextInt();
if (nota >= 5 ){
System.out.println("Has aprobado");
}
}
}
2.1.2.- Condicional doble: Se evalúa la condición y
si ésta se cumple se ejecuta una determinada instrucción o grupo de
instrucciones. Si no se cumple se ejecuta otra instrucción o grupo de
instrucciones.
if(expresión booleana){
instrucciones 1
}else{
instrucciones 2
}
Ejemplo de programa Java que contiene
una estructura condicional doble: Programa que lee la nota de un alumno
y muestra si el alumno ha aprobado o no.
/*
* Programa que pide una nota por teclado y
muestra si se ha aprobado o no
*/
importjava.util.*;
public class
Ejemplo0If {
public static void main( String[] args ){
Scanner leer = new Scanner( System.in );
System.out.print("Nota: ");
int nota = leer.nextInt();
if (nota >= 5 ){
System.out.println("Has aprobado, felicidades");
}
else
System.out.println("Lo Siento, has reprobado");
}
}
2.1.3.- Condicional múltiple: Se obtiene anidando
sentencias if ...else. Permite construir estructuras de selección más
complejas.
if
(expresion_booleana1)
instruccion1;
else if
(expresion_booleana2)
instruccion2;
else
instruccion3;
Cada else se corresponde con el if más próximo
que no haya sido emparejado.
Una vez que se ejecuta un bloque de
instrucciones, la ejecución continúa en la siguiente instrucción que aparezca
después de las sentencias if..else anidadas.
Ejemplo de programa Java que contiene
una estructura condicional múltiple: Programa que lee una hora (número
entero) y muestra un mensaje según la hora introducida.
/*
* Programa que muestra un saludo distinto
según la hora introducida
*/
importjava.util.*;
public class Ejemplo2If {
public static void main(String[] args) {
Scanner leer = new Scanner(System.in);
int hora;
System.out.println("Introduzca una hora (un valor entero): ");
hora = leer.nextInt();
if (hora >=
0 && hora < 12)
System.out.println("Buenos días");
Else
if
(hora >= 12 && hora < 21)
System.out.println("Buenas tardes");
Else
if
(hora >= 21 && hora < 24)
System.out.println("Buenas noches");
else
System.out.println("Hora no válida");
}
}
2.2.1 INSTRUCCION switch
Se utiliza para seleccionar una de entre
múltiples alternativas.
La forma general de la instrucción switch en
Java es la siguiente:
switch (expresión){
case valor 1:
instrucciones;
break;
case
valor 2:
instrucciones;
break;
· ·
·
default:
instrucciones;
}
La instrucción switch se puede usar con datos
de tipo byte, short, char e int. También con tipos enumerados y con las clases
envolventes Character, Byte, Short e Integer. A partir de Java 7 también pueden
usarse datos de tipo String en un switch.
Funcionamiento de la instrucción switch:
-Pr- Primero se evalúa la
expresión y salta al case cuya constante coincida con el valor de la expresión.
– - Se
ejecutan las instrucciones que siguen al case seleccionado hasta que se
encuentra un break o hasta el final del switch. El break produce un salto a la
siguiente instrucción a continuación del switch.
– - Si
ninguno de estos casos se cumple se ejecuta el bloque default (si
existe). No es obligatorio que exista un bloque default y no tiene porqué
ponerse siempre al final, aunque es lo habitual.
Ejemplo de programa Java que contiene una instrucción switch:
Programa que lee por
teclado un mes (número entero) y muestra el nombre del mes.
/*
* Programa que pide un número de mes y
muestra el nombre correspondiente
*/
importjava.util.*;
public class
Ejemplo0Switch {
public static void main(String[] args) {
int mes;
Scanner leer = new Scanner(System.in);
System.out.print("Introduzca un numero de mes: ");
mes = leer.nextInt();
switch (mes){
case 1: System.out.println("ENERO");
break;
case 2: System.out.println("FEBRERO");
break;
case 3: System.out.println("MARZO");
break;
case 4: System.out.println("ABRIL");
break;
case 5: System.out.println("MAYO");
break;
case 6: System.out.println("JUNIO");
break;
case 7: System.out.println("JULIO");
break;
case 8: System.out.println("AGOSTO");
break;
case 9: System.out.println("SEPTIEMBRE");
break;
case 10: System.out.println("OCTUBRE");
break;
case 11: System.out.println("NOVIEMBRE");
break;
case 12: System.out.println("DICIEMBRE");
break;
default : System.out.println("Mes no
válido");
}
}
}
3. ESTRUCTURA ITERATIVA O REPETITIVA
Permiten ejecutar de forma repetida un bloque específico de instrucciones.
Las instrucciones se repiten mientras o hasta que se cumpla una
determinada condición. Esta condición se conoce como condición de salida.
Tipos de estructuras repetitivas:
-
ciclo while
-
ciclo do – while
-
ciclo for
3.1 CICLO WHILE
Las
instrucciones se repiten mientras la condición sea cierta. La condición se comprueba al principio del bucle
por lo que las acciones se pueden ejecutar 0 ó más veces.
La ejecución de un bucle while sigue los siguientes pasos:
1.
Se evalúa la condición.
2. Si el
resultado es false las instrucciones no se ejecutan y el programa sigue
ejecutándose por la siguiente instrucción a continuación del while.
3.
Si el resultado es true se ejecutan las instrucciones y se
vuelve al paso 1
Ejemplo
de programa Java que contiene una instrucción while:
Programa que lee números
por teclado. La lectura acaba cuando el número introducido sea negativo. El programa
calcula y muestra la suma de los números leídos.
/*
* Programa que lee números hasta que se lee
un negativo y muestra la
* suma de los números leídos
*/
importjava.util.*;
public class
Ejemplo1While {
public static void main(String[] args) {
int suma = 0, num;
Scanner leer = new Scanner(System.in);
System.out.print("Introduzca un número: ");
num = leer.nextInt();
while (num >= 0){
suma = suma + num;
System.out.print("Introduzca un número: ");
num = leer.nextInt();
}
System.out.println("La suma es: " + suma );
}
}
3.2 CICLO DO – WHILE
Las instrucciones se ejecutan mientras la
condición sea cierta.
La
condición se comprueba al final
del bucle por lo que el bloque de instrucciones se ejecutarán al menos una vez. Esta es la
diferencia fundamental con la instrucción while. Las instrucciones de un
bucle while es posible que no se ejecuten si la condición inicialmente es
falsa.
La ejecución de un bucle do - while sigue los
siguientes pasos:
1. Se ejecutan las
instrucciones a partir de do{
2. Se evalúa la condición.
3.Si el resultado es false el programa sigue
ejecutándose por la siguiente instrucción a continuación del while.
4. Si el resultado es true
se vuelve al paso 1
Ejemplo de programa Java
que contiene una instrucción do while:
Programa que lee un número entero N. El número debe ser menor
que 100.
/*
* Programa que obliga al usuario a
introducir un número menor que 100
*/
importjava.util.*;
public class
Ejemplo1DoWhile {
public static void main(String[] args) {
int valor;
Scanner leer = new Scanner( System.in );
do {
System.out.print("Escribe un entero < 100: ");
valor = in.nextInt();
}while (valor >= 100);
System.out.println("Ha introducido: " + valor);
}
}
3.3 CICLO FOR
Hace que una instrucción o bloque de
instrucciones se repitan un número determinado de veces mientras se cumpla la condición.
La estructura general de una instrucción for
en Java es la siguiente:
for(inicialización; condición;
incremento/decremento){
instrucción 1;
...........
instrucción N;
}
A continuación de la palabra for y entre paréntesis debe
haber siempre tres zonas
separadas por punto y coma:
-
zona de inicialización.
-
zona de condición
-
zona de incremento ó decremento.
Si en alguna ocasión no es necesario escribir
alguna de ellas se pueden dejar en blanco, pero los dos punto y coma deben
aparecer.
Inicialización: Es la parte en la que la
variable o variables de control del bucle toman su valor inicial. Puede haber
una o más instrucciones en la inicialización, separadas por comas. La
inicialización se realiza solo una vez.
Condición: Es una expresión
booleana que hace que se ejecute la sentencia o bloque de sentencias mientras
que dicha expresión sea cierta. Generalmente en la condición se compara la
variable de control con un valor límite.
Incremento/decremento: Es una expresión que
decrementa o incrementa la variable de control del bucle.
La ejecución de un bucle for sigue los
siguientes pasos:
1. Se inicializa la variable o variables de
control (inicialización).
2. Se evalúa la condición.
3. Si la condición es cierta se ejecutan las
instrucciones. Si es falsa, finaliza la ejecución del bucle y continúa el
programa en la siguiente instrucción después del for.
4. Se actualiza la variable o variables de
control (incremento/decremento).
5. Se vuelve al punto 2.
Ejemplo de programa Java
que contiene una instrucción for:
/*
* programa que muestra los números del 1 al
10
*/
public class
Ejemplo0For {
public static void main(String[] args) {
int i;
for(i=1; i<=10; i++)
System.out.println(i + " ");
}
}
La instrucción for del ejemplo anterior la
podemos interpretar así:
Asigna a i el valor inicial 1, mientras que i
sea menor o igual a 10 muestra i + “ “ , a continuación incrementa el valor de
i y comprueba de nuevo la condición.
3.4 BUCLES INFINITOS EN JAVA
Java permite la posibilidad de construir
bucles infinitos, los cuales se ejecutarán indefinidamente, a no ser que
provoquemos su interrupción.
for(;;){
instrucciones
}
for(;true;){
instrucciones
}
while(true){
instrucciones
}
3.5 BUCLES ANIDADOS
Bucles anidados son aquellos que incluyen instrucciones for, while o do-while
unas dentro de otras.
Debemos tener en cuenta que las variables de control que
utilicemos deben ser distintas.
Los anidamientos de estructuras tienen que ser correctos, es
decir, que una estructura anidada dentro de otra lo debe estar totalmente.
Ejemplo de programa Java con bucles
anidados:
/*
* Programa que dibuja un rectángulo sólido
de asteriscos.
* El número de filas y columnas se pide por
teclado
*/
importjava.util.*;
publicclass
Ejemplo1BuclesAnidados {
public static void main(String[] args) {
Scanner leer = new Scanner(System.in);
int filas, columnas;
//leer número de filas hasta que sea un número > 0
do{
System.out.print("Introduce número de filas: ");
filas = leer.nextInt();
}while(filas<1);
//leer número de columnas hasta que sea un número > 0
do{
System.out.print("Introduce número de columnas: ");
columnas = leer.nextInt();
}while(columnas<1);
for(inti = 1; i<=filas; i++){ //filas
for(int j = 1; j<=columnas;
j++){ //columnas
System.out.print(" * ");
}
System.out.println();
}
}
}
La salida de este programa para filas = 6 y
columnas = 10 es:
* * * * *
* * * * * * *
* * * * *
* * * * * * *
* * * * *
* * * * * * *
* * * * *
* * * * * * *
* * * * *
* * * * * * *
* * * * *
* * * * * * *
Sobre el material ya expuesto, les mostrare en Scratch un programa realizado con las estructuras de control While y If, Else.
- Este programa mostrara los números impresos del 1 al 11.
- Mostrara cuantos números pares hay.
- Mostrara cuantos números impares hay.
- Mostrara la suma de los números pares.
- Mostrara la suma de los números impares.
Para ver el enlace pincha aquí
Esperando que este material les sea de ayuda, hasta la próxima.
