Ci sono molti usi per la variabile final . Qui ci sono solo alcuni
Costanti finali
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 quindi per altre parti dei tuoi codici, o accessibile da altre classi, in questo modo se dovessi cambiare il valore non dovresti cambiarli 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 crea una variabile finale con ambito che aggiunge un prefisso al parametro environmentKey. In questo caso, la variabile finale è finale solo nell'ambito di esecuzione, che è diversa ad ogni esecuzione del metodo. Ogni volta che si inserisce il metodo, il finale viene ricostruito. Non appena viene costruito, non può essere modificato durante l'ambito dell'esecuzione del metodo. Ciò consente di correggere 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");
}
}
Costanti finali
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 righe di codice molto lunghe e generano errori del compilatore in modo da non incorrere in errori di logica / business quando qualcuno modifica accidentalmente variabili che non dovrebbero essere modificate.
Collezioni finali
Caso diverso quando parliamo di Collezioni, è necessario impostarle come non modificabili.
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);
}
in caso contrario, se non lo si imposta come non modificabile:
Set colors = Rainbow.VALID_COLORS;
colors.add(Color.black); // <= logic error but allowed by compiler
Le classi finali e i metodi finali non possono essere estesi o sovrascritti rispettivamente.
MODIFICA: PER INDIRIZZARE IL PROBLEMA DELLA CLASSE FINALE PER QUANTO RIGUARDA L'ECCAPSULAZIONE:
Esistono due modi per rendere finale una classe. Il primo è utilizzare la parola chiave final nella dichiarazione di classe:
public final class SomeClass {
// . . . Class contents
}
Il secondo modo per rendere definitiva una classe è dichiarare privati tutti i suoi costruttori:
public class SomeClass {
public final static SOME_INSTANCE = new SomeClass(5);
private SomeClass(final int value) {
}
Contrassegnarlo come finale ti risparmia il problema se scopri che si tratta di un finale, per dimostrare 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 estenderla. 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 possano causare problemi.
Quindi dovresti segnarlo come finale quando rendi implicitamente una classe finale rendendola privata come costruttore.