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

目录 Lambda表达式的进化之路 为什么要使用Lambda表达式 Lambda表达式的注意点 下面是Lambda表达式的实现过程 1.最开始使用的是定义外部实现类来完成接口 2.开始使用静态内部类来实现 3.使用局部内部类使用 0 Comments

目录
  • Lambda表达式的进化之路
    • 为什么要使用Lambda表达式
    • Lambda表达式的注意点
    • 下面是Lambda表达式的实现过程
      • 1.最开始使用的是定义外部实现类来完成接口
      • 2.开始使用静态内部类来实现
      • 3.使用局部内部类使用
      • 4.使用匿名内部类实现接口
      • 5..最后使用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

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");

}

}

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

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");

}

}

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

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");

}

}

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

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");

}

}

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

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");

}

}

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

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

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注服务器之家的更多内容！

原文链接：https://www.cnblogs.com/ZeeWay/p/15501789.html

本文链接：https://my.lmcjl.com/post/7864.html

展开阅读全文

相关文章

4 评论

留下您的评论.