Los operadores son símbolos especiales que realizan operaciones sobre uno o más valores (operandos) y devuelven un resultado.

Operadores Aritméticos

Estos operadores se utilizan para realizar cálculos matemáticos:

• +: Suma
• -: Resta
• *: Multiplicación
• /: División (puede resultar en punto flotante si los operandos son de tipo double)
• %: Módulo (resto de la división)
• ++: Incremento (aumenta el valor en 1)
• --: Decremento (disminuye el valor en 1)

Manejo de Tipos en Sumas

Cuando se suman operandos de diferentes tipos numéricos, el resultado se promueve al tipo de mayor rango. Si uno de los operandos es de tipo long, la suma será de tipo long. De lo contrario, si no hay long, el resultado será int, a menos que ambos sean tipos más pequeños que int (como short o byte), en cuyo caso el resultado seguirá siendo int.

public class TipoSuma {
    public static void main(String[] args) {
        long valLargo = 123123123123123L;
        int valInt = 123;
        short valShort = 10;
        byte valByte = 8;

        // Suma con long, el resultado es long
        System.out.println(valLargo + valInt + valShort + valByte); // Salida: 123123123123264

        // Suma de int, short, byte. El resultado es int
        System.out.println(valInt + valShort + valByte); // Salida: 141

        // Suma de short y byte. El resultado es int
        System.out.println(valShort + valByte); // Salida: 18
    }
}

Incremento y Decremento (++, --) y Asignación Compuesta

Los operadores de ++ y -- pueden usarse de forma prefija (antes del operando) o postfija (después del operando).

• a++ (postfijo): Usa el valor actual de a y luego lo incrementa.
• ++a (prefijo): Incrementa a y luego usa el nuevo valor.

Los operadores de asginación compuesta como += y -= son atajos para operaciones y asignaciones:

• a += b es equivalente a a = a + b
• a -= b es equivalente a a = a - b

public class IncrementoDecremento {
    public static void main(String[] args) {
        int contador = 3;

        // Postfijo: usa el valor 3, luego incrementa contador a 4
        int valorAsignado1 = contador++;
        System.out.println("Contador después de postfijo: " + contador); // Salida: 4
        System.out.println("Valor asignado con postfijo: " + valorAsignado1); // Salida: 3

        // Prefijo: incrementa contador a 5, luego usa el valor 5
        int valorAsignado2 = ++contador;
        System.out.println("Contador después de prefijo: " + contador); // Salida: 5
        System.out.println("Valor asignado con prefijo: " + valorAsignado2); // Salida: 5
    }
}

Operadores de Asignación

El operador de asignación principle es =, que se utiliza para asignar un valor a una variable.

Operadores Relacionales

Estos operadores comparan dos valores y devuelven un valor booleano (true o false):

• <: Menor que
• >: Mayor que
• >=: Mayor o igual que
• <=: Menor o igual que
• ==: Igual a
• !=: No igual a
• instanceof: Comprueba si un objeto es una instancia de una clase o interfaz específica.

Operadores Lógicos

Se utilizan para combinar expresiones booleanas:

• && (AND lógico): Devuelve true solo si ambas exrpesiones son true.
• || (OR lógico): Devuelve true si al menos una de las expresiones es true.
• ! (NOT lógico): Invierte el valor booleano de la expresión (true se vuelve false y viceversa).

Cortocircuito en Operadores Lógicos

Los operadores && y || realizan "cortocircuito". Si el resultado de la expresión completa se puede determinar a partir de la primera subexpresión, la segunda subexpresión no se evalúa. Para &&, si la primera expresión es false, el resultado será false sin evaluar la segunda. Para ||, si la primera expresión es true, el resultado será true sin evaluar la segunda.

public class LogicaCortocircuito {
    public static void main(String[] args) {
        int valor = 5;

        // La primera parte (valor < 4) es false. Debido al cortocircuito de &&,
        // la segunda parte (valor++ < 4) no se ejecuta.
        boolean resultado = (valor < 4) && (valor++ < 4);

        System.out.println("Resultado: " + resultado); // Salida: false
        // Como valor++ no se ejecutó, el valor de 'valor' sigue siendo 5.
        System.out.println("Valor después de la evaluación: " + valor); // Salida: 5
    }
}

Operadores a Nivel de Bit

Estos operadores actúan sobre los bits individuales de los operandos numéricos:

• & (AND a nivel de bit): Compara bits correspondientes. Si ambos bits son 1, el resultado es 1; de lo contrario, es 0.
• | (OR a nivel de bit): Compara bits correspondientes. Si al menos uno de los bits es 1, el resultado es 1; de lo contrario, es 0.
• ^ (XOR a nivel de bit): Compara bits correspondientes. Si los bits son diferentes, el resultado es 1; si son iguales, es 0.
• ~ (NOT a nivel de bit): Invierte cada bit del operando.
• >> (Desplazamiento a la derecha con signo): Desplaza los bits hacia la derecha. El bit más significativo se copia para mantener el signo.
• << (Desplazamiento a la izquierda): Desplaza los bits hacia la izquierda. Los bits que salen por la izquierda se pierden y se introducen ceros por la derecha.
• >>> (Desplazamiento a la derecha sin signo): Desplaza los bits hacia la derecha. Se introducen ceros por la izquierda, independientemente del signo.

Ejemplo de Operadores a Nivel de Bit

Consideremos dos números binarios:

A = 0011 1100

B = 0000 1101

• A & B = 0000 1100
• A | B = 0011 1101
• A ^ B = 0011 0001
• ~B (asumiendo 8 bits) = 1111 0010

Multiplicación Eficiente con Desplazamiento a la Izquierda

Multiplicar un número por una potencia de 2 se puede lograr eficientemente con el operador de desplazamiento a la izquierda.

Por ejemplo, 2 << 3 es equivalente a 2 * 23 = 2 * 8 = 16.

public class OperadoresBitwise {
    public static void main(String[] args) {
        // 2 en binario es 00000010
        // Desplazar 3 posiciones a la izquierda: 00010000, que es 16 en decimal.
        System.out.println(2 << 3); // Salida: 16
    }
}

Operador Condicional (Ternario)

Este operador proporciona una forma concisa de escribir sentencias if-else simples. Tiene la siguiente sintaxis: condición ? valorSiVerdadero : valorSiFalso.

public class OperadorCondicional {
    public static void main(String[] args) {
        int puntuacion = 95;
        // Si puntuacion es menor que 60, type será "inaprobado", de lo contrario será "aprobado".
        String tipo = (puntuacion < 60) ? "inaprobado" : "aprobado";
        System.out.println(tipo); // Salida: aprobado
    }
}

Operadores de Asignación Extensa

Estos operadores combinan una operación aritmética con una asignación:

• +=
• -=
• *=
• /=
• %=

Operador de Concatenación de Cadenas

El operador + se utiliza para concatenar (unir) cadenas de texto. Cuando se utiliza con una cadena y un número, el número se convierte a su representación de cadena antes de la concatenación.

public class Concatenacion {
    public static void main(String[] args) {
        int numA = 10;
        int numB = 20;

        // Suma aritmética normal
        System.out.println(numA + numB); // Salida: 30

        // Concatenación: primero convierte numA a "10", luego concatena numB
        System.out.println(" " + numA + numB); // Salida:  1020

        // Suma aritmética, luego concatena el resultado con una cadena vacía
        System.out.println(numA + numB + " "); // Salida: 30
    }
}