Lambda表达式的标准格式

三要素：形式参数、箭头、代码块

格式：(形式参数)->(代码块)
    形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
    ->代表指向动作

Lamabda表达式练习1(抽象方法无参无返回值)

//Main.java(测试类)
public class Main{
    public static void main(String[] args){
        //在主方法中调用useFanxing方法
        Fanxing f=new Fanxing();
        useFanxing(f);

        //匿名内部类
        useFanxing(new Fanxing(){
            public void eat(){
                 System.out.println("一天一苹果，医生远离我");
            }
        });

        //Lambda表达式
        useFanxing(()->{
            System.out.println("一天一苹果，医生远离我");
        });

        //

    }
    private static void useFanxing(Fanxing f){
        f.eat();
    }
}

//Fanxing.java(接口)
public interface Fanxing {
    void eat();
}

//Eatablelmp.java(类实现接口)
public class Eatablelmp implements Fanxing{
    @Override
    public void eat(){
        System.out.println("一天一苹果，医生远离我");
    }
}

Lambda表达式的练习2(抽象方法带参无返回值)

//Main.java(测试类)
public class Main{
    public static void main(String[] args){

        //匿名内部类
        useFlyable(new Flyable(){
            @Override
            public void fly(String s){
                System.out.println(s);
                System.out.println("飞机自驾游");
            }
        });

        //Lambda
        useFlyable((String s)->{
            System.out.println(s);
            System.out.println("飞机自驾游");
        });
    }
    //定义一个方法
    private static void useFlyable(Flyable f){
        f.fly("风和日丽，晴空万里");
    }
}

//Flyable.java(接口)
public interface Flyable{
    void fly(String s);
}

Lambda表达式的练习3(抽象方法带参带返回值)

//Main.java(测试类)
public class Main{
    public static void main(String[] args){

        //Lambda
        useAddable((int x,int y)->{

            return (x+y);//控制具体实现

        });
    }

    private static void useAddable(Addable a){
        a.add(1,100);
    }

}

//Addable.java(接口)
public interface Addale{
    int sum=int add(int x,int y);
    System.out.println(sum);
}

Lambda表达式的省略模式

//就练习三为例
//1--参数的类型可以省略-----有多个参数的情况下不可以只省略一个

useAddable((x,y)->{
    return x+y;//101
});

//如果参数类型仅有一个，那么小括号可以省略

useFlyable(s->{
    System.out.println(s);
});

//如果代码块的语句只有一条，可以省略大括号和分号
useFlyable(s->System.out.println(s));
//如果有return，那么return也要省略掉
useAddable((x,y)->x+y);

Lambda表达式的注意事项

//使用Lambda必须要有接口，并且要求接口中1有且仅有一个抽象方法

//使用Lambda必须有上下环境，才能推导出Lambda对应的接口

Lambda表达式和匿名内部类的区别

//匿名内部类--可以是接口、抽象类和具体类
//Lambda只能是接口

//接口中有且仅有一个抽象方法，可以用Lambda表达式，也可以用匿名内部类
//多个抽象方法，只能使用匿名内部类

//匿名内部类--编译之后，产生一个单独的class字节码文件
//Lambda--编译之后，没有产生，对应的字节码会在运行的时候动态生成

接口组成更新

接口组成更新概述

加入了默认方法、静态方法、私有方法

接口中的默认方法

default--代表默认方法
    //public可以省略，default不能省略

接口中的静态方法

static--代表静态方法
    //只能通过接口调用
    //public可以省略，static不能省略

接口中的私有方法

private
    默认方法可以调用私有的静态方法和非静态方法
    静态方法只能调用私有的静态方法

方法引用

方法引用符::

//Lambda表达式
usePrintable(s->System.out.println(s));

//方法引用
usePrintable(System.out::println);
//二者孪生兄弟

相关应用：

//Main.java
public class Main{
    public static void main(String[] args){

        //Lambda表达式
        usePrintable(s->System.out.println(s));

        //方法引用
        usePrintable(System.out::println);
    }
    private static void usePrintable(MyInterface my){
        my.show("12345678910");
    }
}

//MyInterface.java(接口)
public interface MyInterface {
    void show(String s);
}

Lambda表达式支持的方法引用

1、引用类方法

//格式：类名::静态方法

相关应用：

//Main.java
public class Main{
    public static void main(String[] args){
        useConverter(s-> Integer.parseInt(s));

        //引用类方法
        useConverter(Integer::parseInt);
    }
    private static void useConverter(Converter c){
        int num=c.converter("123");
        System.out.println(num);
    }

}

//Converter.java
public interface Converter {
   int converter(String s);
}

引用对象的实例化方法

//格式：对象::成员方法

相关应用：

//Main.java
public class Main{
    public static void main(String[] args){
        usePrinter(s-> System.out.println(s.toUpperCase()));

        //引用方法
        printString ps=new printString();
        usePrinter(ps::printerUpper);
    }

private static void usePrinter(Printer p){
        p.printUpperCase("a");
}
}

//Printer.java
public interface Printer {
   void printUpperCase(String s);
}

//printString.java
public class printString {
public void printerUpper(String s){
    String result=s.toUpperCase();
    System.out.println(result);
}
}

引用类的实例方法

//引用类中的成员方法
//格式：类名::成员方法

相关应用：

//Main.java
public class Main{
    public static void main(String[] args){
        useMyString((String s,int x,int y)->{
            return s.substring(x,y);//截取部分字符串
        });

        useMyString((s,x,y)->s.substring(x,y));

        //引用方法
        useMyString(String::substring);
    }

    private static void useMyString(MyString mm){
        String s=mm.mySubString("helloworld",1,6);
        System.out.println(s);
    }
}

//MyString.java
public interface MyString {
   String mySubString(String s,int x,int y);
}

引用构造器

//格式：类名::new

相关应用：

//Main.java
public class Main{
    public static void main(String[] args){
        useStudentBuilder((String name,int age)->{
            //Student s=new Student(name,age);
            //return s;
            return new Student(name,age);
        });

        useStudentBuilder((name,age)->new Student(name,age));

        //引用方法
        useStudentBuilder(Student::new);

    }

    private static void useStudentBuilder(StudentBuilder sb){
        Student s=sb.Build("lili",19);
        System.out.println(s.getName()+" "+s.getAge());
    }

}

//StudentBuilder.java
public interface StudentBuilder {
   Student Build(String name,int age);
}

//Student.java
public class Student{
    private String name;
    private int age;

    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void setName(){}
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(){}
    public void setAge(int age){
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
}