Doppelpunkt-Operator (::) in Java

In Java ist der zweifache Doppelpunkt (::)-Administrator, auch Strategie-Referenzadministrator genannt, ein starkes Element, das in Java 8 vorgestellt wird. Er bietet eine prägnante und reichhaltige Methode, um auf Techniken oder Konstruktoren hinzuweisen, ohne sie heraufzubeschwören Der Administrator verbessert den Code und verbessert die Codekohärenz, was ihn zu einem wichtigen Instrument für Designer macht. In diesem Artikel werden wir die Sprachstruktur des Doppelpunkt-Administrators untersuchen, über seine Anwendungen sprechen und Code-Anleitungen zum besseren Verständnis geben.

Syntax

Der Doppelpunkt-Operator besteht aus zwei Doppelpunkten (::), die zwischen dem Klassennamen oder der Objektreferenz und dem Methodennamen liegen. Es wird als Kurzschreibweise für die Referenzierung von Methoden oder Konstruktoren in Java verwendet.

// A functional interface with a single abstract method
interface Printer {
   void print(String message);
}

// A class that implements the Printer interface
class ConsolePrinter {
   public static void printMessage(String message) {
      System.out.println(message);
   }
}

public class Main {
   public static void main(String[] args) {
      Printer printer = ConsolePrinter::printMessage;
      printer.print("Hello, World!");
   }
}

Grammatikerklärung

Im obigen Code verwenden wir einen Dienstprogramm-Join-Point namens Printer, um eine Klasse mit einer einzigen dynamischen Methode print() zu definieren. Die ConsolePrinter-Klasse implementiert diesen Verbindungspunkt und stellt eine Implementierung für die printMessage()-Methode bereit. In der Principal-Klasse haben wir eine Druckerinstanz mit dem Doppelpunktoperator erstellt, um auf die printMessage()-Methode der ConsolePrinter-Klasse zu verweisen. Abschließend rufen wir die print()-Methode der Druckerinstanz auf, die wiederum die printMessage()-Methode aufruft.

Algorithmus

• Um den Doppelpunkt-Operator in Java zu verwenden, befolgen Sie diese Schritte -

• Definieren Sie eine funktionale Schnittstelle mit einer einzigen abstrakten Methode.

• Implementieren Sie die Schnittstelle in einer Klasse und stellen Sie die Implementierung der Methode bereit.

• Verwenden Sie den Doppelpunkt-Operator, um auf die Methode oder den Konstruktor zu verweisen

• Verwenden Sie den Doppelpunkt-Operator, um Instanzen funktionaler Schnittstellen zu erstellen.

• Der Aufruf dieser Methode für eine Instanz ruft die referenzierte Methode oder den Konstruktor auf.

Methode 1: Methodenreferenz mit Doppelpunkt-Operator

Ansatz 1 beinhaltet die Verwendung des Doppelpunktoperators, um auf eine statische Methode einer Klasse zu verweisen. Dieser Ansatz ist nützlich, wenn wir eine Methodenreferenz übergeben möchten, die nicht von Instanzvariablen abhängt.

Beispiel

// A functional interface with a single abstract method
interface Calculator {
   int calculate(int a, int b);
}

class MathUtils {
   public static int add(int a, int b) {
      return a + b;
   }
}

public class Main {
   public static void main(String[] args) {
      Calculator calculator = MathUtils::add;
      int result = calculator.calculate(5, 3);
      System.out.println("Result: " + result);
   }
}

Ausgabe

Result: 8

Erklärung

Calculator ist eine funktionale Schnittstelle mit einer abstrakten Methode berechne(). Die statische MathUtils-Funktion add() wird zum Addieren zweier Zahlen verwendet. Der Doppelpunktoperator erstellt eine Calculator-Instanz, die auf die add()-Methode von MathUtils verweist. Wir rufen die Methode „compute()“ des Rechners mit zwei Zahlen auf. Ergebnisse der Konsolenausgabe.

Methode 2: Verwenden Sie Instanzvariablen, um den Doppelpunktoperator für Methodenreferenzen zu verwenden

Ansatz 2 beinhaltet die Verwendung des Doppelpunkt-Operators, um auf eine Instanzmethode eines bestimmten Objekts zu verweisen.

Beispiel

import java.util.ArrayList;
import java.util.List;

class Person {
   private String name;

   public Person(String name) {
      this.name = name;
   }

   public void printName() {
      System.out.println(name);
   }
}

public class Main {
   public static void main(String[] args) {
      List<Person> persons = new ArrayList<>();
      persons.add(new Person("Alice"));
      persons.add(new Person("Bob"));

      persons.forEach(Person::printName);
   }
}

Ausgabe

Alice
Bob

Erklärung

In diesem Beispiel haben wir eine Individual-Klasse mit einer printName()-Strategie zum Drucken des Namens einer Person. Wir haben eine Liste einzelner Projekte erstellt und zwei Beispiele hinzugefügt. Mit dem Doppelpunktoperator verweisen wir auf die printName()-Strategie der Individual-Klasse in der forEach()-Methode der List-Schnittstelle. Dadurch wird die Methode printName() aufgerufen, die den Namen jedes Elements in der Liste auf der Konsole ausgibt.

Methode 3: Verwenden Sie den Doppelpunkt-Operator, um auf die Instanzmethode eines beliebigen Objekts zu verweisen.

Ansatz 3 beinhaltet die Referenzierung einer Instanzmethode eines beliebigen Objekts eines bestimmten Typs mithilfe des Doppelpunktoperators.

Beispiel

import java.util.Arrays;
import java.util.List;

class StringUtil {
   public boolean isPalindrome(String s) {
      String reversed = new StringBuilder(s).reverse().toString();
      return s.equals(reversed);
   }
}

public class Main {
   public static void main(String[] args) {
      List<String> words = Arrays.asList("level", "hello", "radar", "world");

      StringUtil stringUtil = new StringUtil();
      long count = words.stream().filter(stringUtil::isPalindrome).count();

      System.out.println("Number of palindromic words: " + count);
   }
}

Ausgabe

Number of palindromic words: 2

Erklärung

In diesem Codeausschnitt testet eine StringUtil-Klasse mit isPalindrome() eine Liste von Wörtern und verwendet einen Stream, um palindromische Wörter mithilfe der vom Doppelpunkt-Kontrollzentrum empfohlenen Methode zu sortieren .

Ansatz 4: Konstruktorreferenzierung mit Doppelpunkt-Operator.

Methode 4 beinhaltet die Referenzierung des Konstruktors mithilfe des Doppelpunkt-Operators.

Beispiel

import java.util.function.Supplier;

class Employee {
   public String name;
   public int age;

   public Employee() {
      // Default constructor
   }

   public Employee(String name, int age) {
      this.name = name;
      this.age = age;
   }

   public String toString() {
      return "Employee [name=" + name + ", age=" + age + "]";
   }
}

public class Main {
   public static void main(String[] args) {
      Supplier<employee> employeeSupplier = Employee::new;
      Employee employee = employeeSupplier.get();

      employee.name = "John Doe";
      employee.age = 30;

      System.out.println(employee);
   }
}
</employee>

Ausgabe

Employee [name=John Doe, age=30]

Erklärung

In diesem Modell haben wir eine repräsentative Klasse mit einem definierten Konstruktor. Mithilfe des Doppelpunktoperators erstellen wir eine Instanz des Interaktionspunkts der Provider-Funktion, der auf den Representative-Konstruktor verweist. Anschließend rufen wir die Methode get() für die Instanz „employeeSupplier“ auf, um ein weiteres Representative-Objekt abzurufen. Wir legen den Namen und das Alter des Mitarbeiters fest und geben sie mithilfe der toString()-Methode auf der Konsole aus.

Fazit

Der Doppelpunkt-Operator (::) in Java ist ein leistungsstarkes Element, das in Java 8 eingeführt wurde. Es bietet eine übersichtliche und umfassende Möglichkeit, auf Methoden oder Konstruktoren zu verweisen, ohne sie direkt aufzurufen. Durch die Verwendung des Doppelpunktoperators können wir den Code verbessern, die Lesbarkeit erhöhen und die Vorteile der funktionalen Programmierung in Java nutzen. Jeder Java-Entwickler muss die Syntax und die verschiedenen Verwendungsmethoden des Doppelpunktoperators verstehen. Erkunden Sie diese Funktion also unbedingt und nutzen Sie sie in Ihren zukünftigen Java-Projekten, um Ihr Programmiererlebnis zu verbessern.

Das obige ist der detaillierte Inhalt vonDoppelpunkt-Operator (::) in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!