¿Qué es el Casteo en Java?
El casteo o conversión de tipos (type casting) es el proceso de convertir un dato de un tipo a otro en Java. Es una operación fundamental cuando trabajamos con diferentes tipos de variables y necesitamos compatibilidad entre ellas.
Tipos de Variables en Java
Antes de entender el casteo, es importante conocer los tipos de datos primitivos en Java:
Tipos Numéricos Enteros:
- byte: 8 bits (-128 a 127)
- short: 16 bits (-32,768 a 32,767)
- int: 32 bits (-2,147,483,648 a 2,147,483,647)
- long: 64 bits (rango muy amplio)
Tipos Numéricos Decimales:
- float: 32 bits (decimales de precisión simple)
- double: 64 bits (decimales de precisión doble)
Otros Tipos:
- char: 16 bits (un solo carácter Unicode)
- boolean: true o false
Tipos de Casteo en Java
1. Casteo Implícito (Automático o Widening)
Ocurre automáticamente cuando convertimos un tipo de dato más pequeño a uno más grande. Java lo hace sin necesidad de especificarlo porque no hay pérdida de información.
Orden de conversión automática:
byte → short → int → long → float → double
Ejemplo de Casteo Implícito:
public class CasteoImplicito {
public static void main(String[] args) {
// De int a double (automático)
int entero = 100;
double decimal = entero;
System.out.println("Entero: " + entero);
System.out.println("Convertido a double: " + decimal);
// Salida: 100.0
// De int a long (automático)
int numero = 500;
long numeroLargo = numero;
System.out.println("Long: " + numeroLargo);
// De float a double (automático)
float flotante = 3.14f;
double dobleDecimal = flotante;
System.out.println("Double: " + dobleDecimal);
}
}2. Casteo Explícito (Manual o Narrowing)
Se requiere cuando convertimos un tipo de dato más grande a uno más pequeño. Debemos especificarlo manualmente porque puede haber pérdida de información.
Sintaxis:
tipoDestino variable = (tipoDestino) valorOrigen;Ejemplo de Casteo Explícito:
public class CasteoExplicito {
public static void main(String[] args) {
// De double a int (manual)
double precio = 99.99;
int precioEntero = (int) precio;
System.out.println("Precio double: " + precio);
System.out.println("Precio int: " + precioEntero);
// Salida: 99 (se pierden los decimales)
// De long a int (manual)
long numeroGrande = 500000L;
int numeroChico = (int) numeroGrande;
System.out.println("Convertido: " + numeroChico);
// De double a float (manual)
double valorDoble = 3.141592653589793;
float valorFlotante = (float) valorDoble;
System.out.println("Float: " + valorFlotante);
// Se pierde precisión
}
}¿Para Qué Se Usa el Casteo? Ejemplos Prácticos
Ejemplo 1: Mostrar Porcentajes sin Decimales
Este es un caso muy común en aplicaciones comerciales:
public class DescuentoTienda {
public static void main(String[] args) {
double descuento = 0.15; // 15% en formato decimal
// Sin casteo
System.out.println("Descuento: " + (descuento * 100) + "%");
// Salida: Descuento: 15.0%
// Con casteo
System.out.println("Descuento: " + (int)(descuento * 100) + "%");
// Salida: Descuento: 15%
}
}Ejemplo 2: Cálculos con División Entera
public class DivisionNumeros {
public static void main(String[] args) {
int a = 7;
int b = 2;
// División entera (resultado sin decimales)
int resultadoEntero = a / b;
System.out.println("División entera: " + resultadoEntero);
// Salida: 3
// División con decimales (usando casteo)
double resultadoDecimal = (double) a / b;
System.out.println("División decimal: " + resultadoDecimal);
// Salida: 3.5
}
}Ejemplo 3: Conversión de Char a Int (Códigos ASCII)
public class CharAInt {
public static void main(String[] args) {
char letra = 'A';
int codigoASCII = (int) letra;
System.out.println("La letra '" + letra + "' tiene el código ASCII: " + codigoASCII);
// Salida: 65
// De int a char
int codigo = 66;
char caracter = (char) codigo;
System.out.println("El código " + codigo + " es la letra: " + caracter);
// Salida: B
}
}Ejemplo 4: Redondear Números
public class RedondeoNumeros {
public static void main(String[] args) {
double nota = 8.75;
// Truncar (eliminar decimales)
int notaTruncada = (int) nota;
System.out.println("Nota truncada: " + notaTruncada);
// Salida: 8
// Redondear (usando Math.round que devuelve long)
int notaRedondeada = (int) Math.round(nota);
System.out.println("Nota redondeada: " + notaRedondeada);
// Salida: 9
}
}⚠️ Cuidados al Usar Casteo
1. Pérdida de Precisión
double pi = 3.141592653589793;
float piFloat = (float) pi;
System.out.println("Double: " + pi);
System.out.println("Float: " + piFloat);
// Se pierde precisión en los decimales2. Desbordamiento (Overflow)
long numeroGrande = 3000000000L;
int numeroChico = (int) numeroGrande;
System.out.println("Resultado: " + numeroChico);
// Puede dar un resultado inesperado por desbordamiento3. Pérdida de Parte Decimal
double precio = 99.99;
int precioEntero = (int) precio;
// Se pierden los 0.99, no se redondea, solo se truncaConversión entre String y Tipos Primitivos
De String a Primitivo:
// String a int
String texto = "123";
int numero = Integer.parseInt(texto);
// String a double
String textoDecimal = "45.67";
double decimal = Double.parseDouble(textoDecimal);
// String a boolean
String textoBoolean = "true";
boolean valor = Boolean.parseBoolean(textoBoolean);De Primitivo a String:
// int a String
int edad = 25;
String edadTexto = String.valueOf(edad);
// O simplemente:
String edadTexto2 = "" + edad;
// double a String
double precio = 99.99;
String precioTexto = String.valueOf(precio);Conclusión
El casteo es una herramienta esencial en Java que nos permite trabajar con diferentes tipos de datos de manera flexible. Debemos usarlo con cuidado, especialmente el casteo explícito, ya que puede causar pérdida de información. Entender cuándo y cómo usar el casteo nos ayudará a escribir código más eficiente y sin errores.
Recuerda:
- El casteo implícito es seguro y automático (pequeño a grande)
- El casteo explícito requiere precaución (grande a pequeño)
- Siempre verifica que tu conversión no cause pérdida crítica de datos
- Usa Math.round() si necesitas redondear en lugar de truncar
