1. 概述

接口，是java语言中的一种引用类型，是方法的集合。
类中可以封装成员变量、构造方法和成员方法，
接口只能封装方法：抽象方法（jdk7以前），默认方法和静态方法（jdk8）私有方法（jdk9）
接口更多的体系是对行为的抽象

2. 定义格式

  1.  接口用关键字`interface`修饰
  1. public interface 接口名 {}

3. 接口的使用

接口不能创建对象，必须有实现类才能使用 类实现接口用implements表示

  1. public class 类名 implements 接口名1,接口名2,···接口名n {}

注意：接口的实现类必须重写接口中的所有的抽象方法，除非该类是一个抽象类

4. 接口成员的特点

4.1 成员变量

只能是常量，默认修饰符为：public static final,因此三个关键字可以省略

  1. public interface A{
  2.     // 以下两行的代码作用是一样的
  3.     // public static final int A = 1;
  4.     int A = 1;
  5. }

4.2 成员方法

只能是抽象方法。默认修饰符：public abstract,因此这两个关键字可以省略

  1. public interface A{
  2.     // 以下这两行代码的作用是一样的
  3.     //  public abstract void a();
  4.     void a();   
  6.     // 接口中不能有方法体
  7.     // void b(){}
  8. }

4.3 构造方法

没有。因为接口主要是拓展功能的。

  1. public interface A{
  2.     // 接口中没有构造方法，会报错
  3.   //  public A{}

5. 接口的实现类

5.1 子类是抽象类

接口的子类可以是抽象类，但是意义不大。
public abstract class InterImpl implements Inter{}

5.2 子类是具体类

子类是具体类，要实现接口中所有的抽象方法
所有类都默认基础Object类，Object类是所有类的超类

  1. public interface Inter{
  3.     // 接口中只能定义常量
  4.     // 默认修饰符是 public static final 可以省略不写
  5.     public static final int NUM1 = 10;
  6.     public final int NUM2 = 20;
  7.     public int NUM3 = 30;
  8.     int NUM4 = 40;
  11.     // 默认修饰符：public abstract
  12.      public abstract void method1();
  14.     public void method2();
  16.     void method3();
  18. }
  20. public class InterImpl implements Inter{
  21.      public InterImpl(){
  22.          // super() 调的是Object类
  23.          super();
  24.      }
  26.     @Override
  27.     public void method1(){
  28.         System.out.println("实现类中的method1");
  29.     }
  31.     @Override
  32.     public void method2(){
  33.         System.out.println("实现类中的method2");
  34.     }
  36.     @Override
  37.     public void method3(){
  38.         System.out.println("实现类中的method3");
  39.     }
  40. }

6. 测试接口

接口不能实例化
可以通过多态的方法实例化
访问成员变量通过接口名.常量名
接口的常量是不能修改的

  1. public class Test{
  2.      public static void main(String[] args){
  3.          // 接口不能实例化
  4.          // Inter i = new Inter();
  6.          // 通过多态的方法实例化
  7.          Inter i = new InterImpl();
  9.          // 访问成员变量
  10.          System.out.println(i.num1);
  11.          System.out.println(InterImpl.num2);
  13.          // 接口的常量是不能修改的
  14.          // i.num1 = 100;
  16.          i.method1();    // 实现类中的method1
  17.          i.method2();    // 实现类中的method2
  18.          i.method3();    // 实现类中的method3
  19.      }   
  20. }

7. 类与类的关系

类与类： 继承关系，只能单继承，不能多继承，可以多层继承 接口与接口： 继承关系，可以单继承，也可以多继承。 public interface Sister extends Father,Mother{} 类与接口： 实现关系，可以单实现，也可以多实现 并且可以在继承一个类的同时实现多个接口 public class Son extends Object implements Father,Mother

8. 抽象类与接口的区别

8.1 成员区别

抽象类:
成员变量：可以是变量，也可以是常量
构造方法：有
能否实例化：否
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以是静态常量（可以省略 public static final）
构造方法：无
能否实例化：否
成员方法：只可以抽象（可以省略 public abstract）

8.2 关系区别

类与类：
继承，单继承，多层继承
类与接口：
实现，单实现，多实现
接口与接口：
继承，单继承，多继承

8.3 设计理念区别

抽象类：共性功能
接口：拓展功能

9. 继承父类并实现多个接口

一个类只能继承一个父类，也能实现多个接口，也可以在继承父类的时候实现多个接口
非抽象类重新接口，必须实现接口中所有的抽象方法
一个接口可以继承多个接口
接口多继承之后，如果想使用，还必须定义实现类

9.1 格式

class 类名 [extends 父类名] implements 接口名1,接口名2,···,接口名n {]

9.2 代码

  1. // 定义接口
  2. interface A{
  3.     public abstract void showA1();
  4.     void show();
  5. }
  6. interface B{
  7.     void showB1();
  8.     void show();
  9. }
  10. //定义父类
  11. public class Fu{}
  12. // 定义实现类
  13. public class C extends Fu implements A,B{
  14.     @Override
  15.     public void showA1(){
  16.         System.out.println("showA1");
  17.     }
  18.     @Override
  19.     public void showB1(){
  20.         System.out.println("showB1");
  21.     }
  22.     // 多个父类有相同的抽象方法，只需要重写一次即可
  23.     @Override
  24.     public void show(){
  25.         System.out.println("show");
  26.     }
  27. }

注意事项：

  1. 接口中，有多个抽象方法时，实现类必须重写所有的抽象方法，如果抽象方法有重名的，只需要重写一次即可
  2. 如果实现类继承了父类，这个父类是一个抽象类时，我们还需要重写抽象类中的所有抽象方法
  3. 抽象类实现了接口，可以不用写接口中的抽象方法，但抽象类的实现类需要写

    10. 接口小结

  • 接口中只有常量和抽象方法
  • 接口没有静态代码块和构造方法
  • 一个类的直接父类时唯一的，但是一个类可以同时实现多个接口，单继承，多实现
  • 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要重写一次即可

  • 如果实现类没有重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类

    11. 接口案例

    需求：对猫和狗进行训练，他们就可以跳高了，这里加入跳高功能。
    请采用抽象类和接口来实现猫狗案例，并在测试类中进行测试。
    实现
    以下代码不能写在同一个文件中 ```java / Animal类 定义了姓名与年龄属性 定义了有参无参构造 封装了属性 为每个属性提供了get/set方法 定义了一个抽象方法eat(); 拥有抽象方法的类必须声明为抽象类 / public abstract class Animal { private String name; private int age;

    public Animal() { }

    public Animal(String name, int age) {

    1.   this.name = name;
    2.   this.age = age;

    }

    public String getName() {

    1.   return name;

    }

    public void setName(String name) {

    1.   this.name = name;

    }

    public int getAge() {

    1.   return age;

    }

    public void setAge(int age) {

    1.   this.age = age;

    }

    public abstract void eat(); }

/ 跳高接口 抽象方法 跳高 / public interface Jumpping { public abstract void jump(); }

/ 定义一个猫类继承Animal类，实现Jumpping接口,即拥有这就接口里的跳高功能 /

public class Cat extends Animal implements Jumpping { // 无参构造 public Cat() { } // 有参构造，调用父类有参构造 public Cat(String name, int age) { super(name, age); } // 重写父类方法的抽象方法 @Override public void eat() { System.out.println(“猫吃鱼”); } // 重写接口的抽象方法 @Override public void jump() { System.out.println(“猫可以跳高了”); } }

/ 测试类 实例化一个对象名c 为c的名字赋值为 加菲 为c的年龄赋值为 5 分别调用两个方法 / public class AnimalDemo { public static void main(String[] args) { Cat c = new Cat(); c.setName(“加菲”); c.setAge(5); System.out.println(c.getName()+”,”+c.getAge()); // 加菲，5 c.eat(); // 猫吃鱼 c.jump(); // 猫可以跳高了 } } ```