【Java基础篇 | 面向对象】—— 聊聊什么是接口（上篇）-蒲公英云

个人主页：兜里有颗棉花糖
欢迎点赞? 收藏✨ 留言✉ 加关注?本文由兜里有颗棉花糖原创
收录于专栏【JavaSE_primary】
本专栏旨在分享学习JavaSE的一点学习心得，欢迎大家在评论区交流讨论?

关于接口的简单的介绍请看这篇文章（接口的简单介绍），本文将继续接着上篇对接口进行更加详细的讲解。

一、接口的代码实现（简单接口回顾）

这里由于代码过长所以只能以图片的方式进行呈现了，大家先凑活看哈，请看：
接口：

运行结果如下：

二、接口特性

接口是不能进行实例化的：接口类型是一种引用类型，所以不能new接口的对象。
接口中的每个方法都是public abstract修饰的方法，接口中的方法都会被隐式的指定为public abstract，也只能是被public abstract修饰，使用其它的修饰符都会报错。
接口中的方法不能在接口中实现，只能在实现接口中的类进行实现，如果非要在接口中进行实现的话，该方法必须由default进行修饰。
子类实现接口中方法的时候，这个方法必须是由public进行修饰（因为接口中的抽象方法一定是由public abstract进行修饰的）。
接口中可以含有变量，这个变量会被隐式的指定为public static final修饰。
接口中不能含有静态代码块和构造方法。
接口虽然不是类，但是接口编译完成后字节码文件的后缀格式就是.class
如果类中没有实现接口中的所有抽象方法，则该类必须设置为抽象类（出来混迟早要还的）。
jdb8中，接口中还可以包含default方法。

三、实现多个接口

下面来看多接口的代码：

interface IFlying {
    void fly();
}
interface ISwimming {
    void swim();
}
interface IRunning {
    void run();
}
abstract class Animal {
    public int age;
    public String name;
    public abstract void eat();
}
class Dog extends Animal implements IRunning,ISwimming {
    @Override
    public void eat() {
        System.out.println(this.name + "正在吃狗粮");
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在跑步");
    }
    @Override
    public void swim() {
        System.out.println(this.name + "正在狗刨式游泳");
    }
}

解释1：子类Dog必须先继承父类然后再实现接口中的方法。即class Dog extends Animal implements IRunning,ISwimming
java中之所以子类必须先继承父类然后再实现接口中的方法是因为java不支持多继承。

解释2：为什么不把三个接口中的方法写到抽象类Animal中？
在上述代码中，将飞行、游泳和奔跑这三个行为分别定义在了接口IFlying、ISwimming和IRunning中，而没有将它们写入抽象类Animal中的原因是因为接口和抽象类具有不同的设计目的和用途。
抽象类用于表示一类对象的通用特性和行为，并且可以包含具体的方法实现。抽象类可以作为其他类的基类，被继承和扩展。（请结合上述代码加以理解。）
接口则用于定义一组行为或功能的契约，它只能包含方法声明，而不能包含方法的实现。接口允许一个类实现多个接口，从而具备多个角色或行为。接口实现了多态性的概念，使得不同的类可以实现相同的接口，并根据自己的需求来实现具体的方法。
在给定的例子中，抽象类Animal表示了动物的通用特性，并且包含了方法的具体实现（例如eat方法）。而接口IFlying、ISwimming和IRunning表示了特定的行为，是动态的、可扩展的契约。通过在Dog类中实现这些接口，Dog类表明自己具有飞行、游泳和奔跑的能力。（并不是所有的动物都会飞或者游泳或者跑）
如果把接口换成类也是不可以的，因为java中只支持单继承。所以Java中的接口提供了一种解决多继承问题的机制。

好了，现在我们对上述代码进行拓展方便大家能够更好的进行理解，代码如下：

interface IFlying {
    void fly();
}
interface ISwimming {
    void swim();
}
interface IRunning {
    void run();
}
abstract class Animal {
    private int age;
    private String name;
    public abstract void eat();
    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
class Dog extends Animal implements IRunning,ISwimming {
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(this.getName() + "正在吃狗粮");
    }
    @Override
    public void run() {
        System.out.println(this.getName() + "正在跑步");
    }
    @Override
    public void swim() {
        System.out.println(this.getName() + "正在狗刨式游泳");
    }
}
class Bird extends Animal implements IFlying {
    public Bird(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(this.getName() + "正在吃鸟粮!");
    }
    @Override
    public void fly() {
        System.out.println(this.getName() + "正在用翅膀飞!");
    }
}
class Robot implements IRunning {
    @Override
    public void run() {
        System.out.println("机器人正在跑!");
    }
} // Robot甚至不是动物，但是机器人会跑啊，所以我们依然可以结合IRunning()接口来进行使用。
public class Test {
    public static void test1(Animal animal) {
        animal.eat();
    }
    public static void test2(IFlying iFlying) {
        iFlying.fly();
    }
    public static void testRun(IRunning iRunning) {
        iRunning.run();
    }
    public static void testSwim(ISwimming iSwimming) {
        iSwimming.swim();
    }
    public static void main(String[] args) {
        test2(new Bird("小鸟3",3));
        testRun(new Dog("小狗2",2));
        testSwim((new Dog("小狗3",4)));
        testRun(new Robot());
    }
    public static void main1(String[] args) {
        test1(new Bird("小鸟1",3)); // 向上转型:父类引用引用了子类，子类中重写了父类中的抽象方法
        test1(new Dog("小狗1",3)); // 向上转型:父类引用引用了子类，子类中重写了父类中的抽象方法
    }
}

上述代码是java面向对象编程中最常见的一个用法：一个类继承父类，并且实现了多个接口。

继承表达的是一个is a的意思，即它是哪一类东西，而接口表达的具有某种特性。举个栗子：
青蛙是一种动物，它可以在水里游泳
老鹰也是一种动物，它可以在天空中遨游
狼是一种动物，它可以在草地上跑

java中的这种设计（一个类继承父类，并且实现了多个接口）提醒我们要忘记某一事物的类型，因为有了接口之后我们只需要关心该事物是否具有某种特性。

四、接口间的继承（extends）

类和类之间是通过extends来来进行继承的。
类和接口之间的关系：通过implements来实现接口。
接口和接口之间也是存在关系的，是通过extends来进行关联的。即拓展接口功能。
如下图，请看：

上图接口C不仅仅有自己的功能也会同时由接口A和接口B的功能。

上图中的类D不仅仅要实现接口C的功能，而且还需要实现接口A和接口B的功能。（接口间的继承可以理解为把多个接口合并在一起）