Lambda表达式

理解Function Interface(函数式接口) 是学习Java8 lambda表达式的关键所在。

函数式接口的定义：

　　任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

public interface Runnable{
   public abstract void run(); 
 }

对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

代码推导lambda表达式：无参数型

 1 package Thread;
 2 /*
 3 * 从1到5一步步简化
 4 *
 5 * */
 6 public class LambdaTest {
 7 
 8     //3 静态内部类
 9     static class Like2 implements ILike{
10         @Override
11         public void lambda() {
12             System.out.println("I like lambda2");
13         }
14     }
15 
16     public static void main(String[] args) {
17         ILike like=new Like();
18         like.lambda();
19 
20         like=new Like2();
21         like.lambda();
22 
23         //4局部内部类
24         class Like3 implements ILike{
25 
26             @Override
27             public void lambda() {
28                 System.out.println("I like lambda3");
29             }
30         }
31         like=new Like3();
32         like.lambda();
33 
34         //5 匿名内部类，没有类的名称，必须借助接口或父类
35         like=new ILike() {
36             @Override
37             public void lambda() {
38                 System.out.println("I like lambda4");
39             }
40         };
41         like.lambda();
42 
43         //6 用lambda简化
44         like=()->{
45             System.out.println("I like lambda5");
46         };
47         like.lambda();
48 
49     }
50 }
51 
52 //1，定义一个函数式接口
53 interface ILike{
54     void lambda();
55 }
56 //2 实现类
57 class Like implements ILike{
58     @Override
59     public void lambda() {
60         System.out.println("I like lambda");
61     }
62 }

代码推导lambda表达式：有参数型

 1 package Thread;
 2 
 3 public class LambdaTest2 {
 4 
 5     //3 静态内部类
 6     static class MyLove2 implements ILove{
 7 
 8         @Override
 9         public void love(int a) {
10             System.out.println("I LOVE YOU "+a);
11         }
12     }
13     public static void main(String[] args) {
14         ILove love=new MyLove();
15         love.love(520);
16 
17         new MyLove2().love(250);
18         
19         //4局部内部类
20         class MyLove3 implements ILove{
21 
22             @Override
23             public void love(int a) {
24                 System.out.println("I LOVE YOU "+a);
25             }
26         }
27         new MyLove3().love(113);
28 
29         //5 匿名内部类，没有类的名称，必须借助接口或父类
30         love=new ILove(){
31 
32             @Override
33             public void love(int a) {
34                 System.out.println("I LOVE YOU "+a);
35             }
36         };
37         love.love(3);
38 
39         //6 用lambda简化
40         love=(a)->{
41             System.out.println("I LOVE YOU "+a);
42         };
43         love.love(379);
44 
45     }
46 }
47 //1，定义一个函数式接口
48 interface ILove{
49     void love(int a);
50 }
51 //2 实现类
52 class MyLove implements ILove{
53     @Override
54     public void love(int a) {
55         System.out.println("I LOVE YOU "+a);
56     }
57 }