public interface JDK8Interface {
    /*
     * 默认就是 public abstract 的,不需要加修饰符
    */
    void add();
    /*
     * JDK8 提供 默认的方法
     */
    default void get(){
        System.out.println("get");
    }

    /*
     * JDK8 提供的静态方法 只能通过 接口名.方法名来 调用
     */
    static void del(){
        System.out.println("del");
    }
}

编写接口的实现类

public class JDK8InterfaceImpl implements JDK8Interface {

    @Override
    public void add() {
        System.out.println("add");
    }
    
}

测试

public class Test01 {
    public static void main(String[] args) {
        JDK8InterfaceImpl jdk8Interface = new JDK8InterfaceImpl();
        jdk8Interface.add();
        jdk8Interface.get();
        JDK8Interface.del();    
    }
}

我们可以得到这样一个结论：接口中定义的默认方法只有子类对象才能调用，而接口中定义的静态方法只有接口类才能调用。

2、Lambda表达式（重点）

什么是 Lambda 表达式？

Lanmbda 表达式是一个匿名函数，即没有函数名的函数，基于数学中的 λ 而得名。

优点：简化匿名内部类的调用，减少代码量。

缺点：不好调试

编写接口：

public interface OrderService {
    void get();
}

测试：

public class Test02 {
    public static void main(String[] args) {

        // 1. 通过匿名内部类创建一个实现OrderService接口的子类
        OrderService service = new OrderService() {
            @Override
            public void get() {
                System.out.println("get");
            }
        };
        service.get();

        // 2. lambda 表达式  括号代表参数列表
        ((OrderService) ()-> System.out.println("get")).get();

        // 3. 同样是lambda表达式
        new Thread(()-> System.out.println("get")).start();

    }
}

注意：这里的接口只能有一个抽象方法！具体原因看下面。

2.1、Lambda 表达式规范

2.1.1、函数接口的定义

Java 中使用 Lambda 表达式依赖于函数接口。我们在 new 一个对象，需要传入的参数是接口类型时，可以使用该接口的实现类，也可以直接构造一个匿名内部类（这里我们就可以通过 lambda 表达式来简化代码，提高开发效率，主要是看起来是真的舒服）。

在接口当中只允许存在一个抽象方法。
允许使用 default 和 static 修饰的方法。
使用注解 @FunctionalInterface 来标记该接口为函数接口（接口中只包含一个方法的叫做函数接口），我们可以发现，如果接口中出现了超过1个的抽象方法代码就会爆红。
可以定义 Object 类中的方法

下面是我自定义的一个函数接口。

/**
 * 函数接口 只允许包含一个抽象方法
 * 4. 使用注解 @FunctionalInterface 来标注着是一个函数接口
 */
@FunctionalInterface
public interface MyFunctionInterface {
    // 1. 只允许存在一个方法
    void get();

    // 2. 允许存在 default 和 static 修饰的方法
    default void add(){
        System.out.println("add");
    }
    static void ss(){
        System.out.println("ss");
    }

    // 3. 可以存在 Object 类中的方法
    String toString();
    boolean equals(Object obj);
    int hashCode();
}

2.1.2、Java 内置的函数接口

new Thread(new Runnable() {
            @Override
            public void run() {
               // 方法体 
            }
        }).start();

正因为i Runnable 是一个函数接口，所以我们可以这样简写：

new Thread(()->{
          // 方法体  
        }).start();

2.2、Lambda 基础语法

语法：

() -> {}

()：参数列表
->：分隔符
{}：方法体

2.2.1、无参方法调用

（1）编写函数接口

@FunctionalInterface
public interface ParamLambdaInterface {
    void get();
}

（2）使用 lambda

public class Test03 {
    public static void main(String[] args) {
        // 1. 匿名内部类
        new ParamLambdaInterface(){
            @Override
            public void get() {
                System.out.println("get");
            }
        };
        // 2. lambda 表达式
        ParamLambdaInterface pl = () -> {
            System.out.println("get");
        };
        pl.get();

    }
}

2.2.2、有参方法调用

（1）编写函数接口

@FunctionalInterface
public interface OrderService {
    void get(String name);
}

（2）使用 lambda

public class Test04 {
    public static void main(String[] args) {

        // 1. 通过匿名内部类创建一个实现OrderService接口的子类
        OrderService service = new OrderService() {
            @Override
            public void get(String name) {
                System.out.println(name);
            }
        };
        service.get("tom");

        // 2. lambda 表达式 参数类型可以省略
        OrderService od = (name)->{
            System.out.println(name);
        };
        od.get("get");
    
        // 简化
        ((OrderService) System.out::println).get("tom");
    }
}

2.3、Lambda 的精简写法

2.3.1、无参方法

上面 2.2.1 也可以这么写：

// 一行代码的情况下 可以省去花括号
((ParamLambdaInterface) () -> System.out.println("get")).get();

2.3.2、有参方法

2.2.2 可以这么写：

如果参数只有一个可以省去括号

((OrderService) name -> System.out.println(name)).get("get");

练习

定义一个用于计算和的函数接口

@FunctionalInterface
public interface AddInterface {
    int add(int a,int b);
}

测试，求 1 和 2 的和

int result = ((AddInterface) (a, b) -> a + b).add(1, 2);

2.4、Lambda 实战

forEach

定义一个存放姓名的 List ：

List<String> list = new ArrayList<>();
        list.add("mike");
        list.add("tom");
        list.add("bob");

使用 List 的 forEach 方法打印所有元素：

可以看到 forEach 的参数也是一个函数接口，而且只有一个抽象方法 accept。

    // 1. 普通写法
    list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });    
    
    // 2. lambda
    list.forEach(name-> System.out.println(name) );

    // 简化
    list.forEach(System.out::println);

将输出结果全部大写输出：

// 将名字转为大写再输出
        list.forEach(name-> System.out.println(name.toUpperCase(Locale.ROOT)));

集合排序

数据准备

public class User {
    private String name;
    private Integer age;

    public User(){}

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

创建一个 User 集合

List<User> list = new ArrayList<>();
        list.add(new User("mike",20));
        list.add(new User("bob",18));
        list.add(new User("tom",25));

使用 lambda 进行排序：

    // 1. 普通写法
    list.sort(new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return 0;
            }
        });
    // 2. lambda 表达式
    list.sort((user1,user2)-> user1.getAge()-user2.getAge());   // 升序排列
    
    // 输出结果
    list.forEach(System.out::println);

运行结果：

User{name='bob', age=18}
User{name='mike', age=20}
User{name='tom', age=25}