Java面向对象编程（Object Oriented Programming，OOP）之接口（Interface）

谁践踏了优雅 2022-05-16 23:22 137阅读 0赞

## 引言 ##

**接口（Interface）**

在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口的声明：

interface Demo{
        //变量
        //方法
    }

接口很像类，与类具有下列相似点：

>  *  一个接口可以有多个方法。
>  *  接口文件保存在 .java 结尾的文件中，文件名使用接口名。
>  *  接口的字节码文件保存在 .class 结尾的文件中。
>  *  接口相应的字节码文件必须在与包名称相匹配的目录结构中。

但是与类有所区别：

>  *  接口不能用于实例化对象。
>  *  接口没有构造方法。
>  *  接口中所有的方法必须是抽象方法。
>  *  接口不能包含成员变量，除了 static 和 final 变量。
>  *  接口不是被类继承了，而是要被类实现。
>  *  **接口支持多继承。**

接口特性：

>  *  接口中每一个方法也是隐式抽象的,接口中的**方法**会被隐式的指定为 **public abstract**（只能是 public abstract，其他修饰符都会报错）。
>  *  接口中可以含有变量，但是接口中的**变量**会被隐式的指定为 **public static final** 变量（并且只能是 public，用 private 修饰会报编译错误）。
>  *  接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类与接口的区别：

>  *  1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
>  *  2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 **public static final**、**default**和**static**类型的。
>  *  3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
>  *  4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

在JDK1.8后的版本中，default和static可以在接口中实现方法：

InterfaceTest.java

interface Test {
        default String defaultMethod(String a) {
            System.out.println("默认方法");
            return a;
        }
    
        static void staticMethod() {
            System.out.println("静态方法");
        }
    }
    
    public class InterfaceTest implements Test {
        public static void main(String[] args) {
            InterfaceTest interfaceTest = new InterfaceTest();
            Test.staticMethod(); //调用静态方法
            interfaceTest.defaultMethod("张三"); //调用default方法
            System.out.println(interfaceTest.defaultMethod("张三")); //打印方法返回值
        }
    }

结果：

> 静态方法  
> 默认方法  
> 默认方法  
> 张三
> 
> Process finished with exit code 0

示例：

InterfaceDemo.java

interface Animal {
        void eat();
    
        void run();
    }
    
    public class InterfaceDemo implements Animal {
    
        @Override
        public void eat() {
            System.out.println("重写的eat方法");
        }
    
        @Override
        public void run() {
            System.out.println("重写的run方法");
        }
    
        public static void main(String[] args) {
            InterfaceDemo interfaceDemo = new InterfaceDemo();
            interfaceDemo.eat();
            interfaceDemo.run();
        }
    }

结果：

> 重写的eat方法  
> 重写的run方法
> 
> Process finished with exit code 0

重写接口方法应该注意：

>  *  类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
>  *  类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
>  *  如果实现接口的类是抽象类，那么就没必要实现该接口的方法。

实现接口时应该注意：

>  *  一个类可以同时实现多个接口。
>  *  一个类只能继承一个类，但是能实现多个接口。
>  *  一个接口能继承另一个接口，这和类之间的继承比较相似。

## 接口继承 ##

**单继承**

一个接口继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法，实现子接口必须实现父接口与子接口的所有方法。

InterfaceDemo.java

interface Animal {
        void eat();
    
        void run();
    }
    
    interface MammalAnimal extends Animal {
        void breathingWithLungs();
    
        void viviparous();
    
        void biggerBody();
    }
    
    interface Dog extends MammalAnimal {
        void bark();
    
        void housekeeping();
    }
    
    public class InterfaceDemo implements Dog {
    
        @Override
        public void eat() {
            System.out.println("重写的Animal中eat方法");
        }
    
        @Override
        public void run() {
            System.out.println("重写的Animal中run方法");
        }
    
        @Override
        public void breathingWithLungs() {
            System.out.println("重写的MammalAnimal中breathingWithLungs方法");
        }
    
        @Override
        public void viviparous() {
            System.out.println("重写的MammalAnimal中viviparous方法");
    
        }
    
        @Override
        public void biggerBody() {
            System.out.println("重写的MammalAnimal中biggerBody方法");
    
        }
    
        @Override
        public void bark() {
            System.out.println("重写的Dog中bark方法");
    
        }
    
        @Override
        public void housekeeping() {
            System.out.println("重写的Dog中housekeeping方法");
    
        }
    
        public static void main(String[] args) {
            InterfaceDemo interfaceDemo = new InterfaceDemo(); //实例化一个对象
            interfaceDemo.eat(); //动物中的吃方法
            interfaceDemo.run(); //动物中的走方法
            interfaceDemo.breathingWithLungs(); //哺乳动物中的用肺呼吸方法
            interfaceDemo.viviparous(); //哺乳动物中的胎生方法
            interfaceDemo.biggerBody(); //哺乳动物中的大体格方法
            interfaceDemo.bark(); //狗狗中的叫方法
            interfaceDemo.housekeeping(); //狗狗中的看家方法
        }
    }

结果：

> 重写的Animal中eat方法  
> 重写的Animal中run方法  
> 重写的MammalAnimal中breathingWithLungs方法  
> 重写的MammalAnimal中viviparous方法  
> 重写的MammalAnimal中biggerBody方法  
> 重写的Dog中bark方法  
> 重写的Dog中housekeeping方法
> 
> Process finished with exit code 0

**多继承**

Java中不存在类的多继承，然而接口允许多继承，接口关键字只声明一次，后面用逗号隔开多个接口。

InterfaceDemo.java

interface Animal {
        void eat();
    
        void run();
    }
    
    interface MammalAnimal {
        void breathingWithLungs();
    
        void viviparous();
    
        void biggerBody();
    }
    
    interface Dog extends MammalAnimal, Animal { //接口中继承两个接口，当这个接口被继承时，实现所有相关的方法
        void bark();
    
        void housekeeping();
    }
    
    public class InterfaceDemo implements Dog {
    
        @Override
        public void eat() {
            System.out.println("重写的Animal中eat方法");
        }
    
        @Override
        public void run() {
            System.out.println("重写的Animal中run方法");
        }
    
        @Override
        public void breathingWithLungs() {
            System.out.println("重写的MammalAnimal中breathingWithLungs方法");
        }
    
        @Override
        public void viviparous() {
            System.out.println("重写的MammalAnimal中viviparous方法");
    
        }
    
        @Override
        public void biggerBody() {
            System.out.println("重写的MammalAnimal中biggerBody方法");
    
        }
    
        @Override
        public void bark() {
            System.out.println("重写的Dog中bark方法");
    
        }
    
        @Override
        public void housekeeping() {
            System.out.println("重写的Dog中housekeeping方法");
    
        }
    
        public static void main(String[] args) {
            InterfaceDemo interfaceDemo = new InterfaceDemo(); //实例化一个对象
            interfaceDemo.eat(); //动物中的吃方法
            interfaceDemo.run(); //动物中的走方法
            interfaceDemo.breathingWithLungs(); //哺乳动物中的用肺呼吸方法
            interfaceDemo.viviparous(); //哺乳动物中的胎生方法
            interfaceDemo.biggerBody(); //哺乳动物中的大体格方法
            interfaceDemo.bark(); //狗狗中的叫方法
            interfaceDemo.housekeeping(); //狗狗中的看家方法
        }
    }

运行：

可以看到两个程序不同点就是在一个是接口的单继承，一条线式的继承；后面是多继承，树状继承。

**注意：**

接口的方法声明为public abstract，缺省也会在编译时自动加上。

## 面试题 ##

1. 什么时候使用抽象类和接口？

参考答案：

*  如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。
 *  如果你想实现多重继承，那么你必须使用接口。由于**Java不支持多继承**，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。
 *  如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

2. Java抽象类可以实现接口吗？它们需要实现所有的方法吗？

参考答案：

可以，抽象类可以通过使用关键字implements来实现接口。因为它们是抽象的，所以它们不需要实现所有的方法。好的做法是，提供一个抽象基类以及一个接口来声明类型 。这样的例子是，java.util.List接口和相应的java.util.AbstractList抽象类。因为AbstractList实现了所有的通用方法，具体的实现像LinkedList和ArrayList不受实现所有方法的负担，它们可以直接实现List接口。这对两方面都很好，你可以利用接口声明类型的优点和抽象类的灵活性在一个地方实现共同的行为。Effective Java有个很好的章节，介绍如何使用Java的抽象类和接口，值得阅读。

3. Java抽象类和接口有何不同？

参考答案：

[https://blog.csdn.net/qq\_33567641/article/details/81259174][https_blog.csdn.net_qq_33567641_article_details_81259174]

--------------------

## 参考 ##

[https://www.cnblogs.com/dolphin0520/p/3811437.html][https_www.cnblogs.com_dolphin0520_p_3811437.html]

[http://www.runoob.com/java/java-interfaces.html][http_www.runoob.com_java_java-interfaces.html]

[https://blog.csdn.net/f346867698/article/details/79435263][https_blog.csdn.net_f346867698_article_details_79435263]

[https_blog.csdn.net_qq_33567641_article_details_81259174]: https://blog.csdn.net/qq_33567641/article/details/81259174
[https_www.cnblogs.com_dolphin0520_p_3811437.html]: https://www.cnblogs.com/dolphin0520/p/3811437.html
[http_www.runoob.com_java_java-interfaces.html]: http://www.runoob.com/java/java-interfaces.html
[https_blog.csdn.net_f346867698_article_details_79435263]: https://blog.csdn.net/f346867698/article/details/79435263