Lambda表达式

Lambda表达式

1. 函数式编程思想与面向对象编程思想的区别：

(1) 面向对象的思想:
做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.
(2) 函数式编程思想:
只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程

2. Lambda表达式的标准格式
Lambda表达式由3部分组成：①一些参数 ②一个箭头 ③一段代码

格式：(参数类型 参数名称) -> { 代码语句 }
格式说明：
小括号内的语法与传统的参数列表相同:无参数则留空；多个参数则用逗号隔开
->传递的意思，把参数传递给方法体
大括号的语法与传统方法体要求基本一致

3.练习 Lambda表达式的使用

• 无参数无返回值的使用，同时使用匿名内部类和Lambda表达式
  代码展示

//Cook接口，包含一个抽象方法makeFood()
public interface Cook {
    public abstract void makeFood();
}

//测试类
public class Demo01Cook {
    public static void main(String[] args) {
        //使用匿名内部类
        invokeCook(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭啦");
            }
        });
        //使用Lambda表达式,五无参数无返回值
        invokeCook(()->{
            System.out.println("吃饭啦");
        });
    }

    //包含一个invokeCook方法，参数为Cook接口。里边调用makeFood方法
    private static void invokeCook(Cook cook) {
        cook.makeFood();

    }
}

• 有参数和返回值的使用

需求:
使用数组存储多个Person对象
对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序

代码实现

//Person类
public class Person {
    private String name;
    private int 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;
    }

    public Person() {
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//测试类
public class Demo02Person {
    public static void main(String[] args) {
        //创建一个存放Person的数组
        Person[] arr={
                new Person("猪猪侠",19),
                new Person("孙悟空",39),
                new Person("白骨精",28),
        };
        //进行排序
        Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                //前边减后边
                return o1.getAge()-o2.getAge();
            }
        });
        //使用Lambda表达式
        Arrays.sort(arr,(Person o1, Person o2)->{
            return o1.getAge()-o2.getAge();
        });

        //输出结果
        for (Person p : arr) {
            System.out.println(p);

        }
    }
}

• 自定义接口
  代码实现

/定义一个接口，包含抽象方法calc 可以将两个int型的数相加得到结果
public interface Calculator {
    public abstract int calc(int a,int b);
}
//测试类
public class Demo03Calc {
    public static void main(String[] args) {
        //匿名内部类
        invokeCalc(120, 130, new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a+b;
            }
        });
        //使用Lambda表达式
        invokeCalc(10,20,(int a,int b)->{
            return a+b;
        });

    }
    //定义一个方法
    public static void invokeCalc(int a,int b,Calculator c){
        int sum=c.calc(a,b);
        System.out.println("两个数之和为"+sum);
    }
}

4. Lambda表达式的省略规则

• 小括号内的参数类型可以省略
• 如果小括号内有且仅有一个参数，则小括号可以省略
• 如果大括号内有且只有一条语句，则无论有无返回值，都可以省略大括号，return关键字以及语句分号
  例如：

  //使用Lambda表达式
        invokeCalc(10,20,(int a,int b)->{
            return a+b;
        });
        //简化
        invokeCalc(10,20,( a, b)->a+b);

5. Lambda表达式使用前提

• 使用Lambda表达式必须具有接口，而且接口内有且只有一个抽象方法
• 使用Lambda表达式必须具有上下文推断

也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

• 有且仅有一个抽象方法的接口，称为函数式接口