Java fornisce una nuova funzionalità chiamata riferimento al metodo in Java 8. Il riferimento al metodo viene utilizzato per fare riferimento al metodo dell'interfaccia funzionale. È una forma compatta e semplice di espressione lambda. Ogni volta che utilizzi l'espressione lambda solo per fare riferimento a un metodo, puoi sostituire l'espressione lambda con il riferimento al metodo. In questo tutorial spiegheremo in dettaglio il concetto di riferimento del metodo.
Tipi di metodi di riferimento
Esistono i seguenti tipi di riferimenti ai metodi in Java:
- Riferimento ad un metodo statico.
- Riferimento a un metodo di istanza.
- Riferimento a un costruttore.
1) Riferimento ad un metodo statico
È possibile fare riferimento al metodo statico definito nella classe. Di seguito è riportata la sintassi e l'esempio che descrivono il processo di riferimento al metodo statico in Java.
Sintassi
qual è il file system di linux
ContainingClass::staticMethodName
Esempio 1
Nell'esempio seguente, abbiamo definito un'interfaccia funzionale e riferito un metodo statico al suo metodo funzionale say().
interface Sayable{ void say(); } public class MethodReference { public static void saySomething(){ System.out.println('Hello, this is static method.'); } public static void main(String[] args) { // Referring static method Sayable sayable = MethodReference::saySomething; // Calling interface method sayable.say(); } }Provalo adesso
Produzione:
Hello, this is static method.
Esempio 2
Nell'esempio seguente utilizziamo l'interfaccia funzionale predefinita Runnable per fare riferimento al metodo statico.
applet
public class MethodReference2 { public static void ThreadStatus(){ System.out.println('Thread is running...'); } public static void main(String[] args) { Thread t2=new Thread(MethodReference2::ThreadStatus); t2.start(); } }Provalo adesso
Produzione:
Thread is running...
Esempio 3
È inoltre possibile utilizzare l'interfaccia funzionale predefinita per fare riferimento ai metodi. Nell'esempio seguente, utilizziamo l'interfaccia BiFunction e il suo metodo apply().
import java.util.function.BiFunction; class Arithmetic{ public static int add(int a, int b){ return a+b; } } public class MethodReference3 { public static void main(String[] args) { BiFunctionadder = Arithmetic::add; int result = adder.apply(10, 20); System.out.println(result); } }Provalo adesso
Produzione:
30
Esempio 4
È inoltre possibile sovrascrivere i metodi statici facendo riferimento ai metodi. Nell'esempio seguente abbiamo definito e sovraccaricato tre metodi di aggiunta.
import java.util.function.BiFunction; class Arithmetic{ public static int add(int a, int b){ return a+b; } public static float add(int a, float b){ return a+b; } public static float add(float a, float b){ return a+b; } } public class MethodReference4 { public static void main(String[] args) { BiFunctionadder1 = Arithmetic::add; BiFunctionadder2 = Arithmetic::add; BiFunctionadder3 = Arithmetic::add; int result1 = adder1.apply(10, 20); float result2 = adder2.apply(10, 20.0f); float result3 = adder3.apply(10.0f, 20.0f); System.out.println(result1); System.out.println(result2); System.out.println(result3); } }Provalo adesso
Produzione:
30 30.0 30.0
2) Riferimento ad un metodo di istanza
come i metodi statici, puoi anche fare riferimento ai metodi di istanza. Nell'esempio seguente descriviamo il processo di riferimento al metodo di istanza.
Sintassi
strumento di cattura in Ubuntu
containingObject::instanceMethodName
Esempio 1
Nell'esempio seguente ci riferiamo a metodi non statici. È possibile fare riferimento ai metodi per oggetto classe e oggetto anonimo.
interface Sayable{ void say(); } public class InstanceMethodReference { public void saySomething(){ System.out.println('Hello, this is non-static method.'); } public static void main(String[] args) { InstanceMethodReference methodReference = new InstanceMethodReference(); // Creating object // Referring non-static method using reference Sayable sayable = methodReference::saySomething; // Calling interface method sayable.say(); // Referring non-static method using anonymous object Sayable sayable2 = new InstanceMethodReference()::saySomething; // You can use anonymous object also // Calling interface method sayable2.say(); } }Provalo adesso
Produzione:
rom
Hello, this is non-static method. Hello, this is non-static method.
Esempio 2
Nell'esempio seguente ci riferiamo al metodo di istanza (non statico). L'interfaccia eseguibile contiene solo un metodo astratto. Quindi, possiamo usarlo come interfaccia funzionale.
public class InstanceMethodReference2 { public void printnMsg(){ System.out.println('Hello, this is instance method'); } public static void main(String[] args) { Thread t2=new Thread(new InstanceMethodReference2()::printnMsg); t2.start(); } }Provalo adesso
Produzione:
Hello, this is instance method
Esempio 3
Nell'esempio seguente, stiamo utilizzando l'interfaccia BiFunction. È un'interfaccia predefinita e contiene un metodo funzionale apply(). Qui ci riferiamo al metodo Aggiungi per applicare il metodo.
import java.util.function.BiFunction; class Arithmetic{ public int add(int a, int b){ return a+b; } } public class InstanceMethodReference3 { public static void main(String[] args) { BiFunctionadder = new Arithmetic()::add; int result = adder.apply(10, 20); System.out.println(result); } }Provalo adesso
Produzione:
30
3) Riferimento ad un Costruttore
Puoi fare riferimento a un costruttore utilizzando la nuova parola chiave. Qui ci riferiamo al costruttore con l'aiuto dell'interfaccia funzionale.
Sintassi
ClassName::new
Esempio
interface Messageable{ Message getMessage(String msg); } class Message{ Message(String msg){ System.out.print(msg); } } public class ConstructorReference { public static void main(String[] args) { Messageable hello = Message::new; hello.getMessage('Hello'); } }Provalo adesso
Produzione:
Hello