Ecco alcuni dei motivi per cui può essere benefitial di aver quasi tutto contrassegnati comefinal
finale Costanti
public static class CircleToolsBetter {
public final static double PI = 3.141;
public double getCircleArea(final double radius) {
return (Math.pow(radius, 2) * PI);
}
}
Questo può essere usato poi per altre parti dei vostri codici, o accessibile da altre classi, in questo modo se cambieresti il valore non dovresti cambiarlo uno per uno.
variabili finali
public static String someMethod(final String environmentKey) {
final String key = "env." + environmentKey;
System.out.println("Key is: " + key);
return (System.getProperty(key));
}
}
In questa classe, si costruiscono una variabile finale ambito che aggiunge un prefisso al parametro environmentKey. In questo caso, la variabile finale è valida solo nell'ambito di esecuzione, che è differente ad ogni esecuzione del metodo. Ogni volta che si inserisce il metodo, la finale viene ricostruita. Non appena viene creato, non può essere modificato durante l'esecuzione del metodo. Questo permette di fissare una variabile in un metodo per la durata del metodo. vedi sotto:
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");
}
}
finale Costanti
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
}
Questi sono particolarmente utili quando si hanno veramente lunghe linee di codici, e genererà errore del compilatore in modo da non correre per logica/errore di business quando qualcuno cambia accidentalmente variabili che non devono essere modificate.
Collezioni finali
caso diverso quando stiamo parlando Collezioni, è necessario impostare loro come un immodificabile.
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);
}
altrimenti, se non si imposta come immodificabile:
Set colors = Rainbow.VALID_COLORS;
colors.add(Color.black); // <= logic error but allowed by compiler
classi finali e metodi finali non può essere esteso o sovrascritti, rispettivamente.
EDIT: PER AFFRONTARE LA CLASSE PROBLEMA finale per quanto riguarda INCAPSULAMENTO:
Ci sono due modi per fare un finale di classe. Il primo è quello di utilizzare la parola chiave final nella dichiarazione della classe:
public final class SomeClass {
// . . . Class contents
}
Il secondo modo per fare una classe finale è di dichiarare tutti i suoi costruttori come privato:
public class SomeClass {
public final static SOME_INSTANCE = new SomeClass(5);
private SomeClass(final int value) {
}
marcatura finale puoi risparmiare il guaio se si scopre che è effettivamente una finale, per dare un'occhiata a questa classe di test. sembra pubblico a prima vista.
public class Test{
private Test(Class beanClass, Class stopClass, int flags)
throws Exception{
// . . . snip . . .
}
}
Sfortunatamente, poiché l'unico costruttore della classe è privato, è impossibile estendere questa classe. Nel caso della classe Test, non vi è alcun motivo per cui la classe debba essere definitiva. La classe Test è un buon esempio di come le classi finali implicite possono causare problemi.
Quindi è necessario contrassegnarlo come finale quando si effettua implicitamente un finale di classe rendendolo privato del costruttore.
Vedi http://stackoverflow.com/questions/137868/using-final-modifier-whenever-applicable-in-java –