Palabra clave alternativa C / ref / out en Java

　　Poco después de aprender Java, me encontré con un problema hoy. Necesitaba modificar el valor del objeto entrante en el método. Para ser precisos, necesitaba usar un método para crear un objeto y devolver su referencia. Mi
　　
　　primera reacción fue familiar con C #. Es la palabra clave ref / out en C #. Resulta que no hay una palabra clave similar en Java, por lo que solo puedo pensar en cómo resolver este problema.
　　
　　Paso de parámetros:
　　
　　hay dos tipos de paso de parámetros en el método, uno es paso de valor y el otro es Transferencia de referencia, pero de hecho copia de transferencia.
　　
　　Transferencia de valor: consiste en copiar la copia de los datos en sí, y operarla en el método entrante, y el valor se copia.
　　
　　Transferencia de referencia: es copiar una copia de una referencia a un objeto, y el objeto puede ser operado por esta referencia en el método entrante.
　　
　　Entonces, en lo que respecta a mi problema actual, necesito un método. Paso una referencia y creo el objeto requerido en el método.
　　
　　Luego, en Java, solo puedo encapsular el objeto actual en una capa (definir una nueva clase), Haga que el objeto que necesita ser creado sea miembro de la nueva clase y asigne un valor al miembro en el método
　　
　　Ejemplo:
　　
　　C #:
　　
　　/// <summary>
　　
　　/// model
　　
　　/// </ summary>
　　
　　public class Student
　　
　　{
　　
　　public string Name;
　　
　　public int Age; public int Age;
　　
　　}
　　
　　/// Método:
　　
　　/// <resumen>
　　
　　/// Error Demostración
　　
　　///
　　
　　/// La referencia del alumno se copia y se crea para crear un nuevo Alumno correspondiente
　　
　　/// Asigne la referencia al alumno. Cuando el método vuelve a la pila, la referencia del alumno vuelve al frente de la pila.
　　
　　/// Luego el número de referencia del objeto del alumno es 0, esperando el GC, el alumno de referencia sigue siendo el valor original (dirección lógica)
　　
　　/// < / summary>
　　
　　/// <param name = "student"> </ param>
　　
　　static void createStudent (Student student)
　　
　　{
　　
　　student = new Student {Name = "Stephen Lee", Age = 1};
　　
　　}
　　
　　/// <summary>
　　
　　/// Práctica correcta
　　
　　////
　　
　　/// Transfiera la operación directamente al método a través de la palabra clave ref
　　
　　/// </ summary>
　　
　　/// <param name = "student"> </ param>
　　
　　static void createStudent (ref Estudiante estudiante)
　　
　　{
　　
　　estudiante = estudiante nuevo {Nombre = "Stephen Lee", Edad = 1};
　　
　　}
　　
　　// Cliente
　　
　　vacío estático Principal (cadena [] args)
　　
　　{
　　
　　Consola.WriteLine ("demostración de error");
　　
　　Estudiante student1 = null;
　　
　　createStudent (student1);
　　
　　if (student1 == null)
　　
　　Console.WriteLine ("Error al crear el objeto"); de lo
　　
　　contrario
　　
　　Console.WriteLine ("Objeto creado con éxito, Nombre:" + student1.Name);
　　
　　Console.WriteLine ("Práctica correcta");
　　
　　Estudiante estudiante2 = nulo;
　　
　　createStudent (ref estudiante2);
　　
　　if (estudiante2 == nulo)
　　
　　Console.WriteLine ("Error al crear el objeto"); de lo
　　
　　contrario
　　
　　Console.WriteLine ("Objeto creado con éxito, Nombre:" + student2.Name);
　　
　　}
　　
　　Java:
　　
　　/ ** Modelo
　　
　　* @author Stephen
　　
　　*
　　
　　* /
　　
　　public class Student
　　
　　{
　　
　　public String Name;
　　
　　public int Age;
　　
　　public Student (String name, int age)
　　
　　{
　　
　　this.Name = name;
　　
　　this.Age = age;
　　
　　}
　　
　　}
　　
　　/ ** 错误 示范, 原因 同 C #
　　
　　* @param student
　　
　　* /
　　
　　private void createStudent (Estudiante estudiante)
　　
　　{
　　
　　estudiante = estudiante nuevo ("Stephen Lee", 1);
　　
　　}
　　
　　/ ** 正确 做法
　　
　　* @param studentPack
　　
　　* /
　　
　　private void createStudent (StudentPack studentPack)
　　
　　{
　　
　　studentPack.student = nuevo estudiante ("Stephen Lee", 1);
　　
　　}
　　
　　/ ** 包装 器
　　
　　* @author Stephen
　　
　　*
　　
　　* /
　　
　　public class StudentPack
　　
　　{
　　
　　public Student student;
　　
　　}
　　
　　// Cliente
　　
　　StudentPack studentPack = new StudentPack ();
　　
　　createStudent (studentPack);
　　
　　System.out.println (studentPack.student.Name);