Artículo

¿Java pasa por valor o por referencia? Respuesta con ejemplos

Java siempre pasa los argumentos por valor, también con objetos: se copia la referencia. Qué significa en la práctica, con un ejemplo que muestra cada caso.

En resumen: Java siempre pasa por valor. Con primitivos se copia el valor; con objetos se copia la referencia (la «dirección» del objeto). Por eso un método puede modificar el objeto que recibe (ambas referencias apuntan al mismo), pero no puede hacer que la variable del llamador apunte a otro objeto. Probado con Java 25, compatible desde Java 17.

Es una de las preguntas favoritas en entrevistas y una fuente constante de confusión, porque con objetos parece paso por referencia. El ejemplo lo deja claro.

Vídeo explicativo

Ejemplo con todos los casos

import java.util.ArrayList;
import java.util.List;

class Persona {
    String nombre;

    Persona(String nombre) {
        this.nombre = nombre;
    }
}

public class Main {
    static void incrementar(int n) {
        n = n + 1;
    }

    static void cambiarNombre(Persona p) {
        p.nombre = "Luis";          // modifica el objeto al que apunta la copia
    }

    static void reasignar(Persona p) {
        p = new Persona("Marta");   // solo cambia la copia local de la referencia
    }

    static void anadir(List<String> lista) {
        lista.add("nuevo");
    }

    static void concatenar(String s) {
        s = s + " mundo";           // String es inmutable: crea otro objeto
    }

    public static void main(String[] args) {
        int x = 5;
        incrementar(x);
        System.out.println("int tras incrementar: " + x);

        Persona ana = new Persona("Ana");
        cambiarNombre(ana);
        System.out.println("Tras cambiarNombre: " + ana.nombre);

        reasignar(ana);
        System.out.println("Tras reasignar: " + ana.nombre);

        List<String> lista = new ArrayList<>();
        anadir(lista);
        System.out.println("Lista tras anadir: " + lista);

        String saludo = "hola";
        concatenar(saludo);
        System.out.println("String tras concatenar: " + saludo);
    }
}

Salida:

int tras incrementar: 5
Tras cambiarNombre: Luis
Tras reasignar: Luis
Lista tras anadir: [nuevo]
String tras concatenar: hola

Qué ocurre en cada caso

LlamadaQué se copia¿Cambia algo fuera?Por qué
incrementar(x)El número 5NoEl método trabaja con su propia copia
cambiarNombre(ana)La referencia al objetoSí, el objetoLas dos referencias apuntan al mismo objeto
reasignar(ana)La referencia al objetoNoSolo la copia local pasa a apuntar a otro objeto
anadir(lista)La referencia a la listaSí, la listaSe modifica el objeto compartido
concatenar(saludo)La referencia al StringNoString es inmutable: + crea otro objeto

La clave está en reasignar: si Java pasara por referencia, ana acabaría apuntando a «Marta». No ocurre, porque el método solo recibió una copia de la referencia.

main:          ana ──┐
                     ├──► Persona{nombre="Luis"}
reasignar:     p  ───┘          (antes de p = new ...)

reasignar:     p  ──────► Persona{nombre="Marta"}   (después: solo cambia p)
main:          ana ─────► Persona{nombre="Luis"}    (intacta)

Consecuencias prácticas

  • Un método puede modificar tus objetos sin avisar. Si pasas una lista a un método de otra clase, puede vaciarla. Para evitarlo, pasa una copia (List.copyOf(lista)) o usa objetos inmutables: tienes cómo en inmutabilidad en Java.
  • No puedes escribir un swap(a, b) que intercambie dos variables del llamador. Devuelve el resultado o usa un objeto contenedor.
  • Los tipos inmutables se comportan como valores: String, Integer, LocalDate y los records no pueden cambiar, así que pasarlos es seguro.
  • Cuidado con los getters que devuelven colecciones internas: quien las recibe puede modificarlas. Devuelve copias o vistas inmutables.

Preguntas frecuentes

Entonces, ¿los objetos se pasan por referencia?

No. Se pasa por valor una referencia. La diferencia se nota justo al reasignar el parámetro, como en el ejemplo.

¿Y los arrays?

Son objetos: un método puede cambiar sus elementos (array[0] = 99) y el cambio se ve fuera, pero no puede reemplazar el array del llamador.

¿Por qué String no cambia si es un objeto?

Porque es inmutable: ningún método modifica el objeto, todos devuelven uno nuevo. Lo vemos en String, StringBuilder y StringBuffer.

¿Qué pasa con Integer?

Igual que con String: es inmutable, así que n++ dentro de un método crea otro Integer y el del llamador no cambia.

Sigue aprendiendo

Referencias, memoria y objetos son la base del curso de Java desde cero. Si quieres ver qué hace la JVM con esos objetos después, tienes gestión de memoria en Java.

paso por valor paso por referencia java referencias objetos

Newsletter Semanal de Java

Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.

Sin spam. Cancela cuando quieras.

Compartir artículo