函数式接口

只有一个抽象接口，方便使用lambda表示。可以有若干default修饰的或static修饰的普通方法。子类可以实现抽象方法和重写default方法。在接口上使用@FunctionalInterface，在编译期检查是否符合函数式接口。

@FunctionalInterface
public interface DemoInterface {

    Optional<String> sayHello();

    default Optional<String> hello1() {
        return Optional.ofNullable("hello");
    }

    default Stream<String> hello2() {
        return Stream.of("a", "b", "c");
    }

    static Optional<Integer> hello3() {
        return Optional.ofNullable(0);
    }

    static Stream<Integer> hello4() {
        return Stream.of(1, 2, 3);
    }
}

public class DemoImpl implements DemoInterface {
    @Override
    public Optional<String> sayHello() {

        hello1();
        hello2();

        DemoInterface.hello3();
        DemoInterface.hello4();
        return Optional.empty();
    }
}

方法引用

参考官方文档。

public class Car {

    public static Car create(Supplier<Car> supplier) {
        return supplier.get();
    }

    public static void collide(Car car) {
        System.out.println("collide:" + car.toString());
    }

    public void repair() {
        System.out.println("repair:" + this.toString());
    }

    public void follow(Car car) {
        System.out.println("follow:" + car.toString());
    }

    public static void main(String[] args) {
        // 构造器
        Car car = Car.create(Car::new);

        List<Car> cars = Arrays.asList(car);
        // 静态方法
        cars.forEach(Car::collide);
        // 普通方法
        cars.forEach(Car::repair);
        // 有一个参数的方法
        cars.forEach(car::follow);
    }
}

引用

http://ifeve.com/java-8-features-tutorial/