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

Java 8新特性

  • 一、JDK 8 接口的变化
  • 1、前言
    • 1).在JDK 8之前
    • 2).JDK 8 之后
  • 2、概述
  • 3、默认方法
    • 1)、为什么要增加默认方法
    • 2)、接口默认方法的语法格式
    • 3)、接口中默认方法的使用
    • 4)、样例
  • 4、静态方法
    • 1)、语法规则
    • 2)、静态方法的使用
    • 3)、样例
  • 5、接口静态方法、默认方法的区别介绍
  • 6、接口默认方法的”类优先”原则
  • 7、定义函数式接口
  • 8、java8接口的变化总结

一、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对接口进行注解 ,该接口只能有 一个抽象方法。

你可能感兴趣的:(java,jvm,开发语言,JDK,8接口)