Java核心技术卷接口的实现与继承多态知识梳理总结
Java核心技术卷接口的实现与继承多态知识梳理总结
接口的概念
在Java程序设计语言中，接口不是类，而是对希望符合这个接口的类的一组需求。
form： Java核心技术·卷 I（原书第11版） 基础知识 by 凯 S.霍斯特曼
在Java中，接口（Interface）是一种抽象类型，它定义了一组方法的签名（方法名、返回类型、参数列表）但没有提供方法的实现，即接口不能够被实例化。类实现（implements）接口，从而承诺提供接口定义的所有方法的实现。接口提供了一种方式来实现多重继承，因为一个类可以实现多个接口。
为何使用接口编程
接口编程是一种促进良好软件设计实践的方法，可以改善代码的结构、可维护性和可扩展性。通过定义清晰的接口，我们能够更好地组织和管理复杂的软件系统，使用接口主要有以下几种原因：
-
抽象和解耦： 接口提供了一种抽象层，使得实现和使用代码可以相互独立。通过定义接口，我们可以将系统的不同组件解耦，降低它们之间的依赖关系。这有助于提高代码的模块性和可维护性。
-
多态性： 接口允许多态性，即一个对象可以以多种形式存在。通过使用接口，我们可以编写可以操作不同类型对象的通用代码，从而增加了代码的灵活性和可扩展性。
-
规范标准： 接口定义了一组规范和标准，用于描述类或模块的行为。这有助于团队协作，因为开发人员可以遵循相同的接口规范，确保代码的一致性和可预测性。
-
测试和调试： 接口使得单元测试更加容易。通过编写适当的接口，可以使用模拟对象或模拟接口来测试代码的不同部分，而无需实际实现所有相关的类或模块。
-
提高可替代性： 通过使用接口，我们可以在不影响整个系统的情况下替换具体的实现。这使得在不修改调用方代码的情况下更容易切换实现，从而提高系统的可替代性。
-
降低耦合度： 接口编程有助于减少代码之间的紧密耦合。这意味着当一个模块发生变化时，其他模块不太可能受到影响，从而提高了代码的可维护性和稳定性。
-
提高代码的可读性和理解性： 接口提供了一种清晰的契约，描述了类或模块的期望行为。这有助于提高代码的可读性，并使其他开发人员更容易理解和使用你的代码。
定义接口
注意：接口的访问控制符只能是包默认（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）
-
接口定义： 在面向对象编程中，接口是一种抽象类型，它定义了一组方法（或方法签名）而没有提供方法的具体实现。接口可以包含常量（静态不可变的变量），但通常主要包含方法声明。
-
实现接口： 类可以实现一个或多个接口，表示该类将提供接口中定义的所有方法的具体实现。通过实现接口，类可以达到多继承的效果。
-
Java中的接口： 在Java编程语言中，接口是通过
interface关键字定义的，类通过implements关键字来实现接口。接口的实例方法默认是public abstract的。
public interface MyInterface {
void myMethod();
int myAnotherMethod();
}
API（Application Programming Interface）
-
API定义： API是一组定义了软件组件之间交互的规范。它可以包含类、函数、协议、工具等，允许不同的软件系统之间进行交互和集成。
-
种类： API的种类很多，包括库级别的API、操作系统级别的API、网络API等。在编程中，常见的是库级别的API，用于与库或框架进行交互。
-
示例： Java API指的是Java编程语言提供的类和方法，而不同的库、框架、操作系统也都有各自的API。例如，Java提供的
java.util.List接口和ArrayList类就是Java API的一部分。
List<String> myList = new ArrayList<>();
myList.add("Hello");
myList.add("World");
区别
-
定义： 接口是一种抽象类型，定义了一组方法的声明而没有具体实现。API是一组规范，可以包括接口、类、函数等，用于软件组件之间的交互。
-
用途： 接口用于定义类的合同，规定了类应该提供哪些方法，而API用于描述各种软件组件之间的交互方式。
-
实现： 类可以实现一个或多个接口，但接口本身并不提供具体的实现。API可以包含具体的实现，例如库或框架提供的类和方法。
-
示例：
java.util.List是一个接口，而Java API包含了许多类似ArrayList的具体实现，以及其他各种类和方法。
总体而言，接口是一种抽象的概念，用于定义类的契约，而API是一组规范，用于描述软件组件之间的交互。在软件开发中，开发人员通常需要实现接口来满足一定的规范，并使用各种API来构建应用程序。