个人学习笔记：接口

接口格式声明

[访问修饰符] interface 接口名 [extends 父接口1,父接口2…] {

常量定义；

方法定义；

}

说明：

1. 接口中没有构造器
2. 接口如何声明：interface
3. 在JDK1.8之前，接口中只有两个部分内容：

(1)常量：固定修饰符 public static final

(2)抽象方法：固定修饰符 public abstract

4. 类与接口的关系是实现关系，类实现接口
5. 一旦实现一个接口，那么实现类中要重写接口中的全部的抽象方法；如果没有全部重写抽象方法，那么这个实现类可以变成一个抽象类
6. java只有单继承，但是有多实现
7. 先继承 再实现 例如：class Student extends Person implements TestInterface01,TestInterface02{}

接口的作用

定义规则，接口定义好规则后，实现类负责实现即可

接口和继承的多态

1. 父类当做方法的形参，传入具体的子类的对象
2. 父类当作方法的返回值，返回的是具体的子类的对象
3. 接口当作方法的形参，传入具体的实现类的对象
4. 接口当作方法的返回值，返回的是具体的实现类的对象

JDK1.8之后

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

1. 被public default修饰的非抽象方法：

1. 1. default修饰符必须要加上，否则出错
   2. 实现类中要是想重写接口中的非抽象方法，那么default修饰符必须不能加，否则出错。

2. 静态方法：

1. 1. static不可以省略不写
   2. 静态方法不能重写

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

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

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

public interface TestInterface01 {
    public static final int NUM = 520;
    public abstract void a();
    public abstract void b(int num);
    public abstract int c(String name);
}

interface TestInterface02{
    public abstract void f();
    public abstract void e();
}

class Strudent extends Person implements TestInterface01,TestInterface02{
    @Override
    public void a() {
        System.out.println("陈小狗喜欢方小云！！!");
    }
    @Override
    public void b(int num) {
        System.out.println("陈小狗喜欢喜欢方小云！！!");
    }
    @Override
    public int c(String name) {
        return 520;
    }
    @Override
    public void e() {
        System.out.println("陈小狗喜欢喜欢喜欢方小云！！!");
    }

    @Override
    public void f() {
        System.out.println("陈小狗喜欢喜欢喜欢喜欢方小云！！!");
    }
}

class Demo {
    public static void main(String[] args) {
        TestInterface02 t = new Strudent();

        System.out.println(TestInterface01.NUM);
        System.out.println(Strudent.NUM);
        Strudent s = new Strudent();
        System.out.println(s.c("fang"));
        s.a();
        s.b(10);
        s.e();
        s.f();
    }
}