java - puede - palabra clave final en los parámetros del método
se puede instanciar una clase final (11)
@stuXnet, podría hacer el argumento exactamente opuesto. Si pasa un objeto a una función y cambia las propiedades del objeto pasado, la persona que llama verá el valor modificado en su variable. Esto implica un sistema de pase por referencia, no pasa por valor.
Lo que es confuso es la definición de pasar por valor o pasar por referencia en un sistema donde el uso de punteros está completamente oculto para el usuario final.
Java definitivamente NO pasa por valor, ya que ser así, significaría que uno podría mutar el objeto pasado y el original no se vería afectado.
Observe que no puede mutar las primitivas, solo puede asignarlas a las variables. Por lo tanto, probar un Pase por referencia o por valor mediante el uso de primitivas no es una prueba.
Lo que no se puede hacer en Java que se puede hacer en otros idiomas es reasignar las variables de la persona que llama a un nuevo valor porque no hay punteros en Java, por lo que resulta confuso.
Esta pregunta ya tiene una respuesta aquí:
A menudo encuentro métodos que se parecen a los siguientes:
public void foo(final String a, final int[] b, final Object1 c){
}
¿Qué ocurre si se llama a este método sin pasarle los parámetros finales? es decir, un Object1 que luego se cambia (por lo que no se declara como final) se puede pasar a este método simplemente bien
Casi todas las cosas se han dicho sobre los parámetros del método final en Java ; pero me gustaría añadir algo muy simple que se puede pensar en este parámetro de método final como los parámetros de const pass-by-reference en C++ like =>
void someMethod(const int* param1)
{
...
}
Considere esta implementación de foo ():
public void foo(final String a) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
System.out.print(a);
}
});
}
Debido a que la instancia de Runnable sobrevivirá al método, esto no se compilará sin la palabra clave final : final le dice al compilador que es seguro tomar una copia de la referencia (para referirse a ella más adelante). Por lo tanto, es la referencia lo que se considera final, no el valor . En otras palabras: como persona que llama, no puedes estropear nada ...
Hay una circunstancia en la que debe declararla definitiva; de lo contrario, provocará un error de compilación, es decir, pasarla a clases anónimas. Ejemplo básico:
public FileFilter createFileExtensionFilter(final String extension) {
FileFilter fileFilter = new FileFilter() {
public boolean accept(File pathname) {
return pathname.getName().endsWith(extension);
}
};
// What would happen when it''s allowed to change extension here?
// extension = "foo";
return fileFilter;
}
Al eliminar el modificador final se produciría un error de compilación, porque ya no se garantiza que el valor sea una constante de tiempo de ejecución. Cambiar el valor desde fuera de la clase anónima provocaría que la instancia de clase anónima se comporte diferente después del momento de la creación.
Java es solo valor por paso. (o mejor - pass-reference-by-value)
Entonces, el argumento pasado y el argumento dentro del método son dos manejadores diferentes que apuntan al mismo objeto (valor).
Por lo tanto, si cambia el estado del objeto, se reflejará en cualquier otra variable que lo haga referencia. Pero si reasigna un nuevo objeto (valor) al argumento, entonces otras variables que apuntan a este objeto (valor) no se reasignan.
Java siempre hace una copia de los parámetros antes de enviarlos a los métodos. Esto significa que el final no significa ninguna diferencia para el código de llamada. Esto solo significa que dentro del método las variables no pueden ser reasignadas. (tenga en cuenta que si tiene un objeto final, aún puede cambiar los atributos del objeto).
La palabra clave final en un parámetro de método no significa absolutamente nada para la persona que llama. Tampoco significa absolutamente nada para el programa en ejecución, ya que su presencia o ausencia no cambia el bytecode. Solo garantiza que el compilador se quejará si la variable de parámetro se reasigna dentro del método. Eso es todo. Pero eso es suficiente.
Algunos programadores (como yo) piensan que eso es algo muy bueno y usan el final en casi todos los parámetros. Hace que sea más fácil comprender un método largo o complejo (aunque se podría argumentar que los métodos largos y complejos deben ser refactorizados). También destaca los parámetros del método que no están marcados con final .
La palabra clave final en el parámetro de entrada del método no es necesaria. Java crea una copia de la referencia al objeto, por lo que ponerlo final no hace que el objeto sea final sino solo la referencia, lo que no tiene sentido
Las cadenas son inmutables, así que en realidad no puedes cambiar la cadena después (solo puedes hacer que la variable que mantiene el objeto String apunte a un objeto String diferente).
Sin embargo, esa no es la razón por la que puede vincular cualquier variable a un parámetro final . Todas las comprobaciones del compilador consisten en que el parámetro no se reasigna dentro del método. Esto es bueno para fines de documentación, podría decirse que es un buen estilo, e incluso puede ayudar a optimizar el código de bytes para la velocidad (aunque esto parece no hacer mucho en la práctica).
Pero incluso si reasigna un parámetro dentro de un método, la persona que llama no lo nota, porque java hace que todos los parámetros pasen por valor. Después de la secuencia
a = someObject();
process(a);
los campos de a pueden haber cambiado, pero a sigue siendo el mismo objeto que era antes. En los idiomas de referencia, esto puede no ser cierto.
Si declara cualquier parámetro como final, no puede cambiar el valor de este.
class Bike11{
int cube(final int n){
n=n+2;//can''t be changed as n is final
n*n*n;
}
public static void main(String args[]){
Bike11 b=new Bike11();
b.cube(5);
}
}
Ouput: error de tiempo de compilación
Para más detalles, visite: http://javabyroopam.blogspot.com
final significa que no puede cambiar el valor de esa variable una vez que fue asignada.
Mientras tanto, el uso de final para los argumentos en esos métodos significa que no le permitirá al programador cambiar su valor durante la ejecución del método . Esto solo significa que dentro del método las variables finales no pueden ser reasignadas.