Verschiedene Techniken zur Namenswiederverwendung in Java

In Java gibt es verschiedene Techniken zur Namenswiederverwendung für verschiedene Arten von Entitäten wie Variablen, Methoden, Datentypen oder Pakete. Diese Technologien beeinflussen die Zugänglichkeit und das Verhalten von Entitäten basierend auf ihren Bedürfnissen und ihrer Nutzung. In diesem Artikel besprechen wir vier gängige Methoden zur Wiederverwendung von Namen in Java: Überschreiben, Ausblenden, Überladen und Schatten

Name-Wiederverwendungstechnologie in Java

Schatten

Diese Technik ermöglicht es einer lokalen Variablen, denselben Namen wie ein anderes Feld oder Mitglied der umschließenden Klasse zu haben. In diesem Fall wird die vorherige Implementierung des Members durch die Deklaration der neuen Variablen verdeckt. Auf ausgeblendete Variablen kann in ausgeblendeten Bereichen nicht über ihren einfachen Namen zugegriffen werden.

Schattenbeispiel

Das folgende Beispiel zeigt die Schattierung von Variablen

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
   }
}

Ausgabe

Value 1: 11368
Value 2: 12109659

Im obigen Code haben wir die Instanzvariable „val1“ in der Methode „printX()“ versteckt. Um auf „val1“ zuzugreifen, verwenden wir das Schlüsselwort „this“.

Verstecken

Diese Technik ermöglicht es Unterklassen, statische Methoden oder Felder auszublenden, die in ihrer Oberklasse definiert sind. Entitäten der Unterklasse müssen denselben Namen und dieselbe Signatur wie die Entität der Oberklasse haben. am meisten Einige von uns glauben fälschlicherweise, dass das Verstecken überwältigend ist. Beim Überschreiben von Methoden werden Unterklassen ersetzt Implementieren Sie die ursprüngliche Methode mit der neuen Methode, aber im Verborgenen verstecken wir uns einfach Superklasse-Methode. Außerdem können wir statische Methoden nicht überschreiben.

Beispiel ausblenden

Das folgende Beispiel veranschaulicht das Ausblenden von Methoden.

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();
   }
}

Ausgabe

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

Im obigen Code definieren wir eine „Super“- und eine „Sub“-Klasse sowie eine „print()“ Verfahren. Die Methode „print()“ der Klasse „Sub“ verbirgt die Methode der Klasse „Super“. wenn 's2.print' druckt den Inhalt der Unterklasse, dann wird dieses Beispiel berücksichtigt Als Methode überschrieben und nicht ausgeblendet.

Methodenüberladung

Wenn wir zwei oder mehr Methoden mit demselben Namen, aber unterschiedlichen Listen erstellen Wenn sich die Parameter dann im selben Klassenkörper befinden, nennen wir das Methodenüberladung. Compiler Bestimmen Sie Methodenaufrufe zur Kompilierungszeit basierend auf Parametertypen

Beispiel für eine Methodenüberladung

Dieses Beispiel zeigt die Implementierung der Methodenüberladung.

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");
   }
}

Ausgabe

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

Im obigen Code definieren wir zwei Methoden mit demselben Namen, aber unterschiedlichen Parametern. Während des Anrufs verwendeten wir unterschiedliche Argumente.

Umschreiben der Methode

Wenn wir zwei oder mehr Methoden mit demselben Namen und derselben Parameterliste in der Superklasse und Unterklasse erstellen, nennen wir das Methodenüberschreiben. Auch der Rückgabetyp der Methode ist derselbe.

Beispiel zum Umschreiben einer Methode

Das folgende Beispiel demonstriert das Überschreiben von Methoden.

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");
   }
}

Ausgabe

First method string: Tutorialspoint
Second Method string: Tutorialspoint

Im obigen Code überschreibt die Unterklasse „Ovriid2“ die „methodA()“ der Oberklasse.

Fazit

In diesem Artikel haben wir verschiedene Techniken zur Wiederverwendung von Variablen- und Methodennamen kennengelernt, z. B. Methodenüberladung, Ausblenden, Ausblenden und Überschreiben von Methoden. Wir haben auch gesehen, wie man sie tatsächlich in einem Java-Programm implementiert.

Das obige ist der detaillierte Inhalt vonVerschiedene Techniken zur Namenswiederverwendung in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!