Java核心技术卷接口的实现与继承多态知识梳理总结

Java核心技术卷接口的实现与继承多态知识梳理总结

接口的概念

在Java程序设计语言中，接口不是类，而是对希望符合这个接口的类的一组需求。

form： Java核心技术·卷 I（原书第11版） 基础知识 by 凯 S.霍斯特曼

在Java中，接口（Interface）是一种抽象类型，它定义了一组方法的签名（方法名、返回类型、参数列表）但没有提供方法的实现，即接口不能够被实例化。类实现（implements）接口，从而承诺提供接口定义的所有方法的实现。接口提供了一种方式来实现多重继承，因为一个类可以实现多个接口。

为何使用接口编程

接口编程是一种促进良好软件设计实践的方法，可以改善代码的结构、可维护性和可扩展性。通过定义清晰的接口，我们能够更好地组织和管理复杂的软件系统，使用接口主要有以下几种原因：

1. 抽象和解耦： 接口提供了一种抽象层，使得实现和使用代码可以相互独立。通过定义接口，我们可以将系统的不同组件解耦，降低它们之间的依赖关系。这有助于提高代码的模块性和可维护性。

2. 多态性： 接口允许多态性，即一个对象可以以多种形式存在。通过使用接口，我们可以编写可以操作不同类型对象的通用代码，从而增加了代码的灵活性和可扩展性。

3. 规范标准： 接口定义了一组规范和标准，用于描述类或模块的行为。这有助于团队协作，因为开发人员可以遵循相同的接口规范，确保代码的一致性和可预测性。

4. 测试和调试： 接口使得单元测试更加容易。通过编写适当的接口，可以使用模拟对象或模拟接口来测试代码的不同部分，而无需实际实现所有相关的类或模块。

5. 提高可替代性： 通过使用接口，我们可以在不影响整个系统的情况下替换具体的实现。这使得在不修改调用方代码的情况下更容易切换实现，从而提高系统的可替代性。

6. 降低耦合度： 接口编程有助于减少代码之间的紧密耦合。这意味着当一个模块发生变化时，其他模块不太可能受到影响，从而提高了代码的可维护性和稳定性。

7. 提高代码的可读性和理解性： 接口提供了一种清晰的契约，描述了类或模块的期望行为。这有助于提高代码的可读性，并使其他开发人员更容易理解和使用你的代码。

定义接口

注意：接口的访问控制符只能是包默认（default）和public两种类型

使用 interface 关键字来定义接口。接口可以包含方法签名、常量（静态 final 域），但不能包含字段（成员变量）或实现方法的代码块，并且接口中的所有方法都是自动视为public的，故不需要书写public，并且接口中的常量会被默认置为public static final，并且必须进行初始化操作

public interface MyInterface {
    // 接口方法的签名 不需要实现
    void myMethod();

    // 接口中的常量 隐式声明为 public static final
    int MY_CONSTANT = 42;
}

在上述接口中，我们定义了一个返回值为void，无需形参的方法签名，该方法本质上是abstract的，只是在接口实现中，未实现方法默认abstract，所以不用书写关键字，当然可以加上显式声明，不过并不推荐：

接口默认方法（Java 8+）

在Java8之后的版本，接口可以包含默认方法，这是在接口中提供方法实现的新特性。实现类可以选择重写默认方法。

public interface MyInterface {
    // 抽象方法
    void myMethod();

    // 默认方法
    default void defaultMethod() {
        System.out.println("Default implementation of defaultMethod");
    }
}

静态方法（Java 8+）：

在Java8之后的版本，接口可以包含静态方法，这是在接口级别提供工具方法的一种方式，即可以通过接口名调用静态方法。

public interface MyInterface {
    // 静态方法
    static void staticMethod() {
        System.out.println("Static method in interface");
    }
}

实现接口

警告：在接口声明中，没有将类中方法声明为public，这是因为在接口中的所有方法都自动是public。不过,在实现接口时，必须把方法声明为public；否则，编译器将认为这个方法的访问属性是包可见性，这是类的默认访问属性，之后编译器就会报错，指出你试图提供更严格的访问权限。

from： Java核心技术·卷 I（原书第11版） 基础知识 by 凯 S.霍斯特曼 page 224（根据博文进行了简单修改）

抽象类实现

抽象类实现接口，可以不扩展方法

interface InterfaceOne{
    void occupyLocationFunc();
}

abstract class AbstractClass implements InterfaceOne{
	// code   
}

单接口实现

在类使用 implements 关键字来实现接口。实现接口的可实例化类必须提供接口中定义的所有方法的具体实现。

public class MyClass implements MyInterface {
    // 实现接口中定义的方法
    @Override
    public void myMethod() {
        // 具体的实现逻辑
        System.out.println("Implementation of myMethod and MY_CONSTANT is " + MY_CONSTANT);
    }
}

注意：在外部访问接口中的常量：

InterfaceName.constant_name			// 接口名.常量名

多接口实现

一个类可以实现多个接口，通过使用逗号分隔接口名称。

public class MyMultiInterfaceClass implements Interface1, Interface2 {
    // 实现接口中定义的方法
    // ...
}

多接口实现时的准确指定

在 Java 中，一个类可以实现多个接口，而这些接口可能包含相同签名的默认方法。当一个类实现多个接口，并且这些接口中有相同签名的默认方法时，需要使用 super 关键字明确指定调用哪个接口的默认方法。

考虑以下的例子：

interface InterfaceA {
    default void defaultMethod() {
        System.out.println("Default method in InterfaceA");
    }
}

interface InterfaceB {
    default void defaultMethod() {
        System.out.println("Default method in InterfaceB");
    }
}

class MyClass implements InterfaceA, InterfaceB {
    @Override
    public void defaultMethod() {
        InterfaceA.super.defaultMethod(); // 明确指定调用 InterfaceA 的默认方法
        InterfaceB.super.defaultMethod(); // 明确指定调用 InterfaceB 的默认方法
        System.out.println("Overridden default method in MyClass");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass myObject = new MyClass();
        myObject.defaultMethod();
    }
}

在这个例子中，MyClass 类实现了两个接口 InterfaceA 和 InterfaceB，并且这两个接口都定义了相同签名的默认方法 defaultMethod。在 MyClass 中，通过使用 InterfaceA.super.defaultMethod() 和 InterfaceB.super.defaultMethod() 明确指定调用哪个接口的默认方法。

这种情况下，使用 super 关键字的语法为：

InterfaceName.super.defaultMethod();

其中，InterfaceName 是接口的名称。这样就能够避免默认方法冲突的问题，同时在实现类中提供自定义的实现。

接口继承

接口可以扩展其他接口，使用 extends 关键字。

public interface ExtendedInterface extends MyInterface {
    // 可以定义新的方法或使用继承的方法
    // ...
}

接口演化

接口演化是指的在接口的第一个版本实现后，又增加了新的方法签名（先允许我这样说，那么会产生一个问题，我们在原有接口基础上增加一个方法签名：

public interface MyInterface {
    int MY_CONSTANT = 42;

    void myMethod();
    void printHelloWorldForUser(String user_name);
}

假如在此之前我已经实现了一个类：

public class MyClass implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("Implementation of myMethod and MY_CONSTANT is " + MY_CONSTANT);
    }
}

那么增加过后，我的类将无法编译，因为我并未提供完整的接口实现，void printHelloWorldForUser(String user_name)并没有实现（已经编译好的不受影响），所以无法编译，此时就需要我们的默认方法实现：

public interface MyInterface {
    int MY_CONSTANT = 42;

    void myMethod();
    default void printHelloWorldForUser(String user_name){
        System.out.println("Hi " + user_name + " Hello World");
    }
}

即使用默认方法以保证源代码兼容

接口与继承同时实现

在类实现接口时，也可以从超类进行继承，不过继承必须写在前面，否则会报错：

abstract class MyBaseClass{
    abstract void myBaseClassFunc();
}

public class MyClass extends MyBaseClass  implements MyInterface {
    @Override
    public void myBaseClassFunc(){
        System.out.println("This is the base class method implementation");
    }

    @Override
    public void myMethod() {
        System.out.println("Implementation of myMethod and MY_CONSTANT is " + MY_CONSTANT);
    }
}

接口与抽象类的差异

由于Java中不能使用像C++中的多重继承，因为Java设计者认为多重继承会使得代码过于复杂，抽象类由于每次只能扩展一个类，其无法满足多扩展的需求

C++注释：C++具有多重继承特性,随之带来了一些复杂的特性，如虚基类、控制规则和横向指针类型转换，等等。很少有C++程序员使用多重继承，甚至有些人说就不应该使用多重继承。也有些程序员建议只对“混合”风格的继承使用多重继承。在“混合”风格中,一个主要基类描述父对象，其他的基类(所谓的混合类)提供辅助特性。这种风格类似于一个Java类扩展一个基类且派生并实现多个接口。

from: Java核心技术·卷 I（原书第11版） 基础知识 by 凯 S.霍斯特曼 page 230

解决默认方法冲突

• 超类优先：如果超类提供了一个具体方法，同名而且有相同参数类型的默认方法会被忽略。

public interface MyInterface {
    default void printHello(){
        System.out.println("Hello World");
    }
}

class BaseClass{
    public void printHello(){
        System.out.println("Hello Java");
    }
}

public class SubClass extends BaseClass implements MyInterface {
    public static void main(String[] args){
        SubClass object = new SubClass();
        object.printHello();
    }
}

• 接口冲突：如果一个接口提供了一个默认方法，另一个接口提供了一个同名而且参数类型（不论是否是默认参数）相同的方法，必须覆盖这个方法来解决冲突。

public interface MyInterfaceOne {
    default void printHello(){
        System.out.println("Hello World");
    }
}

interface MyInterfaceTwo{
    default void printHello(){
        System.out.println("Hello Java");
    }
}

public class SubClass implements MyInterfaceOne, MyInterfaceTwo {
    @Override
    public void printHello() {
        MyInterfaceOne.super.printHello();
        // System.out.println("Hello IDEA");
    }

    public static void main(String[] args){
        SubClass object = new SubClass();
        object.printHello();
    }
}

接口的回调操作

回调(callback)是一种常见的程序设计模式。在这种模式中，可以指定某个特定事件发生时应该采取的动作。例如，按下鼠标或选择某个菜单项时，你可能希望完成某个特定的动作。

form： Java核心技术·卷 I（原书第11版） 基础知识 by 凯 S.霍斯特曼 page 233

我们通过模拟日常生活中数码产品USB接入电脑的操作来模拟接口回调：

• 定义接口USBInterface并定义工作状态方法签名

interface USBActionable {
    void workingStart();
    void workingStop();
}

• 实现接口扩展不同工作状态

class Phone implements USBActionable {
    @Override
    public void workingStart(){
        System.out.println("The phone usb interface work starts");
    }

    @Override
    public void workingStop(){
        System.out.println("The phone usb interface stops working");
    }
}

class Camera implements USBActionable {
    @Override
    public void workingStart(){
        System.out.println("The camera usb interface work starts");
    }

    @Override
    public void workingStop(){
        System.out.println("The camera usb interface stops working");
    }
}

• 在Computer中定义进行USB接入时的回调行为（这里为了演示方便，定义为静态方法）

class Computer{
    public static void printWorkingStatus(USBActionable other){
        other.workingStart();
        other.workingStop();
    }
}

• 在Main类中运行

public class Main {
    public static void main(String[] args){
        Phone phone = new Phone();
        Camera camera = new Camera();
        Computer.printWorkingStatus(phone);
        Computer.printWorkingStatus(camera);
    }
}

接口多态实现

基类引用实现运行时多态

在原有代码基础上进行修改：

public class Main {
    public static void main(String[] args){
        USBActionable phone = new Phone();
        USBActionable camera = new Camera();
        phone.workingStart();
        camera.workingStart();
    }
}

我们使用接口类型的变量引用对应的实现了接口的对象，运行时，会根据引用的对象来调用对应的方法

方法签名重载实现编译时多态

interface InterfaceOne{
    void occupyLocationFunc();
    void occupyLocationFunc(Object occupy_variable);
}

个人觉得这种东西区分一下即可，毕竟实现接口就已经重写覆盖了对应的方法，实质上也就是一种编译时多态

接口继承实现多态传递

interface InterfaceOne{
    default void occupyLocationFunc(){
        System.out.println("occupyLocationFunc of InterfaceOne");
    };
}


interface InterfaceTwo extends InterfaceOne{
    default void printHelloWorld(){
        System.out.println("printHelloWorld of InterfaceTwo");
    }
}


class TestClass implements InterfaceTwo{

}


public class ExtendsClassMain {
    public static void main(String[] args) {
        InterfaceOne one = new TestClass();
        one.occupyLocationFunc();
    }
}

在上述代码中，我们以最外层接口类型InterfaceOne变量来指向引用的TestClass对象，并调用其继承自InterfaceOne的方法，实现了多态的传递

工程拓展-接口与API

身边很多人经常挂在嘴边，但是不明所以，所以一并写下

接口（Interface）和API（Application Programming Interface）是软件开发中经常使用的两个术语，它们有不同的含义和用法。

接口（Interface）

1. 接口定义： 在面向对象编程中，接口是一种抽象类型，它定义了一组方法（或方法签名）而没有提供方法的具体实现。接口可以包含常量（静态不可变的变量），但通常主要包含方法声明。

2. 实现接口： 类可以实现一个或多个接口，表示该类将提供接口中定义的所有方法的具体实现。通过实现接口，类可以达到多继承的效果。

3. Java中的接口： 在Java编程语言中，接口是通过interface关键字定义的，类通过implements关键字来实现接口。接口的实例方法默认是public abstract的。

public interface MyInterface {
    void myMethod();
    int myAnotherMethod();
}

API（Application Programming Interface）

1. API定义： API是一组定义了软件组件之间交互的规范。它可以包含类、函数、协议、工具等，允许不同的软件系统之间进行交互和集成。

2. 种类： API的种类很多，包括库级别的API、操作系统级别的API、网络API等。在编程中，常见的是库级别的API，用于与库或框架进行交互。

3. 示例： Java API指的是Java编程语言提供的类和方法，而不同的库、框架、操作系统也都有各自的API。例如，Java提供的java.util.List接口和ArrayList类就是Java API的一部分。

List<String> myList = new ArrayList<>();
myList.add("Hello");
myList.add("World");

区别

1. 定义： 接口是一种抽象类型，定义了一组方法的声明而没有具体实现。API是一组规范，可以包括接口、类、函数等，用于软件组件之间的交互。

2. 用途： 接口用于定义类的合同，规定了类应该提供哪些方法，而API用于描述各种软件组件之间的交互方式。

3. 实现： 类可以实现一个或多个接口，但接口本身并不提供具体的实现。API可以包含具体的实现，例如库或框架提供的类和方法。

4. 示例： java.util.List是一个接口，而Java API包含了许多类似ArrayList的具体实现，以及其他各种类和方法。

总体而言，接口是一种抽象的概念，用于定义类的契约，而API是一组规范，用于描述软件组件之间的交互。在软件开发中，开发人员通常需要实现接口来满足一定的规范，并使用各种API来构建应用程序。