Java udostępnia nową funkcję zwaną odwołaniem do metody w Javie 8. Odwołanie do metody służy do odwoływania się do metody interfejsu funkcjonalnego. Jest to zwarta i łatwa forma wyrażenia lambda. Za każdym razem, gdy używasz wyrażenia lambda do odwoływania się do metody, możesz zastąpić to wyrażenie lambda odwołaniem do metody. W tym samouczku szczegółowo wyjaśniamy koncepcję referencji do metody.
formatowanie ciągu Java
Rodzaje odniesień do metod
W Javie istnieją następujące typy odwołań do metod:
- Odniesienie do metody statycznej.
- Odwołanie do metody instancji.
- Odniesienie do konstruktora.
1) Odniesienie do metody statycznej
Możesz odwołać się do metody statycznej zdefiniowanej w klasie. Poniżej znajduje się składnia i przykład opisujący proces odwoływania się do metody statycznej w Javie.
Składnia
ContainingClass::staticMethodName
Przykład 1
W poniższym przykładzie zdefiniowaliśmy interfejs funkcjonalny i odnieśliśmy metodę statyczną do jej metody funkcjonalnej 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(); } }Przetestuj teraz
Wyjście:
Hello, this is static method.
Przykład 2
W poniższym przykładzie używamy predefiniowanego interfejsu funkcjonalnego Runnable do odwoływania się do metody statycznej.
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(); } }Przetestuj teraz
Wyjście:
jak czytać z pliku csv w Javie
Thread is running...
Przykład 3
Możesz także użyć predefiniowanego interfejsu funkcjonalnego do odwoływania się do metod. W poniższym przykładzie używamy interfejsu BiFunction i jego metody 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); } }Przetestuj teraz
Wyjście:
30
Przykład 4
Możesz także zastąpić metody statyczne, odwołując się do metod. W poniższym przykładzie zdefiniowaliśmy i przeciążyliśmy trzy metody add.
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); } }Przetestuj teraz
Wyjście:
30 30.0 30.0
2) Odniesienie do metody instancji
podobnie jak metody statyczne, możesz także odwoływać się do metod instancji. W poniższym przykładzie opisujemy proces odwoływania się do metody instancji.
Składnia
containingObject::instanceMethodName
Przykład 1
W poniższym przykładzie odwołujemy się do metod niestatycznych. Możesz odwoływać się do metod według obiektu klasy i obiektu anonimowego.
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(); } }Przetestuj teraz
Wyjście:
Hello, this is non-static method. Hello, this is non-static method.
Przykład 2
W poniższym przykładzie odwołujemy się do metody instancji (niestatycznej). Uruchomialny interfejs zawiera tylko jedną metodę abstrakcyjną. Możemy więc używać go jako funkcjonalnego interfejsu.
łączenie w przód
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(); } }Przetestuj teraz
Wyjście:
Hello, this is instance method
Przykład 3
W poniższym przykładzie używamy interfejsu BiFunction. Jest to predefiniowany interfejs zawierający funkcjonalną metodę Apply(). Tutaj odnosimy się do metody dodawania do metody stosowania.
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); } }Przetestuj teraz
Wyjście:
30
3) Odniesienie do konstruktora
Konstruktora można odwołać za pomocą słowa kluczowego new. Tutaj odwołujemy się do konstruktora za pomocą interfejsu funkcjonalnego.
Składnia
ClassName::new
Przykład
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'); } }Przetestuj teraz
Wyjście:
Hello