Lambda表达式的进化之路

Lambda表达式的进化之路

为什么要使用Lambda表达式

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

Lambda表达式的注意点

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

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

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

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

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

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    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. 开始使用静态内部类来实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    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. 使用局部内部类使用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    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. 使用匿名内部类实现接口

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    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表达式实现函数式接口

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    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表达式的进化之路
https://blake315.github.io/2022/09/01/Lambda表达式/
作者
Zeeway
发布于
2022年9月1日
许可协议