如何理解 Java 中接口存在的意义

0. 前言

在我本身早期学习编程的时候，对接口存在的意义实在困惑，我本身乱写代码的时候基本上不可能意识到须要去写接口，不知道接口到底有什么用，为何要定义接口，感受定义接口只是提早作了个多余的工做。git

这里我先抛出一个形象的解释，你们带着这个解释结合全文来理解接口存在的意义是什么：程序员

咱们把电脑主板上的内存插槽，显卡插槽等类比为接口，为何在主板上搞这么多插槽呢？多浪费机箱空间啊？直接用电烙铁把显卡和内存的引脚一根一根焊到主板上不就得了（手动滑稽）。估计读到这里大伙儿内心也大概明白了接口的大体做用，焊死了后，若是你焊错位置了或者拆电脑的时候，就须要使用电烙铁进行拆装，多愚蠢哦。web

全文脉络思惟导图以下：面试

1. 什么是抽象类

在讲解接口以前，抽象类是绕不过去的一个概念，接口能够认为是一个比抽象类还要抽象的类。算法

什么是抽象类？「包含一个或多个抽象方法的类就是抽象类，抽象方法即没有方法体的方法」，抽象方法和抽象类都必须声明为 abstract。例如：数据库

// 抽象类
public abstract class Person {
    // 抽象方法
 public abstract String getDescription();
}

切记！「除了抽象方法以外，抽象类还能够包含具体数据和具体方法」。例如，抽象类 Person 还保存着姓名和一个返回姓名的具体方法：编程

public abstract class Person{
    private String name;
    public Person(String name){
     this.name = name ;
    }
    public abstract String getDescription();
    public String getName(){
     return name;
    }
}

❝
许多程序员都会「错误」的认为，在抽象类中不能包含具体方法。其实这也是接口和抽象类的不一样之处，接口中是不能包含具体方法的。设计模式
❞

「抽象类不能被实例化」。也就是说，若是将一个类声明为 abstract, 就不能建立这个类的对象。安全

new Person("Jack"); // Error

能够定义一个抽象类的对象变量，可是它只能引用非抽象子类的对象。假设 Student 类是 Person 的非抽象子类：微信

Person p = new Student("Jack"); // Right

所谓非抽象子类就是说，若是建立一个继承抽象类的子类并为之建立对象，那么就「必须为父类的全部抽象方法提供方法定义」。若是不这么作（能够选择不作），子类仍然是一个抽象类，编译器会强制咱们为新类加上 abstract 关键字。

下面定义扩展抽象类 Person 的具体子类 Student：

public class Student extends Person { 
    private String major; 
    public Student(String name, String major) { 
        super(name); 
        this.major = major; 
    } 
    @Override
    public String getDescription(){ // 实现父类抽象方法
     return "a student majoring in " + major; 
    } 
}

在 Student 类中实现了父类中的抽象方法 getDescription 。所以，「在 Student类中的所有方法都是非抽象的，这个类再也不是抽象类」。

👇 调用以下：

Person p = new Student("Jack","Computer Science");
p.getDescription();

因为不能构造抽象类 Person的对象，因此变量 p 永远不会引用 Person 对象，而是引用诸如 Student这样的具体子类对象，而这些对象中都重写了 getDescription方法。

2. 什么是接口

接口的本质其实也是一个类，并且是一个比抽象类还要抽象的类。怎么说呢？抽象类是可以包含具体方法的，而接口杜绝了这个可能性，「在 Java 8 以前，接口很是纯粹，只能包含抽象方法，也就是没有方法体的方法」。而 Java 8 中接口出现了些许的变化，开始容许接口包含默认方法和静态方法，这个下文会讲解。

Java 使用关键字 interface 而不是 class 来建立接口。和类同样，一般咱们会在关键字 interface 前加上 public 关键字，不然接口只有包访问权限，只能在接口相同的包下才能使用它。

public interface Concept {
    void idea1();
    void idea2();
}

一样的，接口中既然存在抽象方法，那么他就须要被扩展（继承）。使用 implements 关键字使一个类扩展某个特定接口（或一组接口），通俗来讲：接口只是外形，如今这个扩展子类要说明它是如何工做的。

class Implementation implements Concept {
    @Override
    public void idea1() {
        System.out.println("idea1");
    }
    
    @Override
    public void idea2() {
        System.out.println("idea2");
    }
}

这里须要注意的是，你能够选择显式地声明接口中的方法为 public，可是「即便你不这么作，它们也是 public 的」。因此当实现一个接口时，来自接口中的方法必须被定义为 public。不然，它们只有包访问权限，这样在被继承时，它们的可访问权限就被下降了，这是 Java 编译器所不容许的。

另外，接口中是容许出现常量的，与接口中的方法都自动地被设置为 public—样，「接口中的域将被自动被设置为 public static final 类型」，例如：

public interface Concept {
 void idea1(); // public void idea1();
    // 静态属性
 double item = 95; // a public static final constant
}

❝
能够将接口方法标记为 public，将域标记为 public static final。有些程序员出于习惯或提升清晰度的考虑，愿意这样作。但 Java 语言规范却「建议不要书写这些多余的关键字」。
❞

3. 接口的特性

接口和类其中不一样的一点就是，咱们「没法像类同样使用 new 运算符来实例化一个接口」：

x = new Concept(. . .); // ERROR

缘由也很简单，接口连具体的构造方法都没有，确定是没法实例化的。

固然，尽管不能构造接口的对象，声明接口的变量仍是能够的：

Concept x; // OK

接口变量必须引用实现了接口的类对象：

x = new Implementation(. . .); // OK provided Implementation implements Concept

接下来，如同使用 instanceof 检查一个对象是否属于某个特定类同样，也可使用 instanceof检查一个对象是否实现了某个特定的接口：

if(x instanceof Concept){
 ...
}

另外，与能够创建类的继承关系同样，「接口也能够被继承」：

public interface Concept1 {
    void idea1();
    void idea2();
}

-------------------------------------------
    
public interface Concept2 extends Concept1{
 double idea3();
}

固然，读到这里你们可能依然没法理解，既然有了抽象类，为何 Java 程序设计语言还要任劳任怨地引入接口这个概念？

很重磅！由于「一个类能够实现多个接口，可是一个类只能继承一个父类」。正是接口的出现打破了 Java 这种单继承的局限，为定义类的行为提供了极大的灵活性。

class Implementation implements Concept1, Concept2 // OK

有一条实际经验：在合理的范围内尽量地抽象。显然，接口比抽象类还要抽象。所以，通常更倾向使用接口而不是抽象类。

4. Java 8 接口新特性

上文提过一嘴，「在 Java 8 中，容许在接口中增长静态方法和默认方法」。理论上讲，没有任何理由认为这是不合法的，只是这有违于将接口做为抽象规范的初衷。举个例子：

public interface Concept {
    // 静态方法
 public static void get(String name){
     System.out.println("hello " + name);
    }
    // 默认方法
    default void idea1(){
        System.out.println("this is idea1");
    };
}

用 default 修饰符标记的方法就是默认方法，这样子类就不须要去实现这个方法了。

不过，引入默认方法后，就出现了一个「默认方法冲突」的问题。若是先在一个接口 A 中将一个方法 idea 定义为默认方法，而后又在另外一个接口 B 或者超类 C 中定义了一样的方法 idea，而后类 D 实现了这两个接口 A 和 B（或超类 C）。因而类 D 中就有了方法 idea 的两个默认实现，出现了冲突，为此，Java 制定了一套规则来解决这个二义性问题：

1 ) 「超类优先」。若是超类提供了一个具体方法，接口中的同名且有相同参数类型的默认方法会被忽略。

2 ) 「接口冲突」。若是一个父类接口提供了一个默认方法，另外一个父类接口也提供了一个同名并且参数类型相同的方法，子类必须覆盖这个方法来解决冲突。例如：

interface A {
 default void idea(){
  System.out.println("this is A");
 }
}

interface B {
 default void idea(){
  System.out.println("this is B");
 }
}

// 须要在 D 类中覆盖 idea 方法
class D implements A, B{
    public void getName(){
     System.out.println("this is D");
    }
}

如今假设 B接口没有为 idea 提供默认实现：

interface B {
 void idea();
}

那么 D 类会直接从 A 接口继承默认方法吗？这好像挺有道理，不过，Java 设计者更强调一致性。两个接口如何冲突并不重要，「只要有一个接口提供了一个默认实现，编译器就会报告错误，咱们就必须解决这个二义性」。

固然，若是两个接口都没有为共享方法提供默认实现，那么就与 Java 8 以前的状况同样，这里不存在冲突。

5. 接口存在的意义

在我本身早期学习编程的时候，对接口存在的意义实在困惑，我本身乱写代码的时候基本上不可能意识到须要去写接口，不知道接口到底有什么用，为何要定义接口，感受定义接口只是提早作了个多余的工做。

其实不是，定义接口并不是多余，「接口是用来提供公用的方法，规定子类的行为的」。举个例子，让你们直观的感觉下接口的做用：

好比有个网站，须要保存不一样客户的信息，有些客户从 Web 网站来，有些客户从手机客户端来，有些客户直接从后台管理系统录入。假设不一样来源的客户有不一样的处理业务流程，这个时候咱们定义接口来提供一个保存客户信息的方法，而后不一样的平台实现咱们这个保存客户信息的接口，之后保存客户信息的话，咱们只须要知道这个接口就能够了，具体调用的方法被封装成了黑盒子，这也就是 Java 的多态的体现，「接口帮助咱们对这些有相同功能的方法作了统一管理」。

再好比说，咱们要作一个画板程序，其中里面有一个面板类，主要负责绘画功能，而后你就定义了这个类，但是在不久的未来，你忽然发现这个类知足不了你了，而后你又要从新设计这个类，更糟糕是你可能要废弃这个现有的类，那么其余引用这个类的地方也须要作出修改，显然这样很是麻烦。

若是你一开始定义了一个接口，把绘画功能放在这个接口里，而后定义类时实现这个接口，那么你只须要用这个接口去引用实现它的类就好了，之后要修改的话只不过是引用另外一个类而已。「接口的使用提升了代码的可维护性和可扩展性」。

另外，从这两个例子咱们也能看出，接口不只「下降了代码的耦合度」，并且仅仅描叙了程序对外的服务，不涉及任何具体的实现细节，这样也就比较「安全」一些。

参考资料

《Java 核心技术 - 卷 1 基础知识 - 第 10 版》
《Thinking In Java（Java 编程思想）- 第 4 版》

😁 点击下方卡片关注公众号「飞天小牛肉」（专一于分享计算机基础、Java 基础和面试指南的相关原创技术好文，帮助读者快速掌握高频重点知识，有的放矢），与小牛肉一块儿成长、共同进步

🎉 并向你们强烈推荐我维护的 Gitee 仓库 「CS-Wiki」（Gitee 推荐项目，目前已 0.9k star。面向全栈，致力于构建完善的知识体系：数据结构、计算机网络、操做系统、算法、数据库、设计模式、Java 技术栈、机器学习、深度学习、强化学习等），相比公众号，该仓库拥有更健全的知识体系，欢迎前来 star，仓库地址 https://gitee.com/veal98/CS-Wiki。也可直接下方扫码访问

原创不易，读完有收获不妨点赞|分享|在看支持

本文分享自微信公众号 - 飞天小牛肉（CS-Wiki）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。