JAVA接口

JDK1.8之前

1. 接口是接口，类是类。它们是同一层次的概念。
2. 接口中没有构造器。
3. 接口如何声明：interface
4. 在JDK1.8之前，接口中只有两部分内容，（1）常量：固定修饰符：public static final（2）抽象方法：固定修饰符：public abstract
   注意：修饰符可以不写，idea会帮你自动补全。建议写上，防止遗忘。

   public interface TestInterface01{
     常量：public static final int NUM = 10;
     抽象方法：public abstract void a();
              public abstract void a();
              public abstract void b(int num);
              public abstract int c(String name);
   }
   

5. 类和接口的关系：实现关系。类实现接口。
6. 一旦实现一个接口，那么实现类要重写接口中的全部的抽象方法：

   class Student implements TestInterface01{
   
   }
   

7.如果没有全部重写抽象方法，那么这个类可以变成一个抽象类。
8.Java只有单继承，Java有多实现。一个类继承其他类，只能继承一个父类。但是实现接口的话，可以实现多个接口。
因为父类的方法存在多态，如果有相同名称的方法，多继承的话不知道该实现哪个。
9. 写法：先继承，再实现：extends Person implements TestInterface01
10. 接口不能创建对象。但是接口可以指向实现类。TestInterface01 student = new Student();接口指向实现类-》多态。
11. 接口中常量如何访问：
System.out.println(TestInterface01.NUM)； System.out.println(Student.NUM)； Student student = new Student(); System.out.println(student.NUM); TestInterface02 t2 = new Studnet();
12. 接口的作用是什么：
定义规则，跟抽象类不同，接口不是类。
接口定义好规则之后，实现类负责实现即可。
13. 继承和实现的概念：
继承：子类对父类的继承。
实现：实现类对接口的实现。
14. 案例：风筝，小鸟，飞机。
定义一个接口Flyable
15. 多态的应用场合：
父类当作方法的形参，传入具体的子类的对象。
父类当作方法的返回值，返回的是具体的子类的对象。
接口当作方法的形参，传入的是具体的实现类的对象。
接口当作方法的返回值，传入的是具体的实现类的对象。
16. 接口跟抽象类的区别。
抽象类：1. 抽象类使用abstract修饰。2.抽象类不能实例化。3.含有抽象方法的类是抽象类，必须使用abstract修饰。4.抽象类可以含有抽象方法，也可以不含有抽象方法，抽象类中可以有具体的方法。5.抽象类的抽象方法只有方法体，没有具体实现。
接口：1. 接口使用interface修饰。2.接口不能被实例化。3.一个类只能继承一个类，但是可以实现多个接口。4.接口中的方法都是抽象方法。5.接口中不能包含实例或静态方法（静态方法必须实现，接口中的方法是抽象方法，不能实现）。

JDK1.8之后

1. 新增非抽象方法：
   （1）被public default修饰的非抽象方法：
   注意1：default修饰符必须要加上，否则出错。
   注意2：实现类要是想重写接口中的非抽象方法，那么default修饰符必须不能加，否则出错。
   （2）静态方法：
   注意1：static可以省略不写。
   注意2：静态方法不能重写。

     public interface TestInterface {
         //常量：
         public static final int NUM = 10;
         //抽象方法：
         public abstract void a();
         //public default 修饰的方法：
         public default void b(){
             System.out.println("---------TestInterface---b------");
         }
         //静态方法
         public static void c(){
             System.out.println("TestInterface中的静态方法");
         }
     }
     class Test implements TestInterface{
         public static void c(){
             System.out.println("Test类中的静态方法");
         }
         public void d(){
             //调用一下接口中的b方法
             b();
             TestInterface.super.b();
         }
   
         @Override
         public void a() {
             System.out.println("重写了a方法");
         }
   
         @Override
         public void b() {
   
         }
     }
     class A{
         public static void main(String[] args) {
             Test test = new Test();
             test.c();
             TestInterface.c();
         }
     }
   
   

2. 为什么要在接口中加入非抽象方法：
   方便维护代码，如果修改接口中的内容，那么所有实现类都需要实现这个抽象方法，如果在接口中加入非抽象的公用方法，可以不用修改其他实现类。