Einführung in Final Keyword in Java
In diesem Beitrag beschäftigen wir uns mit den verschiedenen Schlüsselwörtern für Java. Es ist ein Schlüsselwort, das in der Java-Sprache verwendet wird, um die Verwendung oder Änderung durch andere Klassen oder Variablen einzuschränken. Mit diesem Schlüsselwort wird der Interpreter angewiesen, zukünftige Änderungen an dieser Variablen oder Methode nicht zuzulassen und als konstant zu behandeln. Es kann mit unter 3 Szenarien verwendet werden: -
- Variable: Wenn Sie eine Variable als endgültig deklarieren, wird ihre Änderung so eingeschränkt, dass sie auf einen anderen Wert oder eine andere Referenz verweist.
- Methoden: Wenn Sie eine Methode als final deklarieren, wird das Überschreiben dieser Methode in den untergeordneten Klassen eingeschränkt.
- Klassen: Wenn Sie eine Klasse als final deklarieren, wird die Vererbung dieser Klasse verhindert.
Es wird immer empfohlen, diese Schlüsselwörter in Großbuchstaben zu deklarieren.
Syntax des letzten Schlüsselworts in Java
Dieses Schlüsselwort kann auf drei Arten verwendet werden: -
1. Variable
Variablen in Java können als Variable deklariert werden, um jede Änderung ihrer Werte einzuschränken. Es kann auf eine der folgenden drei Arten deklariert werden:
Syntax:
final int VAR1=21;//final variable
final int VAR2; //blank final variable
static final double DUMMY= 45.504;//final static variable
static final double PK;//blank final static variable
final String builder sb = neuer StringBuilder (“LetsLearn”);
2. Methoden
Die mit dem Schlüsselwort final deklarierte Methode wird als final bezeichnet. Die endgültige Methode kann nicht von ihrer untergeordneten Klasse überschrieben werden. Dies bedeutet, dass die untergeordnete Klassenmethode die Definition der endgültigen Methode in der übergeordneten Klasse nicht ändern kann. Wenn die Implementierung einer in der Elternklasse definierten Methode in allen Kindklassen befolgt werden soll, müssen wir diese Methode als final deklarieren.
Syntax:
final int my1()(
//method defination
)
3. Klassen
Final-Schlüsselwörter können auch mit Klassen verwendet werden, um sie zu einer Final-Klasse zu machen. Dies bedeutet, dass die bestimmte Klasse nicht durch andere Klassen erweitert oder vererbt werden kann.
Syntax:
final class myClass(
/member variables and member functions.
)
Wie funktioniert das endgültige Keyword in Java?
Das letzte Schlüsselwort hilft, das Überschreiben der Klassen, Member oder Variablen während der Vererbung einzuschränken.
1. Endgültige Variablen
Wenn Sie eine Variable als endgültig deklarieren, wird jede Änderung des Werts der Variablen in den geerbten Klassen eingeschränkt. Eine endgültige Variable kann nur einmal initialisiert werden und muss unverändert verwendet werden. Daher muss eine endgültige Variable initialisiert werden. Es wird meistens mit static verwendet, um eine konstante Klassenvariable zu erstellen.
Beispielsweise:
final int a =0;
Wir können Referenzvariablen auch als final deklarieren, auch in diesem Fall kann eine Referenzvariable nicht auf verschiedene Objekte verweisen. In Java kann jedoch der interne Zustand eines Objekts geändert werden, das von der endgültigen Referenzvariablen referenziert wird. Somit können wir den Wert der Referenzvariablen ändern. Dies entspricht der Verwendung von finalen Arrays wie folgt:
Code:
class MyClass
(
public static void main(String args())
(
final int myarr() = (1, 2, 3, 4, 5);
for (int q = 0; q < myarr.length; q++)
(
myarr (q) = myarr (q)*10;
System.out.println(myarr (q));
)
)
)
Ausgabe:
Erläuterung
Hier bezieht sich Array a1 auf dasselbe Objekt, nur der Wert dieses Objekts ändert sich, da wir alle wissen, dass die Variable des Arrays nur die Anfangsadresse des Speicherorts enthält, an dem diese Elemente des Arrays gespeichert sind.
Und im selben Fall wird vom Compiler ein Fehler ausgegeben, wenn wir versuchen, ein anderes Array mit der gleichen Arrayvariablen a1 zu referenzieren. Wenn Sie hier das word-final-Array verwenden, bedeutet dies, dass Änderungen am Mitglied des Arrays vorgenommen werden können, die Variable jedoch kein anderes Objekt referenzieren darf.
Dinge, an die man sich erinnern sollte
Die Initialisierung einer endgültigen Variablen ist erforderlich, um Kompilierungsfehler zu vermeiden. Es gibt einen Unterschied zwischen C ++ - Konstantenvariablen und diesen endgültigen Variablen, dass Konstantenvariablen nicht initialisiert werden müssen. Es gibt drei Möglichkeiten, eine endgültige Variable zu initialisieren:
- Initialisierung zum Zeitpunkt der Deklaration selbst : Wir können eine endgültige Variable zum Zeitpunkt der Deklaration leicht deklarieren. Falls es nicht initialisiert wird, wird diese Variable als leere Endvariable betrachtet, und eine der beiden folgenden Möglichkeiten kann uns dabei helfen, eine leere Endvariable zu initialisieren.
- Verwenden des Instanzinitialisierungsblocks : In diesem Block oder im Konstruktor kann eine leere endgültige Variable einfach initialisiert werden. Denken Sie bei der Initialisierung mit einem Konstruktor immer daran, die jeweilige Variable in allen verfügbaren Konstruktoren zu initialisieren.
- Statischer Block: Sie können auch einen statischen Block verwenden, um die leere endgültige Variable zu initialisieren. Der statische Block wird immer einmal für jede Klasse ausgelöst, sodass der Variablenwert, dessen Werte nicht geändert werden sollen, mit diesem Block einfach initialisiert werden kann.
Das Schlüsselwort final wird daher nur für die Variablen verwendet, deren Wert während der Ausführung des Programms nicht geändert werden muss. Alle endgültigen Variablen, die innerhalb einer Methode oder eines Blocks erstellt wurden, müssen dort selbst initialisiert werden. Solche Typvariablen werden als lokale Endvariablen bezeichnet.
Erläuterung
Im folgenden Beispiel wurde eine Variable i in der Hauptfunktion deklariert und initialisiert, sodass sie auch als letzte lokale Variable betrachtet wird.
Code:
class myClass
(
public static void main(String args())
(
// local final variable
final int i;
i = 20;
System.out.println(i);
)
)
Ausgabe:
2. Endgültige Methoden
Eine als final deklarierte Methode kann in keiner der Unterklassen überschrieben werden, wird also als final-Methode bezeichnet. Die Methode muss als final deklariert werden, wenn die untergeordneten Klassen auf dieselbe Implementierung der Klasse folgen sollen.
Hinweis: Es ist nicht erforderlich, dass endgültige Methoden in der Anfangsphase der Vererbung (Basisklasse) deklariert werden. Die Methode kann in jeder Unterklasse als final deklariert werden, wenn weitere Unterklassen derselben Definition folgen sollen.Code:
class A(
void myMethod()(
//method definition
)
)
class B extends A(
final void myMethod()(
//overrides the method in parent class
//runs successfully
)
)
class C extends B(
void myMethod()(
//will throw error
)
)
3. Abschlussklassen
Als final deklarierte Klassen können nicht von anderen Klassen geerbt werden. Das Erwähnen eines letzten Schlüsselworts vor dem Klassennamen teilt dem Compiler mit, dass die Definition dieser Klasse nur so verwendet werden kann, wie sie ist. Keine andere Klasse kann dieser Definition ihre Spezifikationen hinzufügen oder ihren Code wiederverwenden. Falls versucht wird, die letzte Klasse zu erweitern, wird vom Compiler ein Fehler ausgegeben, der darauf hinweist, dass diese Klasse nicht erweitert werden soll. Endgültige Schlüsselwörter in Java können für die folgenden zwei Zwecke verwendet werden:
- Die erste besteht darin, die Vererbung dieser Klasse zu verhindern. Zum Beispiel sind alle Wrapper-Klassen, die im java.lang-Paket enthalten sind, endgültige Klassen, daher können wir sie nicht in unseren Klassen erweitern, sondern können sie durch Deklaration ihrer Objekte verwenden. Jeder Versuch, auf diese Klassen zuzugreifen, führt zu einem Fehler des Compilers.
final class myParentClass
(
// member variables and member functions
)
// illegal extend.
class myChildClass extends parentClass
(
// Can't subclass A
)
- Die zweite Verwendung von final with classes ist, wenn eine unveränderliche Klasse erstellt werden muss, dh wenn das Objekt der Klasse erstellt wurde, können wir seinen Inhalt nicht wie die vordefinierte String-Klasse ändern. Die Klasse muss als final deklariert werden, um sie unveränderlich zu machen.
Hinweis :
- Wenn eine Klasse als final deklariert wird, werden ihre Membervariablen und Memberfunktionen vom Compiler ebenfalls als final betrachtet.
- Eine Klasse kann nicht als abstrakt deklariert werden, wenn ihre Definition von den untergeordneten Klassen abhängig ist. Sie kann auch als final deklariert werden, was die Vererbung selbst verhindert.
Beispiele für Final Keyword in Java
Nachfolgend finden Sie ein anderes Beispiel für ein endgültiges Schlüsselwort in Java:
1. Final Variable verwenden
Im folgenden Beispiel werden verschiedene Variablen mit verschiedenen Methoden initialisiert. Beispielsweise wird die Variable SECOND mit einem Konstruktor initialisiert, während THIRD mit einem Initialisierer initialisiert wird.
Code:
class myClass
(
final int FIRST = 5;
// a blank final variable
final int SECOND;
// another blank final variable
final int THIRD;
FIRST =10; //illegal attempt to change the value of final variable
// a final static variable PI
// direct initialize
static final double MINVALUE = 3.141592653589793;
// a blank final static variable
static final double MAXRANGE;
(
THIRD = 25; // initializer block
)
static(
MAXRANGE = 200.3;
)
public myClass()
(
SECOND = -1;//needs to be initialised in every constructor
)
)
Ausgabe:
2. Verwenden der endgültigen Methoden
In dem folgenden Beispiel deklariert die abstrakte Klasse myShape die final-Methoden getWidth und get8, die von den geerbten Klassen nicht überschrieben werden müssen. Es deklariert auch eine abstrakte Funktion, deren Implementierung in den nachfolgenden Klassen obligatorisch ist. Somit ist die einzige Definition einer abstrakten Funktion in einer ersten Kindklasse sowie einer zweiten Kindklasse implementiert.
Code:
abstract class myShape
(
private double width;
private double height;
public myShape(double width, double height)
(
this.width = width;
this.height = height;
)
public final double getWidth() //override not allowed
(
return width;
)
public final double getHeight() //override not allowed
(
return height;
)
abstract double getArea(); //needs to be defined in the child class
)
class firstChildClass extends myShape
(
public firstChildClass(double width, double height)
(
super(width, height);
)
final double getArea()
(
return this.getHeight() * this.getWidth();
)
)
class secondChildClass extends myShape
(
public secondChildClass(double side)
(
super(side, side);
)
final double getArea()
(
return this.getHeight() * this.getWidth();
)
)
public class myClass
(
public static void main(String() args)
(
myShape s1 = new firstChildClass(10, 20);
myShape s2 = new secondChildClass(10);
System.out.println("width of s1 : "+ s1.getWidth());
System.out.println("height of s1 : "+ s1.getHeight());
System.out.println("width of s2 : "+ s2.getWidth());
System.out.println("height of s2 : "+ s2.getHeight());
System.out.println("area of s1 : "+ s1.getArea());
System.out.println("area of s2 : "+ s2.getArea());
)
)
Ausgabe:
3. Final Classes verwenden
Im folgenden Programm verwenden wir eine endgültige Klasse Solid, die eine Methode zum Berechnen des Volumens einer Form anhand ihrer Abmessungen definiert. Die Anzeige des Volumens einer Box erfolgt jedoch mithilfe der printVol-Funktion in der geerbten Klasse. Shape Da Solid eine letzte Klasse ist, darf die Klasse Shape sie nicht erweitern (oder erben). Daher wird das Objekt von Shape verwendet, um das Volumen von Shape zu berechnen, indem nur die Argumente an die Funktionen übergeben werden.
Code:
final class Solid (
public double getVol(double length, double width, double height) (
return length * width * height;
)
)
class Shape (
private float length;
private float width;
private float height;
Shape(float length, float width, float height) (
this.length = length;
this.width = width;
this.height = height;
)
public void printVol(Solid bObj) (
double volume = bObj.getVol(this.length, this.width, this.height);
System.out.println("Volume of the Shape: " + volume);
)
)
public class myClass (
public static void main(String() args) (
Solid bObj = new Solid();
Shape obj = new Shape(5, 4, 3);
obj.printVol(bObj);
)
)
Ausgabe:
Fazit
Das letzte Schlüsselwort verhindert, dass Klassen, Variablen und Methoden von den untergeordneten Klassen überschrieben werden. Es kann auch verwendet werden, um Klassen unveränderlich zu machen, wodurch die Änderung des Werts ihrer Objekte eingeschränkt wird. Die endgültige Schlüsselwortprüfung wird immer nur zur Kompilierungszeit überprüft. Es ist ein großartiges Dienstprogramm, um die Wiederverwendung der definierten Variablen, Logik und Klassen zu verhindern.
Empfohlene Artikel
Dies ist eine Anleitung zum Beispiel für Final Keyword in Java. Hier diskutieren wir, wie das letzte Schlüsselwort in Java funktioniert? Dazu gehören endgültige Variablen, endgültige Methoden, endgültige Klassen sowie die Syntax. Sie können sich auch die folgenden Artikel ansehen, um mehr zu erfahren -
- Typen und Modifikatoren, die für JComponent in Java verwendet werden
- Neue Funktionen von Java 8
- Wie erstelle ich ein Objekt in JavaScript?
- Was ist Case Statement in JavaScript?
- Werfen vs wirft | Die 5 wichtigsten Unterschiede, die Sie kennen sollten
- Deklarieren einer abstrakten Klasse in C # mit Beispiel
- Verwendet und Beispiele für dieses Schlüsselwort