Casting y conversión de tipos

🔁 Casting y conversión de tipos

En Java, cuando mezclamos tipos de datos en una expresión, el compilador debe asegurarse de que ambos operandos “hablen el mismo idioma”.

🔁 Casting y conversión de tipos

La regla base es esta:

✅ Java convierte automáticamente cuando NO hay pérdida de datos.

⚠️ Si hay posible pérdida, Java te obliga a hacerlo a mano (casting explícito).

1) ✅ Conversión implícita (automática)

Mira este ejemplo: short + int.

public class Main {
    public static void main(String[] args) {
        short x = 1;
        int y = x + 2;
        System.out.println(y);
    }
}

Salida: 3

🔍 ¿Qué pasa “bajo el capó”?

• short usa 2 bytes
• int usa 4 bytes

Como un int puede guardar todo lo que cabe en un short, Java hace esto:

🔍 ¿Qué pasa “bajo el capó”?

1. Convierte x a int (sin que lo veas)
2. Luego suma: 1 + 2
3. Guarda el resultado en y

Esto se llama conversión implícita (o automática).

📌 Cadena de conversión automática

La conversión implícita ocurre hacia tipos “más grandes”:

byte → short → int → long → float → double

👉 Esto es seguro porque, en general, vas hacia un tipo con más capacidad (menos riesgo de perder info).

2) ✅ Otro ejemplo: double + int

public class Main {
    public static void main(String[] args) {
        double x = 1.1;
        double y = x + 2;
        System.out.println(y);
    }
}

Salida: 3.1

Aquí pasa esto:

• x es double
• 2 es int
• Java convierte el 2 a double → 2.0
• Luego suma: 1.1 + 2.0 = 3.1

✅ No hay pérdida, así que Java lo hace solo.

3) ⚠️ ¿Y si quiero un int como resultado?

Si intentas esto:

double x = 1.1;
int y = x + 2;  // ❌ error

Da error porque:

• x + 2 produce un double (3.1)
• y un int NO puede guardar decimales sin perder información

Java no lo hace automáticamente.

✅ Casting explícito (tú lo ordenas)

Si de verdad no te importan los decimales, debes decirlo tú:

public class Main {
    public static void main(String[] args) {
        double x = 1.1;
        int y = (int) x + 2;
        System.out.println(y);
    }
}

Salida: 3

📌 Paso a paso:

• (int) x convierte 1.1 a 1 (se corta la parte decimal)
• 1 + 2 = 3

⚠️ Importante: casting a int NO redondea, solo trunca (corta).

4) ⚠️ “Tipos compatibles”: no todo se puede castear

Entre números sí podemos (porque son compatibles). Pero no podemos castear directamente una String a int:

String x = "1";
int y = (int) x;  // ❌ NO se puede

✅ Convertir String a número: parseInt

Cuando el dato viene como texto, usamos las clases contenedoras (wrappers).

Ejemplo con Integer.parseInt():

✅ Convertir String a número: parseInt

public class Main {
    public static void main(String[] args) {
        String x = "1";
        int y = Integer.parseInt(x) + 2;
        System.out.println(y);
    }
}

Salida: 3

📌 ¿Por qué esto es tan importante?

Porque en casi cualquier interfaz (web, móvil, escritorio), la entrada del usuario llega como texto (String). Así que necesitamos convertirla a número para poder sumar, restar, etc.

5) ⚠️ Si el texto tiene decimales…

Si haces:

String x = "1.1";
int y = Integer.parseInt(x);  // ❌ falla

Eso lanza una excepción (Java te dice: “esto no es un int válido”). Luego veremos excepciones con calma.

Si el usuario escribe 1.1, entonces usamos Double.parseDouble():

public class Main {
    public static void main(String[] args) {
        String x = "1.1";
        double y = Double.parseDouble(x) + 2;
        System.out.println(y);
    }
}

Salida: 3.1

🧾 ¿De qué tipo queda una expresión? (la regla que confunde)

Cuando haces una operación como x + 2, Java decide el tipo del resultado así:

👉 El resultado queda del tipo “más grande” entre los operandos
(es decir, Java “sube” el más pequeño para que ambos queden iguales).

Recuerda la escalera:

byte → short → int → long → float → double

✅ Ejemplos rápidos (mira el tipo del resultado)

Caso 1: short + int

short x = 1;
int y = x + 2;   // ✅ x se convierte a int automáticamente

• x se “sube” a int
• resultado: int

Caso 2: double + int

double x = 1.1;
double y = x + 2;   // ✅ 2 se convierte a double automáticamente

• el 2 se “sube” a double (2.0)
• resultado: double

Caso 3: double + int pero quiero int

double x = 1.1;
int y = (int) x + 2;  // ✅ casting explícito

• (int) x corta 1.1 → 1
• resultado: int

⚠️ Nota: (int) no redondea, solo trunca.

🔥 La idea clave

En una expresión:

✅ Java convierte automáticamente hacia arriba (más grande) ⚠️ Para convertir hacia abajo (más pequeño), tú debes hacer casting.

📊 Gráfico: “la escalera” de conversión de tipos

Cuando mezclas tipos en una expresión, Java sube el más pequeño al más grande.

                 (más grande / más preciso)
                         double
                           ▲
                          float
                           ▲
                          long
                           ▲
                          int
                           ▲
                         short
                           ▲
                          byte
                 (más pequeño / menos preciso)

🔍 Cómo se usa la escalera en una expresión

Ejemplo 1: short + int

short   +   int
  ▲          │
  └─── sube ─┘     →  resultado: int

Ejemplo 2: double + int

double  +   int
  │          ▲
  └─── gana ─┘ sube  →  resultado: double

⚠️ Y si quieres bajar… tú decides (casting)

double  →  int
  │        ▲
  └─(int)──┘   (bajar puede perder decimales → Java NO lo hace solo)

🧭 Diagrama de flujo: ¿Java convierte solo o necesito casting?

           ¿Estás mezclando tipos en una expresión?
                         │
                      (sí)│
                         ▼
        ¿El resultado cabe en el tipo de la izquierda
            SIN perder información (sin pérdida)?
                         │
            ┌────────────┴────────────┐
            │                         │
          (sí)                      (no)
            │                         │
            ▼                         ▼
 Conversión implícita            Necesitas casting
 (automática, Java lo hace)      explícito (tú lo haces)
            │                         │
            ▼                         ▼
  byte→short→int→long→float→double     (int) (short) ...
            │                         │
            ▼                         ▼
        ✅ compila                   ⚠️ compila solo si casteas

short x = 1;
int y = x + 2;        // short sube a int automáticamente

double x = 1.1;
double y = x + 2;     // 2 sube a 2.0 automáticamente

⚠️ Con posible pérdida → necesitas casting

double x = 1.1;
int y = (int) x + 2;  // (int) corta 1.1 → 1

🧠 Resumen clave

• Implícita: Java convierte solo si no hay pérdida
• Explícita: tú haces el casting cuando puede haber pérdida
• Strings: no se castea; se convierte con parse...()