一、Java 8新特性_JDK 8 接口的变化

一、JDK 8 接口的变化

1、前言

1).在JDK 8之前

interface 接口名{
	静态常量（public static final）;
	抽象方法（public abstract）;
}

在JDK 8 以前，接口中只有抽象方法和静态常量，会存在以下问题：在接口中新增方法，所有实现类都要重写该方法，不利于接口的扩展。

    public class TestInterface {
        A a=new B();
        A c=new C();
    }
    interface A{
        /**
         * 在接口中新增方法，所有实现类都要重写该方法，不利于接口的扩展
         */
        void test01();
        void test02();
    }
    class B implements A{

        @Override
        public void test01() {

        }

        @Override
        public void test02() {

        }
    }
    class C implements A{

        @Override
        public void test01() {

        }

        @Override
        public void test02() {

        }
    }

2).JDK 8 之后

interface 接口名{
	静态常量（public static final）;
	抽象方法（public abstract）;
	默认方法
	静态方法
}

2、概述

1.增加了default方法和static方法，分别使用 static 和 default 关键字修饰，这两种方法可以有方法体 (下面是需要注意的地方)。
2、default方法属于实例 [必须要有实现类才能调用] ，static方法属于类(接口)。
要注意的是： default 方法可以被继承，static 方法不会。接口中的静态方法在实现类中是不能被重写的，调用的话只能通过接口类型来实现: 接口名.静态方法名();
3、接口中的静态方法不会被继承，而静态变量可以被继承。
4、如果一个类实现了多个接口，并且这些接口之间没有继承关系，同时又存在相同的默认方法，
会报错：不相关默认值；
如果多个接口有继承关系，默认方法会被子接口覆盖。
5、如果遇到一个类实现了多个接口，这些接口之间没有继承关系，但是存在相同的默认方法，实现 类可以通过特殊的语法指定要访问那个接口的默认方法
在实现类(或子接口)中重写默认方法，在方法里面写：
<接口名>.super.<方法名>([参数]);
示例：

public interface TestInterfaceA {
    default void testDefaultMethod(){
        System.out.println("TestInterfaceA default method run");
    }
}
interface TestInterfaceB{
    default void testDefaultMethod(){
        System.out.println("TestInterfaceB default method run");
    }
}
class Test implements TestInterfaceA,TestInterfaceB {
    public void testDefaultMethod(){
        TestInterfaceB.super.testDefaultMethod();
    }
    public static void main(String[] args) {
        Test test = new Test();
        test.testDefaultMethod();//输出    TestInterfaceB default method run
    }
}

6、如果一个接口只有一个抽象方法(包括继承的)，该接口是一个函数式接口，函数式接口可以使用Lambda表达式实现。
7、如果接口里面使用FunctionalInterface注解，限定接口里面只能有一个抽象方法。

3、默认方法

1)、为什么要增加默认方法

在JDK8以前接口中只能有抽象方法和静态常量，会存在以下的问题：
如果接口中新增抽象方法，那么实现类都必须要抽象这个抽象方法，非常不利于接口的扩展的
接口中新增抽象方法，所有实现类都需要重写这个方法，不利于接口的扩展

2)、接口默认方法的语法格式

interface 接口名{
	修饰符 default 返回值类型 方法名{
		方法体;
	}
}

3)、接口中默认方法的使用

1. 实现类直接调用接口的默认方法
2. 实现类重写接口的默认方法

4)、样例

interface A {
    /**
     * 在接口中新增方法，所有实现类都要重写该方法，不利于接口的扩展
     */
    void test01();

    void test02();

    public default String testDefaultMethod() {
        System.out.println("接口中的默认方法执行了");
        return "Hello";
    }
}

在这里插入代码片

class B implements A {

    @Override
    public void test01() {

    }

    @Override
    public void test02() {

    }
   //重写接口的默认方法
    @Override
    public String testDefaultMethod() {
        System.out.println("B实现了接口的默认方法");
        return "OK --";
    }
}

class C implements A {

    @Override
    public void test01() {

    }

    @Override
    public void test02() {

    }
}

public class TestInterface {
    public static void main(String[] args) {
        A a = new B();
        a.testDefaultMethod();//默认方法通过实例调用
        A c = new C();
        c.testDefaultMethod();
    }

}

4、静态方法

JDK8中为接口新增了静态方法，作用也是为了接口的扩展

1)、语法规则

interface 接口名{
    修饰符 static 返回值类型 方法名{
    方法体;
	}
}

2)、静态方法的使用

接口中的静态方法在实现类中是不能被重写的，调用的话只能通过接口类型来实现: 接口名.静态方法名();

3)、样例

public interface TestInterA {

    /**
     * 在接口中新增方法，所有实现类都要重写该方法，不利于接口的扩展
     */
    void testAbstract01();

    void testAbstract02();

    static void testStaticMethod(){
        System.out.println("TestInterA里面的静态方法");
    }

    default void testDefaultMethod(){
        System.out.println("TestInterA里面的默认方法testDefaultMethod");
    }
}

class B implements A {

    @Override
    public void test01() {

    }

    @Override
    public void test02() {

    }

    @Override
    public String testDefaultMethod() {
        System.out.println("B实现了接口的默认方法");
        return "OK --";
    }

class C implements A {

    @Override
    public void test01() {

    }

    @Override
    public void test02() {

    }
}

public class TestInterface {
    public static void main(String[] args) {
        A a = new B();
        a.testDefaultMethod();//默认方法通过实例调用
        TestInterA .testStaticMethod();//静态方法通过接口名调用
        A c = new C();
        c.testDefaultMethod();
    }

5、接口静态方法、默认方法的区别介绍

1. 默认方法通过实例调用，静态方法通过接口名调用
2. 默认方法可以被继承，实现类可以直接调用接口默认方法，也可以重写接口默认方法
3. 静态方法不能被继承，实现类不能重写接口的静态方法，只能使用接口名调用

6、接口默认方法的”类优先”原则

若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时

选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。
接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法），那么必须覆盖该方法来解决冲突

7、定义函数式接口

定义函数式接口的方式有两种，一种是定义一个接口并且在该接口中只有一个抽象方法；第二种方式是使用@FunctionalInterface 注解声明该接口是一个函数式接口，一旦加了@FunctionalInterface 注解那么在该接口中只能定义一个抽象方法，定义多了或者不定义会报错。

@FunctionalInterface
public interface TestFunctionalInterface { 
    //使用@FunctionalInterface的接口，有且仅有一个抽象方法(static方法和default方法无限制)S
    static void staticMethod(){}  
    default void defaultMethod(){}
    void functionalInterfaceMethod();
    // void functionalInterfaceMethod2(); 不允许
}

8、java8接口的变化总结

1. 静态方法和默认方法，方法前面使用static或者default进行修饰，这种方法必须有方法体；
2. 如果一个接口只有一个抽象方法，默认自动变为函数式接口；
3. 如果使用了FunctionalInterface对接口进行注解 ，该接口只能有 一个抽象方法。