面向对象03-Lambda表达式

最新推荐文章于 2023-09-13 15:09:21 发布

一个优质的胖纸

最新推荐文章于 2023-09-13 15:09:21 发布

阅读量152

点赞数

分类专栏： Java 文章标签： java android 开发语言

本文链接：https://blog.csdn.net/weixin_48302551/article/details/130797421

版权

Java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

面向对象高级(3)-Lambda表达式

二、Lambda表达式

2.1 体验Lambda表达式

而由于Lambda表达式是函数式思想的体现，所以在这里，我们首先给大家介绍一下函数式编程思想。

来，看这里，这个符号就叫做Lambda。它被称为函数式编程。

在这里插入图片描述

要想知道什么是函数式编程，我们先得知道什么是函数。

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”。

而我们目前学习的Java语言是一种面向对象语言，面向对象思想强调“必须通过对象的形式来做事情”。也就是说做一件事情之前，我们要先创建一个对象。

而函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”，我们要学习的Lambda表达式就是函数式思想的体现。它强调的是做什么。

了解了函数式思想后，下面我们来看一个需求，分别通过面向对象思想和函数式思想来实现。

需求：按照如下代码要求，使用接口，进行测试

在这里插入图片描述

面向对象思想：匿名内部类实现

函数式思想：Lambda表达式实现

public interface Inter {
    void show();
}

/*
    测试类
 */
public class InterDemo {
    public static void main(String[] args) {
        //匿名内部类实现
        useInter(new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类实现");
            }
        });

        //Lambda表达式实现
        useInter(() -> {
            System.out.println("Lambda表达式实现");
        });
    }

    public static void useInter(Inter i) {
        i.show();
    }
}

Lambd表达式的方式比匿名内部类更简洁，而且它重点是关注要做的事情。而不是按照面向对象的方式去思考哪个对象去怎么做事情。

2.2 Lambda表达式标准格式

匿名内部类方式和Lambda表达式方式的代码区别：

匿名内部类中重写show()方法的代码分析

方法形式参数为空，说明调用方法时不需要传递参数
方法返回值类型为void，说明方法执行没有结果返回
方法体中的内容，是我们具体要做的事情

在这里插入图片描述

Lambda表达式的代码分析

()：里面没有内容，可以看成是方法形式参数为空
->：用箭头指向后面要做的事情
{ }：包含一段代码，我们称之为代码块，可以看成是方法体中的内容

在这里插入图片描述

组成Lambda表达式的三要素：形式参数，箭头，代码块

Lambda表达式的格式

格式：(形式参数) -> {代码块}
形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
->：由英文中划线和大于符号组成，固定写法。代表指向动作
代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

总结起来就是一句话：拿着形式参数去做代码块中的事情

2.3 练习1(无参无返回值)

Lambda表达式的使用前提：

有一个接口
接口中只能有一个抽象方法

练习1：

定义一个接口(Eatable)，里面定义一个抽象方法：void eat();
定义一个测试类(EatableDemo)，在测试类中提供两个方法
- 一个方法是：useEatable(Eatable e)
- 一个方法是主方法，在主方法中调用useEatable方法

public interface Eatable {
    void eat();
}

/*
    Lambda表达式的格式：(形式参数) -> {代码块}

    练习1：
        1:定义一个接口(Eatable)，里面定义一个抽象方法：void eat();
        2:定义一个测试类(EatableDemo)，在测试类中提供两个方法
            一个方法是：useEatable(Eatable e)
            一个方法是主方法，在主方法中调用useEatable方法
 */
public class EatableDemo {
    public static void main(String[] args) {
        //在主方法中调用useEatable方法
        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一苹果，医生远离我");
            }
        });

        //Lambda表达式
        useEatable(() -> {
            System.out.println("一天一苹果，医生远离我");
        });
    }

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

2.4 练习2(带参无返回值)

练习2：

定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);
定义一个测试类(FlyableDemo)，在测试类中提供两个方法
一个方法是：useFlyable(Flyable f)
一个方法是主方法，在主方法中调用useFlyable方法

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

/*
    Lambda表达式的格式：(形式参数) -> {代码块}

    练习2：
        1:定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);
        2:定义一个测试类(FlyableDemo)，在测试类中提供两个方法
            一个方法是：useFlyable(Flyable f)
            一个方法是主方法，在主方法中调用useFlyable方法
 */
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("飞机自驾游");
            }
        });
        System.out.println("--------");

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

    }

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

2.5 练习3(带参带返回值)

练习3：

定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);
定义一个测试类(AddableDemo)，在测试类中提供两个方法
一个方法是：useAddable(Addable a)
一个方法是主方法，在主方法中调用useAddable方法

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

/*
    Lambda表达式的格式：(形式参数) -> {代码块}

    练习3：
        1:定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);
        2:定义一个测试类(AddableDemo)，在测试类中提供两个方法
            一个方法是：useAddable(Addable a)
            一个方法是主方法，在主方法中调用useAddable方法
 */
public class AddableDemo {
    public static void main(String[] args) {
        //在主方法中调用useAddable方法
        useAddable((int x,int y) -> {
            return x + y;
//            return  x - y;
        });

    }

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

2.6 Lambda的省略模式

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

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

/*
    Lambda表达式的省略模式
 */
public class LambdaDemo {
    public static void main(String[] args) {
//        useAddable((int x,int y) -> {
//            return x + y;
//        });
        //参数的类型可以省略
        useAddable((x, y) -> {
            return x + y;
        });
        //但是有多个参数的情况下，不能只省略一个
//        useAddable((x,int y) -> {
//            return x + y;
//        });

//        useFlyable((String s) -> {
//            System.out.println(s);
//        });
//        useFlyable((s) -> {
//            System.out.println(s);
//        });
        //如果参数有且仅有一个，那么小括号可以省略
//        useFlyable(s -> {
//            System.out.println(s);
//        });

        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyable(s -> System.out.println(s));

        //如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
        useAddable((x, y) -> x + y);
    }

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

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

省略规则：

参数类型可以省略。但是有多个参数的情况下，不能只省略一个
如果参数有且仅有一个，那么小括号可以省略
如果代码块的语句只有一条，可以省略大括号和分号，甚至是return

2.7 Lambda和匿名内部类的区别

public interface Inter {
    void show();
//    void show2();
}

public abstract class Animal {
    public abstract void method();
}

public class Student {
    public void study() {
        System.out.println("爱生活，爱Java");
    }
}

/*
    Lambda表达式和匿名内部类的区别
 */
public class LambdaDemo {
    public static void main(String[] args) {
        //匿名内部类
        /*
        useInter(new Inter() {
            @Override
            public void show() {
                System.out.println("接口");
            }
        });

        useAnimal(new Animal() {
            @Override
            public void method() {
                System.out.println("抽象类");
            }
        });

        useStudent(new Student(){
            @Override
            public void study() {
                System.out.println("具体类");
            }
        });
        */

        useInter(new Inter() {
            @Override
            public void show() {
                System.out.println("接口");
            }
        });

        //Lambda
//        useInter(() -> System.out.println("接口"));
//        useAnimal(() -> System.out.println("抽象类"));
//        useStudent(() -> System.out.println("具体类"));

//        useInter(() -> System.out.println("接口"));

//        useInter(new Inter() {
//            @Override
//            public void show() {
//                System.out.println("show");
//            }
//
//            @Override
//            public void show2() {
//                System.out.println("show2");
//            }
//        });

    }

    private static void useStudent(Student s) {
        s.study();
    }

    private static void useAnimal(Animal a) {
        a.method();
    }

    private static void useInter(Inter i) {
        i.show();
    }
}

总结：

所需类型不同
- 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
- Lambda表达式：只能是接口
使用限制不同
- 如果接口中仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
- 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
实现原理不同
- 匿名内部类：编译之后，产生一个单独的.class字节码文件
- Lambda表达式：编译之后，你没有看到一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

al(Animal a) {
a.method();
}

private static void useInter(Inter i) {
    i.show();
}

}


总结：

- **所需类型不同**
  - 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
  - Lambda表达式：只能是接口
- **使用限制不同**
  - 如果接口中仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
  - 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
- **实现原理不同**
  - 匿名内部类：编译之后，产生一个单独的.class字节码文件
  - Lambda表达式：编译之后，你没有看到一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

一个优质的胖纸

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象03-Lambda表达式

而由于Lambda表达式是函数式思想的体现，所以在这里，我们首先给大家介绍一下函数式编程思想。来，看这里，这个符号就叫做Lambda。它被称为函数式编程。要想知道什么是函数式编程，我们先得知道什么是函数。在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”。而我们目前学习的Java语言是一种面向对象语言，面向对象思想强调“必须通过对象的形式来做事情”。也就是说做一件事情之前，我们要先创建一个对象。
复制链接

扫一扫