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
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.
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 } }
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".
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.
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(); } }
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é.
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
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"); } }
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.
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.
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"); } }
First method string: Tutorialspoint Second Method string: Tutorialspoint
Dans le code ci-dessus, la sous-classe "Ovriid2" remplace la "methodA()" de la superclasse.
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!