Paso por valor en Java
Comprenda el paso por valor de Java: tipos primitivos frente a referencias, reasignación frente a mutación, arrays y dificultades relacionadas con la inmutabilidad.
Paso por valor en Java es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 1 de 3. 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 3 lecciones en total.
Descripción general del paso por valor
Objetivo: Aprender cómo Java pasa los parámetros. Comparará tipos primitivos frente a referencias, reasignación frente a mutación, arreglos e inmutabilidad.
Copia de tipos primitivos
Los tipos primitivos se pasan por valor: el método llamado recibe una copia. Reasignar el parámetro no cambia la variable del código que realizó la llamada.
public class Main {
static void inc(int x) {
x = x + 1; // modifies the local copy only
}
public static void main(String[] args) {
int a = 5;
inc(a);
System.out.println("a after inc(a) = " + a); // still 5
}
}
Referencias: mutar frente a reasignar
En el caso de los objetos, se copia la referencia. Mutar el objeto a través de ella afecta al objeto del código que realizó la llamada; reasignar el parámetro no lo hace.
public class Main {
static class Box { int n; }
static void setTo999(Box b) { b.n = 999; } // mutate via copied reference
static void reassign(Box b) { b = new Box(); b.n = 123; } // reassign local copy only
public static void main(String[] args) {
Box bx = new Box();
bx.n = 10;
setTo999(bx);
System.out.println("after setTo999: bx.n = " + bx.n); // 999
reassign(bx);
System.out.println("after reassign: bx.n = " + bx.n); // still 999
}
}
Arreglos: mutar frente a reasignar
Los arreglos son objetos. Si los modifica, afecta al arreglo del código que realizó la llamada; reasignar el parámetro no reemplaza ese arreglo.
public class Main {
static void fillZero(int[] a) {
for (int i = 0; i < a.length; i = i + 1) a[i] = 0; // mutate caller array
}
static void replace(int[] a) {
a = new int[] {9, 9, 9}; // reassign local copy of the reference
}
public static void main(String[] args) {
int[] arr = {1, 2, 3};
fillZero(arr);
System.out.println("after fillZero: " + arr[0] + "," + arr[1] + "," + arr[2]); // 0,0,0
replace(arr);
System.out.println("after replace: " + arr[0] + "," + arr[1] + "," + arr[2]); // still 0,0,0
}
}
Inmutable frente a mutable
String es inmutable (devuelve objetos nuevos); StringBuilder es mutable (cambia la misma instancia).
public class Main {
static void tryChangeString(String s) {
s = s + "!"; // new String; original unchanged
}
static void changeBuilder(StringBuilder sb) {
sb.append("!"); // mutates same object
}
public static void main(String[] args) {
String s = "hi";
tryChangeString(s);
System.out.println("after tryChangeString: " + s); // "hi"
StringBuilder sb = new StringBuilder("hi");
changeBuilder(sb);
System.out.println("after changeBuilder: " + sb.toString()); // "hi!"
}
}
Intercambiar correctamente
Como los parámetros son copias, intercambiar tipos primitivos dentro de un método no afecta al código que realizó la llamada. Devuelva valores nuevos (o un objeto contenedor).
public class Main {
static void trySwap(int a, int b) {
int t = a; a = b; b = t; // swaps local copies only
}
static int[] swap(int a, int b) {
return new int[] { b, a }; // return results to the caller
}
public static void main(String[] args) {
int x = 1, y = 2;
trySwap(x, y);
System.out.println("after trySwap: x=" + x + ", y=" + y); // 1,2
int[] res = swap(x, y);
x = res[0]; y = res[1];
System.out.println("after swap: x=" + x + ", y=" + y); // 2,1
}
}
Comprobación del paso por valor
Comprobación rápida: ¿Qué afirmación sobre el paso de parámetros de Java es correcta?
Repaso y siguiente paso
Repaso: Vio tipos primitivos frente a referencias, mutación frente a reasignación, arreglos como objetos, inmutabilidad y un patrón seguro para intercambiar valores. Siguiente paso: métodos estáticos frente a métodos de instancia.
Preguntas frecuentes
¿La lección «Paso por valor en Java» es gratis?
Sí — el texto completo de «Paso por valor en Java» 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 3 lecciones en total.
¿Qué aprenderé en «Paso por valor en Java»?
Comprenda el paso por valor de Java: tipos primitivos frente a referencias, reasignación frente a mutación, arrays y dificultades relacionadas con la inmutabilidad. 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 3.
¿Cuánto tiempo toma la lección «Paso por valor en Java»?
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
- Paso por valor en Java
- Métodos estáticos y de instancia
- Descomposición de métodos y código limpio