valor - variable referencia java




Java Variable cadena de ajuste-referencia o valor? (6)

¡No es relevante si String se trata como un objeto primitivo o como un objeto!

En el ejemplo de Cadena, la concatenación de dos cadenas produce una nueva instancia de Cadena , que luego se asigna a s1. La variable s2 todavía hace referencia a la instancia de String antigua sin cambios (!).

Suponiendo que BankAccount tenía un método para establecer el saldo, que devuelve una nueva BankAccount, su ejemplo podría verse así:

BankAccount b1 = new BankAccount(500); // 500 is initial balance parameter
BankAccount b2 = b1; // reference to the same object
b1 = b1.createNewAccountWithBalance(0); // create and reference a new object
System.out.println(b1.getBalance() + " " + b2.getBalance()); // prints "0 500"

El siguiente segmento de código Java es de un examen de práctica de ciencias computacionales AP.

String s1 = "ab";
String s2 = s1;
s1 = s1 + "c";
System.out.println(s1 + " " + s2);

La salida de este código es "abc ab" en BlueJ. Sin embargo, una de las posibles opciones de respuesta es "abc abc". La respuesta puede depender de si Java establece una referencia de cadena como tipos primitivos (por valor) o Objetos similares (por referencia).

Para ilustrar esto, veamos un ejemplo con tipos primitivos:

int s1 = 1;
int s2 = s1; // copies value, not reference
s1 = 42;

System.out.println(s1 + " " + s2); // prints "1 42"

Pero, digamos que tenemos objetos de BankAccount que tienen saldos.

BankAccount b1 = new BankAccount(500); // 500 is initial balance parameter
BankAccount b2 = b1; // reference to the same object
b1.setBalance(0);
System.out.println(b1.getBalance() + " " + s2.getBalance()); // prints "0 0"

No estoy seguro de cuál es el caso con cuerdas. Técnicamente son objetos, pero mi compilador parece tratarlos como tipos primitivos al establecer variables entre sí.

Si Java pasa variables de cadena como el tipo primitivo, la respuesta es "abc ab". Sin embargo, si Java trata las variables de cadena como referencias a cualquier otro objeto, la respuesta sería "abc abc"

¿Cuál crees que es la respuesta correcta?


De hecho, String es una clase y se asigna / pasa por referencia. Pero lo que es confuso es la afirmación:

String s = "abc";

Lo que sugiere que String es una primitiva (como ' int x = 10; '); Pero eso es solo un atajo, la declaración 'String s = "abc";' en realidad se compila como ' String s = new String( "abc" ); 'Al igual que' Integer x = 10; 'se compila como' Integer x = new Integer( 10 ); '

Este mecanismo se llama 'boxeo'.

Y más confuso es: hay una clase ' Integer ' y una primitiva ' int ', pero String no tiene un equivalente primitivo (aunque char[] se acerca)

Sije de Haan


La afirmacion

Si Java trata las variables de cadena como referencias a cualquier otro objeto, la respuesta sería "abc abc"

Es incorrecto. Java trata las variables de cadena como referencias a cualquier otro objeto. Strings son objetos, pero la respuesta es "abc ab", no obstante.

El problema no es lo que hace el operador de asignación. El operador de asignación asigna una referencia a un objeto String en cada caso en su ejemplo.

El problema es qué hace el operador de concatenación ('+'). Crea un nuevo objeto String. Como han dicho otros, esto es necesario porque un objeto String es inmutable pero es un problema de comportamiento del operador y no simplemente porque String es inmutable. El operador de concatenación podría devolver un nuevo objeto incluso si un objeto String fuera mutable.

En contraste, en su segundo ejemplo, b1.setBalance (0) no crea un nuevo objeto, modifica el objeto existente.


La diferencia entre tu cuenta bancaria y una cadena es que una cadena es inmutable. No hay tal cosa como 'setValue ()' o 'setContent ()'. El ejemplo equivalente con su cuenta bancaria sería:

BankAccount b1 = new BankAccount(500); // 500 is initial balance parameter
BankAccount b2 = b1; // reference to the same object
b1 = new BankAccount(0);
System.out.println(b1.getBalance() + " " + s2.getBalance()); // prints "0 500"

Entonces, si lo piensas de esta manera (no en realidad lo que hace el compilador, sino funcionalmente equivalente) el escenario de concatenación de cadenas es:

String s1 = "ab";
String s2 = s1;
s1 = new String("abc");
System.out.println(s1 + " " + s2); //prints "abc ab"

java.lang.String es un objeto, no un primitivo.

Lo que hizo el código en el primer ejemplo es:

  1. Definir s1 como "ab"
  2. Establecer s2 igual al mismo objeto subyacente que s1
  3. Establecer s1 igual a una nueva cadena que es la combinación del valor antiguo de s1 y "c"

Pero para responder a su pregunta sobre la referencia o el valor, es por referencia.








reference