【Java基础】Lambda表达式-CSDN博客

package com.company;

public class Main {
    class MyThread01 implements Runnable{
        @Override
        public void run() {
            System.out.println("成员内部类");
        }
    }

    public static void main(String[] args) {
	// write your code here
        //创建Main类的对象
        Main main = new Main();
        //创建Main类对象main中的MyThread01类的对象
        MyThread01 myThread01 = main.new MyThread01();
        //用Thread加载MyThread01类的对象
        new Thread(myThread01).start();
    }
}

可以看到我们需要在类内部定义一个类继承Runnable接口，然后重写run()方法，然后再主函数中先定义外Main类的对象，然后通过Main对象来定义MyThread01对象，然后通过Thread装载MyThread01的对象才可以完成线程启动

局部内部类

package com.company;

public class Main {
    public static void main(String[] args) {
	// write your code here
        class MyThread01 implements Runnable{
            @Override
            public void run() {
                System.out.println("局部内部类");
            }
        }
        //区别:不需要通过Main对象来创建MyThread01对象了
        MyThread01 myThread01 = new MyThread01();
        new Thread(myThread01).start();
    }
}

与成员内部类不同的是，成员内部类将MyThread01类定义在了主函数外部，而局部内部类将MyThread01类定义在了主函数内部，这样在创建MyThread01对象的时候就不用通过创建Main类的对象来创建MyThread01对象了。

静态内部类

package com.company;

public class Main {
    static class MyThread01 implements Runnable{
        @Override
        public void run() {
            System.out.println("静态内部类");
        }
    }
    public static void main(String[] args) {
	// write your code here
        //可以直接创建
        MyThread01 myThread01 = new MyThread01();
        new Thread(myThread01).start();
    }
}

与成员内部类不同的是，静态内部类在类前面增加了static修饰关键词，静态内部类除了写在一个类内部以外，具备所有外部类的特性。也可以直接创建MyThread01对象。

匿名内部类

package com.company;

public class Main {

    public static void main(String[] args) {
	// write your code here
        Runnable myThread01 = new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类");
            }
        };
        new Thread(myThread01).start();
    }
}

静态内部类是可以直接通过实例化接口，然后再内部直接进行对方法的定义，这么定义没有类名，无法调用第二次。

函数式接口

Lambda表达式只支持函数式接口的简化，所以在了解Lambda表达式的用法前，需要先了解什么是函数式接口。

函数式接口：只有一个抽象方法的接口

比如Runnable接口，我们可以查看Runnable接口的源码

@FunctionalInterface注解用于判断是不是一个函数式接口

我们可以看到接口中只有一个叫run的方法

    public abstract void run();

这里方法前用abstract修饰，而且只有这一个方法，说明Runnable接口是一个只有一个抽象方法run的接口

这种函数式接口我们也可以自己定义

Lambda表达式语法

概括来说就是

(方法形参类型 方法的变量, ...)->{方法内部的语句}

例如

package com.company;

public class Main {

    public static void main(String[] args) {
	// write your code here
        //调用Runnable的run方法，然后输出Lambda
        Runnable myThread01 = ()-> {System.out.println("Lambda")};
        new Thread(myThread01).start();
    }
}

当{}内部的语句只有一条时，{}可以省略

语句就从

Runnable myThread01 = ()-> {System.out.println("Lambda")};

变为

Runnable myThread01 =() -> System.out.println("Lambda");

再例如，如果抽象方法中带有形参,可以省去形参类型

由

(int a,String b,double c)->{方法内部的语句}

变为

(a,b,c)->{方法内部的语句}