Java语法-Lambda表达式

1、面向对象的思想和函数编程思想区别是什么？

面向对象的思想是重视过程，解决一个事情，找到一个合适的对象，调用对象的方法；
函数式编程思想是重视结果，给定输入，得到结果即可；

2、如何写Lambda表达式？这种写法如何理解？

括号（含参或不含参） + 箭头 + {方法体}；
（1）参数列表 传递给 方法体；
参数列表是接口中抽象方法的参数列表；
方法体是重写接口的抽象方法；
（2）用创建线程的匿名内部类方法理解 —— 相当于省略了new Runable, public void run；

public class test {
    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "创建了新线程");
            }
        }).start();

        new Thread(()->{
            System.out.println(Thread.currentThread().getName() + "创建了新的线程");
        }).start();

    }
}

3、Lambda表达式的作用是什么？

本来需要新建一个接口的实现类对象，重写其中的run方法；
现在只要在需要传入这个对象的位置用Lambda表达式就可以了；

public interface Cook {
    public abstract void makeFood();
}

public class test {
    public static void main(String[] args) {
    
        invokeCook(()->{ System.out.println("青椒肉丝"); });

//        Cook cook = new Cook() {
//            @Override
//            public void makeFood() {
//                System.out.println("青椒肉丝");
//            }
//        };
//        invokeCook(cook);
    }

    public static void invokeCook(Cook cook){
        cook.makeFood();
    }
}

public class Person {

    private int age;
    private String name;

    public Person() {
    }

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

    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

public class test {
    public static void main(String[] args) {

        // 引用类型定义数组
        Person[] arr =
                {new Person("Lebron James",35),
                        new Person("Kobe",40),
                        new Person("Dong77",20)
        };

//        Arrays.sort(arr, new Comparator<Person>() {
//            @Override
//            public int compare(Person o1, Person o2) {
//                return o1.getAge() - o2.getAge();
//            }
//        });

        Arrays.sort(arr,(Person o1, Person o2)->{return o1.getAge() - o2.getAge();});

        for (Person p : arr) {
            System.out.println(p);
        }
    }
}

public interface Calculator {
    public abstract int calc(int a, int b);
}

public class test {
    public static void main(String[] args) {

//        invokeCalc(3, 2, new Calculator() {
//            @Override
//            public int calc(int a, int b) {
//                return a+b;
//            }
//        });

        invokeCalc(3,2,(a,b)->{return a+b;});

    }

    private static void invokeCalc(int a, int b, Calculator calculator){
        int result = calculator.calc(a, b);
        System.out.println("结果 = " + result);
    }
}

4、Lambda表达式的使用场景有哪些?

无参无返回的系统接口/自定义接口；
有参有返回的系统接口/自定义接口；
接口仅有一个抽象方法 --> 有且只有一个抽象方法的接口叫做“函数式接口"
只有在new一个接口的时候才能用！