Aquí está la traducción al español del artículo de teoría de programación, siguiendo todas las reglas especificadas:

¿Qué es esto y para qué sirve?

Imagina que eres un robot que toma decisiones. Por ejemplo: «Si está lloviendo afuera, entonces toma un paraguas». O: «Si tengo 100 rublos Y quiero helado, entonces cómpralo». En programación, estas decisiones se toman con la ayuda de operadores de comparación (comparan números o texto) y operadores lógicos (conectan varias condiciones en una).

En Java, como en la vida, tenemos preguntas: «¿Es 10 mayor que 5?», «¿Son iguales dos palabras?», «¿Se cumplen dos condiciones al mismo tiempo?». Las respuestas siempre son «sí» (true) o «no» (false). Es como un semáforo: si está en verde (true) — avanzamos, si está en rojo (false) — nos detenemos.

¿Para qué sirve esto? Sin ellos, la computadora no podría decidir por sí misma qué hacer en diferentes situaciones. Por ejemplo, en un juego: si al jugador se le acabaron las vidas (vidas == 0), entonces mostrar «Game Over». O en una calculadora: si se ingresó un número mayor a 100, entonces mostrar una advertencia. Los operadores de comparación y los operadores lógicos son la base de cualquier comportamiento «inteligente» de los programas.

En Python, por cierto, todo es muy similar: también existen ==, !=, >, <, >=, <= y los operadores lógicos and, or, not. Pero en Java hay una diferencia importante: las cadenas (texto) no se comparan con ==, sino con un comando especial .equals(). Analizaremos esto en detalle.

Ejemplos de código con explicación

Ejemplo 1: Comparación de números (simple «mayor/menor»)

// Declaramos variables con números
int edadPedro = 12;
int edadVasya = 14;

// Comparamos: ¿es la edad de Pedro mayor que la edad de Vasya?
boolean pedroEsMayor = edadPedro > edadVasya;
System.out.println("¿Pedro es mayor que Vasya? " + pedroEsMayor); // Muestra: false

// Comparamos: ¿es la edad de Pedro menor que la edad de Vasya?
boolean pedroEsMenor = edadPedro < edadVasya;
System.out.println("¿Pedro es menor que Vasya? " + pedroEsMenor); // Muestra: true

// Verificamos igualdad
boolean sonDeLaMismaEdad = edadPedro == edadVasya;
System.out.println("¿Tienen la misma edad? " + sonDeLaMismaEdad); // Muestra: false

// Verificamos desigualdad
boolean edadDiferente = edadPedro != edadVasya;
System.out.println("¿Son de edades diferentes? " + edadDiferente); // Muestra: true

Explicación: Creamos dos variables con números. El operador > verifica si el primer número es mayor que el segundo. Si es así — el valor es true, de lo contrario false. El operador < — al revés. == verifica igualdad (nota: son dos signos igual, ¡no uno! Un signo es asignación). != — verifica que los números no sean iguales. El resultado de cada comparación es un valor lógico true o false, que guardamos en una variable de tipo boolean (tipo lógico).

Ejemplo 2: Comparación de cadenas (texto) — diferencia importante con Python

String nombre1 = "Ana";
String nombre2 = "Ana";
String nombre3 = "Iván";

// Comparamos cadenas con equals (¡no con ==!)
boolean anaYAnaSonIguales = nombre1.equals(nombre2);
System.out.println("¿Nombre1 y Nombre2 son iguales? " + anaYAnaSonIguales); // true

boolean anaYIvanSonIguales = nombre1.equals(nombre3);
System.out.println("¿Nombre1 y Nombre3 son iguales? " + anaYIvanSonIguales); // false

// Comparamos sin distinguir mayúsculas/minúsculas
String nombre4 = "ana";
boolean sinDistinguirMayusculas = nombre1.equalsIgnoreCase(nombre4);
System.out.println("¿Ana y ana (sin distinguir mayúsculas)? " + sinDistinguirMayusculas); // true

// Esto NO se debe hacer (explicaremos por qué en errores)
boolean comparacionPeligrosa = (nombre1 == nombre2);
System.out.println("Con ==: " + comparacionPeligrosa); // Puede dar true, ¡pero es casualidad!

Explicación: En Java, las cadenas no son números simples, sino objetos complejos. El operador == en ellas verifica si las cadenas están en el mismo lugar de la memoria, no si tienen el mismo texto. Por eso, para comparar texto se usa el método .equals(). Si quieres comparar sin distinguir mayúsculas/minúsculas (por ejemplo, «Ana» y «ana»), usa .equalsIgnoreCase(). En Python, por cierto, para cadenas se puede usar == — allí funciona correctamente. Pero en Java — recuerda: ¡las cadenas solo con equals!

Ejemplo 3: Operadores lógicos — «Y» (&&), «O» (||), «NO» (!)

int temperatura = 25;
boolean haySol = true;
boolean hayViento = false;

// Verificamos una condición compleja: "Salir a caminar si hace calor Y hay sol"
boolean sePuedeCaminar = (temperatura > 20) && haySol;
System.out.println("¿Se puede caminar? " + sePuedeCaminar); // true (25 > 20 Y hay sol = true)

// Verificamos: "Llevar chaqueta si hace frío O hay viento"
boolean llevarChaqueta = (temperatura < 15) || hayViento;
System.out.println("¿Llevar chaqueta? " + llevarChaqueta); // false (NO hace frío Y NO hay viento)

// Usamos "NO": "Si NO llueve, salimos a caminar"
boolean estaLloviendo = false;
boolean noEstaLloviendo = !estaLloviendo; // ! convierte false -> true
System.out.println("¿No llueve? " + noEstaLloviendo); // true

// Ejemplo complejo: "Quedarse en casa si hace frío Y (llueve O hay viento)"
int temperatura2 = 10;
boolean lluvia = true;
boolean viento = false;
boolean quedarseEnCasa = (temperatura2 < 15) && (lluvia || viento);
System.out.println("¿Quedarse en casa? " + quedarseEnCasa); // true (hace frío Y llueve)

Explicación: Los operadores lógicos funcionan como en matemáticas y en la vida. && (Y) da true solo si ambas condiciones son true. || (O) da true si al menos una condición es true. ! (NO) invierte el valor: true se convierte en false, false en true. En Python es lo mismo, solo que se escribe con palabras: and, or, not. En Java se usan símbolos, pero el significado es absolutamente el mismo. Los paréntesis ayudan a establecer el orden: primero se evalúa lo que está entre paréntesis, luego el resto.

Ejemplo 4: Uso en if-else (decisiones reales)

int puntos = 85;
int puntuacionMinima = 70;

if (puntos >= puntuacionMinima) {
    System.out.println("¡Has aprobado! ¡Felicidades!");
} else {
    System.out.println("Inténtalo de nuevo.");
}