Java8新特性之接口

一、接口中的默认方法

interface Test {
    //java8接口中允许有默认方法的存在，子类实现接口
    //可以不用重写默认方法，如果有需要也可以进行重写
    default void show() {
        System.out.println("hello");
    }
}
class ClassTest01 implements Test {
    @Override
    public void show() {
        //调用接口中的默认方法，需要使用这种方式
        //如果是通过继承的方式则使用 super.show()
        Test.super.show();
    }
    public static void main(String[] args) {
        ClassTest01 classTest01 = new ClassTest01();
        classTest01.show();
    }
}

在Java8中，允许在接口中实现默认方法，默认方法实现类可以不用重写。在实际开发过程中，一个接口可能有多个实现类，这些实现类每个都得实现接口的所有方法，使用起来很不方便，默认方法的引入可以减少代码冗余，提高开发效率。当然，我们也要注意不能滥用默认方法。

1.默认方法的一般形式

default void show() {
    System.out.println("hello");
}

默认方法使用default关键字进行修饰。

2.在实现类中使用默认方法

2.1 重写

 @Override
public void show() {
     //调用接口中的默认方法，需要使用这种方式
     //如果是通过继承的方式则使用 super.show()
     Test.super.show();
}

如果有重写的需要，可以对方法进行重写，如果在重写方法中调用接口中的默认方法，需要使用Test.super.show()的形式。Test是接口名，super是Java关键字，show是接口中的默认方法。

2.2 直接使用

如果不需要对默认方法重写，则可以直接使用接口中的默认方法。

二、接口中的静态方法

在Java8中，接口也可以有静态方法。

1.使用

interface Test {
    //这是接口中的静态方法
    static void show02(){
        System.out.println("我是接口中的静态方法");
    }
}

在接口中定义静态方法和在普通类中定义静态方法没有太大的区别，但是使用上有区别。

不论是接口中的静态方法，还是普通类中的静态方法，他们都是无法实现多态的，子类/实现类中无法继承/实现静态方法。

在使用时，普通类的实例可以调用静态方法，而接口中的静态方法只能通过接口名进行调用。

三、函数式接口

函数式接口是Java8提供的一组特殊接口，通过函数式接口，我们可以配合lambad表达式和Stream流减少代码开发的难度。

1.函数式接口的一般形式

@FunctionalInterface
public interface Consumer<T> {
    
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

函数式接口一般使用@FunctionalInterface注解进行标注，表示该接口为函数式接口
函数式接口中只允许有一个抽象方法，但是可以有多个默认方法
@FunctionalInterface注解也可以不加，但是必须确保里面只有一个抽象方法

2.常用的函数式接口类型

2.1 消费型

Consumer<String> consumer = new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
};
consumer.accept("hello world!");

消费型是指接口中的方法只接受参数，没有返回值

2.2 判定型

Predicate<String> predicate = new Predicate<String>() {
    List<String> list = Arrays.asList("A","B","C");
    @Override
    public boolean test(String s) {
        return list.contains(s);
    }
};
System.out.println(predicate.test("A"));

判定型返回布尔值，用来进行一些判定操作。

2.3 供给型

Supplier<Object> supplier = new Supplier<Object>() {
    @Override
    public Object get() {
        return new Object();
    }
};

供给型用来输出值，类似一个工厂，一直生产对象，提供给外界。

2.4 函数式

Function<String,Integer> function = new Function<String, Integer>() {
    @Override
    public Integer apply(String s) {
        return Integer.parseInt(s);
    }
};