Lambda表达式体验
格式：（形式参数）->{代码块}

package test08;

public class MyRunnable implements Runnable {
    @Override
    public void run(){
        System.out.println("多线程启动了");
    }
}

package test08;

/*
需求：启动一个线程，在控制台输出多线程启动了
 */
public class LambdaDemo {
    public static void main(String[] args) {
//        //实现类的方式实现需求
//        MyRunnable my = new MyRunnable();
//        Thread t = new Thread(my);
//        t.start();

//        //匿名内部类的方式改进
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("多线程启动了");
//            }
//        }).start();

        //Lambda表达时方式改进
        new Thread(() -> {
            System.out.println("多线程启动了");
        }).start();
    }
}

Lambda使用前提，有一个接口，接口中有且仅有一个方法
lambda表达式，抽象方法无参无返回值

//package test08;
//
//public class EatableImp implements Eatable{
//    @Override
//    public void eat(){
//        System.out.println("one day");
//    }
//
//}

package test08;

public interface Eatable {
    void eat();
}

package test08;

public class EatableDemo {
    public static void main(String[] args) {
//        //在主方法中调用useEatable方法
//        EatableImp e = new EatableImp();
//        useEatable(e);

        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("匿名内部类");
            }
        });

        //Lambda表达式（前提：定义一个接口，有且仅有一个方法；定义一个方法使用接口）
        useEatable(() -> {
            System.out.println("lambda表达式");
        });

    }

    //定义一个方法使用接口
    public static void useEatable(Eatable e) {
        e.eat();
    }
}

lambda表达式，抽象方法带参无返回值

package test08;

public interface Flyable {
    //定义一个接口，定义一抽象方法
    void fly(String s);
}

package test08;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

public class FlyableDemo {
    public static void main(String[] args) {
        //在主方法中调用useFlyable方法
        //匿名内部类
        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("lambda");
//        });
        
//        //可以省略括号
//        useFlyable(s -> {
//            System.out.println(s);
//            System.out.println("lambda");
//        });
        //如果代码块只有一条，可以省略大括号和分号
        useFlyable(s ->
                System.out.println("lambda")
        );


    }

    public static void useFlyable(Flyable f) {
        f.fly("Flyable接口");
    }
}

lambda表达式，抽象方法带参带返回值

package test08;

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

package test08;

public class AddableDemo {
    public static void main(String[] args) {
//        useAddable((int x,int y)->{
//            return x+y;
            return x-y;
//        });
        //参数的类型可以省略，需要一起省略
        useAddable(( x, y)->{
            return x+y;
        });

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