【学习笔记】线程（三）之Lambda表达式

线程（三）之Lambda表达式

 

Lambda 表达式

• 为什么要使用Lambda表达式

  • 为了避免匿名内部类定义过多

  • 可以让代码看起来很简洁

  • 去掉一些没有意义的代码，只留下核心的逻辑

• 函数式接口（Functional Interface）

  • 定义：任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口

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

下面我们来一步一步地推导lambda表达式

首先我们定义一个函数式接口

//定义一个函数式接口
interface Ilike{
    void  lambda();
}

1. 通过外部实现类

//1.实现类
class Like implements Ilike{
​
    @Override
    public void lambda() {
        System.out.println("i like lambda1");
    }
}
public class TestLambda1 {
    public static void main(String[] args) {
        Ilike like = new Like();
        like.lambda();
    }
}
​

这种方式是在外部写一个类去实现这个函数式接口，然后在主函数中实例化这个类，在调用它地方法

 

2. 静态内部类

public class TestLambda1 {
    //静态内部类
    static class Like2 implements Ilike{
​
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }
    public static void main(String[] args) {
​
        Ilike like = new Like2();
        like.lambda();
​
    }
}

静态内部类：把这个实现类写在一个类里面，需要用 static 来修饰

 

3. 局部内部类

public class TestLambda1 {
  
    public static void main(String[] args) {
​
        //3.局部内部类
        class Like3 implements Ilike{
​
            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }
        Ilike like = new Like3();
        like.lambda();
    }
}

局部内部类：定义在方法里面

 

4. 匿名内部类

public class TestLambda1 {
​
    public static void main(String[] args) {
​
        //4.匿名内部类
        Ilike like = new Ilike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };
    }
}

匿名内部类：也是定义在方法里面，但是它没有类的名称，必须借助接口或者父类定义

 

5. lambda表达式

public class TestLambda1 {
 
    public static void main(String[] args) {
        
        Ilike like = null;
       
        //5.Lambda表达式
        like = () -> {
            System.out.println("i like lambda5");
        };
        like.lambda();
    }
}

只剩下一个方法体，原因是函数式接口只有一个抽象方法，所以lambda表达式中的代码块，就一定是 这个方法的方法体。

 

下面写一个带参数的lambda 表达式，然后一步一步简化它的格式

 

1. 最原始的状态

public class TestLambda2 {
    public static void main(String[] args) {
        ILove love = null;
        love = (int a) -> {
            System.out.println("i love you --->" + a);  
        };
        love.love(520);
    }
}
​
interface ILove{
    void love(int a);
}

2. 去掉参数类型

public class TestLambda2 {
    public static void main(String[] args) {
        ILove love = null;
        //简化参数类型
        love = (a) -> {
            System.out.println("i love you --->" + a);
        };
        love.love(520);
    }
}

3. 去掉括号

public class TestLambda2 {
    public static void main(String[] args) {
        ILove love =null;
        //简化括号
        love = a -> {
            System.out.println("i love you --->" + a);
        };
        love.love(520);
    }
}

4. 去掉花括号

public class TestLambda2 {
    public static void main(String[] args) {
        ILove love =null;
        //简化花括号
        love = a -> System.out.println("i love you --->" + a);
        love.love(520);
    }
}

 

总结：简化的要求

1. lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，就用代码块包裹，也就是花括号

2. 前提为接口是函数式接口

3. 多个参数也可以去掉函数类型，要去掉就都去了，必须加上括号

 

Runnable 接口就是一个函数式接口，可以使用 lambda 表达式来简化代码

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