一、JDK1.8之前

1、类是类，接口是接口，它们是同一层次的概念
2、接口中没有构造器
3、接口如何声明：interface
4、在jdk1.8之前，接口只有两部分内容
a、常量 public static final
b、抽象方法 pubilc abstract
注意：修饰符可以省略不写，ide会帮助你自动补全
5、类和接口的关系是什么？ 实现关系，类实现接口
6、一旦实现一个接口，那么实现类要重写接口中全部的重写方法
7、如果没有全部重写抽象方法，那么这个类变成一个抽象类
8、java只有单继承，java还有多实现
一个类继承其他类，只能直接继承一个父类
但是实现类实现接口的话，可以实现多个接口
9、写法：先继承 再实现 class Student extends Person implements TestInterface01, TestInterface02
10、接口不能创建对象

package com.msb_interface;

/*
1、类是类，接口是接口，它们是同一层次的概念
2、接口中没有构造器
3、接口如何声明：interface
4、在jdk1.8之前，接口只有两部分内容
    a、常量  public static final
    b、抽象方法 pubilc abstract
    注意：修饰符可以省略不写，ide会帮助你自动补全
 */
public interface TestInterface01 {
    //常量
    /*public static final*/ int NUM = 10;

    //抽象方法
    /*public abstract*/ void a();

    /*public abstract*/ void b(int num);

    /*public abstract*/ int c(String name);
}

interface TestInterface02 {
    void e();

    void f();
}

/*5、类和接口的关系是什么？ 实现关系，类实现接口
6、一旦实现一个接口，那么实现类要重写接口中全部的重写方法
7、如果没有全部重写抽象方法，那么这个类变成一个抽象类
8、java只有单继承，java还有多实现
一个类继承其他类，只能直接继承一个父类
但是实现类实现接口的话，可以实现多个接口
9、写法：先继承 再实现 class Student extends Person implements TestInterface01, TestInterface02

 */
class Student extends Person implements TestInterface01, TestInterface02 {
    @Override
    public void a() {
        System.out.println("a.....");
    }

    @Override
    public void b(int num) {
        System.out.println("b.....");
    }

    @Override
    public int c(String name) {
        return 0;
    }

    @Override
    public void e() {
        System.out.println("e.....");
    }

    @Override
    public void f() {
        System.out.println("f.....");
    }
}

class Test{
    public static void main(String[] args) {
        //10、接口不能创建对象
        TestInterface01 t =new Student();  //接口指向实现类——》多态

        //11、接口中的常量如何访问
        System.out.println(TestInterface01.NUM);
        System.out.println(Student.NUM);

        Student s = new Student();
        System.out.println(s.NUM);

        TestInterface01 t1 = new Student();
        System.out.println(t1.NUM);

    }
}

二、接口的作用

定义规则：只是跟抽象类不同地方在哪？它是接口不是类
接口定义好规则之后，实现类负责实现即可

继承：子类对父类的继承
实现：实现类对接口的实现

继承：收集 extends 照相机 “is-a”的关系，手机是一个照相机。
上面的写法不好。
实现：收集 implements 拍照功能 “has-a”的关系，手机具备照相的能力。

案例：飞机、小鸟、风筝

多态的应用场合：
1、父类当作方法的形参，传入具体的子类的对象
2、父类当作方法的返回值，返回的是具体的子类的对象
3、接口当作方法的形参，传入具体的实现类的对象
4、接口当作方法的返回值，返回的是具体的实现类的对象

三、JDK1.8之后，新增非抽象方法

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

package com.msb_interface1;

public interface TestInterface {
    //常量
    public static final int num =10;
    //抽象方法
    public abstract void a();
    //public default修饰的非抽象方法
    public default void b(){
        System.out.println("--TestInterface---b()----");
    }
}

class Test implements TestInterface{
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }

    @Override
    public void b() {
        TestInterface.super.b();
    }

    public void c(){
        //用接口中的b方法
        b();  //可以
//        super.b();  不可以
        TestInterface.super.b(); //可以
    }
}

四、静态方法

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

package com.msb_interface1;

public interface TestInterface2 {
    // 常量
    public static final int NUM = 10;

    // 抽象方法
    public abstract void a();

    //public default非抽象方法、
    public default void b() {
        System.out.println("----b----");
    }

    //静态方法
    public static void c() {
        System.out.println("---c--");
    }
}


class Demo implements TestInterface2{
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }

    public static void c() {
        System.out.println("---Demo中的c方法--");
    }
}

class A{
    public static void main(String[] args) {
        Demo d = new Demo();
        d.c();
        Demo.c();
        TestInterface2.c();
    }
}

---Demo中的c方法--
---Demo中的c方法--
---c--

为什么要在接口中加入非抽象方法？
如果接口中只能定义抽象方法，那么我要是修改接口中的内容，那么对实现类的影响太大了，所有实现类都会受到影响。
现在在接口中加入非抽象方法，对实现类没有影响，想调用去调用即可。