Hay muchos usos para la variable final. Aquí hay algunos
Constantes finales
public static class CircleToolsBetter {
public final static double PI = 3.141;
public double getCircleArea(final double radius) {
return (Math.pow(radius, 2) * PI);
}
}
Esto puede usarse luego para otras partes de sus códigos, o acceder a otras clases, de esa manera si alguna vez cambiara el valor, no tendría que cambiarlos uno por uno.
Variables finales
public static String someMethod(final String environmentKey) {
final String key = "env." + environmentKey;
System.out.println("Key is: " + key);
return (System.getProperty(key));
}
}
En esta clase, construye una variable final con ámbito que agrega un prefijo al parámetro environmentKey. En este caso, la variable final es final solo dentro del alcance de ejecución, que es diferente en cada ejecución del método. Cada vez que se ingresa el método, se reconstruye el final. Tan pronto como se construye, no se puede cambiar durante el alcance de la ejecución del método. Esto le permite corregir una variable en un método durante la duración del método. vea abajo:
public class FinalVariables {
public final static void main(final String[] args) {
System.out.println("Note how the key variable is changed.");
someMethod("JAVA_HOME");
someMethod("ANT_HOME");
}
}
Constantes finales
public double equation2Better(final double inputValue) {
final double K = 1.414;
final double X = 45.0;
double result = (((Math.pow(inputValue, 3.0d) * K) + X) * M);
double powInputValue = 0;
if (result > 360) {
powInputValue = X * Math.sin(result);
} else {
inputValue = K * Math.sin(result); // <= Compiler error
}
Estos son especialmente útiles cuando tiene líneas de códigos realmente largas, y generará un error del compilador para que no se encuentre con un error lógico / comercial cuando alguien cambia accidentalmente variables que no deberían cambiarse.
Colecciones finales
Caso diferente cuando hablamos de colecciones, debe establecerlas como no modificables.
public final static Set VALID_COLORS;
static {
Set temp = new HashSet( );
temp.add(Color.red);
temp.add(Color.orange);
temp.add(Color.yellow);
temp.add(Color.green);
temp.add(Color.blue);
temp.add(Color.decode("#4B0082")); // indigo
temp.add(Color.decode("#8A2BE2")); // violet
VALID_COLORS = Collections.unmodifiableSet(temp);
}
de lo contrario, si no lo configura como no modificable:
Set colors = Rainbow.VALID_COLORS;
colors.add(Color.black); // <= logic error but allowed by compiler
Las clases finales y los métodos finales no pueden ampliarse ni sobrescribirse, respectivamente.
EDITAR: PARA ABORDAR EL PROBLEMA DE CLASE FINAL SOBRE LA ENCAPSULACIÓN:
Hay dos formas de hacer una clase final. El primero es usar la palabra clave final en la declaración de clase:
public final class SomeClass {
// . . . Class contents
}
La segunda forma de hacer que una clase sea final es declarar a todos sus constructores como privados:
public class SomeClass {
public final static SOME_INSTANCE = new SomeClass(5);
private SomeClass(final int value) {
}
Marcarlo como final te ahorra el problema si descubres que es una final real, para demostrar que miras esta clase de Prueba. parece público a primera vista.
public class Test{
private Test(Class beanClass, Class stopClass, int flags)
throws Exception{
// . . . snip . . .
}
}
Desafortunadamente, dado que el único constructor de la clase es privado, es imposible extender esta clase. En el caso de la clase Test, no hay razón para que la clase sea final. La clase Test es un buen ejemplo de cómo las clases finales implícitas pueden causar problemas.
Por lo tanto, debe marcarlo como final cuando implícitamente haga una clase final haciendo que su constructor sea privado.