java8新特性----函数式接口和默认方法

函数式接口和默认方法
函数式接口：当接口里面只有一个抽象方法的时候，就是函数式接口，可以使用注解强制限定接口只能有一个抽象方法
注解：从java5开始引入注解，对字节码文件进行一些说明
@FunctionalInterface注解的作用时用于在编译时告诉编译器该接口只能有一个抽象方法
interface testFunctionalInterface {
//接口里面只有一个抽象方法，该接口可以用于函数式编程
void test1();
}
interface testFunctionalInterface2 {
//接口里面有两个抽象方法，该接口就不是函数式接口
void test1();
void test2();
}
@FunctionalInterface//添加了该注解，强制限定该接口里只有一个抽象方法，可以用于函数式编程
interface testFunctionalInterface3 {
void test1();
}

接口里面的静态方法：
从java8开始接口里面可以有静态方法，和普通类里面的静态方法类似，使用static修饰，但是接口里面的只能是public修饰
[public] static<返回值> <方法名>([形参列表]){
//方法体
}

interface testFunctionalInterface {
//是函数式接口，因为这个接口里面只有一个抽象方法
void test1();
//静态方法不是抽象方法
static void test2(){
System.out.println(“这是接口里的静态方法，直接可以使用接口调用此方法”);
}

public static void main(String[] args) {
    System.out.println("自从接口可以有静态方法，从此接口可以写main方法，可以作为程序的入口");
    //调用接口的静态方法
    testFunctionalInterface.test2();
}

}
class TestStaticMethodClass{
public static void main(String[] args) {
//调用接口的静态方法
testFunctionalInterface.test2();
}
}

运行结果：
自从接口可以有静态方法，从此接口可以写main方法，可以作为程序的入口
这是接口里的静态方法，直接可以使用接口调用此方法

接口里面的默认方法：
java8，除了可以在接口里面写静态方法，还可以写非静态方法，但是必须用default修饰
interface testFunctionalInterface {
//使用default修饰的方法，表示实例方法，必须通过实例来方法
public default void test(){
System.out.println(“这个是接口里面的默认方法”+this);
}
public static void main(String[] args){
//使用匿名内部类初始化实例
testFunctionalInterface tfi=new testFunctionalInterface() {
};
//使用对象来访问默认方法
tfi.test();
}
}

默认方法可以被继承。

interface A {
default void test(){
System.out.println(“接口A里面的默认方法”);
}
}
interface B {
default void test(){
System.out.println(“接口B里面的默认方法”);
}
}
//报错：这时候在A，B里面都有test方法，系统不知道该使用哪个方法
interface C extends A,B{
}

修改：在子接口中重写重复的方法，明确指定调用哪个父接口的方法

interface C extends A,B{
default void test(){
//明确指定引用父接口。使用super引用调用父接口的默认方法
//<父接口类名>.super.<重复的方法名>([参数])
B.super.test();
}
}

注意点：
1.如果继承了多个父接口，有重复的默认方法被继承到子接口，必须使用super引用明确指定调用哪个接口的默认方法在子接口，在子接口必须重写重复的方法，并使用下面的语法解决父接口方法的重复问题。
<父接口类名>.super.<重复的方法名>([参数])
2.同样，如果类实现了多个接口，遇到有重复的默认方法，也需要重写重复的方法，使用super引用解决问题。和接口一样
3.父接口的抽象方法，在子接口里面可以使用默认方法实现，这样是实现类里面就不需要再实现了。
如果实现类再去实现默认方法，那么像防御是“方法覆盖”
4.如果父接口有一个抽象方法，在子接口里面可以重写为抽象方法（去掉父接口的行为）

interface A {
default void test(){
System.out.println(“接口A里面的默认方法”);
}
}
interface B extends A{
//在子接口里面重写父接口的默认方法，把默认方法改为抽象方法
void test();
}

class RemoveDefaultMethod{
public static void main(String[] args) {
A a=new A(){};
a.test();

    //B接口把A接口里面的默认方法改为抽象方法了，所以需要在类里面重写抽象方法
    B b=new B(){
        public void test(){
            System.out.println("匿名内部类重写父接口的方法");
        }
    };

    b.test();
}

}

运行结果：
接口A里面的默认方法
匿名内部类重写父接口的方法