Introduction au mot-clé final en Java
Dans cet article, nous allons examiner les différents mots clés finaux pour java. Il s'agit d'un mot clé utilisé en langage java pour appliquer des restrictions sur son utilisation ou sa modification par d'autres classes ou variables. En utilisant ce mot-clé, on dit à l'interpréteur de ne permettre aucune modification future de cette variable ou méthode et de la traiter comme constante. Il peut être utilisé avec moins de 3 scénarios: -
- Variable: déclarer une variable comme finale limite sa modification à toute autre valeur ou référence.
- Méthodes: la déclaration d'une méthode comme finale limite la substitution de méthode à cette méthode dans les classes enfants.
- Classes: déclarer une classe comme finale empêche l'héritage de cette classe.
Il est toujours recommandé de déclarer ces mots clés en majuscules conformément aux bonnes pratiques de codage.
Syntaxe du mot-clé final en Java
Ce mot-clé peut être utilisé de 3 façons: -
1. Variable
Les variables en java peuvent être déclarées comme variables pour restreindre toute modification de ses valeurs. Il peut être déclaré de l'une des trois manières suivantes:
Syntaxe:
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 = new StringBuilder («LetsLearn»);
2. Méthodes
La méthode déclarée avec le mot clé final serait la méthode finale. La méthode finale ne peut pas être remplacée par sa classe enfant, ce qui signifie que la méthode de classe enfant ne peut pas modifier la définition de la méthode finale présente dans la classe parent. Lorsque nous voulons que l'implémentation d'une méthode définie dans la classe parent soit suivie dans toutes ses classes enfants, nous devons déclarer cette méthode comme définitive.
Syntaxe:
final int my1()(
//method defination
)
3. Classes
Les mots-clés finaux peuvent également être utilisés avec des classes pour en faire une classe finale qui signifie que la classe particulière ne peut pas être étendue ou héritée par d'autres classes.
Syntaxe:
final class myClass(
/member variables and member functions.
)
Comment fonctionne le mot clé final en Java?
Le mot-clé final permet de restreindre le remplacement des classes, membres ou variables lors de l'héritage.
1. Variables finales
Déclarer une variable comme finale signifie restreindre toute altération de la valeur de la variable dans les classes héritées. Une variable finale ne peut être initialisée qu'une seule fois et doit être utilisée telle quelle, il faut donc initialiser une variable finale. Il est principalement utilisé avec static pour créer une variable de classe constante.
Par exemple:
final int a =0;
Nous pouvons également déclarer des variables de référence finales également, dans ce cas, une variable de référence ne peut pas faire référence à des objets différents. Mais en java, l'état interne d'un objet peut être modifié par la variable de référence finale. Ainsi, nous pouvons modifier la valeur de la variable de référence. Cela revient à utiliser les tableaux finaux comme indiqué ci-dessous: -
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));
)
)
)
Production:
Explication
Ici, le tableau a1 fait référence au même objet, seule la valeur de cet objet change, car nous savons tous que la variable du tableau contient uniquement l'adresse de début de l'emplacement de mémoire où ces éléments du tableau sont stockés.
Et de la même manière, si nous essayons de référencer un tableau différent en utilisant la même variable de tableau a1, une erreur sera générée par le compilateur. Ainsi, en utilisant le mot-tableau final signifie ici que toute modification peut être apportée au membre du tableau mais la variable n'est pas autorisée à référencer un autre objet.
Choses dont il faut se rappeler
L'initialisation d'une variable finale est nécessaire pour éviter les erreurs de compilation. Il existe une différence entre les variables const C ++ et ces variables finales qui n'ont pas besoin d'être initialisées. Il existe trois façons d'initialiser une variable finale:
- Initialiser au moment de la déclaration elle - même : Nous pouvons facilement déclarer une variable finale au moment de la déclarer. Dans le cas où elle n'est pas initialisée, cette variable est considérée comme une variable finale vide, et l'une des 2 façons suivantes peut nous aider à initialiser une variable finale vide.
- Utilisation du bloc d'initialisation d'instance : à l'intérieur de ce bloc ou du constructeur, une variable finale vide peut être facilement initialisée. Lorsque vous utilisez un constructeur pour initialiser, n'oubliez pas d'initialiser la variable particulière dans tous les constructeurs disponibles.
- Bloc statique: on peut également utiliser un bloc statique pour initialiser la variable finale vide. Le bloc statique est toujours déclenché une fois pour chaque classe, ainsi la valeur variable dont les valeurs ne sont pas censées être modifiées peut facilement être initialisée à l'aide de ce bloc.
Ainsi, le mot-clé final est utilisé pour les seules variables qui n'ont pas besoin de changer leur valeur pendant l'exécution du programme. Toutes les variables finales créées à l'intérieur d'une méthode ou d'un bloc doivent y être initialisées. Ces variables de type sont appelées variables finales locales.
Explication
Dans l'exemple ci-dessous, une variable i a été déclarée dans la fonction principale et initialisée est donc également considérée comme une variable locale finale.
Code:
class myClass
(
public static void main(String args())
(
// local final variable
final int i;
i = 20;
System.out.println(i);
)
)
Production:
2. Méthodes finales
Une méthode déclarée comme finale ne peut être remplacée dans aucune des sous-classes, ainsi appelée comme méthode finale. La méthode doit être déclarée comme finale si nous exigeons que la même implémentation de la classe soit suivie par les classes enfants.
Remarque - Il n'est pas nécessaire que les méthodes finales soient déclarées au stade initial de l'héritage (classe de base). La méthode peut être déclarée finale dans n'importe quelle sous-classe pour laquelle d'autres sous-classes doivent suivre la même définition.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. Classes finales
Les classes déclarées comme finales ne peuvent être héritées par aucune autre classe. La mention d'un mot clé final avant le nom de la classe indique au compilateur que la définition de cette classe ne peut être utilisée que telle quelle. Aucune autre classe ne peut ajouter ses spécifications à cette définition ou réutiliser son code. Dans le cas où l'on tente d'étendre la classe finale, une erreur est générée par le compilateur indiquant que cette classe n'est pas destinée à être étendue. On peut utiliser des mots clés finaux en java dans n'importe quel but en dessous de 2: -
- La première consiste à empêcher l'héritage de cette classe. Par exemple, toutes les classes Wrapper présentes dans le paquet java.lang sont des classes finales, nous ne pouvons donc pas les étendre dans nos classes mais nous pouvons les utiliser en déclarant leurs objets. Toute tentative d'accès à ces classes entraînera une erreur du compilateur.
final class myParentClass
(
// member variables and member functions
)
// illegal extend.
class myChildClass extends parentClass
(
// Can't subclass A
)
- La deuxième utilisation de final avec des classes est quand on a besoin de créer une classe immuable, c'est-à-dire qu'une fois l'objet de la classe créé, nous ne pouvons pas changer son contenu comme la classe String prédéfinie. La classe doit être déclarée finale pour la rendre immuable.
Remarque :
- Si une classe est déclarée finale, ses variables membres et fonctions membres sont également considérées comme finales par le compilateur.
- Une classe ne peut pas être déclarée abstraite lorsqu'elle dépend des classes enfants pour compléter sa définition ainsi que finale, ce qui empêche l'héritage lui-même.
Exemples de mots clés finaux en Java
Voici les différents exemples de mots clés finaux en Java:
1. Utilisation de la variable finale
Dans l'exemple ci-dessous, différentes variables sont initialisées à l'aide de différentes méthodes. Par exemple, la variable SECOND est initialisée à l'aide du constructeur tandis que THIRD est initialisée à l'aide d'un initialiseur.
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
)
)
Production:
2. Utilisation des méthodes finales
Dans l'exemple ci-dessous, la classe abstraite myShape déclare les méthodes finales getWidth et en obtient huit qui n'ont pas besoin d'être remplacées par les classes héritées. Il déclare également une fonction abstraite dont l'implémentation est obligatoire dans les classes suivantes. Ainsi, la seule définition d'une fonction abstraite est implémentée dans une première classe enfant ainsi que dans une deuxième classe enfant.
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());
)
)
Production:
3. Utilisation des classes finales
Dans le programme ci-dessous, nous utilisons une classe finale Solid qui définit une méthode pour calculer le volume d'une forme en utilisant ses dimensions, mais l'affichage du volume d'une boîte se fait en utilisant la fonction printVol dans la classe héritée. Shape As Solid est une classe finale, donc la classe Shape ne sera pas autorisée à l'étendre (ou à l'hériter). Ainsi, il utilise l'objet Shape pour calculer le volume de n'importe quelle forme en passant simplement les arguments aux fonctions.
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);
)
)
Production:
Conclusion
Le mot clé final est utilisé pour empêcher les classes, variables et méthodes d'être écrasées par ses classes enfants. Il peut également être utilisé pour rendre les classes immuables, ce qui limite la modification de la valeur de ses objets. La vérification finale des mots clés est toujours vérifiée au moment de la compilation uniquement. C'est un excellent utilitaire pour empêcher la réutilisation des variables, de la logique et des classes définies.
Articles recommandés
Ceci est un guide d'exemple de mot-clé final en Java. Ici, nous discutons du fonctionnement du mot-clé final en java? qui comprend les variables finales, les méthodes finales, les classes finales ainsi que la syntaxe. Vous pouvez également consulter les articles suivants pour en savoir plus -
- Types et modificateurs utilisés pour JComponent en Java
- Nouvelles fonctionnalités de Java 8
- Comment créer un objet en JavaScript?
- Qu'est-ce que la déclaration de cas en JavaScript?
- Lancer vs lancer | Les 5 principales différences que vous devez savoir
- Déclaration d'une classe abstraite en C # avec un exemple
- Utilisations et exemples de ce mot-clé