JAVAEE细细看 进阶 17 - 新特性：Lambda、接口的组成、方法引用

新特性：Lambda、接口的组成、方法引用

一 Lambda

案例
启动一个线程，在控制台输出一句话：多线程程序启动了

// 方法一 需要建一个类实现Runnable接口
Lambda lambda = new Lambda();

// 线程
Thread thread = new Thread(lambda);
thread.start();

// 方法 二 改进
// 匿名内部类的方式实现
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("多线程程序启动了！！！");
    }
}).start();

// 使用lambda实现
new Thread( () -> {
    System.out.println("多线程程序启动了！！！");
}).start();

lambda的三要求：形式参数、箭头，代码块
使用前提：

1. 有一个接口
2. 接口中有且只有一个抽象方法

案例一 无参

public interface Eatable {
    void eat();
}
public class EatableDemo {
    public static void main(String[] args) {

        // 第一种
        Eatable eat = new EatImpl();
        useEatable(eat);

       // 第二种
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一苹果，医生远离我！！");
            }
        });

        // 第三种
        useEatable(() -> {
                System.out.println("一天一苹果，医生远离我！！");
        });
    }

    private static void useEatable(Eatable e) {
        e.eat();
    }
}

案例二 一个参数

public interface Flyable {
    void fly(String s);
}
public class FlyableDemo {
    public static void main(String[] args) {

        useFlyable((s) -> {
            System.out.println(s);
        });

    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }
}

案例三 多个参数

public interface Addable {
    int add(int x,int y);
}
public class AddableDemo {
    public static void main(String[] args) {
        useAddable((int a, int b) -> {
            return a + b;
        });
    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

lambda省略格式

public static void main(String[] args) {

    // 1. 参数类型可以省略
    useFlyable((s) -> {
        System.out.println(s);
    });
    useAddable((x, y) -> {
        return x + y;
    });

    // 2. 参数只有一个 小括号可以省略
    useFlyable(s -> {
        System.out.println(s);
    });

    // 3. 语句只有一条，可以省略大括号和分号，有return也要省略
    useFlyable(s -> System.out.println(s));
    useAddable((a, b) -> a + b);
}

private static void useFlyable(Flyable f) {
    f.fly("风和日丽，晴空万里");
}

private static void useAddable(Addable a) {
    int sum = a.add(10, 20);
    System.out.println(sum);
}

二. Lambda表达式和匿名内部类的区别

三. 接口的组成更新

1. 常量
2. 抽象方法
3. 默认方法(java 8)
4. 静态方法(java 8)
5. 私有方法(java 9)

接口中的默认方法
定义：
public default void show(){}

注意事项：
a. 默认方法不是抽象方法，所以不强制被重写，但是可以被重写，重写的时候去掉defalut关键字
b. 声明的时候，public可以省略，但是default不可以省略

接口中的静态方法
定义：
public static void show(){} // 和正常的静态方法相同

注意事项：
a. 静态方法只能通过接口调用，不能通过实现类名或者对象名调用
b. public可以省略，static不能省略

接口中的私有方法
格式1: private void show(){}
格式2：private static void show(){}

注意事项：
a. 默认方法可以调用私有的静态方法和非静态方法
b. 静态方法，只能调用静态方法

四. 方法引用

符号 ::
方法因为是lambda的孪生兄弟

样例：

public interface Printable {
    void printInt(int i);
}

// 测试类
public class PrintableDemo {
    public static void main(String[] args) {
        usePrintable(System.out::println);
    }

    private static void usePrintable(Printable p) {
        p.printInt(100);
    }
}

Lambda表达支持的方法引用
常见的引用：
a. 引用类方法
b. 引用对象的实例方法
c. 引用类的实例方法
d. 引用构造器

 // 引用类方法
 useConverter(Integer::parseInt);
public static void useConverter(Coverter c) {
    int k =  c.convert("100");
    System.out.println(k);
}

  // 引用对象方法
    PrintString p = new PrintString();
   usePrinter(p::toUpperCase);
public static void usePrinter(PrintInterface p){
   String s = p.printUpCase("womendoushihaohaizi");
    System.out.println(s);
}

五. 总结