Este artículo analiza la llamada por valor en Java con ejemplos. Compártelo con todos para tu referencia. El análisis específico es el siguiente:
Java opera instancias de objetos por referencia.
Lo que se puede confirmar es que la forma de operar objetos en Java es operar objetos por referencia. Para entender esto más profundamente escribí el siguiente código:
Primero defina un tipo personalizado. Copie el código. El código es el siguiente: public class Person {.
Nombre de cadena;
Persona (nombre de cadena) {
this.nombre = nombre;
}
}
El nombre aquí por defecto es público (que es diferente del atributo predeterminado de clase en C++)
Entonces la llamada en la función Principal es la siguiente:
Copie el código de la siguiente manera: public class Main {
/**
* argumentos @param
*/
público estático vacío principal (String [] argumentos) {
// TODO Código auxiliar de método generado automáticamente
Persona p1 = nueva Persona("Pablo");
Persona p2 = nueva Persona("Griefen");
System.out.println("p1.nombre = " + p1.nombre + " p2.nombre = " + p2.nombre);
Persona tmp;
tmp = p1;
p1 = p2;
System.out.println("tmp.name = " + tmp.name + " p1.name = " + p1.name + " p2.name = " + p2.name);
}
}
La salida en este momento es la siguiente:
Copie el código de la siguiente manera: p1.name = Paul p2.name = Griefen
tmp.name = Paul p1.name = Griefen p2.name = Griefen
¿Eh? ¿Por qué es este un resultado? ¡Como CPPer estoy confundido! Es una referencia, por lo que luego de ejecutar la siguiente declaración, copie el código de la siguiente manera: Person tmp;
tmp = p1;
p1 = p2;
Debido a que entiendo esta operación de acuerdo con el concepto de referencia en C ++, entonces tmp p1 p2 deberían ser todos el mismo objeto en este momento, es decir, todos deberían apuntar al objeto p2. ¡Pero el resultado demuestra claramente que esta comprensión es errónea! Entonces, ¿dado que las referencias en Java no son lo mismo que las referencias en C++? ! ! ! ¿Es lo mismo que un puntero en C++?
¡bien! Entendamos este proceso de operación según los consejos de C++.
En primer lugar, Person tmp; declara un puntero, que es similar a la declaración de puntero en C++. En C ++, se estipula claramente que la declaración de referencia no se puede escribir por separado de esta manera. Cuando se realiza la declaración de referencia, debe apuntar a un objeto. Obviamente, el razonamiento del primer paso es correcto. ¡Este es un buen comienzo! Entonces tmp = p1; p1 = p2 Obviamente, tmp apunta a p1 y p1 apunta a p2. ¡Se encontró que era consistente!
Eso significa que si las referencias en Java se comparan con las operaciones de datos en C++, ¡deberían ser más similares al concepto de punteros en C++!
Los punteros en C++ implementan las funciones anteriores.
Dado que el método anterior para operar objetos en Java es similar al puntero en C++, echemos un vistazo a cómo implementar el método anterior en C++. Copie el código de la siguiente manera: #include "stdafx.h".
#incluir <cadena>
#incluir <iostream>
persona de clase
{
público:
std::nombre de cadena;
público:
Persona(std::nombre de cadena)
{
esto->nombre = nombre;
};
};
int _tmain(int argc, _TCHAR* argv[])
{
Persona* p1 = nueva Persona("Pablo");
Persona* p2 = nueva Persona("Griefen");
std::cout<< "p1.nombre " << p1->nombre << " p2.nombre = " << p2->nombre << std::endl;
Persona* tmp;
tmp = p1;
p1 = p2;
std::cout<<"tmp.name" << tmp->nombre << " p1.name " << p1->nombre << " p2.name = " << p2->nombre << std::endl ;
eliminar tmp;
eliminar p1;
devolver 0;
}
Después de la depuración, descubrí que el resultado de salida es el mismo que el resultado de ejecución de Java anterior.
La implementación subyacente de cualquier lenguaje es la misma.
Dado que el efecto de referencia en Java parece ser el mismo que el del puntero en C++, ¿por qué no se llama puntero directamente en Java? Obviamente existen diferencias. Por ejemplo, las referencias en Java no pueden realizar operaciones ++, pero los punteros en C++ pueden moverse a voluntad. Obviamente, en este punto, Java ha trabajado mucho en sus punteros para restringirlos y hacerlos ejecutar de manera más segura. Pero no importa cuán grande parezca la capa superior, cuando llega a la capa inferior, debe solicitar memoria y la memoria debe liberarse una vez que se agote. ¡Esto es trabajo en cualquier idioma!
Espero que este artículo sea útil para la programación Java de todos.