Lambda表达式的进化之路

为什么要使用Lambda表达式

  • 可以简洁代码,提高代码的可读性
  • 可以避免匿名内部类定义过多导致逻辑紊乱
  • 在原先实现接口抽象方法的时候,需要通过定义一个实现接口的外部类来实现,后面变为定义内部静态类,然后变为用局部内部类实现,再后面变成了定义匿名内部类来实现,最后的最后,为了代码的更加简洁,推出了Lambda表达式,最终实现了用一行代码完成之前多行代码的效果

Lambda表达式的注意点

  • Lambda表达式实际上属于是函数式编程的概念,所以在使用的时候要知道是否属于函数式编程

  • Lambda表达式的实现依赖于接口和父类,所以必须有两者之一才能实现Lam表达式

  • Lambda表达式实现的接口中要求只有一个抽象方法,如果有多个抽象方法就无法使用Lambda表达式来编程

  • Lambda表达式即适用于无参方法,也适用于含参方法

  • Lambda表达式最早在JDK 8中开始出现,所以只有 JDK 8 以后的版本才支持


下面是Lambda表达式的实现过程

  1. 最开始使用的是定义外部实现类来完成接口

    public class tt1 {
    public static void main(String[] args) {
    //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象
    //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难
    lover l1 = new lover();
    l1.love();
    }
    }
    //定义接口
    interface ILove {
    void love();
    }
    //外部实现类
    class lover implements ILove{
    @Override
    public void love() {
    System.out.println("I love you my lover ---> 1");
    }
    } //输出为:I love you lover ---> 1
  2. 开始使用静态内部类来实现

    public class tt1 {
    //静态内部类
    static class lover2 implements ILove{
    @Override
    public void love() {
    System.out.println("I love you my lover ---> 2");
    }
    }
    public static void main(String[] args) {
    //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象
    //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难
    ILove l1 = new lover1();
    l1.love();
    //使用静态内部类来实现,由于实现类和main方法位于相同主类中,方便了开发人员阅读,但是实现过程还是比较麻烦
    ILove l2 = new lover2();
    l2.love();
    }
    }
    //定义一个函数式接口
    interface ILove {
    void love();
    }
    //外部实现类
    class lover1 implements ILove{
    @Override
    public void love() {
    System.out.println("I love you my lover ---> 1");
    }
    } //输出为:I love you my lover ---> 1
    // I love you my lover ---> 2
  3. 使用局部内部类使用

    public class tt1 {
    //静态内部类
    static class lover2 implements ILove{
    @Override
    public void love() {
    System.out.println("I love you my lover ---> 2");
    }
    } public static void main(String[] args) { //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象
    //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难
    ILove l1 = new lover1();
    l1.love();
    //使用静态内部类来实现,由于实现类和main方法位于相同主类中,方便了开发人员阅读,但是实现过程还是比较麻烦
    ILove l2 = new lover2();
    l2.love(); //局部内部类
    class lover3 implements ILove{
    @Override
    public void love() {
    System.out.println("I love you my lover ---> 3");
    }
    }
    ILove l3 = new lover3();
    l3.love(); }
    }
    //定义一个函数式接口
    interface ILove {
    void love();
    }
    //外部实现类
    class lover1 implements ILove{
    @Override
    public void love() {
    System.out.println("I love you my lover ---> 1");
    }
    } //输出为:I love you my lover ---> 1
    // I love you my lover ---> 2
    // I love you my lover ---> 3
  4. 使用匿名内部类实现接口

    public class tt1 {
    //静态内部类
    static class lover2 implements ILove{
    @Override
    public void love() {
    System.out.println("I love you my lover ---> 2");
    }
    } public static void main(String[] args) { //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象
    //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难
    ILove l1 = new lover1();
    l1.love();
    //使用静态内部类来实现,由于实现类和main方法位于相同主类中,方便了开发人员阅读,但是实现过程还是比较麻烦
    ILove l2 = new lover2();
    l2.love(); //局部内部类
    class lover3 implements ILove{
    @Override
    public void love() {
    System.out.println("I love you my lover ---> 3");
    }
    }
    ILove l3 = new lover3();
    l3.love(); //使用内部匿名类
    ILove l4 = new ILove() {
    @Override
    public void love() {
    System.out.println("I love you my lover ---> 4");
    }
    }; }
    }
    //定义一个函数式接口
    interface ILove {
    void love();
    }
    //外部实现类
    class lover1 implements ILove{
    @Override
    public void love() {
    System.out.println("I love you my lover ---> 1");
    }
    } //输出为:I love you my lover ---> 1
    // I love you my lover ---> 2
    // I love you my lover ---> 3
    // I love you my lover ---> 4
  5. 最后使用Lambda表达式实现函数式接口

    public class tt1 {
    //静态内部类
    static class lover2 implements ILove{
    @Override
    public void love() {
    System.out.println("I love you my lover ---> 2");
    }
    } public static void main(String[] args) { //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象
    //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难
    ILove l1 = new lover1();
    l1.love();
    //使用静态内部类来实现,由于实现类和main方法位于相同主类中,方便了开发人员阅读,但是实现过程还是比较麻烦
    ILove l2 = new lover2();
    l2.love(); //局部内部类
    class lover3 implements ILove{
    @Override
    public void love() {
    System.out.println("I love you my lover ---> 3");
    }
    }
    ILove l3 = new lover3();
    l3.love(); //使用内部匿名类
    ILove l4 = new ILove() {
    @Override
    public void love() {
    System.out.println("I love you my lover ---> 4");
    }
    };
    l4.love(); //使用Lambda表达式实现接口
    ILove l5 = () ->{
    System.out.println("I love you my lover ---> 5");
    };
    l5.love();
    }
    }
    //定义一个函数式接口
    interface ILove {
    void love();
    }
    //外部实现类
    class lover1 implements ILove{
    @Override
    public void love() {
    System.out.println("I love you my lover ---> 1");
    }
    } //输出为:
    I love you my lover ---> 1
    I love you my lover ---> 2
    I love you my lover ---> 3
    I love you my lover ---> 4
    I love you my lover ---> 5

关于Lambda表达式的更加极致的简化(针对有参数的Lambda表达书)

  • 简化数据类型 在Lambda表达式中可以将参数的数据类型省略,只留下一个数据名称。比较特殊的是如果有多个参数,省略的时候应该将所有参数的数据类型都省略,不然就全部不省略,而且需要用括号将参数包含在内。
  • 省略括号 参照上一条,只有一个参数要求的时候才可以省略括号
  • 省略花括号 在Lambda表达式中,只有当输出语句或者代码只有一行的时候可以省略花括号。假如有多条执行代码,还是需要用花括号将代码包含在内

Java中Lambda表达式的进化之路的更多相关文章

  1. Java中lambda表达式详解

    原文地址:http://blog.laofu.online/2018/04/20/java-lambda/ 为什么使用lambda 在java中我们很容易将一个变量赋值,比如int a =0;int ...

  2. Java中Lambda表达式的使用

    简介(译者注:虽然看着很先进,其实Lambda表达式的本质只是一个"语法糖",由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能.本人建议不要乱用,因 ...

  3. Java中Lambda表达式的使用(转)

    https://www.cnblogs.com/franson-2016/p/5593080.html 简介(译者注:虽然看着很先进,其实Lambda表达式的本质只是一个"语法糖" ...

  4. 快速掌握Java中Lambda表达式的用法

    Lambda表达式的作用: Lambda表达式的作用就是简化代码开发,让代码看起来更加简介.它是用来简化匿名内部类的.但是并不是所有的匿名内部类都能用Lambda表达式简化,Lambda表达式是有使用 ...

  5. Java中Lambda表达式的简单使用

    Lambda表达式是Java SE 8中一个重要的新特性.你可以把 Lambda表达式 理解为是一段可以传递的代码 (将代码像数据一样进行传递).可以写出更简洁.更灵活的代码.作为一种更紧凑的代码风格 ...

  6. Java中lambda(λ)表达式的语法

    举一个排序的例子,我们传入代码来检查一个字符串是否比另一个字符串短.这里要计算: first.length() - second.length() first和second是什么?他们都是字符串.Ja ...

  7. 为什么Java中lambda表达式不能改变外部变量的值,也不能定义自己的同名的本地变量呢?

    作者:blindpirate链接:https://www.zhihu.com/question/361639494/answer/948286842来源:知乎著作权归作者所有.商业转载请联系作者获得授 ...

  8. Java中Lambda表达式基础及使用详解

    概述 Lambda 是JDK 8 的重要新特性.它允许把函数作为一个方法的参数(函数作为参数传递进方法中),使用 Lambda 表达式可以使代码变的更加简洁紧凑,使Java代码更加优雅. 标准格式 三 ...

  9. Java中lambda表达式学习

    一.Lambda表达式的基础语法: Java8中引入了一个新的操作符"->"该操作符称为箭头操作符或Lambda操作符,箭头操作符将Lambda表达式拆分为两部分: 左侧:L ...

随机推荐

  1. scrum项目冲刺_day11 第一阶段总结

    "智能垃圾分类APP"第一阶段总结 总任务: 一.appUI页面(已完成) 二.首页功能: 1.图像识别功能(已完成) 2.语音识别功能(已完成) 3.垃圾搜索功能(基本完成) 4 ...

  2. phpQuery

    以下资料均来自官方文档,官方文档地址:https://code.google.com/archive/p/phpquery/wikis 基础 示例 phpQuery::newDocumentFileX ...

  3. Android命令行启动模拟器

    我们在平时的开发中会经常需要使用模拟器进行调试,这个时候我们就要先打开Android Studio来启动模拟器,然后再运行App.这个流程中启动Android Studio需要花费一些时间,而模拟器的 ...

  4. 『GoLang』反射

    方法和类型的反射 反射是应用程序检查其所拥有的结构,尤其是类型的一种能.每种语言的反射模型都不同,并且有些语言根本不支持反射.Go语言实现了反射,反射机制就是在运行时动态调用对象的方法和属性,即可从运 ...

  5. UOJ#454-[UER #8]打雪仗【通信题】

    正题 题目链接:https://uoj.ac/problem/454 题目大意 \(Alice\)有一个长度为\(2n\)的\(01\)串,\(Bob\)有\(n\)个在\([1,2n]\)位置的下标 ...

  6. P3244-[HNOI2015]落忆枫音【dp】

    正题 题目链接:https://www.luogu.com.cn/problem/P3244 题目大意 给出一个\(\text{DAG}\),保证\(1\)可以到达所有点.然后再加入一条边(之后不一定 ...

  7. Python3入门系列之-----函数

    什么是函数 函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段. 函数能提高应用的模块性,和代码的重复利用率.你已经知道Python提供了许多内建函数,比如print().但你也可以自己 ...

  8. Redis之品鉴之旅(二)

    2)hash类型,上代码 using (RedisClient client = new RedisClient("127.0.0.1", 6379, "12345&qu ...

  9. easy-rule 学习

    Easyrule是个规则引擎,类似于drools,我们来熟悉一下这个东西 [ ] 一个简单实例规则,这个规则会被一直触发,然后行为是打印helloWorld @Rule(name="hell ...

  10. 小白自制Linux开发板 二. u-boot移植

    上一篇:小白自制Linux开发板 一. 瞎抄原理图与乱画PCB  中我们做了一个小型而没用的开发板,用的是Licheepi Nano的镜像,那从本篇开始我们开始自己构建它的灵魂吧. 我们都知道,PC在 ...