JAVA学习笔记——接口

1、概念及定义

在 Java 程序设计语言中，接口不是类，而是对类的一组需求描述，这些类要遵从接口描述的统一格式进行定义。

换一个角度来说，接口是一系列方法构成的一个特殊的“集合”，一个接口实现一个主要的功能，而这一系列方法共同完成了这个功能的实现。定义了接口以后，可以用接口对类的功能进行扩展，即给类附加这个这个接口所实现的功能。

2、接口的格式

• 接口用关键字interface修饰：

interface 接口名{}

• 类实现接口用implements关键字：

class 类名 implements 接口名{}

代码演示：

//定义一个接口
interface Jumping {
    public abstract void jump();
}

//Cat类，用类实现接口，关键字为implements
class Cat implements Jumping{
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");//重写里面的方法
    }
}

3、接口的特点

1. 定义接口时，使用 interface 关键字。

2. 一个具体的类实现接口，必须要实现接口中所有抽象方法。

3. 一个类可以继承一个类的同时实现多个接口，也可以直接实现多个接口。

4、接口成员的特点

1. 成员变量：只能是常量，默认修饰符：public static final 。

2. 构造方法：

接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在的（不能实例化）

一个类如果没有父类，则默认继承自Object类；

3. 接口中定义的所有方法只能是抽象方法，默认修饰符：public abstract 。

代码演示：

 interface Inter {
    public  int num1 = 10;
    public final int num2 = 20;
    public static final int num3 = 30; //等价于int num3 = 30

//  public Inter(); //报错，因为接口不能有构造方法

//  public void show(){} //报错，因为接口不能有非抽象方法

    public abstract void show();
    //上面等价于：void show(); 因为接口里的方法默认修饰为public abstract
}

//Inter接口的实现类
class InterImpl implements Inter {
    //重写show方法
    @Override
    public void show() {
        System.out.println("show方法");
    }
}

public class InterfaceDemo3 {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        i.show();
        System.out.println(i.num1);
        //i.num1 = 10; //会报错，因为接口中的变量默认用static和final修饰
        System.out.println(i.num2);
        System.out.println(Inter.num3);
    }
}

结果
show方法
10
20
30

4、类和接口的关系

类和类的关系：继承关系，只能单继承，但是可以多层继承。

类和接口的关系：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。

接口和接口的关系：继承关系，可以单继承，也可以多继承。

5、抽象类与接口的区别

1）成员区别：

抽象类：变量，常量；有构造方法，有抽象方法，也有非抽象方法

接口：常量；抽象方法

2）关系区别：

类与类：继承，单继承

类与接口：实现，可以单实现，也可以多实现

接口与接口：继承，可以单继承，也可以多继承

3）设计理念区别：

抽象类：对类抽象，包括属性、行为

接口：对行为抽象，主要是行为

代码演示：

/*
  猫狗案例，加入额外的跳高功能
  猫：
     姓名，年龄
        吃
    狗：
        姓名，年龄
        吃
    会跳高的猫：
        姓名，年龄
        吃
        跳高
    会跳高的狗：
        姓名，年龄
        吃
        跳高
    ----------------------
    动物类（抽象类）：
        姓名，年龄
        吃（抽象方法）

    跳高（接口）：
        跳高（抽象方法）

    猫 extends 动物类:
        重写吃方法

    狗 extends 动物类：
        重写吃方法

    会跳高的猫 extends 动物类 implements 跳高：
        重写吃方法
        重写跳高方法
    会跳高的狗 extends 动物类 implements 跳高：
         重写吃方法
         重写跳高方法

 */
interface Jumping{
    void jump();
}
abstract  class Animal3{
    //成员变量
     String name;
     int age;
    //无参构造方法
    public Animal3() {
    }
    //有参构造方法
    public Animal3(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //抽象构造方法
    public abstract void eat();
}
class Dog3 extends Animal3{
    public Dog3() {
    }

    public Dog3(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("🐕吃🥩");
    }
}
class Cat2 extends Animal3{
    public Cat2() {
    }

    public Cat2(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("🐱吃🐟");
    }
}
class Dog4 extends Animal3 implements Jumping{
    public Dog4() {
    }

    public Dog4(String name, int age) {
        super(name, age);
    }

    @Override
    public void jump() {
        System.out.println("这只🐕会跳高");
    }

    @Override
    public void eat() {
        System.out.println("🐕吃🥩");
    }
}
class Cat3 extends Animal3 implements Jumping{
    public Cat3() {
    }

    public Cat3(String name, int age) {
        super(name, age);
    }

    @Override
    public void jump() {
        System.out.println("这只🐱会跳高");
    }

    @Override
    public void eat() {
        System.out.println("🐱吃🐟");
    }
}
public class InterfaceDemo2 {
    public static void main(String[] args) {
        Cat2 cat2 = new Cat2();
        cat2.eat();
        System.out.println("====================");
        Cat3 cat3 = new Cat3();
        cat3.eat();
        cat3.jump();
        System.out.println("====================");
        Dog3 dog3 = new Dog3();
        dog3.eat();
        System.out.println("====================");
        Dog4 dog4 = new Dog4();
        dog4.eat();
        dog4.jump();
    }
}