Mot clé final en Java expliqué avec des exemples
Nous savons que Java a 48 mots-clés réservés, dont l'un est le mot-clé final. C'est un mot-clé Java qui peut être utilisé pour limiter l'utilisation des entités. Il peut être utilisé pour les classes, les méthodes et les variables. Pour diverses entités, le mot clé Java final est utilisé de plusieurs manières. Le mot-clé final a un objectif différent pour la classe, la variable et les méthodes.
Cet article discutera du mot-clé final en Java et explorera comment l'implémenter et l'utiliser avec différents paramètres.
En Java, quel est le mot clé final ?
Le dernier mot-clé en Java est un spécificateur de non-accès pour restreindre l'accès à une classe, une variable ou une fonction. Si nous utilisons le mot clé final pour initialiser une variable, nous ne pouvons pas modifier sa valeur. Lorsqu'une méthode est déclarée finale, elle ne peut être remplacée par aucune sous-classe. De plus, déclarer une classe final empêche les autres classes d'en hériter ou de l'étendre.
En d'autres termes, aucune autre classe ne peut hériter des classes finales.
C'était un aperçu rapide du mot-clé final de Java. Nous allons maintenant examiner l'utilisation du mot-clé final en Java avec des variables, des méthodes et des classes. Nous allons approfondir les points suivants :
- variable finale
- classe finale
- méthode finale
La variable finale en Java
Nous ne pouvons pas changer la valeur d'une variable une fois que nous l'avons déclarée en utilisant le mot-clé final. Nous aurons une erreur de compilation si nous essayons de changer la valeur de la dernière variable. Nous pouvons généralement considérer une variable finale comme une constante car ses valeurs ne peuvent pas être modifiées.
Et si nous déclarions les variables de référence finales au lieu des variables standard ? La dernière contrainte de la variable de référence est que nous ne pouvons pas changer "ce à quoi l'objet se réfère", mais nous pouvons changer l'objet lui-même. Il n'est pas possible de déclarer une variable final sans l'avoir d'abord initialisée. Lors de la déclaration d'une variable finale, nous devons lui donner une valeur initiale. Si elle est déclarée sans initialisation, la variable finale est une variable vierge finale. Cependant, l'initialisation d'une variable finale pendant ou après la déclaration est nécessaire. Nous aurons une erreur de compilation si nous la laissons non initialisée.
Syntaxe de définition d'une variable finale :
final int numVar = 35; //final variable final float value; //blank final variable static final double rate = 7.5; //final and static variable
Initialisation de la variable finale en Java
Étant donné qu'une variable finale ne peut pas être laissée non initialisée, les méthodes d'initialisation d'une variable finale sont les suivantes :
- La méthode la plus courante consiste à déclarer une variable finale puis à l'initialiser. Nous l'appelons une variable vide finale si vous ne l'initialisez pas lors de sa déclaration. Les deux méthodes suivantes sont utilisées pour créer une variable vide finale.
- Une variable vierge finale peut être initialisée soit dans un bloc d'initialisation d'instance, soit dans le constructeur de la classe. Si la classe contient de nombreux constructeurs, vous devez initialiser la variable finale dans chaque constructeur; sinon, une erreur se produira.
- Nous pouvons initialiser une variable statique finale vide dans un bloc statique.
Code pour illustrer la variable finale Java :
package com.codeunderscored.finalkeyword;
public class racingCode {
//declaring and initializing a final variable
final int speedlimit = 60;
void controlSpeed() {
//Trying to change the value of the final variable will give an error
speedlimit = 150;
}
public static void main(String args[]) {
Vehicle obj = new Vehicle();
obj.controlSpeed();
}
} Code pour illustrer la dernière variable vierge :
package com.codeunderscored.finalkeyword;
public class StudentInfo {
//Blank final variable
final int id;
//parameterized constructor
StudentInfo(int idNum) {
//Blank final variable must be initialized in constructor
id = idNum;
}
void getDetails() {
System.out.println("Id of the Employee is: " + id);
}
public static void main(String args[]) {
StudentInfo stdInfo = new StudentInfo(36);
stdInfo.getDetails();
}
} Code pour illustrer le fonctionnement de la variable de référence finale :
package com.codeunderscored.finalkeyword;
public class FinalRefVariable {
public static void main(String[] args) {
// declaring a final reference variable builder
final StringBuilder sb = new StringBuilder("Code");
System.out.println(sb);
// final reference variable constructor modifies the internal state of an object reference
builder.append("code");
System.out.println(sb);
}
} Quand est-il acceptable d'utiliser une variable finale Java ?
La seule différence entre une variable régulière et une variable finale est que nous pouvons modifier la valeur d'une variable standard après son affectation. Néanmoins, nous ne pouvons pas modifier la valeur de la variable finale après son affectation. Par conséquent, nous ne devons utiliser que les variables finales pour définir des valeurs qui resteront constantes pendant l'exécution du programme.
Méthode finale de Java
Nous avons parlé du mot-clé final et de la façon de déclarer la variable finale avant. En ajoutant le mot-clé Final avant le nom de la méthode, nous pouvons déclarer les méthodes Java en tant que méthodes finales. Les sous-classes ne peuvent pas remplacer la méthode à l'aide du mot-clé final. Le but de la méthode finale est de spécifier qu'un enfant ou une sous-classe qui l'étend ne peut pas modifier la définition de la méthode.
Code responsable de l'expression de la méthode finale en Java :
package com.codeunderscored.finalkeyword;
public class Parent {
final void final_method() {
//definition of the Final Method
}
}
public class Child extends Parent {
final void final_Method() // overriding the method from the parent class
{
// another definition of the final method
}
} La méthode finale crée une erreur de compilation dans l'exemple ci-dessus. Étant donné que la méthode Final de la classe Parent a été remplacée par la méthode Final de la classe Child, cela n'est pas possible dans le langage de programmation Java.
Objectif des méthodes finales en Java
L'objectif de la définition des méthodes finales est d'empêcher l'utilisation involontaire et incorrecte des définitions de méthode tout en remplaçant la méthode. Bien qu'elle ne soit pas théoriquement erronée, elle peut altérer le sens de l'approche, amenant le lecteur à la mal interpréter. Par conséquent, nous déclarons les méthodes comme finales dans de tels cas pour éviter les déclarations de méthodes inutiles.
Nous créons une classe Mammal et y ajoutons une fonction non finale appelée sound(). Si quelqu'un construit une classe humaine et remplace la méthode jump(), l'humain imprimera le saut incorrect, tel que galop. Cela entraînera une mauvaise utilisation de notre méthode; ainsi, pour éviter cela, nous utiliserons la méthode finale, comme indiqué dans le code ci-dessous. Pour comprendre le but de la méthode finale, utilisez le code suivant :
package com.codeunderscored.finalkeyword;
public class Mammal {
final void features() {
int legs = 4;
int ears = 2;
int eyes = 2;
int tail = 1;
System.out.println("The General Mammalia Characteristics are: ");
System.out.println("Legs: " + legs);
System.out.println("Eyes: " + eyes);
System.out.println("Ears: " + ears);
System.out.println("Tail: " + tail);
}
}
public class Human extends Mammal {
final void jump() {
System.out.println();
System.out.println("More humanly Characteristics:");
System.out.println("Jump: Hop Skip");
}
public static void main(String[] args) {
Human human = new Human();
human.characteristics();
human.jump ();
}
}
Classe finale de Java
En Java, on peut aussi déclarer une classe avec le mot clé final. Lorsqu'une classe est déclarée finale, elle empêche les autres classes d'en hériter ou de l'étendre. En d'autres termes, une classe finale Java ne peut pas être étendue par d'autres classes d'héritage. Si une autre classe essaie d'étendre la classe finale, il y aura un problème de compilation.
L'extrait de code pour la classe finale :
final class Codeunderscored {
// methods and variables of the class Tech
}
class coding extends Codeunderscored {
// COMPILE- TIME error as it extends final class
}
Pour comprendre la classe finale, utilisez le code suivant :
package com.codeunderscored.finalkeyword;
public class Coding extends Codeunderscored {
void test() {
System.out.println("My Method");
}
public static void main(String[] args {
Coding code = new Coding();
code.test();
}
}
final class Codeunderscored {
//code inside class
}
Exemple :Variable finale
class Car{
final int speedlimit=180;//final variable
void run(){
speedlimit=400;
}
public static void main(String args[]){
Car cr=new Car();
cr.run();
}
}//end of class
Exemple :méthode finale
class Car{
final void run(){System.out.println("running");}
}
class Benz extends Car{
void run(){System.out.println("safely running at100kmph");}
public static void main(String args[]){
Benz bz= new Benz();
bz.run();
}
} Exemple :Classe finale Java
final class Car{}
class Benz extends Car{
void run(){System.out.println("safely racing at 180kmph");}
public static void main(String args[]){
Benz bz= new Benz();
bz.run();
}
}
Conclusion
Nous avons conclu l'article sur le mot-clé final de Java. Nous avons découvert que le mot clé final en Java pouvait être utilisé avec des variables, des méthodes et des classes à diverses fins. Vous pouvez utiliser le mot clé final avec des variables, des classes et des méthodes pour restreindre certaines choses dans des circonstances exceptionnelles. Nous avons également examiné comment utiliser une norme et une variable de référence avec un mot-clé final.
De plus, nous avons appris comment empêcher une classe de surcharger une méthode. Une classe peut également être rendue finale, l'empêchant d'être étendue par d'autres classes. C'est tout ce qui concerne le mot-clé final de Java.
