Doppelpunkt-Operator(::) in Java
In Java können wir den doppelten Doppelpunktoperator (::) verwenden, um eine Methode aufzurufen, indem wir mit Hilfe ihres Klassennamens auf sie verweisen.
Wir können dies auch tun, indem wir die Lambda-Ausdrücke verwenden. Der einzige Unterschied, den wir hier finden, besteht darin, dass wir die Methode direkt über den Namen referenzieren können, während wir den Operator :: verwenden.
Wenn wir dagegen Lambda-Ausdrücke verwenden, benötigen wir einen Delegaten für die Methode, die wir aufrufen müssen. Dieser Artikel behandelt die Verwendung des Operators :: in Java.
Es gibt verschiedene Stellen, an denen wir den Operator :: in Java verwenden können. Wir können den Operator :: zum Referenzieren von Methoden verwenden.
Daher können wir mit :: statische Methoden aus Klassen oder Objekten extrahieren. Wir können sogar den Operator :: für Konstruktoren verwenden.
Wenn wir einen Eingabestrom erhalten, können wir auch den Operator :: verwenden, um die Elemente des Eingabestroms auszugeben.
Wann und wie man den Doppelpunkt-Operator (::) in Java verwendet
Wir können den Operator :: beim Umgang mit statischen Methoden, Instanzmethoden, Supermethoden, Instanzmethoden eines beliebigen Objekts eines bestimmten Typs und sogar Klassenkonstruktoren verwenden.
Lassen Sie uns jeden der Ansätze einzeln besprechen.
Beim Umgang mit statischen Methoden
Wir können den Operator :: in Java verwenden, wenn wir es mit statischen Methoden zu tun haben. Um eine Referenz auf die statische Methode einer Klasse zu erhalten, schreiben wir zuerst den Klassennamen, gefolgt vom Operator ::, und dann schreiben wir den Methodennamen.
Schauen wir uns die Syntax dieses Ansatzes an:
Syntax:
(ClassName::methodName)
Sehen wir uns nun den folgenden Code an, um zu verstehen, wie er funktioniert.
import java.util.*;
public class Main {
static void staticFunction(String s) // static function which is called using :: operator
{
System.out.println(s);
}
public static void main(String args[]) {
List<String> list = new ArrayList<String>();
list.add("This");
list.add("is");
list.add("an");
list.add("example");
list.forEach(Main::staticFunction);
}
}
Ausgabe:
This
is
an
example
Beim Umgang mit Instanzmethoden
Wir können auch den Operator :: in Java verwenden, wenn es um Instanzmethoden geht.
Um eine Referenz auf die Instanzmethode einer Klasse zu erhalten, schreiben wir zunächst das Objekt der Klasse. Dann setzen wir den Operator :: und schließlich schreiben wir den Namen der Methode.
Betrachten wir die Syntax dieses Ansatzes.
Syntax:
(ObjectOfTheClass::methodName)
Sehen wir uns nun den folgenden Code an, um zu verstehen, wie er funktioniert.
import java.util.*;
public class Main {
void instanceFunction(String s) // function which is called using :: operator
{
System.out.println(s);
}
public static void main(String args[]) {
List<String> list = new ArrayList<String>();
list.add("This");
list.add("is");
list.add("an");
list.add("example");
Main object = new Main();
list.forEach(object::instanceFunction);
}
}
Ausgabe:
This
is
an
example
Beim Umgang mit Supermethoden
Wir können auch den Operator :: in Java verwenden, wenn es um Supermethoden geht.
Um die Super-Methode einer Klasse zu referenzieren, schreiben wir zuerst das Schlüsselwort super. Dann setzen wir den Operator :: und schließlich schreiben wir den Namen der Methode.
Betrachten wir die Syntax dieses Ansatzes.
Syntax:
(super::methodName)
Sehen wir uns nun den folgenden Code an, um zu verstehen, wie er funktioniert.
// Java code to show use of double colon operator for super methods
import java.util.*;
import java.util.function.*;
class SuperClass {
// super function to be called
String printFunction(String s) {
return ("This is Print function output from the SuperClass: " + s);
}
}
public class Main extends SuperClass {
// instance method to override super method
@Override
String printFunction(String s) {
// call the super method
// using double colon operator
Function<String, String> func = super::printFunction;
String newValue = func.apply(s);
System.out.println(newValue);
return newValue;
}
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("This");
list.add("is");
list.add("an");
list.add("example");
Main object = new Main();
list.forEach(object::printFunction);
}
}
Ausgabe:
This is Print function output from the SuperClass: This
This is Print function output from the SuperClass: is
This is Print function output from the SuperClass: an
This is Print function output from the SuperClass: example
Beim Umgang mit der Instanzmethode eines beliebigen Objekts eines bestimmten Typs
Wir können auch den Operator :: in Java verwenden, wenn es um die Instanzmethode eines beliebigen Objekts eines bestimmten Typs geht.
Um die Instanzmethode eines beliebigen Objekts eines bestimmten Typs zu referenzieren, schreiben wir zuerst den Klassennamen. Dann setzen wir den Operator :: und schließlich schreiben wir den Namen der Methode.
Betrachten wir die Syntax dieses Ansatzes.
Syntax:
(ClassName::methodName)
Sehen wir uns nun den folgenden Code an, um zu verstehen, wie er funktioniert.
// Java code to show the use of double colon operator for instance method of arbitrary type
import java.util.*;
class Test {
String s = null;
Test(String s) {
this.s = s;
}
// instance function to be called
void instanceFunction() {
System.out.println(this.s);
}
}
public class Main {
public static void main(String[] args) {
List<Test> list = new ArrayList<Test>();
list.add(new Test("This"));
list.add(new Test("is"));
list.add(new Test("an"));
list.add(new Test("example"));
list.forEach(Test::instanceFunction); // call the instance method using double colon operator
}
}
Ausgabe:
This
is
an
example
Beim Umgang mit dem Klassenkonstruktor
Wir können auch den Operator :: in Java verwenden, wenn wir uns mit dem Klassenkonstruktor befassen.
Um einen Verweis auf den Klassenkonstruktor zu erhalten, schreiben wir zuerst den Namen der Klasse. Dann setzen wir den Operator :: und schließlich schreiben wir new, das den Konstruktor dieser bestimmten Klasse aufruft.
Betrachten wir die Syntax dieses Ansatzes.
Syntax:
(ClassName::new)
Sehen wir uns nun den folgenden Code an, um zu verstehen, wie er funktioniert.
// Java code to show the use of double colon operator for class constructor
import java.util.*;
public class Main {
public Main(String s) {
System.out.println(s);
}
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("This");
list.add("is");
list.add("an");
list.add("example");
list.forEach(Main::new); // call the instance method using double colon operator
}
}
Ausgabe:
This
is
an
example
Fazit
In diesem Artikel haben wir uns fünf Stellen angesehen und den doppelten Doppelpunktoperator (::) in Java verwendet.
Alle Techniken haben ihre Bedeutung, und Sie können den Operator :: immer dann anwenden, wenn Sie auf eine der oben genannten Situationen stoßen. Achten Sie auf die Syntax, da eine unsachgemäße Verwendung zu einer fehlerhaften Situation führen kann.