JDK1.8以后的接口新增内容

在JDK1.8之前，接口中只有两部分内容：

（1）常量：固定修饰符public static  final

（2）抽象方法：固定修饰符：public abstract

在JDK1.8之后，新增非抽象方法：

（1）被public defalut修饰的非抽象方法：

注意1：defalut修饰符必须要加上，否则出错

注意2：实现类中想要重写接口中的非抽象方法，那么defalut修饰符不能写，否则出错

package com.msb5;

/**
 * @Auther:liu
 * @Date:-16:24:12
 * @Description:IntelliJ IDEA
 * @Version:1.0
 */
public interface TestInterface {
    //常量：
    public static final int NUM=10;
    //抽象方法:
    public abstract void d();
    //被public defalut修饰的非抽象方法
    public default void b(){
        System.out.println("这个是TestInterface下面defalut修饰的方法体");
    }
}
class Test implements TestInterface{
    public  void c(){
        //用一下接口中的b方法
        b();//可以使用
        //super.b();这样不可以super代表的是父类
        TestInterface.super.b();//可以
    }
    @Override
    public void d() {
        System.out.println("实现接口中d抽象方法的重写");
    }

    @Override
    public void b() {
            }
}

 

（2）静态方法：

注意1：static不能省略不写

注意2：静态方法不能重写

package com.msb5;

/**
 * @Auther:liu
 * @Date:-16:48:03
 * @Description:IntelliJ IDEA
 * @Version:1.0
 */
public interface TestInterface2 {
    //常量：
    public static final int NUM=11;
    //抽象方法
    public abstract void a();
    //public default非抽象方法
    public default void b(){
        System.out.println("-----TestInterface2---b");
    }
    //静态方法
    public static void c(){
        System.out.println("TestInterface2中的静态方法");
    }
}
class Demo implements TestInterface2{
    @Override
    public void a() {
        System.out.println("重写a方法");
    }
    public static void c(){
        System.out.println("Demo中的静态方法");
    }
}
class a{
    //这是一个main方法：是程序的入口
    public static void main(String[] args) {
        Demo d=new Demo();
        d.c();
        TestInterface2.c();
    }
}

疑问：为什么要在接口中加入非抽象方法？

如果接口中只能定义抽象方法的话，那么我要是修改接口中的内容，那么对实现类的影响太大了，所以实现类都会受到影响。

现在在接口中加入非抽象方法，对实现类没有影响，想调用就去调用即可。

package com.msb6;

/**
 * @Auther:liu
 * @Date:-17:00:00
 * @Description:IntelliJ IDEA
 * @Version:1.0
 */
public interface TestInterface {
    public abstract void a();
    public abstract void b();
    public default void c(){
        
    }
}
class Test01 implements TestInterface{
    @Override
    public void a() {

    }

    @Override
    public void b() {

    }
}
class Test02 implements TestInterface{
    @Override
    public void a() {

    }
    @Override
    public void b() {

    }
}