接口声明格式

  1. [访问修饰符]  interface 接口名   [extends  父接口1，父接口2…]  {
  2.          常量定义；       
  3.          方法定义；
  4. }

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

  1. 常量，固定修饰符：public static final

  2. 抽象方法，固定修饰符：public abstract

    1. /**
    2. * 1.类是类，接口是接口，它们是同一层次的概念。
    3. * 2.接口中没有构造器
    4. * 3.接口如何声明：interface
    5. * 4.在JDK1.8之前，接口中只有两部分内容：
    6. * （1）常量：固定修饰符：public static final
    7. * （2）抽象方法：固定修饰符：public abstract
    8. * 注意：修饰符可以省略不写，IDE会帮你自动补全，但是初学者建议写上，防止遗忘。
    9. */
    10. public interface TestInterface01 {
    11.  //常量：
    12.  /*public static final*/ int NUM = 10;
    13.  //抽象方法：
    14.  /*public abstract*/ void a();
    15.  /*public abstract*/ void b(int num);
    16.  /*public abstract*/ int c(String name);
    17. }
    18. interface TestInterface02{
    19.  void e();
    20.  void f();
    21. }
    22. /*
    23. 5.类和接口的关系是什么？ 实现关系  类实现接口：
    24. 6.一旦实现一个接口，那么实现类要重写接口中的全部的抽象方法：
    25. 7.如果没有全部重写抽象方法，那么这个类可以变成一个抽象类。
    26. 8.java只有单继承，java还有多实现
    27. 一个类继承其他类，只能直接继承一个父类
    28. 但是实现类实现接口的话，可以实现多个接口
    29. 9.写法：先继承 再实现：extends Person implements TestInterface01,TestInterface02
    30. */
    31. class Student extends Person implements TestInterface01,TestInterface02 {
    32.  @Override
    33.  public void a() {
    34.      System.out.println("---1");
    35.  }
    36.  @Override
    37.  public void b(int num) {
    38.      System.out.println("---2");
    39.  }
    40.  @Override
    41.  public int c(String name) {
    42.      return 100;
    43.  }
    44.  @Override
    45.  public void e() {
    46.      System.out.println("---3");
    47.  }
    48.  @Override
    49.  public void f() {
    50.      System.out.println("---4");
    51.  }
    52. }
    53. class Test{
    54.  //这是一个main方法，是程序的入口：
    55.  public static void main(String[] args) {
    56.      //10.接口不能创建对象：
    57.      //TestInterface02 t = new TestInterface02();
    58.      TestInterface02 t = new Student();//接口指向实现类 ---》多态
    59.      //11.接口中常量如何访问：
    60.      System.out.println(TestInterface01.NUM);
    61.      System.out.println(Student.NUM);
    62.      Student s = new Student();
    63.      System.out.println(s.NUM);
    64.      TestInterface01 t2 = new Student();
    65.      System.out.println(t2.NUM);
    66.  }
    67. }

    接口的作用是什么？

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

    多态的应用场合：

  3. 父类当做方法的形参，传入具体的子类的对象

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

  6. 接口当做方法的返回值，返回的是具体的实现类的对象

    接口和抽象类的区别

    抽象类

  7. 抽象类使用abstract修饰

  8. 抽象类不能实例化，即不能使用new关键字来实例化对象
  9. 含有抽象方法（使用abstract关键字修饰的方法）的类是抽象类，必须使用abstract关键字修饰
  10. 抽象类可以含有抽象方法，也可以不包含抽象方法，抽象类中可以具体的方法
  11. 如果一个子类实现了父类（抽象类）的所有抽象方法，那么该子类可以不必是抽象类
  12. 抽象类中的抽象方法只有方法体，没有具体实现

接口

  1. 接口使用interface修饰
  2. 接口不能被实现化
  3. 一个类只能继承一个类，但是可以实现多个接口
  4. 接口中方法均为抽象方法
  5. 接口中不能包含实例域或静态方法（静态方法必须实现，接口中方法是抽象方法，不能实现）