Welche Methoden werden in Lambda-Ausdrücken in Java verwendet?

1. Einführung in Lambda-Ausdrücke

Lambda-Ausdruck (Abschluss): Als neue Funktion von Java8 verwendet die Lambda-Operation eine Funktion als Parameter einer Methode, dh die Funktion wird als Parameter an die Methode übergeben . Die Verwendung von Lambda-Ausdrücken kann Ihren Code prägnanter machen.

Verwendungsszenarien von Lambda-Ausdrücken: werden zur Vereinfachung der Schnittstellenimplementierung verwendet.

Was die Schnittstellenimplementierung betrifft, gibt es viele Möglichkeiten, sie zu implementieren. Beispiel: Entwerfen Sie die Implementierungsklasse der Schnittstelle und verwenden Sie anonyme innere Klassen. Aber Lambda-Ausdrücke sind einfacher als diese beiden Methoden.

package test;
/**
 * @author: Mercury
 * Date: 2022/3/20
 * Time: 17:48
 * Description:Lambda表达式
 * Version:1.0
 */
public class Test04 {
    public static void main(String[] args) {
        //使用lambda表达式实现接口
        Test test = () -> {
            System.out.println("test");
        };
        test.test();
    }
}
interface Test{
    public void test();
}

2. Anforderungen an Lambda-Ausdrücke an Schnittstellen

Obwohl Lambda-Ausdrücke die Implementierung von Schnittstellen bis zu einem gewissen Grad vereinfachen können. Allerdings können nicht alle Schnittstellen präzise mit Lambda-Ausdrücken implementiert werden.

Der Lambda-Ausdruck ist schließlich nur eine anonyme Methode. Lambda-Ausdrücke sind nicht anwendbar, wenn die implementierte Schnittstelle zu viele oder zu viele Methoden hat.

Lambda-Ausdrücke können nur funktionale Schnittstellen implementieren.

1. Funktionale Schnittstelle

Wenn wir sagen, dass es in einer Schnittstelle nur eine abstrakte Methode gibt, die die implementierende Klasse implementieren muss! Eine solche Schnittstelle ist eine funktionale Schnittstelle.

Der Code lautet wie folgt (Beispiel):

//有且只有一个实现类必须要实现的抽象方法，所以是函数式接口
interface Test{
    public void test();
}

2.@FunctionalInterface

ist eine Annotation, die vor einer Schnittstelle verwendet wird, um zu bestimmen, ob die Schnittstelle eine funktionale Schnittstelle ist. Wenn es sich um eine funktionale Schnittstelle handelt, gibt es kein Problem. Handelt es sich nicht um eine funktionsfähige Schnittstelle, wird ein Fehler gemeldet. Funktion ähnlich wie @Override.
Der Code lautet wie folgt (Beispiel):

@FunctionalInterface
interface Test{
    public void test();
}

3. Die Syntax des Lambda-Ausdrucks

Ein Lambda-Ausdruck ist im Wesentlichen eine anonyme Funktion. Daher müssen Sie sich beim Schreiben von Lambda-Ausdrücken nicht um den Methodennamen kümmern.

Tatsächlich müssen wir uns beim Schreiben von Lambda-Ausdrücken nicht um den Rückgabewerttyp kümmern.

Wenn wir Lambda-Ausdrücke schreiben, müssen wir nur auf zwei Teile achten: Parameterliste und Methodenkörper.

Grundlegende Syntax von Lambda-Ausdrücken:

(Parameter 1, Parameter 2, …) -> };

Parameterteil: Die Parameterliste der Methode muss mit dem Methodenparameterteil in der implementierten Schnittstelle übereinstimmen, einschließlich der Anzahl und Art der Parameter.

Methodenkörperteil: Der Implementierungsteil der Methode. Wenn die in der Schnittstelle definierte Methode einen Rückgabewert hat, achten Sie bei der Implementierung auf den Rückgabewert.

->: Trennen Sie den Parameterteil und den Methodenkörperteil.

Codebeispiel:

package test;
/**
 * @author: Mercury
 * Date: 2022/3/20
 * Time: 17:48
 * Description:Lambda表达式
 * Version:1.0
 */
public class Test04 {
    public static void main(String[] args) {
        //使用lambda表达式实现接口
        //无参
//        Test test = () -> {
//            System.out.println("test");
//        };
        //有参
//        Test test = (name,age) -> {
//            System.out.println(name+age+"岁了！");
//        };
//        test.test("小新",18);
        //有参+返回值
        Test test = (name,age)  -> {
            System.out.println(name+age+"岁了！");
            return age + 1;
        };
        int age = test.test("小新",18);
        System.out.println(age);
    }
}
//无参
//interface Test{
//    public void test();
//}
//有参 无返回值
//interface Test{
//    public void test(String name,int age);
//}
//有参 有返回值
interface Test{
    public int test(String name,int age);
}

4. Syntaxerweiterung von Lambda-Ausdrücken

Vereinfachung des Parameterteils

ParametertypenDa in der Schnittstellenmethode der Typ jedes Parameters definiert wurde. Und wenn Sie Lambda-Ausdrücke zum Implementieren von Schnittstellen verwenden, müssen Sie sicherstellen, dass Anzahl und Typ der Parameter mit den Methoden in der Schnittstelle übereinstimmen. Daher kann der Parametertyp im Lambda-Ausdruck zu diesem Zeitpunkt weggelassen werden.

Hinweis:

Wenn Sie den Parametertyp weglassen müssen, stellen Sie sicher: Wenn Sie ihn weglassen möchten, muss der Typ jedes Parameters weggelassen werden. Es darf nicht angezeigt werden. Einige Parametertypen werden weggelassen, und einige Parametertypen werden nicht weggelassen.

        //有参+返回值
        Test test = (name,age)  -> {
            System.out.println(name+age+"岁了！");
            return age + 1;
        };
        int age = test.test("小新",18);
        System.out.println(age);

Klammern für Parameter

Wenn in der Parameterliste der Methode nur ein Parameter vorhanden ist, können zu diesem Zeitpunkt die Klammern der Parameterliste weggelassen werden.

Hinweis:

Nur wenn die Anzahl der Parameter eins beträgt, kann mehr oder weniger nicht weggelassen werden.

• Wenn die Klammern weggelassen werden, muss der Typ des Parameters weggelassen werden und Wenn nur ein Satz vorhanden ist, können die geschweiften Klammern weggelassen werden .

          //一个参数
          Test test = name -> {
              System.out.println(name+"test");
          };
          test.test("小新");

3. Funktionsreferenz

• Lambda-Ausdruck soll die Implementierung der Schnittstelle vereinfachen. In Lambda-Ausdrücken sollte keine komplexere Logik auftreten. Die Verwendung übermäßig komplexer Logik in Lambda-Ausdrücken beeinträchtigt die Lesbarkeit des Programms erheblich. Wenn ein Lambda-Ausdruck komplexe Logik verarbeiten muss, schreiben wir normalerweise eine separate Methode, um damit umzugehen. Verweisen Sie einfach direkt im Lambda-Ausdruck auf diese Methode.

Funktionsreferenz

: Verweisen Sie auf eine vorhandene Methode, um den Lambda-Ausdruck zu ersetzen und die Implementierung der Schnittstelle abzuschließen1 Referenz der statischen Methode

Syntax

: Klasse::statische Methode

Hinweise:

Fügen Sie nach der referenzierten Methode keine Klammern hinzu.

Die referenzierte Methode, die Parameter (Anzahl, Typ) und der Rückgabewert müssen mit den in der Schnittstelle definierten übereinstimmen Methoden

Hinweise

:

Fügen Sie nach der referenzierten Methode keine Klammern hinzu.

引用的这个方法， 参数（数量、类型） 和 返回值， 必须要跟接口中定义的⼀致。

package test;
/**
 * @author: Mercury
 * Date: 2022/3/21
 * Time: 8:14
 * Description:lambda表达式对非静态方法的引用
 * Version:1.0
 */
public class Test06 {
    public static void main(String[] args) {
        //对非静态方法的引用，需要使用对象来完成
        Test2 test2 = new Calculator()::calculate;
        System.out.println(test2.calculate(2, 3));
    }
    private static class Calculator{
        public int calculate(int a, int b) {
            return a > b ? a - b : b - a;
         }
    }
}
interface Test2{
    int calculate(int a,int b);
}

3.构造方法的引用

使用场景

如果某个函数式接口中所定义的方法只是为了获取一个类的对象。此时我们就可以使用构造方法的引用，简化这个方法的实现。

语法：类名::new

注意事项：可以通过接口中的方法的参数， 区分引用不同的构造方法。

package com.cq.test;
/**
 * @author: Mercury
 * Date: 2022/4/27
 * Time: 10:31
 * Description:lambda构造方法的引用
 * Version:1.0
 */
public class Test {
    private static class Dog{
        String name;
        int age;
        //无参构造
        public Dog(){
            System.out.println("一个Dog对象通过无参构造被实例化了");
        }
        //有参构造
        public Dog(String name,int age){
            System.out.println("一个Dog对象通过有参构造被实例化了");
            this.name = name;
            this.age = age;
        }
    }
    //定义一个函数式接口,用以获取无参的对象
    @FunctionalInterface
    private interface GetDog{
        //若此方法仅仅是为了获得一个Dog对象，而且通过无参构造去获取一个Dog对象作为返回值
        Dog test();
    }
    //定义一个函数式接口,用以获取有参的对象
    @FunctionalInterface
    private interface GetDogWithParameter{
        //若此方法仅仅是为了获得一个Dog对象，而且通过有参构造去获取一个Dog对象作为返回值
        Dog test(String name,int age);
    }
    // 测试
    public static void main(String[] args) {
        //lambda表达式实现接口
        GetDog lm = Dog::new; //引用到Dog类中的无参构造方法，获取到一个Dog对象
        Dog dog = lm.test();
        System.out.println("修狗的名字："+dog.name+" 修狗的年龄："+dog.age); //修狗的名字：null 修狗的年龄：0
        GetDogWithParameter lm2 = Dog::new;//引用到Dog类中的有参构造，来获取一个Dog对象
        Dog dog1 = lm2.test("萨摩耶",2);
        System.out.println("修狗的名字："+dog1.name+" 修狗的年龄："+dog1.age);//修狗的名字：萨摩耶 修狗的年龄：2
    }
}

四、Lambda表达式需要注意的问题

这⾥类似于局部内部类、匿名内部类，依然存在闭包的问题。

如果在lambda表达式中引用了局部变量，则该局部变量会隐式声明为final变量。是⼀个常量，不能修改值。

Das obige ist der detaillierte Inhalt vonWelche Methoden werden in Lambda-Ausdrücken in Java verwendet?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!