Lambda表达式、方法引用 实例

1、lambda表达式练习

（1）

package learn;

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

package learn;

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

        //Lambda表达式
        useFlyable(s -> {
            System.out.println(s);
            System.out.println("飞机自驾游");
        });
    }

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

（2）

package learn;

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

package learn;

public class AddableDemo {
    public static void main(String[] args) {
        useAddable(new Addable() {
            @Override
            public int add(int x, int y) {
                return x+y;
            }
        });

        //Lambda表达式
        useAddable((x,y)-> x+y);
    }

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

2、接口组成更新：

若一个类同时实现了多个接口，且多个接口中的默认方法名相同。
此时必须进行方法重写
方法重写内容可以是：
（1）可选择保留其中的一个，通过 接口名.super.方法名 选择保留哪个接口的默认方法
（2）自己重写内容

package learn;

public interface Test1 {
    public default void show(){
        System.out.println("test");
    }
}

package learn;

public interface Test2 {
    public default void show(){
        System.out.println("test2");
    }
}

package learn;

public interface Test3 {
    public default void show(){
        System.out.println("test3");
    }
}

package learn;

public class Test implements Test1,Test2,Test3{

    @Override
    public void show() {
        Test2.super.show();
    }
}

package learn;

public class TestDemo {
    public static void main(String[] args) {
        Test td=new Test();
        td.show();
        //test2
    }
}

3、Lambda表达式支持的方法引用

常见引用方式：
（1）引用类方法：类名::静态方法

Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数

package learn;

public interface Converter {
    int convert(String s);
}

package learn;

public class TestDemo {
    public static void main(String[] args) {
        useConverter(Integer::parseInt);
        useConverter(s -> Integer.parseInt(s));
    }

    public static void useConverter(Converter c) {
        int number=c.convert("666");
        System.out.println(number);
    }
}

（2）引用对象的实例方法：对象::成员方法

Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数

package learn;

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

package learn;

public class PrintString {
    public void printUpper(String s){
        s=s.toUpperCase();
        System.out.println(s);
    }
}

package learn;

public class TestDemo {
    public static void main(String[] args) {
        usePrinter(new Printer() {
            @Override
            public void printUpperCase(String s) {
                PrintString ps=new PrintString();
                ps.printUpper(s);
            }
        });//匿名内部类

        usePrinter( s -> new PrintString().printUpper(s));//lambda表达式
        usePrinter(s -> s.toUpperCase());//lambda中指定的操作方案，在PrintString类中已经存在相同方案


        PrintString p=new PrintString();
        usePrinter(p::printUpper);

    }

    public static void usePrinter(Printer p) {
        p.printUpperCase("helloworld");
    }
}

（3）引用类的实例方法：类名::成员方法

Lambda表达式被类的实例方法替代的时候，第一个参数作为调用者，后面的参数全部传递给该方法作为参数

package learn;

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

package learn;

public class TestDemo {
    public static void main(String[] args) {
        use(String::substring);
        use((s,x,y)->s.substring(x,y));
    }

    public static void use(MyString ms) {
        String res=ms.mySubString("HelloWorld",2,5);
        System.out.println(res);
    }
}

（4）引用构造器：类名::new

Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数

package learn;

public interface StudentBuilder {
    Student build(String name,int age);
}

package learn;

public class TestDemo {
    public static void main(String[] args) {
        //use((name, age) -> new Student(name,age));
        use(Student::new);
    }

    public static void use(StudentBuilder sb) {
        Student s=sb.build("林青霞",30);
        System.out.println(s.getName()+","+s.getAge());
    }
}

package learn;

public class Student {
    private String name;
    private int age;
    public Student(){

    }
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}