Das JAVA-Schlüsselwort final wird zum Ändern von Daten, Methoden oder Klassen verwendet, was normalerweise „unveränderlich“ bedeutet, dh Daten können nicht geändert werden, Methoden können nicht überschrieben werden und Klassen können nicht vererbt werden. Im Allgemeinen gibt es zwei Gründe für die Verwendung von final: Design und Effizienz. Da die JAVA-Version aktualisiert wird, können einige Effizienzprobleme vom Compiler und der JVM gelöst werden. Daher ist die Verwendung von final zur Lösung von Effizienzproblemen nicht so wichtig.
Der Final-Modifikator wird hauptsächlich in den Feldern primitiver Datentypen oder unveränderlicher Klassen verwendet (wenn alle Methoden in der Klasse ihr Objekt nicht ändern, ist diese Klasse eine unveränderliche Klasse. String ist eine unveränderliche Klasse).
[endgültige Daten]
Es gibt zwei Hauptsituationen, in denen das Schlüsselwort Final zum Ändern von Daten verwendet wird:
1. Konstanten zur Kompilierungszeit
2. Zur Laufzeit initialisierte Werte
Bei Konstanten zur Kompilierungszeit bezieht es sich auf ein Feld, das sowohl endgültig als auch statisch ist (gemäß der Konvention werden Konstanten zur Kompilierungszeit ausschließlich mit Großbuchstaben benannt und jedes Wort wird durch einen Unterstrich getrennt. Es belegt nur einen Speicherplatz). kann nicht geändert werden. Der Compiler kann Konstanten zur Kompilierungszeit in jede Berechnungsformel ersetzen, die ihn verwenden kann. Das heißt, die Berechnungsformel kann zur Kompilierungszeit ausgeführt werden, was die Laufzeitbelastung relativ reduziert. Einer Kompilierzeitkonstante muss bei der Definition ein Wert zugewiesen werden (nicht unbedingt ein Basistyp).
Für zur Laufzeit initialisierte Werte macht final den Wert für Objektreferenzen unveränderlich, das heißt, er kann nicht geändert werden, um auf ein anderes Objekt zu verweisen. anwendbar auf Arrays, Arrays sind auch Objekte).
privater statischer finaler String TESTD = "test";
öffentlicher statischer finaler String TESTE = "test";
public static final String[] TESTF = {"1","2"}; //Nicht-Basistyp
private static final String[] TESTG = new String[2];
public static void main(String args[]){
final int testA = 1;
final String testB = "test";
final int[] testC = {1,1,2,};
System.out.println(testC[1]);
testC[1] = 123;
System.out.println(testC[1]);
}
}
JAVA ermöglicht die Generierung nicht zugewiesener Endfelder, das Endfeld muss jedoch bei der Definition des Felds oder in jedem Konstruktor (so viele Konstruktoren wie vorhanden) zugewiesen werden, um sicherzustellen, dass es vor der Verwendung initialisiert wird. Auf diese Weise kann final flexibler verwendet werden. In derselben Klasse können verschiedenen Objekten unterschiedliche Werte zugewiesen werden, während unveränderliche Eigenschaften erhalten bleiben.
public javaBlankFinal(){
leer = 2011;
}
public javaBlankFinal(int temp){
leer = 2012;
}
public javaBlankFinal(String temp){
leer = 2014;
}
public static void main(String args[]){
neues javaBlankFinal();
}
}
Es gibt zwei Gründe für die Verwendung der endgültigen Methode: Der eine besteht darin, die Methode zu sperren, um ein Überschreiben der Methode zu verhindern und sicherzustellen, dass das Methodenverhalten während der Vererbung unverändert bleibt. Der andere besteht darin, Methodenaufrufe in Inlining-Aufrufe umzuwandeln, um die Kosten der Methode zu senken Anrufe. In neueren Versionen kann sich die JVM jedoch selbst optimieren, sodass keine endgültigen Methoden zur Lösung von Effizienzproblemen erforderlich sind.
In Bezug auf die endgültige Methode ist noch etwas zu beachten: Alle privaten Methoden in der Klasse werden implizit als endgültige Methoden bezeichnet (Sie können ihnen auch endgültige Änderungen hinzufügen, dies ist jedoch bedeutungslos). Wenn Sie versuchen, eine private Methode zu überschreiben, meldet der Compiler keinen Fehler, aber tatsächlich überschreiben Sie die Methode nicht, sondern generieren lediglich eine neue Methode. Da externe Klassen nicht auf die private Methode zugreifen können, kann sie natürlich nicht überschrieben werden.
Die Verwendung der Annotation @Override kann die oben genannten Probleme verhindern. Wie im Programm gezeigt:
private final void finalFunctionB(){
System.out.println("finalFunctionB");
}
final void finalFunctionC(){
System.out.println("finalFunctionC");
}
void functionD(){}
}
Klasse overrideFinalFunction erweitert finalFunction{
//@Override Fügen Sie die Annotation @Override hinzu, um zu identifizieren, ob es sich um eine Überschreibung handelt
public void finalFunctionA(){
System.out.println("override finalFunctionA");
}
public final void finalFunctionB(){
System.out.println("finalFunctionB überschreiben");
}
//final void finalFunctionC(){} //Die final-Methode von finalFunction kann nicht überschrieben werden
@Override
void functionD(){} //Echte Override-Methode
}
öffentliche Klasse javaFinalFunction erweitert finalFunction{
public static void main(String args[]){
finalFunction ff = new finalFunction();
//ff.finalFunctionA(); //Private Methode kann nicht aufgerufen werden
//ff.finalFunctionB();
overrideFinalFunction off = new overrideFinalFunction();
off.finalFunctionA(); //öffentliche Methode
off.finalFunctionB();
}
}
Die Verwendung finaler Klassen erfolgt im Allgemeinen aus Designgründen, die eine Vererbung der Klasse nicht zulassen. Dies stellt sicher, dass sich das Verhalten der Klasse nicht ändert, und vermeidet möglicherweise auch einige Sicherheitsrisiken. Alle Methoden in der Final-Klasse werden implizit als Final-Methoden bezeichnet und können daher nicht überschrieben werden (da die Final-Klasse die Vererbung verbietet, können Methoden in ihrer Klasse nicht überschrieben werden). In der Java-Kern-API gibt es viele Beispiele für die Anwendung von final, z. B. java.lang.String. Geben Sie final für die String-Klasse an, um das Überschreiben von Methoden wie length() zu verhindern.
Bei endgültigen Feldern werden die Felder in der Klasse nicht automatisch zu endgültigen Feldern, selbst wenn eine Klasse als endgültig deklariert ist.
öffentliche Klasse javaFinalClass{
public static void main(String args[]){
finalClass fc = new finalClass();
System.out.println(fc.testA);
fc.testA = 2012;
System.out.println(fc.testA);
}
}