Final--
Final est utilisé pour indiquer que la classe ne peut pas dériver des sous-classes.
Final est utilisé pour indiquer que la méthode ne peut pas être réécrite par une sous-classe.
Final est utilisé pour représenter les constantes lorsque les variables, similaires au mot clé const en C / C ++.
Final est utilisé pour les variables de membres pour indiquer que la variable membre est une constante et ne peut pas être modifiée.
Final est utilisé pour indiquer que la variable locale est une constante et ne peut pas être modifiée.
statique---
Static est utilisé pour indiquer qu'il n'y a qu'une seule copie de la variable, c'est-à-dire que la variable de membre statique appartient à la classe mais pas à un objet d'instance de classe spécifique. Variable membre, le nom de classe correspondant est terminé. Les variables de membres statiques peuvent être initialisées lorsqu'elles sont définies ou non.
Static est utilisé pour les méthodes, de sorte que les méthodes statiques peuvent être appelées via des noms de classe sans instancier la classe. Référencé.
Static est utilisé pour les classes, qui se réfère à la classe intérieure ici, vous pouvez donc vous référer à cette classe intérieure statique via le nom de classe extérieure ailleurs.
Le statique peut également être utilisé pour les blocs de code de classe, appelés blocs de code statiques. JVM charge la classe, il exécutera ces blocs de code statiques.
Autorisations d'accès des classes (O / N)
|| Mots-clés ||
| Public | Y |
| protégé |
| par défaut | Y |
| privé | y | n | n |
Les trois mots clés publics, protégés et privés peuvent être utilisés pour les classes (classes internes), les variables membre et les fonctions membres. Fonctions, sélectionnez l'autorisation d'accès la plus basse.
interface / outils / étend / classe -
L'interface est utilisée pour déclarer l'interface.
Les outils sont utilisés pour implémenter les interfaces, et toutes les méthodes de l'interface sont nécessaires pour implémenter plusieurs interfaces en même temps.
Les étendues sont utilisées pour hériter de la classe parent ou de l'interface parent.
La classe est utilisée pour déclarer les classes.
abstrait-
Résumé est utilisé pour représenter que cette classe est une classe abstraite et ne peut pas être instanciée.
Résumé est utilisé pour représenter que cette méthode est une méthode abstraite.
Concentrons-nous sur l'utilisation de ceci et super:
Ce
Le mot-clé Java Ceci ne peut être utilisé que dans le corps de la méthode. Lorsqu'un objet est créé, la machine virtuelle Java (JVM) affectera un pointeur à l'objet qui se réfère à lui-même, et le nom de ce pointeur est le suivant. Par conséquent, cela ne peut être utilisé que dans les méthodes non statiques de la classe. Et ceci est uniquement associé à des objets spécifiques, pas à des classes, et différents objets de la même classe ont différent. Voici un exemple complet en utilisant ceci pour illustrer le problème:
Package Org.LeizHimin; Public Class Test6 {Numéro de chaîne privée; = n;;} public test6 (int i, nom d'utilisateur, mot de passe de chaîne) {// ". this.userName = username; this. mot de passe = mot de passe;} // le constructeur par défaut sans paramètres public test6 () {this (0," inconnu "," vide "); // appelle un autre constructeur via ce} public test6 (Nom de chaîne) {ceci (1, nom, "vide"); Invité "); t1.outinfo (t1); t2.outinfo (t2);} private void Outinfo (test6 t) {System.out.println (" ---------------- - "); System.out.println (t.number); System.out.println (t.username); System.out.println (t.password); f (); // Ceci peut être écrit comme: this.f ();} private void f () {// Les variables locales ont le même nom que les variables membre, et la variable membre est bloquée, et la variable membre est accessible sous la forme de "cette. Variables membre". X;
Les résultats de l'opération sont les suivants:
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ------
En regardant l'exemple ci-dessus, nous expliquerons dans quelles circonstances cela est nécessaire:
Tout d'abord, appelez un autre constructeur à travers cela, et l'utilisation est ceci (liste de paramètres).
Deuxièmement, lorsque les paramètres de fonction ou les variables locales de la fonction ont le même nom que la variable membre, la variable membre est bloquée à l'heure actuelle, pour accéder à la variable membre, vous devez utiliser le nom de la variable de membre " référence à la variable membre. Bien sûr, sans le même nom, vous pouvez utiliser le nom de la variable membre directement au lieu de cela, il n'est pas faux de l'utiliser, haha.
Troisièmement, dans la fonction, lorsque vous devez vous référer à l'objet actuel de la classe à laquelle appartient la fonction, utilisez-le directement.
En fait, ces résumés d'utilisation sont tous dérivés d'une compréhension plus profonde de la phrase "C'est un pointeur vers l'objet lui-même".
super
La clé de Super est similaire à celle-ci, à savoir que la variable de membre bloqué ou la méthode des membres devient visible, ou est utilisée pour se référer à la variable de membre bloqué et à la méthode du membre membre.
Cependant, Super est utilisé dans les sous-classes, dans le but d'accéder aux membres bloqués dans la classe Parent directe. Ce qui suit est un exemple de compréhension complets, avec deux classes: une classe de père et une sous-classe de fils de père.
Package org.leizhimin; classe publique père {chaîne publique v = "père"; est appelé! ");} Père public (String V) {this.v =" Méthode du constructeur de paramètres de la classe Père! )); ; À l'avant du corps du constructeur. void OutInfo () {System.out.println ("Son's OutInfo () est appelé"); System.out.println ("-----------"); (sous-classe) Variable de membre V System.out.println (super.v); println (x); - "); outInfo (); // appelant la méthode OutInfo () de la sous-classe this.outinfo (); // appelant la méthode OutInfo () super.outinfo (); // appelant la méthode OutInfo () de la méthode de la méthode de la méthode de la méthode de la méthode de l'oubli Classe parent} public static void main (String [] args) {new Son (). Test ();
Résultats de l'exécution du fils de la sous-classe:
Le constructeur du père est appelé! -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- X !!! -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- --------