Estas son algunas razones por las que puede ser beneficiosa a haber casi todo etiquetado comofinal
final Constantes
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 ser usado luego para otras partes de sus códigos, o accedido por otras clases, de esa manera si alguna vez cambiaras el valor, no tendrías 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, se construye una última variable con ámbito que añade un prefijo al environmentKey parámetro. En este caso, la variable final es final solo dentro del alcance de la 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 por la duración del método. ver más 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 se tiene muy largas líneas de código, y se generarán error del compilador de modo que no se quede en la lógica/error de negocio cuando alguien accidentalmente cambia variables que no deberían cambiarse.
Colecciones finales
Diferentes casos cuando estamos hablando acerca de las colecciones, que tiene necesidad de hacerlo como un inmodificable.
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 se establece como inmodificable:
Set colors = Rainbow.VALID_COLORS;
colors.add(Color.black); // <= logic error but allowed by compiler
clases finales y métodos finales no puede ser extendida o sobrescrito, respectivamente.
EDIT: Para abordar el problema de la clase final con respecto a ENCAPSULACIÓN:
Hay dos maneras de hacer una última clase. La primera es utilizar la última palabra clave en la declaración de clase:
public final class SomeClass {
// . . . Class contents
}
La segunda manera de hacer una clase final es declarar la totalidad de sus constructores como privada:
public class SomeClass {
public final static SOME_INSTANCE = new SomeClass(5);
private SomeClass(final int value) {
}
Marcándola final que ahorra el problema si descubre que es real una final, para demostrar que mira esta clase de Prueba. se ve público a primera vista.
public class Test{
private Test(Class beanClass, Class stopClass, int flags)
throws Exception{
// . . . snip . . .
}
}
Por desgracia, ya que el único constructor de la clase es privada, es imposible extender esta clase. En el caso de la clase de prueba, no hay ninguna razón para que la clase sea final. La clase de prueba es un buen ejemplo de cómo las clases finales implícitas pueden causar problemas.
Por lo tanto, debe marcarlo como definitivo cuando implícitamente haga una clase final haciendo que su constructor sea privado.
Ver http://stackoverflow.com/questions/137868/using-final-modifier-whenever-applicable-in-java –