Aprende sobre estructuras condicionales en Java: if, if-else, switch, break, continue, jump. Muchos ejemplos con explicación para que aprendas de manera rápida.

La toma de decisiones en la programación es similar a la toma de decisiones en la vida real. En la programación también enfrentamos algunas situaciones en las que queremos que se ejecute cierto bloque de código cuando se cumple alguna condición.

Un lenguaje de programación utiliza instrucciones de control para controlar el flujo de ejecución del programa en función de ciertas condiciones. Estos se utilizan para hacer que el flujo de ejecución avance y se ramifique en función de los cambios en el estado de un programa.

Declaraciones de selección de Java:

• if
• if-else
• nested-if
• if-else-if
• switch-case
• jump – break, continue, return

Estas declaraciones le permiten controlar el flujo de la ejecución de su programa en función de condiciones conocidas solo durante el tiempo de ejecución.

1. if

La sentencia if es la declaración de toma de decisiones más simple. Se usa para decidir si una determinada declaración o bloque de enunciados se ejecutará o no; es decir, si una determinada condición es verdadera (true), se ejecutará un bloque de enunciado y, de ser falsa (false), no.

Sintaxis:

if (condición) 
{ 
   // Declaraciones para ejecutar si 
   // la condición es verdadera 
}

Aquí, la condición después de la evaluación será verdadera o falsa. if acepta valores booleanos: si el valor es verdadero, ejecutará el bloque de instrucciones debajo de él. OJO: Si no proporcionamos las llaves ‘{‘ y ‘}’ después del if (condición), entonces de forma predeterminada la sentencia if considerará que la declaración inmediata está dentro de su bloque.

Por ejemplo:

if (condicion) 
   declaracion1; 
   declaracion2; 
// Aquí si la condición es verdadera, el bloque if 
// solo  considerará que la declaracion1 está dentro 
// de su bloque.

Ejemplo:

// Programa Java para ilustrar la declaración If
class IfDemo
{
    public static void main(String args[])
    {
        int i = 10;
 
        if (i > 15)
            System.out.println("10 es menor que 15");
 
        // Esta declaración se ejecutará
        // como si considerara una declaración por defecto
        System.out.println("No estoy en IF");
    }
}

Salida:

No estoy en IF

2. if-else

La declaración if solo nos dice que, si una condición es verdadera ejecutará un bloque de instrucciones y si la condición es falsa, no lo hará. Pero, ¿y si queremos hacer otra cosa cuando la condición sea falsa? Aquí viene la declaración else. Podemos usar la instrucción else con la instrucción if para ejecutar un bloque de código cuando la condición es falsa.

Sintaxis:

if (condición) 
{ 
    // Ejecuta este bloque si 
    // la condición es verdadera 
} 
else 
{ 
    // Ejecuta este bloque si 
    // la condición es falsa 
}

Ejemplo:

// Programa Java para ilustrar la declaración if-else
class IfElseDemo
{
    public static void main(String args[])
    {
        int i = 20;
 
        if (i < 15)
            System.out.println("Soy menor que 15");
        else
            System.out.println("Soy mayor de 15");
    }
}

Salida:

Soy mayor de 15

3. Anidación-if

Una if anidado (nested-if) es una declaración if que se deriva de otro if o else. Las declaraciones if anidadas significan una instrucción if dentro de una declaración if. Sí, Java nos permite anidar las declaraciones if con if, es decir, podemos colocar una instrucción if dentro de otra instrucción if.

Sintaxis:

if (condicion1) 
{ 
   // Ejecuta cuando condicion1 es verdadero 
   if (condition2) 
   { 
      // Ejecuta cuando condicion2 es verdadero 
   } 
}

Ejemplo:

// Programa Java para ilustrar declaraciones anidadas
class NestedIfDemo
{
    public static void main(String args[])
    {
        int i = 10;
 
        if (i == 10)
        {
            // Primera declaración if
            if (i < 15)
                System.out.println("soy menor que 15");
 
            // Declaración if anidada
            // Solo se ejecutará si la instrucción anterior
            // es verdad
            if (i < 12)
                System.out.println("yo también soy menor que 12");
            else
                System.out.println("soy mayor que 15");
        }
    }
}

Salida:

soy menor que 15
yo soy menor que 12

4. Escalera if-else-if

Aquí, un usuario puede decidir entre múltiples opciones. Las sentencias if se ejecutan desde arriba hacia abajo. Tan pronto como una de las condiciones que controlan el if sea verdadera, se ejecuta la instrucción asociada con ese if, y el resto de la escalera se pasa por alto. Si ninguna de las condiciones es verdadera, se ejecutará la sentencia final else.

if (condición) 
    declaración; 
else if (condición) 
    declaración; 
. 
. 
    declaración 
else ;

Ejemplo:

// Programa Java para ilustrar if-else-if ladder
class ifelseifDemo
{
    public static void main(String args[])
    {
        int i = 20;
 
        if (i == 10)
            System.out.println("i es 10");
        else if (i == 15)
            System.out.println("i es 15");
        else if (i == 20)
            System.out.println("i es 20");
        else
            System.out.println("i no está presente");
    }
}

Salida:

i es 20

5. switch-case

La instrucción switch es una declaración de bifurcación de múltiples vías (selección múltiple). Proporciona una forma sencilla de enviar la ejecución a diferentes partes del código en función del valor de la expresión.

Sintaxis:

switch (expresión) 
{ 
  case valor1: 
    declaracion1; 
    break; 
  case value2: 
    declaracion2; 
    break; 
  . 
  . 
  case valorN: 
    declaracionN; 
    break; 
  default: 
    declaracionDefault; 
}

• La expresión puede ser de tipo byte, short, int, char o  una enumeración. A partir de JDK7, la expresión también puede ser de tipo String.
• Los valores duplicados de case no están permitidos.
• La declaración predeterminada default es opcional.
• La declaración de interrupción break; se usa dentro del switch para finalizar una secuencia de instrucción.
• La declaración break; es opcional. Si se omite, la ejecución continuará en el siguiente case.

Ejemplo:

// Java program to illustrate switch-case
class SwitchCaseDemo
{
    public static void main(String args[])
    {
        int i = 9;
        switch (i)
        {
        case 0:
            System.out.println("i es cero.");
            break;
        case 1:
            System.out.println("i es uno.");
            break;
        case 2:
            System.out.println("i es dos.");
            break;
        default:
            System.out.println("i es mayor que 2.");
        }
    }
}

Salida:

i es mayor que 2.

6. jump o saltos

Java admite tres declaraciones de salto: break, continue y return. Estas tres declaraciones transfieren el control a otra parte del programa.

6.1. break

En Java, break se utiliza principalmente para:

1. Terminar una secuencia en una instrucción switch (discutida arriba).
2. Para salir de un bucle
3. Como una forma “civilizada” de goto.

• Usar break para salir de un bucle

Utilizando el break, podemos forzar la terminación inmediata de un bucle, evitando la expresión condicional y cualquier código restante en el cuerpo del bucle.

Nota: break, cuando se utiliza dentro de un conjunto de bucles anidados, solo saldrá del bucle más interno.

// Programa Java para ilustrar usando
// break para salir del bucle
class BreakLoopDemo
{
    public static void main(String args[])
    {
        // Inicialmente, el bucle está configurado para ejecutarse desde 0-9
        for (int i = 0; i < 10; i++)
        {
            // termina el bucle cuando llega a 5.
            if (i == 5)
                break;
 
            System.out.println("i: " + i);
        }
        System.out.println("Bucle completo.");
    }
}

Salida:

i: 0 
i: 1 
i: 2 
i: 3 
i: 4 
Bucle completo.

• Usar break como una forma de Goto

Java no tiene una declaración goto porque proporciona una forma de bifurcar de manera arbitraria y no estructurada. Java usa etiquetas. Una etiqueta se usa para identificar un bloque de código.

Sintaxis:

etiqueta:
{
  declaracion1;
  declaracion2;
  declaracion3;
  .
  .
}

Ahora, la instrucción break se puede utilizar para saltar fuera del bloque objetivo. Así: break etiqueta;

Nota: No puede romper ninguna etiqueta que no esté definida para un bloque envolvente.

Ejemplo:

// Programa Java para ilustrar el uso de break con goto
class BreakLabelDemo
{
    public static void main(String args[])
    {
        boolean t = true;
 
        // etiqueta first
        first:
        {
            // Declaración de la etiqueta second
            second:
            {
                third:
                {
                    // Antes de break
                    System.out.println("Antes de la sentencia break");
 
                    // break tomará el control de
                    // la etiqueta second
                    if (t)
                        break second;
                    System.out.println("Esto no se ejecutará.");
                }
                System.out.println("Esto no se ejecutará.");
            }
 
            // Tercer bloque
            System.out.println("Esto es después del segundo bloque.");
        }
    }
}

Salida:

Antes de la sentencia break
Esto es después del segundo bloque.

6.2. Continue

A veces es útil forzar una iteración temprana de un bucle. Es decir, es posible que desee continuar ejecutando el bucle, pero deje de procesar el resto del código (en su cuerpo) para esta iteración en particular. Esto es, en efecto, un goto pasando del cuerpo del bucle, al final del bucle. La instrucción continue realiza tal acción.

Ejemplo:

// Programa Java para ilustrar usando
// continue en una declaración if
class ContinueDemo
{
    public static void main(String args[])
    {
        for (int i = 0; i < 10; i++)
        {
            // Si el número es par
            // omitir y continuar
            if (i%2 == 0)
                continue;
 
            // Si el número es impar, imprímalo
            System.out.print(i + " ");
        }
    }
}

Salida:

1 3 5 7 9

6.3. Return

la declaración return se usa para regresar explícitamente de un método. Es decir, hace que un control de programa se transfiera nuevamente a quién llama del método.

Ejemplo:

// Programa Java para ilustrar usando return
class Return
{
    public static void main(String args[])
    {
        boolean t = true;
        System.out.println("Antes de return.");
     
        if (t)
            return;
 
        // El compilador eludirá todas las declaraciones
        // después de return
        System.out.println("Esto no se ejecutará.");
    }
}

Salida:

Antes de return.

Hasta aquí hemos visto las estructuras condicionales de Java: if, if-else, switch, break, continue, jump. Cualquier duda, aclaración o aporte, lo puede hacer en los comentarios 😉