0Pricing
Java Academy · Lección

Tipos primitivos frente a tipos de referencia

Comprenda la diferencia fundamental entre los tipos primitivos y los tipos de referencia en Java.

Tipos primitivos frente a tipos de referencia es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Tipos primitivos frente a tipos de referencia

Java tiene dos categorías fundamentales de tipos de datos: tipos primitivos y tipos de referencia. Comprender la diferencia es esencial para escribir código Java correcto y eficiente.

Los ocho tipos primitivos

Java tiene exactamente ocho tipos primitivos:

  • byte (entero de 8 bits)
  • short (entero de 16 bits)
  • int (entero de 32 bits)
  • long (entero de 64 bits)
  • float (decimal de 32 bits)
  • double (decimal de 64 bits)
  • char (carácter Unicode de 16 bits)
  • boolean (true/false)

Los primitivos almacenan el valor directamente en memoria, sin la sobrecarga de un objeto.

int age = 25;
double price = 19.99;
boolean active = true;
char grade = 'A';
long population = 8_000_000_000L;

System.out.println(age);       // 25
System.out.println(price);     // 19.99
System.out.println(active);    // true

Tipos de referencia

Un tipo de referencia almacena una dirección de memoria (referencia) que apunta a un objeto en el heap. Esto incluye:

  • Clases (por ejemplo, String, Scanner)
  • Arrays (por ejemplo, int[])
  • Interfaces
  • Enums y Records

La variable no contiene el objeto, sino un puntero hacia él.

String name = "Alice";       // reference to a String object
int[] scores = {90, 85, 92}; // reference to an array object

// name holds a reference, not the characters directly
System.out.println(name.length());   // 5
System.out.println(scores.length);   // 3

Memoria stack frente a heap

Las variables primitivas se almacenan en la stack: una memoria rápida y de corta duración vinculada a las llamadas a métodos.

Los objetos de tipos de referencia viven en el heap: una memoria más grande y duradera gestionada mediante la recolección de basura. La referencia (la dirección) se encuentra en la stack.

// Stack: holds the int value directly
int x = 42;

// Stack: holds reference; Heap: holds the Person object
class Person {
    String name;
    int age;
}

Person p = new Person(); // p is a reference on stack, object on heap
p.name = "Bob";
p.age = 30;

null: la referencia ausente

A las variables de referencia se les puede asignar null, lo que significa que no apuntan a ningún objeto. Los primitivos no pueden ser null: siempre tienen un valor.

Acceder a una referencia null provoca una NullPointerException (NPE), uno de los errores de ejecución más comunes de Java.

String s = null;
// int n = null; // Compile error — primitives can't be null

try {
    System.out.println(s.length()); // NullPointerException!
} catch (NullPointerException e) {
    System.out.println("Caught NPE: reference was null");
}

Semántica de copia: primitivos

Cuando asigna una variable primitiva a otra, Java copia el valor. Cambiar una no afecta a la otra: son completamente independientes.

int a = 10;
int b = a;  // b gets a copy of the value 10

b = 20;     // changing b does NOT affect a

System.out.println(a); // 10
System.out.println(b); // 20

Semántica de copia: referencias

Cuando asigna una variable de referencia a otra, ambas variables apuntan al mismo objeto. Las modificaciones realizadas mediante una referencia son visibles a través de la otra.

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1; // arr2 points to the SAME array

arr2[0] = 99; // modifies the shared array

System.out.println(arr1[0]); // 99 — arr1 sees the change too!
System.out.println(arr2[0]); // 99

Clases envolventes: boxing de primitivos

Cada primitivo tiene una clase envolvente correspondiente en java.lang:

  • int → Integer
  • double → Double
  • boolean → Boolean
  • char → Character

Las clases envolventes permiten utilizar primitivos como objetos, algo necesario para colecciones como List<Integer>.

Integer boxed = Integer.valueOf(42); // explicit boxing
int unboxed = boxed.intValue();       // explicit unboxing

// Autoboxing / auto-unboxing (Java does this automatically)
Integer auto = 100;  // autoboxed
int val = auto;      // auto-unboxed

System.out.println(Integer.MAX_VALUE);  // 2147483647
System.out.println(Double.MIN_VALUE);   // 5.0E-324

Problemas del autoboxing

El autoboxing resulta práctico, pero puede causar errores sutiles. Integer almacena en caché los valores de -128 a 127; fuera de ese rango, == compara referencias, no valores.

Utilice siempre .equals() para comparar objetos envolventes.

Integer a = 127;
Integer b = 127;
System.out.println(a == b);      // true (cached)

Integer c = 200;
Integer d = 200;
System.out.println(c == d);      // false (different objects!)
System.out.println(c.equals(d)); // true (correct comparison)

Paso a métodos: paso por valor

Java siempre utiliza el paso por valor. En el caso de los primitivos, se copia el valor. En el caso de las referencias, se copia la referencia (la dirección): ambas apuntan al mismo objeto, pero no puede reasignar la variable del código que realiza la llamada desde dentro del método.

static void doubleValue(int n) {
    n = n * 2; // only modifies the local copy
}

static void clearArray(int[] arr) {
    arr[0] = 0; // modifies the shared object
}

int x = 5;
doubleValue(x);
System.out.println(x); // still 5

int[] nums = {10, 20, 30};
clearArray(nums);
System.out.println(nums[0]); // 0 — object was mutated

Tabla resumen práctica

Referencia rápida para comparar tipos primitivos y tipos de referencia:

  • Almacenamiento: primitivo → valor en la stack; referencia → dirección en la stack + objeto en el heap
  • Valor predeterminado: primitivo → 0/false/\u0000; referencia → null
  • Puede ser null: primitivo → No; referencia → Sí
  • Las asignaciones copian: primitivo → valor; referencia → dirección
  • En colecciones: los primitivos necesitan clases envolventes

Comprobación rápida

¿Qué sucede al ejecutar el siguiente código?

Integer x = 200;
Integer y = 200;
System.out.println(x == y);

Resumen: tipos primitivos frente a tipos de referencia

Conclusiones principales de esta lección:

  • Java tiene 8 tipos primitivos que se almacenan directamente en la stack
  • Los tipos de referencia almacenan la dirección de un objeto en el heap; la variable contiene la dirección
  • Los primitivos se copian por valor; las referencias se copian por dirección
  • Las variables de referencia pueden ser null; los primitivos no
  • Las clases envolventes (Integer, Double, etc.) convierten los primitivos en objetos
  • Java siempre utiliza el paso por valor, incluso al pasar referencias

Preguntas frecuentes

¿La lección «Tipos primitivos frente a tipos de referencia» es gratis?

Sí — el texto completo de «Tipos primitivos frente a tipos de referencia» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Tipos primitivos frente a tipos de referencia»?

Comprenda la diferencia fundamental entre los tipos primitivos y los tipos de referencia en Java. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Tipos primitivos frente a tipos de referencia»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Tipos primitivos frente a tipos de referencia
  2. Conversiones de ampliación y reducción
  3. El operador instanceof
  4. Conversiones de tipos en la práctica
← Volver a Java Academy