软件编程
位置:首页>> 软件编程>> java编程>> Java中Lambda表达式的进化之路详解

Java中Lambda表达式的进化之路详解

作者:Thales_ZeeWay  发布时间:2023-04-19 21:17:42 

标签:Java,Lambda,表达式

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表达式中,只有当输出语句或者代码只有一行的时候可以省略花括号。假如有多条执行代码,还是需要用花括号将代码包含在内

来源:https://www.cnblogs.com/ZeeWay/p/15501789.html

0
投稿

猜你喜欢

手机版 软件编程 asp之家 www.aspxhome.com