Este artículo presenta principalmente el uso de la palabra clave final de Java para ayudar a todos a comprender y utilizar mejor Java. Los amigos interesados pueden comprender que
el significado de la palabra clave final de Java es ligeramente diferente según el contexto, pero por lo general se refiere a La respuesta es "Esto no puede ser cambiado". Hay dos razones para evitar el cambio: diseño o eficiencia. Debido a que estas dos razones están muy separadas, es posible hacer un mal uso de la palabra clave final.
Las siguientes secciones discuten tres posibles usos de final: datos, métodos y clases.
1) Datos finales
Para el caso de las constantes en tiempo de compilación, el compilador puede incorporar las constantes al cálculo, lo que puede reducir algunas cargas de tiempo de ejecución. En Java, estas constantes deben ser de tipo básico y se modifican con la palabra clave final. Debe asignar valores al definir constantes .
Las variables básicas estáticas finales con valores iniciales constantes (es decir, constantes en tiempo de compilación) se nombran en mayúsculas y las palabras están separadas por guiones bajos.
Un atributo modificado tanto por estático como por final solo ocupará una sección del espacio de almacenamiento que no se puede cambiar .
Al usar final para decorar referencias a objetos en lugar de tipos básicos,
- Para los tipos básicos, final mantiene constante el valor.
- Para referencias a objetos, final hace que la referencia sea constante.
Una vez que se inicializa la referencia para apuntar a un objeto, no se puede cambiar para apuntar a otros objetos. Sin embargo, el objeto en sí se puede modificar y Java no proporciona un método para establecer ningún objeto como constante. (Puede escribir su propia clase para lograr el efecto de hacer que el objeto sea constante) Esta restricción también se aplica a las matrices, que también son objetos.
Ejemplo:
import java.util.*;
class Value {
int i;
Value(int i) {
this.i = i;
}
}
/**
* @author Limh
*/
public class FinalData {
private static Random rand = new Random(47);
private String id;
public FinalData(String id) {
this.id = id;
}
private final int valueOne = 9;
private static final int VALUE_TWO = 99;
public static final int VALUE_THREE = 39;
private final int i4 = rand.nextInt(20);
static final int INT_5 = rand.nextInt(20);
private Value v1 = new Value(11);
private final Value v2 = new Value(22);
private static final Value VAL_3 = new Value(33);
private final int[] a = {
1, 2, 3, 4, 5, 6};
@Override
public String toString() {
return id + ": " + "i4 = " + i4 + ", INT_5 = " + INT_5;
}
public static void main(String[] args) {
FinalData fd1 = new FinalData("fd1");
//v2=new Value(22);
fd1.v2.i++;
fd1.v1 = new Value(9);
//a.length = 6
for (int i = 0; i < fd1.a.length; i++) {
fd1.a[i]++;
}
System.out.println(fd1);
System.out.println("Creating new FinalData");
FinalData fd2 = new FinalData("fd2");
System.out.println(fd1);
System.out.println(fd2);
}
}
Producción:
fd1: i4 = 15, INT_5 = 18
Creating new FinalData
fd1: i4 = 15, INT_5 = 18
fd2: i4 = 13, INT_5 = 18
Debido a que la primera variable y la segunda variable son tipos básicos finales con valores en tiempo de compilación, ambas pueden usarse como constantes en tiempo de compilación sin mucha diferencia. La tercera variable es una forma más típica de definir constantes: pública significa que se puede acceder a ella fuera del paquete, estática enfatiza que solo hay una y final significa que es una constante.
Como puede ver en main (), v2 es final no significa que no pueda modificar su valor. Debido a que es una referencia, simplemente significa que no puede apuntar a un nuevo objeto.
2) Final en blanco Final en
blanco se refiere al atributo final sin valor inicial.
El compilador asegura que el final en blanco debe inicializarse antes de su uso. De esta manera, el valor de atributo final de cada objeto de una clase puede ser diferente y también puede mantener su inmutabilidad .
Debe realizar la asignación de variables finales en el momento de la definición o en cada constructor. Esto asegura que el atributo final se haya inicializado antes de su uso.
3) Parámetro final
En la lista de parámetros, declarar el parámetro como final significa que el objeto o la variable básica apuntada por el parámetro no se puede cambiar en el método:
class Gizmo {
public void spin() {
}
}
/**
* @author Limh
*/
public class FinalArguments {
void with(final Gizmo g) {
//-g = new Gizmo();
// Illegal -- g is final
}
void without(Gizmo g) {
g = new Gizmo(); // OK -- g is not final
g.spin();
}
//void f(final int i) { i++; } // Can't change
// You can only read from a final primitive
int g(final int i) {
return i + 1;
}
public static void main(String[] args) {
FinalArguments bf = new FinalArguments();
bf.without(null);
bf.with(null);
}
}
4) Hay dos razones por las que los métodos
finales utilizan métodos finales.
Bloquee el método para evitar que las subclases cambien el método sobrescribiendo. Esto es por consideraciones de herencia para garantizar que el comportamiento del método no cambie debido a la herencia.
Utilice final solo para prohibir explícitamente los métodos de sobrescritura.
5)
Todos los métodos privados en las clases finales y privadas se designan implícitamente como finales. Debido a que no se puede acceder al método privado, no se puede anular.
6) Clase final
Cuando se dice que una clase es final (la palabra clave final está antes de la definición de la clase), significa que no se puede heredar. La razón de esto es porque el diseño de la clase nunca necesita cambiarse, o porque no se espera que tenga subclases por razones de seguridad.
Dado que la clase final prohíbe la herencia, todos los métodos de la clase se designan implícitamente como finales, por lo que no hay forma de anularlos. Puede agregar modificadores finales a los métodos en la clase final, pero no agregará ningún significado.
Lo anterior es el contenido detallado del análisis exhaustivo de las palabras clave finales de Java. Para obtener más información sobre las palabras clave finales de Java, ¡preste atención a otros artículos relacionados en el editor!