Java接口的理解

接口

接口是什么？

接口不代表一类事物，而是一种规则，而规则是一成不变的，它也是对行为的抽象。

如何定义和使用一个接口

• 接口用关键词interface来定义

  public interface 接口名{}

• 接口不能实例化

• 接口和类之间是实现关系，通过implements关键字表示

  public class 类名 implements 接口名{}

• 接口的子类（实现类）

  要么重写接口中的所有抽象方法（因为接口中的方法是抽象的）。

  要么也是抽象类。

• 接口和类的实现关系，可以单实现，也可以多实现。

  public class 类名implements 接口名1，接口名2{}

• 实现类还可以在继承一个类的同时实现多个接口。

  public class 类名 extends 父类 implements 接口名1，接口名2{}

接口和类的关系

接口和类直接的关系

实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。

接口和接口之间的关系

继承关系，可以单继承，也可以多继承。

接口的继承

接口的继承就相当于简单的叠加，继承就相当于多几个规则。

接口中的成员特点

• 成员变量

  • 只能是常量

  • 默认修饰符：public static final

• 构造方法

  • 无

• 成员方法

  • 只能是抽象方法（JDK7以前）

  • 默认修饰符：public abstract

接口中的抽象方法

为什么接口中的方法是抽象的？

在Java中，接口中的方法被声明为抽象的，这是为了确保接口的完整性和一致性。以下是几个原因解释为什么接口中的方法是抽象的：

1. 完整性：通过将方法声明为抽象的，接口强制要求实现该接口的类必须提供这些方法的完整实现。这确保了所有使用该接口的类都能够提供一致的行为和功能，从而保持了接口的完整性。

2. 一致性：将方法声明为抽象的有助于保持接口的一致性。如果接口中的方法不是抽象的，那么实现该接口的类可以自由地添加自己的行为和实现细节，这可能导致不一致的行为和功能。通过将方法声明为抽象的，接口明确表示这些方法必须由实现类提供具体的实现，从而保持一致性。

接口抽象方法的默认语法

 public abstract <返回类型> <方法名>(<参数列表>);

抽象方法的调用示例如下：

 public interface MyInterface {
     // 抽象方法示例
     void myAbstractMethod();
 }
 ​
 public class MyClass implements MyInterface {
     // 提供抽象方法的实现
     @Override
     public void myAbstractMethod() {
         System.out.println("This is an abstract method implemented in MyClass.");
     }
     
     public static void main(String[] args) {
         // 创建实现类的实例
         MyClass myClass = new MyClass();
         
         // 调用抽象方法的实现
         myClass.myAbstractMethod();
     }
 }

在这个示例中，MyInterface 接口定义了一个抽象方法 myAbstractMethod，它没有具体的实现。MyClass 类实现了 MyInterface 接口，并提供了 myAbstractMethod 方法的实现。在实现后的方法中，它打印了一条简单的消息。

接口中的默认方法(JDK8以后)

默认方法可以有多个吗？

是的，接口中可以有多个默认方法。默认方法使用 default 关键字进行声明，并且可以包含一个方法体。接口中可以有多个默认方法，它们可以具有不同的名称、参数和返回类型。实现接口的类可以选择是否重写这些默认方法。

为何什么要添加默认方法？

如果一个已经投入使用的接口需要扩展一个新的方法，在JDK8以前，必须在所有实现类中添加该方法的实现，否则编译会出现异常。如果实现类数量少并且我们有权限修改，可能会工作量相对较少。如果实现类比较多或者我们没有权限修改实现类源代码，这样可能就比较麻烦。而默认方法则解决了这个问题，它提供了一个实现，当没有显示提供其他实现时就采用这个实现。这样新添加的方法将不会破坏现有代码。

什么是默认方法？

接口中的默认方法是一种特殊的方法，它可以在接口中定义并实现，而不需要在实现类中进行重写。默认方法的目的是提供一种默认的行为，以便在实现该接口的类中可以继承或覆盖它。

默认方法的语法如下：

 public default <返回类型> <方法名>(<参数列表>) {    // 方法体}

默认方法的调用示例如下：

 package Demo;
 // 定义一个接口
 interface MyInterface {
     // 定义一个抽象方法
     public abstract void myabstractMethod();
     // 定义一个默认方法
     default void myDefaultMethod() {
         System.out.println("This is a default method in an interface.");
     }
 }
 ​
 // 定义一个类，实现接口
 class MyClass implements MyInterface {
     // 重写抽象方法
     @Override
     public void myabstractMethod() {
         System.out.println("This is an abstract method implemented in MyClass.");
     }
 }
 ​
 public class Demo {
     public static void main(String[] args) {
         // 创建一个MyClass实例
         MyClass myClass = new MyClass();
         // 调用myDefaultMethod
         myClass.myDefaultMethod();
         // 调用myabstractMethod
         myClass.myabstractMethod();
     }
 }

在这个示例中，我们有一个接口MyInterface，它包含一个抽象方法myabstractMethod和一个默认方法myDefaultMethod。myDefaultMethod是一个简单的打印操作，告诉我们这是一个默认方法。然后，我们有一个实现了MyInterface的类MyClass。它重写了myabstractMethod，提供了实际的实现。在Demo类的main方法中，我们创建了一个MyClass的实例，并调用了myDefaultMethod和myabstractMethod。当运行这个程序时，输出将是：

This is a default method in an interface. This is an abstract method implemented in MyClass.

接口中的静态方法（JDK8）

为什么要用静态方法？

静态方法属于接口本身可以通过接口直接调用，方便。

静态方法的语法

 public static <返回类型> <方法名>(<参数列表>) {    // 方法体}

接口中静态方法的语法的调用代码示例

 public interface MyInterface {
     // 静态方法示例
     static void myStaticMethod() {
         System.out.println("This is a static method in an interface.");
     }
 }
 ​
 public class MyClass implements MyInterface {
     public static void main(String[] args) {
         // 调用接口中的静态方法
         MyInterface.myStaticMethod();
     }
 }

在上面的示例中，MyClass 类实现了 MyInterface 接口，并包含一个 main 方法。在 main 方法中，我们使用 MyInterface.myStaticMethod() 的方式调用了接口中的静态方法 myStaticMethod。这将输出 "This is a static method in an interface."。

接口中的私有方法（JDK9）

接口中私有方法的作用是什么：

既可以可以减少代码重复，又可以保证对象不会错误调用重复模块的代码。

分为哪两种各自的作用是什么：

• 普通私有方法

  • 格式：private 返回值类型 方法名（参数列表）{}

  • 作用：给默认方法服务，用来补充方法的重复代码。

• 静态私有方法

  • 格式：private static 返回值类型 方法名（参数列表）{}

  • 作用：给静态方法服务，用来补充静态方法的重复代码。

接口的多态

什么是接口的多态？

当一个方法的参数是接口时，可以传递接口所有的实现类对象，这种方式称之为接口的多态。

接口多态的示例代码

 interface Shape {
     void draw();
 }
 ​
 class Circle implements Shape {
     @Override
     public void draw() {
         System.out.println("绘制圆形");
     }
 }
 ​
 class Square implements Shape {
     @Override
     public void draw() {
         System.out.println("绘制方形");
     }
 }
 ​
 public class Main {
     public static void main(String[] args) {
         Shape shape1 = new Circle();
         Shape shape2 = new Square();
         shape1.draw(); // 输出 "绘制圆形"
         shape2.draw(); // 输出 "绘制方形"
     }
 }

接口的多态也可以用在参数传递

为什么存在接口的多态？

接口中的方法默认是抽象方法，可以在子类中被重写。因此，子类可以实现多个接口，并且可以通过多态来实现对接口中方法的调用。虽然接口没有方法体，但是子类可以通过实现接口中的方法来提供具体的实现。因此，接口的多态性是通过子类对接口中方法的重写来实现的。在程序运行时，可以根据对象的实际类型来调用相应的方法，这就是多态的表现。因此，即使接口没有方法体，多态仍然存在并被广泛应用。

可以根据对象的实际类型来调用相应的方法：这句话的意思是，在面向对象编程中，当一个对象被当作接口类型使用时，程序会在运行时根据该对象的实际类型来确定调用哪个方法。这就是多态的表现。

例如，假设有一个接口叫做Shape，它有一个方法叫做draw。现在有两个类，Circle和Square，它们都实现了Shape接口。当一个Circle对象被当作Shape接口使用时，调用它的draw方法就会执行圆的绘制代码；同样，当一个Square对象被当作Shape接口使用时，调用它的draw方法就会执行方形的绘制代码。这就是多态的体现，程序在运行时根据对象的实际类型来决定调用哪个方法。

通过这种方式，接口提供了一种灵活的方式来组织代码，使得程序可以在不修改原有代码的情况下添加新的功能，这也是面向对象编程的一个重要优点。