Ir al contenido principal

Estructuras condicionales: if, else, switch

Introducción

Las estructuras condicionales son componentes fundamentales de cualquier lenguaje de programación que permiten a los programas tomar decisiones y ejecutar diferentes bloques de código según se cumplan o no determinadas condiciones. En Java, estas estructuras nos ayudan a crear aplicaciones inteligentes que pueden responder de forma diferente ante distintas situaciones. Sin ellas, nuestros programas seguirían siempre el mismo camino de ejecución, limitando enormemente su utilidad.

En este artículo aprenderás a utilizar las tres estructuras condicionales principales de Java: if, else y switch. Estos mecanismos son esenciales para implementar la lógica de decisión en tus programas y te permitirán crear aplicaciones más dinámicas y adaptables.

If simple

La estructura if es la forma más básica de control condicional. Evalúa una expresión booleana y ejecuta un bloque de código solo si dicha expresión es verdadera (true).

if (condicion) {
    // Código que se ejecuta si la condición es verdadera
}

Veamos un ejemplo práctico:

public class EjemploIfSimple {
    public static void main(String[] args) {
        int edad = 19;
        
        if (edad >= 18) {
            System.out.println("Eres mayor de edad.");
        }
        
        System.out.println("Programa finalizado.");
    }
}

En este ejemplo, si la variable edad es mayor o igual a 18, se mostrará el mensaje "Eres mayor de edad". El mensaje "Programa finalizado" se mostrará siempre, independientemente de la condición, ya que está fuera del bloque if.

If-else

Cuando queremos ejecutar un bloque de código cuando la condición es verdadera y otro bloque diferente cuando es falsa, utilizamos la estructura if-else:

if (condicion) {
    // Código que se ejecuta si la condición es verdadera
} else {
    // Código que se ejecuta si la condición es falsa
}

Ejemplo práctico:

public class EjemploIfElse {
    public static void main(String[] args) {
        int edad = 15;
        
        if (edad >= 18) {
            System.out.println("Eres mayor de edad.");
        } else {
            System.out.println("Eres menor de edad.");
        }
    }
}

En este caso, si edad es menor que 18, se ejecutará el bloque de código dentro del else, mostrando "Eres menor de edad".

If-else-if

Cuando necesitamos evaluar múltiples condiciones en secuencia, podemos utilizar la estructura if-else-if:

if (condicion1) {
    // Código que se ejecuta si condicion1 es verdadera
} else if (condicion2) {
    // Código que se ejecuta si condicion1 es falsa y condicion2 es verdadera
} else if (condicion3) {
    // Código que se ejecuta si condicion1 y condicion2 son falsas, y condicion3 es verdadera
} else {
    // Código que se ejecuta si todas las condiciones anteriores son falsas
}

Veamos un ejemplo que calcula la categoría de edad:

public class EjemploIfElseIf {
    public static void main(String[] args) {
        int edad = 25;
        
        if (edad < 12) {
            System.out.println("Eres un niño.");
        } else if (edad < 18) {
            System.out.println("Eres un adolescente.");
        } else if (edad < 65) {
            System.out.println("Eres un adulto.");
        } else {
            System.out.println("Eres un jubilado.");
        }
    }
}

Java evalúa cada condición en orden y, en cuanto encuentra una que sea verdadera, ejecuta su bloque de código correspondiente y salta fuera de toda la estructura condicional.

Operador ternario

Java ofrece una forma compacta de expresar condiciones simples mediante el operador ternario ? :. Es especialmente útil para asignaciones condicionales:

variable = (condicion) ? valorSiVerdadero : valorSiFalso;

Ejemplo:

public class EjemploOperadorTernario {
    public static void main(String[] args) {
        int edad = 20;
        String resultado = (edad >= 18) ? "mayor de edad" : "menor de edad";
        
        System.out.println("Esta persona es " + resultado);
    }
}

Este código es equivalente al ejemplo if-else anterior pero más conciso. Sin embargo, es recomendable usarlo solo para casos simples, ya que puede reducir la legibilidad en situaciones complejas.

Switch

La estructura switch es ideal cuando necesitamos evaluar una expresión contra múltiples valores posibles:

switch (expresion) {
    case valor1:
        // Código para valor1
        break;
    case valor2:
        // Código para valor2
        break;
    case valor3:
        // Código para valor3
        break;
    default:
        // Código si ninguno de los valores anteriores coincide
}

La palabra clave break es importante porque detiene la ejecución del switch. Sin ella, la ejecución continuaría con los casos siguientes (un comportamiento llamado "fall-through").

Veamos un ejemplo con los días de la semana:

public class EjemploSwitch {
    public static void main(String[] args) {
        int diaSemana = 3;
        String nombreDia;
        
        switch (diaSemana) {
            case 1:
                nombreDia = "Lunes";
                break;
            case 2:
                nombreDia = "Martes";
                break;
            case 3:
                nombreDia = "Miércoles";
                break;
            case 4:
                nombreDia = "Jueves";
                break;
            case 5:
                nombreDia = "Viernes";
                break;
            case 6:
                nombreDia = "Sábado";
                break;
            case 7:
                nombreDia = "Domingo";
                break;
            default:
                nombreDia = "Día inválido";
        }
        
        System.out.println("El día " + diaSemana + " es " + nombreDia);
    }
}

Switch con String (Java 7+)

Desde Java 7, podemos usar String en las expresiones switch:

public class EjemploSwitchString {
    public static void main(String[] args) {
        String fruta = "manzana";
        
        switch (fruta) {
            case "manzana":
                System.out.println("Las manzanas son rojas o verdes.");
                break;
            case "plátano":
                System.out.println("Los plátanos son amarillos.");
                break;
            case "naranja":
                System.out.println("Las naranjas son naranjas (color).");
                break;
            default:
                System.out.println("No conozco esa fruta.");
        }
    }
}

Switch expressions (Java 14+)

A partir de Java 14, se introdujeron las expresiones switch, que simplifican la sintaxis y evitan los errores comunes al olvidar el break:

public class EjemploSwitchExpression {
    public static void main(String[] args) {
        int diaSemana = 3;
        
        String tipoDia = switch (diaSemana) {
            case 1, 2, 3, 4, 5 -> "Día laborable";
            case 6, 7 -> "Fin de semana";
            default -> "Día inválido";
        };
        
        System.out.println("El día " + diaSemana + " es un " + tipoDia);
    }
}

Las ventajas de esta sintaxis son:

  • No necesita break
  • Permite agrupar múltiples casos en una línea
  • Puede devolver valores directamente
  • El compilador verifica que todos los casos posibles estén cubiertos

If anidados y switch anidados

Tanto las estructuras if como switch pueden anidarse dentro de otras estructuras condicionales, permitiendo lógicas de decisión más complejas:

public class EjemploIfAnidado {
    public static void main(String[] args) {
        int edad = 25;
        boolean tieneLicencia = true;
        
        if (edad >= 18) {
            System.out.println("Eres mayor de edad.");
            
            if (tieneLicencia) {
                System.out.println("Puedes conducir.");
            } else {
                System.out.println("No puedes conducir sin licencia.");
            }
        } else {
            System.out.println("Eres menor de edad, no puedes conducir.");
        }
    }
}

Sin embargo, demasiado anidamiento puede hacer que el código sea difícil de leer y mantener. Es recomendable limitar la profundidad de anidamiento y considerar otras estrategias como métodos separados cuando la lógica se vuelve compleja.

Buenas prácticas

  1. Utiliza llaves siempre - Aunque para bloques de una sola línea las llaves son opcionales, incluirlas siempre mejora la legibilidad y evita errores.

  2. Elige la estructura adecuada - Usa if-else-if cuando las condiciones sean expresiones complejas o rangos, y switch cuando compares una variable contra valores constantes.

  3. No abuses del operador ternario - Úsalo solo para asignaciones simples; para lógica compleja, el if-else tradicional es más legible.

  4. Considera la eficiencia - En if-else-if, coloca las condiciones más probables al principio para reducir el número de evaluaciones.

  5. Mantén la legibilidad - Si tienes demasiadas condiciones anidadas, considera refactorizar tu código en métodos más pequeños.

Ejemplo integrado: Sistema de calificaciones

Veamos un ejemplo que integra varias de las estructuras condicionales que hemos aprendido:

import java.util.Scanner;

public class SistemaCalificaciones {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("Introduce la nota numérica (0-100): ");
        int nota = scanner.nextInt();
        
        // Validamos primero si la nota está en rango
        if (nota < 0 || nota > 100) {
            System.out.println("Error: La nota debe estar entre 0 y 100.");
        } else {
            // Convertimos la nota numérica en letra usando switch
            char letra;
            
            switch (nota / 10) {
                case 10:
                case 9:
                    letra = 'A';
                    break;
                case 8:
                    letra = 'B';
                    break;
                case 7:
                    letra = 'C';
                    break;
                case 6:
                    letra = 'D';
                    break;
                default:
                    letra = 'F';
            }
            
            // Mensaje personalizado según la calificación
            if (letra == 'A') {
                System.out.println("¡Excelente! Tu calificación es " + letra);
            } else if (letra == 'B' || letra == 'C') {
                System.out.println("Buen trabajo. Tu calificación es " + letra);
            } else if (letra == 'D') {
                System.out.println("Aprobado, pero necesitas mejorar. Tu calificación es " + letra);
            } else {
                System.out.println("No has aprobado. Tu calificación es " + letra);
            }
        }
        
        scanner.close();
    }
}

Este ejemplo muestra:

  1. Validación inicial con if-else
  2. Uso de switch para categorizar valores
  3. Uso de if-else-if para mensajes personalizados
  4. Casos agrupados en el switch (casos 10 y 9)

Resumen

Las estructuras condicionales en Java (if, else, switch) son herramientas fundamentales que permiten a nuestros programas tomar decisiones basadas en condiciones lógicas. El if simple ejecuta código cuando una condición es verdadera, mientras que if-else proporciona una alternativa cuando es falsa. Para múltiples condiciones, podemos usar if-else-if o switch, eligiendo la más adecuada según la situación.

A medida que avances en tu aprendizaje de Java, estas estructuras condicionales serán esenciales para implementar la lógica de negocio en tus aplicaciones. En el próximo artículo, exploraremos las estructuras de bucles, que nos permitirán repetir bloques de código y procesar colecciones de datos de manera eficiente.

Volver arriba