Endgültiges Schlüsselwort in Java

In diesem Beitrag werden wir uns die verschiedenen finalen Schlüsselwörter für Java ansehen. Es handelt sich um 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 weist man den Interpreter an, keine zukünftigen Änderungen an dieser Variablen oder Methode zuzulassen und sie als Konstante zu behandeln. Es kann mit den folgenden 3 Szenarien verwendet werden:-

WERBUNG Beliebter Kurs in dieser Kategorie FINANZMODELLIERUNG & BEWERTUNG – Spezialisierung | 51 Kursreihe | 30 Probetests

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

1. Variable: Durch die Deklaration einer Variablen als final wird ihre Änderung auf einen Verweis auf einen anderen Wert oder eine andere Referenz beschränkt.
2. Methoden: Durch die Deklaration einer Methode als endgültig wird das Überschreiben dieser Methode in den untergeordneten Klassen eingeschränkt.
3. Klassen: Durch die Deklaration einer Klasse als final wird die Vererbung dieser Klasse verhindert.

Gemäß guten Codierungspraktiken wird empfohlen, diese Schlüsselwörter immer in Großbuchstaben zu deklarieren.

Syntax des endgültigen Schlüsselworts in Java

Dieses Schlüsselwort kann auf die folgenden drei Arten verwendet werden:-

1. Variable

Variablen in Java können als Variablen deklariert werden, um jegliche Ä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

Hinweis-  Referenzvariablen können auch als statisch deklariert werden, sodass sie keinen Verweis auf ein anderes Objekt enthalten können. Aufgrund der internen Natur des Objekts kann die Referenz jedoch geändert werden.

final String builder sb= new StringBuilder(“LetsLearn”);

2. Methoden

Die mit dem Schlüsselwort final deklarierte Methode wird als finale Methode bezeichnet. Die endgültige Methode kann nicht von ihrer untergeordneten Klasse überschrieben werden, was bedeutet, dass die Methode der untergeordneten Klasse die Definition der in der übergeordneten Klasse vorhandenen endgültigen Methode nicht ändern kann. Wenn wir möchten, dass die Implementierung einer in der übergeordneten Klasse definierten Methode in allen untergeordneten Klassen befolgt werden muss, müssen wir diese Methode als endgültig deklarieren.

Syntax:

final int my1(){
//method defination
}

3. Klassen

Finale Schlüsselwörter können auch mit Klassen verwendet werden, um sie zu einer finalen Klasse zu machen, was bedeutet, dass die jeweilige Klasse nicht von anderen Klassen erweitert oder geerbt werden kann.

Syntax:

final class myClass{
/member variables and member functions.
}

Wie funktioniert das endgültige Schlüsselwort in Java?

Das letzte Schlüsselwort hilft, das Überschreiben der Klassen, Mitglieder oder Variablen während der Vererbung einzuschränken.

1. Endgültige Variablen

Eine Variable als endgültig zu deklarieren bedeutet, jegliche Änderung des Werts der Variablen in den geerbten Klassen einzuschränken. Eine endgültige Variable kann nur einmal initialisiert werden und muss so verwendet werden, wie sie ist. daher muss man eine letzte Variable initialisieren. Es wird hauptsächlich mit Static verwendet, um eine konstante Klassenvariable zu erstellen.

Zum Beispiel:

final int a =0;

Wir können Referenzvariablen auch als final deklarieren; In diesem Fall kann eine Referenzvariable nicht auf verschiedene Objekte verweisen. Aber in Java kann der interne Zustand eines Objekts geändert werden; darauf bezieht sich die letzte Referenzvariable. Somit können wir Änderungen am Wert der Referenzvariablen vornehmen. Dies ist dasselbe wie die Verwendung von endgültigen Arrays, wie unten gezeigt:-

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:

Erklärung

Hier bezieht sich Array a1 auf dasselbe Objekt; Nur der Wert dieses Objekts ändert sich, da wir alle wissen, dass die Array-Variable nur die Startadresse des Speicherorts enthält, an dem diese Elemente des Arrays gespeichert sind.

Und wenn wir gleichzeitig versuchen, mit derselben Array-Variablen a1 auf ein anderes Array zu verweisen, gibt der Compiler einen Fehler aus. Die Verwendung des Wort-End-Arrays hier bedeutet also, dass jede Änderung am Array-Mitglied vorgenommen werden kann, die Variable jedoch nicht auf ein anderes Objekt verweisen darf.

Dinge, die man sich merken sollte

Das Initialisieren einer endgültigen Variablen ist notwendig, um Fehler bei der Kompilierung zu verhindern. Es gibt einen Unterschied zwischen C++-Const-Variablen und diesen finalen Variablen, da Const-Variablen nicht initialisiert werden müssen. Es gibt drei Möglichkeiten, eine endgültige Variable zu initialisieren:

• Initialize at the time of declaration itself: We can easily declare a final variable at the time of declaring it. In case it is not initialized, then that variable is considered a blank final variable, and either of the next 2 ways can help us initialize a blank final variable.
• Using instance-initializer block: Inside this block or the constructor, a blank final variable can be easily initialized. While using a constructor to initialize, always remember to initialize the particular variable in all the available constructors.
• Static Block: One can also use a static block to initialize the blank final variable. Static block is always triggered once for each class; thus, the variable value whose values are not meant to be altered can easily be initialized using this block.

Thus, the final keyword is used for those variables that need not change their value during the program’s execution. All the final variables created inside a method or block must be initialized there itself. Such type of variables is known as local final variables.

Explanation

In the below example, a variable I has been declared within the main function and initialised is considered a final local variable.

Code:

class myClass
{
public static void main(String args[])
{
// local final variable
final int i;
i = 20;
System.out.println(i);
}
}

Output:

2. Final Methods

A method declared as final can not be overridden in any of the subclasses, thus called a final method. The method needs to be declared as final if we require that the child classes follow the class’s same implementation.

Note- Final methods don’t need to be declared in the initial stage of inheritance(base class ). The method can be declared final in any subclass that we want further subclasses to follow the same definition.

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. Final Classes

Classes declared as final can not be inherited by any other classes. Mentioning a  final keyword before the class name tells the compiler that this class’s definition can only be used as they are. No other classes can add their specifications to this definition or reuse its code. If one attempts to extend the final class, an error is thrown by the compiler indicating that this class is not meant to be extended. One can use final keywords in java in any for below 2 purposes:-

1. The first is to prevent the inheritance of that class. E.g., all the Wrapper classes present java.lang package is final classes; therefore, we cannot extend them in our classes but can use it by declaring their objects. Any attempt to access those classes will result in an error by the compiler.

final class myParentClass
{
// member variables and member functions
}
// illegal extend.
class myChildClass extends parentClass
{
// <--COMPILE-ERROR—> Can't subclass A
}

2. The second use of final with classes is when one needs to create an immutable class, i.e. once the class’s object is created, we cannot change its content like the predefined String class. The class must be declared as final to make it immutable.

Note-

• If a class is declared as final, then its member variables and member functions are also considered final by the compiler.
• A class cannot be declared abstract where it depends on the child classes to complete its definition and final, which prevents the inheritance itself.

Examples of Final Keywords in Java

Below is the Different Example of Final Keyword in Java are:

1. Using Final Variable

In the below example, different variables are initialized using various methods. For example- the SECOND variable is initialized using a constructor, whereas THIRD is initialized using an initializer.

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
}
}

Output:

2. Using Final Methods

In the below example, abstract class myShape declares final methods getWidth and get eight those need not be overridden by the inherited classes. It also declares one abstract function whose implementation is mandatory in the subsequent classes. Thus the only the definition of an abstract function is implemented in a first child class and a second child class.

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());
}
}

Output:

3. Using Final Classes

In the below program, we are using a final class Solid that defines a method to calculate the volume of a shape using its dimensions, but displaying the volume of a box is done using the inherited class’s printVol function. Shape As Solid is a final class; thus, class Shape will not be allowed to extend(or inherit) it. Thus, it uses Shape’s object to calculate the volume of any of Shape by just passing the arguments to the functions.

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);
}
}

Output: 

Conclusion

The final keyword is used to prevent the classes, variables, and methods to be overridden by its child classes. It can also be used to make classes immutable that is restricting the change in the value of their objects. The final keyword check is always checked at the compile time only. It is a great utility to prevent the reuse of the defined variables, logic, and classes.

Das obige ist der detaillierte Inhalt vonEndgültiges Schlüsselwort in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!