多线程（2）——Lambda表达式的推导过程

Lambda表达式

学习视频B站狂神java多线程：https://www.bilibili.com/video/BV1V4411p7EF?

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

• 属于函数式编程
  (params) -> expression [表达式]
  (params) -> statement [语句]
  (params) -> {statements}

• Lanbda表达式只能用于函数式接口（Functional Interface）：任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口

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

Lambda表达式实现接口的推导

自定义函数式接口Run

interface Run{
    void run();
}

1. 实现类

public class TestLambda {
    public static void main(String[] args) {
        Run r1=new bird();
        r1.run();
    }
}
//1、实现类
class bird implements Run{
    @Override
    public void run() {
        System.out.println("bird飞");
    }
}

2. 静态内部类（成员内部类：将内部类作为外部类的成员属性）

//2、静态内部类(内部类：内部类可以调用类外的方法，类外不能调用内部类方法)
public class TestLambda{
    static class dog implements Run{
        @Override
        public void run() {
            System.out.println("dog跑");
        }
    }
    
    public static void main(String[] args) {
        Run r2=new dog();
        //Run r2=new TestLambda().new dog();//如果不把内部类设为静态的创建对象方法，调用内部类方法同理
        r2.run();
    }
}

3. 局部内部类（只能在当前方法调用该内部类，方法外不能调用）

public static void main(String[] args) {
        //3、局部内部类
        class cat implements Run{
            @Override
            public void run() {
                System.out.println("cat跑");
            }
        }
        Run r3=new cat();
        r3.run();
    }

4. 匿名内部类

public static  void main(String[] args) {
        //4、匿名内部类（类名不会表示、匿名内部类可以继承两种数据结构：接口和抽象类）
        Run r4=new Run(){
            @Override
            public void run() {
                System.out.println("pig跑");
            }
        };
        r4.run();
    }

5. Lambda表达式

 public static  void main(String[] args) {
        //5、Lambda表达式
        Run r5=()->{
            System.out.println("duck游");
        };
        r5.run();
    }

6. 几种实现接口方式的完整代码：

public class TestLambda {
    //2、静态内部类
     static class dog implements Run{
        @Override
        public void run() {
            System.out.println("dog跑");
        }
    }
    public static  void main(String[] args) {
        Run r1=new bird();
        r1.run();

        Run r2=new dog();
        //Run r2=new TestLambda().new dog();//如果不把内部类设为静态的创建对象方法，调用内部类方法同理
        r2.run();
        
        //3、局部内部类
        class cat implements Run{
            @Override
            public void run() {
                System.out.println("cat跑");
            }
        }
        Run r3=new cat();
        r3.run();
        //4、匿名内部类
        Run r4=new Run(){
            @Override
            public void run() {
                System.out.println("pig跑");
            }
        };
        r4.run();
        //5、Lambda表达式
        Run r5=()->{
            System.out.println("duck游");
        };
        r5.run();

    }
}
//1、实现类
class bird implements Run{
    @Override
    public void run() {
        System.out.println("bird飞");
    }
}
//定义函数式接口
interface Run{
    void run();
}

Lambda表达式的注意点

• 前提：接口必须为函数式接口
• Lambda表达式只能有一行代码的情况下才能简化为一行，如果有多行，需要用代码块

Run r5=()->{
            System.out.println("duck游");
            System.out.println("duck1游");
        };
Run r6 =()-> System.out.println("duck游");

• 参数可以去掉参数类型，如果有多个参数需要加括号，如果去掉参数类型需要同时去掉，参数类型在接口中定义

public class TestLambda2 {
    public static void main(String[] args) {
        Sleep s=(a,b,c) -> {
            System.out.println(a);
            System.out.println(b);
            System.out.println(c);
        };
        s.sleep(12,45,6);
    }
}
interface Sleep{
    void sleep(int a,int b,int c);
}