java---函数.Lambda

标准格式

package 函数.Lambda.标准格式;

public interface Addable {
    int add(int x,int y);
}

package 函数.Lambda.标准格式;
/*
Lambda标准格式
   格式： （形式参数） —> {代码块}
       1.形式参数：  如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
       2.-> :       代表指向动作，固定写法

     前提：
        1，有一个接口
        2，有且只一个抽象方法

 */

public class AddableDemo {
    public static void main(String[] args) {
        //在主方法中调用useAddble方法
        useAddble((int x, int y) -> {
            return x + y;
        });
    }

    private static void useAddble(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

省略模式

package 函数.Lambda.省略模式;

public interface Addable {
    int add(int x, int y);
}

package 函数.Lambda.省略模式;

public interface Flyable {
    void fly(String s);
}

package 函数.Lambda.省略模式;
/*
    省略规则：
        1，参数类型可以省略。但是有多个参数的情况下，不能只省略一个
        2，如果参数只有一个，那么小括号可以省略
        3，如果代码块的语句只有一条，可以省略大括号和分号，甚至是return
 */

public class LambdaDemo{
    public static void main(String[] args) {
        //省略参数类型
        useAddable((x, y) ->{
            return x+y;
        });
        //但是有多个参数的情况下，不能只省略一个
        /*useAddable((x,int y) ->{
            return x+y;
        });
        */
        //如果参数只有一个，那么小括号可以省略
        useFlyable(f -> {
            System.out.println(f);
        });
        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyable(s -> System.out.println(s));
        //甚至是return
        useAddable((x, y) -> x+y);
    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }

    private static void useAddable(Addable a){
        int sum=a.add(10,20);
        System.out.println(sum);
    }
}

注意事项

package 函数.Lambda.注意事项;

public interface Inter  {
    void run();
}

package 函数.Lambda.注意事项;
/*
    注意事项:
        1,使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
        2,必须有上下文环境，才能推导出Lambda对应的接口
            根据局部变量的赋值得知Lambda对应的接口:
                Runnable r=() -> System.out.println(“Lambda表达式”);
            根据调用方法的参数得知Lambda对应的接口:
                new Thread(() -> System.out.println(“Lambda表达式”)).start)

    Lambda表达式和匿名内部类的区别
        1.所需类型不同
            匿名内部类:可以是接口，也可以是抽象类，还可以是具体类
            Lambda表达式:只能是接口

        2.使用限制不同
            如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
            如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

        3.实现原理不同
            匿名内部类:编译之后，产生一个单独的class字节码文件
            Lambda表达式:编译之后，没有一个单独的class字节码文件。对应的字节码会在运行的时候动态生成

 */

public class LambdaDemo {

}