Le rôle de l'utilisation de la finale pour modifier les paramètres dans Java
L'ajout du mot-clé final avant les paramètres de la méthode est d'empêcher que les données soient modifiées dans le poids de la méthode.
Il existe deux situations principales: premièrement, utilisez Final pour modifier le type de données de base; Deuxièmement, utilisez Final pour modifier le type de données de référence.
Dans le premier cas, modifiez le type de données de base, date à laquelle la valeur du paramètre ne peut pas être modifiée dans le corps de la méthode, c'est-à-dire qu'elle ne peut pas être réaffectée. Sinon, la compilation ne sera pas adoptée.
Le deuxième cas consiste à modifier le type de référence. À l'heure actuelle, l'objet référencé par la variable de paramètre ne peut pas être modifié. Cependant, pour les types de données de référence, il est parfaitement acceptable de modifier leurs propriétés.
Par conséquent, si vous souhaitez utiliser le mot-clé final, utilisez le type de données de base, ce qui est très utile.
Variable finale:
Utilisez Final pour les types de base: c'est une constante, la valeur est constante et la valeur reste inchangée.
Utilisez Final pour les références d'objet: rendez la référence constante et une fois la référence initialisée pour pointer vers un objet, il ne peut pas être modifié pour pointer vers un autre objet. Cependant, l'objet lui-même peut être modifié et Java ne fournit pas de moyen de rendre un objet constant. Cette limitation utilise également des tableaux, qui sont des objets.
exemple:
classe de classe {int i; Valeur publique (int i) {this.i = i; }} classe publique FinalData {private static aléal random = new random (47); ID de chaîne privée; public finalData (String id) {this.id = id; } private final int ValueOne = 9; private static final int value_two = 99; public static final int value_three = 39; Final privé int i4 = random.nextint (20); statique final int int_5 = random.nextint (20); valeur privée v1 = nouvelle valeur (11); valeur finale privée v2 = nouvelle valeur (22); valeur finale statique privée val_3 = nouvelle valeur (33); Final privé int [] a = {1, 2, 3, 4, 5, 6}; public String toString () {return id + ":" + "i4 =" + i4 + ", int_5 =" + int_5; } public static void main (String [] args) {finalData fd1 = new FinalData ("fd1"); //! fd1.valueOne ++; // Parce que ValueOne est une constante de type de base, sa valeur est constante fd1.v2.i ++; // Le contenu de l'objet modifié par final peut être modifié fd1.v1 = nouvelle valeur (9); pour (int i = 0; i <fd1.a.length; i ++) fd1.a [i] ++; //! fd1.v2 = nouvelle valeur (0); // Parce que V2 est un type de référence modifié par final, sa référence ne peut pas être modifiée pour pointer vers un autre objet //! fd1.val_3 = nouvelle valeur (1); // Il occupe un espace mémoire qui ne peut pas être modifié //! fd1.a = new int [3]; // Array modifié final System.out.println (FD1); System.out.println ("Création de nouveaux FinalData"); FinalData fd2 = new FinalData ("FD2"); System.out.println (FD1); System.out.println (FD2); }} / * sortie: fd1: i4 = 15, int_5 = 18creting new FinalDatafd1: i4 = 15, int_5 = 18fd2: i4 = 13, int_5 = 18 * /analyser:
Pour FD1, FD2 deux objets, I4 est unique, c'est-à-dire que chaque objet a un i4, mais Int_5 est déclaré statique, c'est-à-dire qu'il est partagé par la classe, FD1 et FD2 partagent Int_5, qui est initialisé au moment du chargement, plutôt que d'initialiser chaque fois qu'un nouvel objet est créé (par exemple, i4); Mais il est défini en même temps, donc sa référence est immuable, c'est-à-dire qu'elle ne peut pas être modifiée pour pointer un autre objet.
Finale vierge:
est déclaré définitif mais n'a aucune valeur initiale donnée. Final doit être attribué à l'aide d'expressions dans la définition du domaine ou dans chaque constructeur, c'est pourquoi le domaine final est toujours initialisé avant utilisation.
Paramètres finaux:
Cela signifie que vous ne pouvez pas modifier la référence du paramètre dans la méthode pour pointer vers un autre paramètre, mais vous pouvez modifier ce que l'objet final pointe vers
exemple:
classe Gizmo {int i = 0; public void spin () {}} classe publique finalArguments {void avec (final gizmo g) {//! g = new gizmo (); // La référence modifiée par final n'est pas modifiée pour pointer vers un autre objet g.i ++; // mais le contenu pointé par l'objet final peut être modifié} void sans (gizmo g) {g = new gizmo (); g.spin (); } // int g (final int i) {// //! i ++; // Parce que le paramètre I est une valeur constante //} int g (final int i) {return i + 1; } public static void main (String [] args) {finalArguments bf = new FinalArguments (); bf.with (null); bf.with (null); }}analyser:
Le paramètre est déclaré final. S'il s'agit d'un paramètre de base, il est constant et ne peut pas être modifié; S'il s'agit d'une variable de référence, il ne peut pas être modifié pour pointer vers un autre objet, mais le contenu de l'objet mentionné par la référence peut être modifié.
Fianl Méthode:
Raison d'utilisation:
Toutes les méthodes privées de la classe sont implicitement spécifiées comme finales, et comme la méthode privée ne peut pas être utilisée, elle ne peut pas être écrasée. Un modificateur final peut être ajouté à la méthode privée, mais cela ne donne aucun sens supplémentaire à la méthode.
exemple:
classe avec final {private final void f () {System.out.println ("avec finals.f ()"); } private void g () {System.out.println ("OverridingPrivate.f ()"); }} classe OverridingPrivate s'étend avec les finales {private final void f () {System.out.println ("OverridridPrivate.f ()"); }} classe OverridridPrivate2 étend la mise en œuvre de l'approvisionnement {/ * * Lorsque vous utilisez l'annotation de remplacement pour forcer la méthode f () à écraser la méthode f () de la classe parent, une erreur sera signalée * car elle ne sait pas si la classe parent a la méthode. Pour la méthode g (), il génère simplement une nouvelle méthode et * ne remplace pas la méthode g () dans la classe parent. * / // @ Override public final void f () {System.out.println ("OverridingPrivate2.f ()"); } public void g () {System.out.println ("OverridingPrivate2.g ()"); }} classe publique FinaloverridingIllusion {public static void main (String [] args) {overridingPrivate2 op2 = new overridingprivate2 (); op2.f (); op2.g (); // Vous pouvez transformer vers le haut vers le haut, OP = OP2; //! op.f (); // La méthode finale de la classe parent est invisible pour la sous-classe //! op.g (); Avec les finales wf = op2; // wf.f (); // wf.g (); }} / * output: overrimingprivate2.f () suverridprivate2.g () * /analyser:
Quand la couverture se produit-elle:
1. Méthodes qui apparaissent dans des sous-classes qui sont exactement les mêmes que celles des classes parentales
2. Une sous-classe peut être transformée en une classe de parent vers le haut et appeler la méthode dans la classe parentale
Si une méthode dans la classe parent est déclarée finale ou privée, cette méthode est invisible pour la sous-classe. Même si une méthode exactement comme la classe parent est créée dans la sous-classe, il s'agit d'une nouvelle méthode, plutôt que d'une méthode remplacée par la classe parent.
Classe finale:
C'est-à-dire que cette classe ne peut pas être héritée, que ce soit vous ou d'autres, c'est-à-dire que cette classe ne nécessite aucun changement, ni ne nécessite de sous-classes, telles que la classe String.
exemple:
class smallbrain {} class final dinosaur {int i = 7; int j = 1; Petite-Brain x = new smallbain (); void f () {}} // Erreur: le type ne peut pas sous-classer la classe finale Dinosaur // la classe de dinosaures ne peut pas avoir des sous-classes // classe étend plus dinosaure {} classe publique Jurassic {public static void main (String [] args) {dinosaur n = new dinosaur (); nf (); ni = 40; N.J ++; }}Résumer
Ce qui précède est l'intégralité du contenu de cet article. J'espère que le contenu de cet article a une certaine valeur de référence pour l'étude ou le travail de chacun. Si vous avez des questions, vous pouvez laisser un message pour communiquer. Merci pour votre soutien à wulin.com.