Operadores de asignación en Java

// Sintaxis:  variable = expresión;

// Asignación de valores literales
int edad = 25;
double salario = 2850.50;
char inicial = 'A';
boolean activo = true;
String nombre = "María García";

// Asignación del resultado de una expresión
int suma = 10 + 20;               // suma = 30
double promedio = (8.5 + 9.0) / 2; // promedio = 8.75
int cuadrado = edad * edad;        // cuadrado = 625

// Opción 1: Declaración e inicialización simultánea
int contador = 0;

// Opción 2: Declaración primero, asignación después
int resultado;
resultado = calcularTotal();  // se asigna más adelante

// ⚠️ ERROR: usar variable local sin inicializar
int x;
System.out.println(x);  // Error de compilación:
                         // "variable x might not have been initialized"

// Conversiones de ampliación: siempre seguras
byte b = 42;
short s = b;      // byte → short  ✅
int i = s;        // short → int   ✅
long l = i;       // int → long    ✅
float f = l;      // long → float  ✅ (posible pérdida de precisión)
double d = f;     // float → double ✅

// Cadena de ampliación completa:
// byte → short → int → long → float → double
//                char → int → long → float → double

// Conversiones de estrechamiento: requieren casting explícito
double precio = 29.99;
int precioEntero = (int) precio;   // precioEntero = 29 (se trunca)

long distancia = 150_000_000L;
int distanciaInt = (int) distancia; // Posible pérdida si > Integer.MAX_VALUE

// ⚠️ ERROR sin casting:
// int x = 3.14;  // Error: incompatible types: possible lossy conversion

// Caso especial: literales enteros pequeños a byte/short
byte b1 = 127;    // ✅ El compilador verifica que cabe
byte b2 = 128;    // ❌ Error: incompatible types
byte b3 = (byte) 128;  // ✅ Compila, pero b3 = -128 (overflow)

public class OperadoresCompuestos {
    public static void main(String[] args) {
        // --- Operador += (suma y asigna) ---
        int puntos = 100;
        puntos += 25;     // puntos = 125
        puntos += 10;     // puntos = 135
        System.out.println("Puntos: " + puntos);  // 135

        // --- Operador -= (resta y asigna) ---
        double saldo = 1500.00;
        saldo -= 250.75;  // saldo = 1249.25
        System.out.println("Saldo: " + saldo);

        // --- Operador *= (multiplica y asigna) ---
        int base = 2;
        base *= 3;   // base = 6
        base *= 5;   // base = 30
        System.out.println("Base: " + base);  // 30

        // --- Operador /= (divide y asigna) ---
        int total = 100;
        total /= 3;  // total = 33 (división entera, se trunca)
        System.out.println("Total: " + total);  // 33

        double preciso = 100.0;
        preciso /= 3;  // preciso = 33.333...
        System.out.println("Preciso: " + preciso);

        // --- Operador %= (módulo y asigna) ---
        int numero = 17;
        numero %= 5;  // numero = 2 (resto de 17/5)
        System.out.println("Resto: " + numero);  // 2

        // --- Uso con String (solo +=) ---
        String saludo = "Hola";
        saludo += " mundo";     // saludo = "Hola mundo"
        saludo += "!";          // saludo = "Hola mundo!"
        System.out.println(saludo);
    }
}

public class SistemaPermisos {
    // Definición de permisos como constantes de bits
    static final int PERMISO_LECTURA    = 0b0001;  // 1
    static final int PERMISO_ESCRITURA  = 0b0010;  // 2
    static final int PERMISO_EJECUCION  = 0b0100;  // 4
    static final int PERMISO_ADMIN      = 0b1000;  // 8

    public static void main(String[] args) {
        int permisos = 0;  // Sin permisos

        // Activar permisos con |= (OR)
        permisos |= PERMISO_LECTURA;     // permisos = 0001
        permisos |= PERMISO_ESCRITURA;   // permisos = 0011
        permisos |= PERMISO_EJECUCION;   // permisos = 0111

        // Verificar permiso con &
        boolean puedeLeer = (permisos & PERMISO_LECTURA) != 0;  // true
        boolean esAdmin = (permisos & PERMISO_ADMIN) != 0;      // false

        // Desactivar un permiso con &= y complemento
        permisos &= ~PERMISO_ESCRITURA;  // permisos = 0101

        // Alternar un permiso con ^= (XOR)
        permisos ^= PERMISO_ADMIN;  // Activa admin: permisos = 1101
        permisos ^= PERMISO_ADMIN;  // Desactiva admin: permisos = 0101

        System.out.println("Permisos finales: " + Integer.toBinaryString(permisos));
    }
}

// ¿Por qué compila uno y otro no?

byte b = 10;

// ❌ ERROR de compilación:
// b = b + 1;   // b + 1 se promueve a int, no cabe en byte

// ✅ Compila correctamente:
b += 1;         // Equivale a: b = (byte)(b + 1)

// Otro ejemplo con short:
short s = 100;
// s = s * 2;   // ❌ Error: s * 2 es int
s *= 2;         // ✅ Equivale a: s = (short)(s * 2)

// Ejemplo con char:
char c = 'A';   // valor Unicode 65
// c = c + 1;   // ❌ Error: c + 1 es int
c += 1;         // ✅ c = (char)(c + 1) → 'B'
System.out.println(c);  // B

// Demostración de overflow silencioso
byte b = 127;        // Valor máximo de byte
b += 1;              // b = (byte)(127 + 1) = (byte)(128)
System.out.println(b);  // -128 (¡overflow silencioso!)

// ¿Por qué ocurre?
// 128 en binario: 00000000 10000000
// Truncado a byte:          10000000 = -128 en complemento a dos

// Asignación encadenada
int a, b, c;
a = b = c = 100;
// Se evalúa: c = 100 → b = 100 → a = 100
// Las tres variables valen 100

// Declaración múltiple con asignación
int x = 1, y = 2, z = 3;

// Intercambio de valores (requiere variable auxiliar)
int temp = x;
x = y;
y = temp;

// Asignación en contextos de expresión
int[] numeros = {5, 10, 15, 20};
int indice;
int valor = numeros[indice = 2];  // indice = 2, valor = 15
System.out.println("Índice: " + indice + ", Valor: " + valor);

int x = 5;

// ❌ ERROR de compilación (Java te protege):
// if (x = 10) { ... }  // x = 10 devuelve int, no boolean

// ✅ CORRECTO:
if (x == 10) { ... }  // Compara si x es igual a 10

// ⚠️ CASO PELIGROSO con boolean:
boolean encontrado = false;
if (encontrado = true) {   // ¡COMPILA! Asigna true y evalúa true
    System.out.println("Siempre se ejecuta");
}
// Lo correcto era:
if (encontrado == true) { ... }
// O simplemente:
if (encontrado) { ... }

// Problema: resultado truncado
int total = 7;
total /= 2;
System.out.println(total);  // 3, no 3.5

// Solución: usar double desde el inicio
double totalPreciso = 7.0;
totalPreciso /= 2;
System.out.println(totalPreciso);  // 3.5

final int MAX = 100;
// MAX = 200;       // ❌ Error: cannot assign a value to final variable
// MAX += 50;       // ❌ Mismo error: los operadores compuestos
                    //    también son asignaciones

final int[] datos = {1, 2, 3};
// datos = new int[5];  // ❌ No se puede reasignar la referencia
datos[0] = 99;          // ✅ Sí se puede modificar el contenido

// float tiene solo ~7 dígitos de precisión
float f = 1_000_000.0f;
f += 0.1f;
System.out.println(f);  // 1000000.1 (¿o no?)
// En realidad: 1000000.125 (¡error de representación!)

// Para cálculos financieros, usar BigDecimal:
import java.math.BigDecimal;
BigDecimal precio = new BigDecimal("19.99");
BigDecimal descuento = new BigDecimal("2.50");
BigDecimal precioFinal = precio.subtract(descuento);
System.out.println(precioFinal);  // 17.49 (exacto)

/**
 * Sistema de gestión de inventario que demuestra todos
 * los operadores de asignación de Java.
 */
public class GestionInventario {

    // Banderas de estado del producto (operadores bitwise)
    static final int ESTADO_ACTIVO     = 0b0001;  // 1
    static final int ESTADO_DESCUENTO  = 0b0010;  // 2
    static final int ESTADO_NOVEDAD    = 0b0100;  // 4
    static final int ESTADO_AGOTADO    = 0b1000;  // 8

    public static void main(String[] args) {
        // --- Asignación simple (=) ---
        String nombreProducto = "Portátil ProBook X5";
        double precioBase = 899.99;
        int stock = 50;
        int vendidos = 0;

        // --- Operador += (registrar ventas) ---
        System.out.println("=== Registro de ventas ===");
        vendidos += 5;   // Primera venta: 5 unidades
        vendidos += 12;  // Segunda venta: 12 unidades
        vendidos += 3;   // Tercera venta: 3 unidades
        System.out.println("Total vendidos: " + vendidos);  // 20

        // --- Operador -= (actualizar stock) ---
        stock -= vendidos;  // stock = 50 - 20 = 30
        System.out.println("Stock restante: " + stock);

        // --- Operador *= (aplicar incremento de precio) ---
        double precioVenta = precioBase;
        precioVenta *= 1.21;  // Aplicar 21% de IVA
        System.out.printf("Precio con IVA: %.2f€%n", precioVenta);

        // --- Operador /= (calcular precio medio) ---
        double ingresoTotal = precioVenta * vendidos;
        double ticketMedio = ingresoTotal;
        ticketMedio /= vendidos;  // Ingreso total / unidades
        System.out.printf("Ticket medio: %.2f€%n", ticketMedio);

        // --- Operador %= (calcular paquetes completos) ---
        int unidadesPorCaja = 6;
        int cajasCompletas = stock / unidadesPorCaja;  // 5 cajas
        int unidadesSueltas = stock;
        unidadesSueltas %= unidadesPorCaja;  // 30 % 6 = 0 sueltas
        System.out.println("Cajas completas: " + cajasCompletas);
        System.out.println("Unidades sueltas: " + unidadesSueltas);

        // --- Operadores bitwise (gestión de estados) ---
        int estado = 0;
        estado |= ESTADO_ACTIVO;     // Activar producto
        estado |= ESTADO_NOVEDAD;    // Marcar como novedad
        estado |= ESTADO_DESCUENTO;  // Añadir descuento

        System.out.println("\n=== Estado del producto ===");
        System.out.println("Activo: " + ((estado & ESTADO_ACTIVO) != 0));
        System.out.println("Novedad: " + ((estado & ESTADO_NOVEDAD) != 0));
        System.out.println("Descuento: " + ((estado & ESTADO_DESCUENTO) != 0));

        // Quitar novedad tras 30 días
        estado &= ~ESTADO_NOVEDAD;   // Desactivar bit de novedad
        System.out.println("Novedad (tras 30 días): " +
            ((estado & ESTADO_NOVEDAD) != 0));  // false

        // --- Resumen de concatenación con += ---
        String resumen = "";
        resumen += "Producto: " + nombreProducto + "\n";
        resumen += "Precio base: " + precioBase + "€\n";
        resumen += "Vendidos: " + vendidos + " uds.\n";
        resumen += "Stock: " + stock + " uds.\n";
        resumen += "Estado: " + Integer.toBinaryString(estado);
        System.out.println("\n=== Resumen ===");
        System.out.println(resumen);
    }
}