前言必读

读者手册（必读）_云边的快乐猫的博客-CSDN博客

一、概念

接口:Interface

1.比如有三个类。兔子、狗、青蛙这三个类。要定义一个公共游泳方法出来。但是兔子不会这个游泳，那么就不使用这个接口，另外的狗和青蛙会游泳，就会使用这个游泳接口。简单来说，就是谁需要功能接口谁就使用这个功能接口就好了

2.接口存在的意义就是为了解耦，多继承

3.接口不能实例化

4.接口和抽象类的区别：抽象类更多的是定义在父类中，接口是单独定义一个出来的

二、使用语法

1.public interface 接口名 {}

2.通过在类名处使用implements调用

三、代码例子

父类动物类，子类兔子不会游泳所以不使用游泳接口，青蛙子类会游泳就使用游泳接口

父类–动物类

package bao;
//父类--动物类
public abstract class Animal {
    //1.定义父类成员变量
    private String name;
    private double age;
    //2.快捷键生成set和get方法
    public String getName() {
        return name;
    }

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

    public double getAge() {
        return age;
    }

    public void setAge(double age) {
        this.age = age;
    }
    //3.快捷键生成构造方法
    public Animal(String name, double age) {
        this.name = name;
        this.age = age;
    }
    //定义一个父类的eat抽象方法
    //为什么要定义成抽象方法呢，因为要强制子类必须重写使用本方法
    public abstract void eat();
}

接口–游泳

package bao;
//接口--游泳
public interface Swim {
    //定义一个抽象方法
    public abstract void swim();
}

子类–青蛙

package bao;
//子类--青蛙
public class Frog extends Animal implements Swim{
    //1.生成构造方法
    public Frog(String name, double age) {
        super(name, age);
    }

    //2.重写父类方法，快捷键：光标放在类名处，alt+回车键，选择第一个回车
    @Override
    public void eat() {
        System.out.println("青蛙在吃东西");
    }

    @Override
    public void swim() {
        System.out.println("青蛙在游泳");
    }
}

子类–兔子

package bao;
//子类--兔子
public class Rabbit extends Animal{
        //1.生成构造方法
    public Rabbit(String name, double age) {
        super(name, age);
    }
        //2.重写父类方法
    @Override
    public void eat() {
        System.out.println("兔子在吃东西");
    }
}

测试类

package bao;
//测试类
public class Test {
    public static void main(String[] args) {
        //实例化青蛙类
        Frog f = new Frog("青蛙",1);
        f.eat();
        f.swim();
        //实例化兔子类
        Rabbit r = new Rabbit("兔子",2);
        r.eat();
    }
}

运行结果