Différentes techniques de réutilisation de noms en Java

En Java, il existe différentes techniques de réutilisation de noms pour différents types d'entités telles que des variables, des méthodes, des types de données ou des packages. Ces technologies influencent l'accessibilité et le comportement des entités en fonction de leurs besoins et de leurs usages. Dans cet article, nous aborderons quatre manières courantes de réutiliser les noms en Java : le remplacement, le masquage, la surcharge et l'observation

Technologie de réutilisation de noms en Java

Ombres

Cette technique permet à une variable locale d'avoir le même nom qu'un autre champ ou membre de la classe englobante. Dans ce cas, l'implémentation précédente du membre est masquée par la déclaration de la nouvelle variable. Les variables masquées ne sont pas accessibles par leurs noms simples dans les étendues masquées.

Exemple d'ombre

L'exemple suivant montre l'ombrage des variables

class OuterClass {
   int val1 = 12109659; // instance variable
   void printX() {
      int val1 = 11368; // local variable
      System.out.println("Value 1: " + val1); // belongs to current method
      System.out.println("Value 2: " + this.val1); // belongs to class
   }
}
public class Shwd {
   public static void main(String[] args) {
      OuterClass oc = new OuterClass(); // creating class object
      oc.printX(); // method call
   }
}

Sortie

Value 1: 11368
Value 2: 12109659

Dans le code ci-dessus, nous avons masqué la variable d'instance "val1" dans la méthode "printX()". Pour accéder à "val1", nous utilisons le mot-clé "this".

Masquer

Cette technique permet aux sous-classes de masquer les méthodes statiques ou les champs définis dans leur superclasse. Les entités de sous-classe doivent avoir le même nom et la même signature que l'entité de superclasse. la plupart Certains d’entre nous croient à tort que se cacher est une tâche écrasante. Lors du remplacement de méthode, la sous-classe remplace Implémentez la méthode d'origine avec la nouvelle méthode, mais en nous cachant, nous nous cachons simplement Méthode super classe. De plus, nous ne pouvons pas remplacer les méthodes statiques.

Masquer l'exemple

L'exemple suivant illustre le masquage de méthode.

class ClassA {
   public static void print() {
      System.out.println("This is Super Class method");
   }
}
class ClassB extends ClassA {
   public static void print() {
      System.out.println("This is Sub Class method");
   }
}
public class Main {
   public static void main(String[] args) {
      ClassA s1 = new ClassA(); // creating object
      ClassA s2 = new ClassB();
      // calling the methods
      s1.print();
      s2.print();
      ClassB.print();
   }
}

Sortie

This is Super Class method
This is Super Class method
This is Sub Class method

Dans le code ci-dessus, nous définissons une classe "Super" et une classe "Sub" et un "print()" méthode. La méthode 'print()' de la classe 'Sub' masque la méthode de la classe 'Super'. si 's2.print' imprimera le contenu de la sous-classe, alors cet exemple sera considéré Remplacé en tant que méthode plutôt que masqué.

Surcharge de méthodes

Lorsque nous créons deux méthodes ou plus avec le même nom mais avec des listes différentes Ensuite, si les paramètres sont dans le même corps de classe, nous appelons cela une surcharge de méthode. compilateur Déterminer les appels de méthode au moment de la compilation en fonction des types de paramètres

Exemple de surcharge de méthode

Cet exemple montre l'implémentation de la surcharge de méthode.

public class Ovrld {
   public static void methodA(String st1) {
      System.out.println("First method string: " + st1);
   }
   public static void methodA(String st1, String st2) { // overloading
      System.out.println("Second Method");
      System.out.println("String1: " + st1 + ", String2: " + st2);
   }
   public static void main(String args[]) {
      Ovrld obj = new Ovrld();
      // method calling
      obj.methodA("Tutorialspoint");
      obj.methodA("Simple", "Learning");
   }
}

Sortie

First method string: Tutorialspoint
Second Method
String1: Simple, String2: Learning

Dans le code ci-dessus, nous définissons deux méthodes avec le même nom mais des paramètres différents. Lors de l'appel, nous avons utilisé différents arguments.

Réécriture de méthodes

Lorsque nous créons deux méthodes ou plus avec le même nom et la même liste de paramètres dans la super classe et la sous-classe, nous appelons cela le remplacement de méthode. Le type de retour de la méthode est également le même.

Exemple de réécriture de méthode

L'exemple suivant montre le remplacement de méthode.

class Ovriid1 {
   public void methodA(String st1) {
      System.out.println("First method string: " + st1);
   }
}
public class Ovriid2 extends Ovriid1 {
   public void methodA(String st1) {
      System.out.println("Second Method string: " + st1);
   }
   public static void main(String args[]) {
      Ovriid1 obj1 = new Ovriid1();
      Ovriid1 obj2 = new Ovriid2();
      obj1.methodA("Tutorialspoint");
      obj2.methodA("Tutorialspoint");
   }
}

Sortie

First method string: Tutorialspoint
Second Method string: Tutorialspoint

Dans le code ci-dessus, la sous-classe "Ovriid2" remplace la "methodA()" de la superclasse.

Conclusion

Dans cet article, nous avons appris diverses techniques pour réutiliser les noms de variables et de méthodes, telles que la surcharge, le masquage, le masquage et le remplacement de méthodes. Nous avons également vu comment les implémenter dans un programme Java.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!