Sentencias de ramificación son aquellas que nos permiten romper con la ejecución lineal de un programa.
El programa se va ejecutando de forma lineal, sentencia a sentencia. Si queremos romper esta linealidad tenemos las sentencias de ramificación.
Las sentencias de ramificación en Java son: break y continue
A ejecutar una La sentencia continue dejaremos de ejecutar las sentencias que quedan para acabar el bloque dentro de un bucle para volver a evaluar una expresión.
La estructura de unas sentencia continue sería:
while (expresion) {
sentencia(s) iniciales;
continue;
sentencias(s) finales;
} podemos realizar continue etiquetados. En este caso la sentencia continue nos llevará directamente a la primera condición de evaluación del bloque.
La estructura en este caso sería la siguiente:
etiqueta:
while (expresion) {
sentencia(s) iniciales;
while (expresion) {
sentencia(s) iniciales;
continue etiqueta;
sentencia(s) finales;
}
sentencia(s) finales;
break dentro de estructuras repetitivas suele aparecer cuando estamos realizando la búsqueda de un elemento por una estructura de datos y lo hemos encontrado.
Por ejemplo, si tenemos un array y queremos buscar un número dentro del array podríamos tener el siguiente código:
int[] numeros = {12,3,4,5,6,7,9,10};
int posicion = 0;
boolean encontrado = false;
while (posicion < numeros.length) {
if (numeros[posicion] == 5) {
encontrado = true;
break;
}
posicion++;
}
if (encontrado) {
System.out.println("El número está en la posición: " + posicion);
} else {
System.out.println("Número no encontrado");
las sentencias de control de flujo las cuales permiten alterar el fujo de ejecución para tomar decisiones o repetir sentencias.
Sentencias de control en JAVA
Dentro de las sentencias de control de flujo tenemos las siguientes:
Sentencias de bucle permiten ejecutar un bloque de sentencias tantas veces como queramos, o tantas veces como se cumpla una condición.
En el momento que se cumpla esta condición será cuando salgamos del bucle.
Las sentencias de bucle en Java son: while, do-while y for.
for nos permite escribir toda la estructura del bucle de una forma más acotada. Si bien, su cometido es el mismo.
for (sentencias_inicio;expresion;incremento) {
bloque_sentencias;
}
do-while, lo que vamos a conseguir es que el bloque de sentencias se ejecute, al menos, una vez.
do {
bloque_sentencias;
} while (expresion)
while tenemos un bucle que se ejecuta mientas se cumple la condición, pero puede que no se llegue a ejecutar nunca, si no se cumple la condición la primera vez.
while (expresion) {
bloque_sentencias;
Subtopic
Sentencias de decisión permiten tomar una decisión para poder ejecutar un bloque de sentencias u otro.
Las sentencias de decisión son: if-then-else y switch.
switch podremos evaluar múltiples decisiones y ejecutar un bloque asociado a cada una de ellas.
switch (expresion) {
case valor1:
bloque1;
break;
case valor2:
bloque2;
break;
case valor3:
bloque3;
break;
…
default:
bloque_por_defecto;
}
Mediante if-then-else podremos evaluar una decisión y elegir por un bloque u otro.
if (expresion) {
// Bloque then
} else {
// Bloque else
De esta forma podríamos tener el siguiente código fuente:
int valor = 4;
if (valor < 10) {
System.out.println("El número es menor de 10");
} else {
System.out.println("El número es mayor de 10");
