43.Lambda表达式

    public static void main(String[] args) {
        //匿名内部类启动线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类的方式启动线程");
            }
        }).start();
        //    lambda表达式启动线程
        new Thread(() ->{
            System.out.println("lambda表达式的方式启动线程");
        }).start();
    }

public interface Eatable {
public abstract void eat();
}

public class EatableImpl implements Eatable {
    @Override
    public void eat() {
        System.out.println("吃东西");
    }
}

public class EatableDemo {
    public static void main(String[] args) {
        //1.创建接口实现类对象实现调用eat()方法
        EatableImpl eatable = new EatableImpl();
        useEatable(eatable);
//        2.创建接匿名内部类实现调用eat()方法
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("吃东西");
            }
        });
//        3.Lambda表达式实现调用eat()方法
        useEatable(() -> {//"()"就代表Eatable接口里面唯一的抽象方法:eat();因为eat()不需要参数,所以()也没有参数
            System.out.println("吃东西");
        });
    }

    private static void useEatable(Eatable e) {
        e.eat();
    }
}

public interface Fly {
    void fly(String s);
}
public class FlyDemo {
    public static void main(String[] args) {
        flyTo(new Fly() {
            @Override
            public void fly(String s) {
                System.out.println("我要飞到" + s);//我要飞到北京
            }
        });
        flyTo((String s) -> {
            System.out.println("我要飞到" + s);
        });
    }

    private static void flyTo(Fly fly) {
        fly.fly("北京");
    }
}

public interface Add {
    int add(int a,int b);
}

public class AddDemo {
    public static void main(String[] args) {
         addDo(new Add() {
            @Override
            public int add(int a, int b) {
                return a + b;
            }
        });
        addDo((int a, int b) -> {
            return a + b;
        });

    }

    private static void addDo(Add add){
         int sum=add.add(1,2);
         System.out.println(sum);//3

    }
}

public interface Fly {
    void fly(String s);
}
public interface Add {
    int add(int a,int b);
}
public class Demo {
    public static void main(String[] args) {
         addDo(new Add() {
            @Override
            public int add(int a, int b) {
                return a + b;
            }
        });
        addDo((int a, int b) -> {
            return a + b;
        });
//        1.参数类型可以省略,但是多个参数的时候,不能只省略一个参数的类型
        addDo((a,b)->{
            return a+b;
        });
//        2.如果参数只要一个,那么小括号可以省略
        flyTo(new Fly() {
            @Override
            public void fly(String s) {
                System.out.println("我要飞到:"+s);
            }
        });
        flyTo(s->{
            System.out.println("我要飞到:"+s);
        });
//        3.如果代码块的语句只有一条,可以省略大括号和分号,如果是return语句,要省略return;
        flyTo(s-> System.out.println("我要飞到"+s));
        addDo((a,b)->a+b);
    }

    private static void addDo(Add add){
         int sum=add.add(1,2);
         System.out.println(sum);
    }
    public static void flyTo(Fly fly){
        fly.fly("北京");
    }
}