一、默认方法的基本概念

（一）定义阐述

在 Java 中，接口默认方法是一种比较特殊且实用的存在。简单来说，它就是接口里可以有实现的方法。以往在 Java 里，接口中基本都是抽象方法，意味着实现接口的类必须去实现这些抽象方法才行。但从 Java 8 开始引入了默认方法这个概念，我们只需在方法名前面加上 “default” 关键字，就定义了一个接口默认方法，而且实现类并不强制去实现该方法。

打个比方，假如有个名为 “MyInterface” 的接口，里面定义了一个默认方法 “myDefaultMethod”，代码可能像这样：

public interface MyInterface {
 default void myDefaultMethod() {
 System.out.println("这是一个默认方法示例");
 }
}

这样一来，实现这个接口的类可以选择实现这个默认方法，也可以直接使用接口里默认提供的实现方式，给代码编写带来了很大的灵活性，也让接口在进行功能扩展等方面变得更加便捷了。

（二）语法格式展示

下面来具体看看 Java 接口默认方法的语法格式，示例如下：

public interface Animal {
 void makeSound(); // 抽象方法，实现类必须实现它
 default void move() {
 System.out.println("动物正在移动");
 }
}

在上述代码中，“Animal” 是一个接口，里面既有抽象方法 “makeSound”，又有默认方法 “move”。对于抽象方法 “makeSound”，实现 “Animal” 接口的类必须去重写并给出具体实现逻辑；而对于默认方法 “move”，实现类可以选择重写它，也可以直接使用接口中默认的实现，也就是会输出 “动物正在移动” 这句话。例如，有个类 “Dog” 实现了 “Animal” 接口：

class Dog implements Animal {
 @Override
 public void makeSound() {
 System.out.println("汪汪汪");
 }
 // 这里没有重写move方法，那么调用时就会使用接口里默认的实现
}

通过这样的语法格式和示例，可以更清晰地了解 Java 接口默认方法在代码层面是如何呈现和运用的。

二、默认方法的使用场景

（一）接口演化应用

在接口的演化过程中，Java 接口默认方法发挥着重要作用。比如，当我们有一个已经被广泛使用的接口，且存在众多实现类时，如果需要向这个接口里新增方法，在 Java 8 之前，所有实现该接口的类都必须去实现这个新添加的方法，否则代码就会报错，这无疑会破坏原有的代码结构。

而有了默认方法后，情况就大不一样了。例如，我们假设有一个名为 “Drawable” 的接口，很多图形类都实现了它，代码可能如下：

public interface Drawable {
 void draw();
}

现在需要给这个接口新增一个方法用于显示图形的颜色信息，定义为默认方法 “displayColor”：

public interface Drawable {
 void draw();
 default void displayColor() {
 System.out.println("该图形颜色暂未设定");
 }
}

这样一来，那些已经实现了 “Drawable” 接口的类，并不强制要求去重写 “displayColor” 这个默认方法，如果不需要特殊的颜色显示逻辑，就可以直接使用接口里默认提供的实现方式，也就是输出 “该图形颜色暂未设定” 这句话，原有的代码依然能够正常运行，不会因为接口新增方法就出现报错等问题，使得接口在功能扩展时更加平滑，不会破坏现有的代码体系，极大地提升了接口演化的便捷性和兼容性。

（二）多接口实现情况

当一个类实现多个接口，并且这些接口存在相同默认方法时，就需要妥善处理这种情况，避免出现冲突。

一种处理方式是创建自己的默认方法覆盖重写接口的默认方法。比如，有 “Flyable” 和 “Swimmable” 两个接口，都定义了名为 “move” 的默认方法：

interface Flyable {
 default void move() {
 System.out.println("通过飞行移动");
 }
}
interface Swimmable {
 default void move() {
 System.out.println("通过游泳移动");
 }
}

然后有一个类 “Duck” 实现了这两个接口，为了避免冲突，“Duck” 类可以重写 “move” 方法：

class Duck implements Flyable, Swimmable {
 @Override
 public void move() {
 System.out.println("鸭子既能游泳又能飞行来移动");
 }
}

另一种方式是使用 “接口名.super. 方法名” 来调用指定接口的默认方法。还是以上面的 “Flyable” 和 “Swimmable” 接口为例，若 “Duck” 类想分别调用两个接口的默认方法，可以这样写：

class Duck implements Flyable, Swimmable {
 public void move() {
 Flyable.super.move();
 Swimmable.super.move();
 }
}

在 “Duck” 类的 “move” 方法中，通过 “Flyable.super.move ()” 就能调用 “Flyable” 接口里的默认 “move” 方法，输出 “通过飞行移动”；通过 “Swimmable.super.move ()” 则可以调用 “Swimmable” 接口里的默认 “move” 方法，输出 “通过游泳移动”，从而根据实际需求来灵活处理多接口中相同默认方法的调用情况，避免出现方法调用的歧义等问题。

三、接口静态方法相关内容

（一）静态方法的定义与特点

在 Java 8 中，接口当中允许定义静态方法啦。其格式为 “public static 返回值类型 方法名称（参数列表）{方法体}”，简单来说，就是将以往接口里抽象方法定义时的 “abstract” 或者默认方法定义里的 “default” 关键字换成 “static” 就行，而且要带上具体的方法体哦。

接口的静态方法与默认方法有着明显区别呢。默认方法可以通过实现类的对象来进行调用，实现类也能根据自身需求选择重写或者直接使用接口中默认的实现方式；而静态方法只能通过接口本身去调用，实现接口的类或者子接口并不会继承接口中的静态方法哦。比如说，我们有一个接口定义了静态方法，那在使用这个静态方法时，必须通过 “接口名称。静态方法名 (参数)” 这样的形式，而不能试图通过接口实现类的对象去调用该静态方法呢。

（二）静态方法的使用示例

下面咱们来看一个接口中定义静态方法以及调用的具体代码示例呀。

首先定义一个接口，名为 “MyInterfaceStatic”，在里面定义一个静态方法，代码如下：

public interface MyInterfaceStatic {
 public static void methosStatic() {
 System.out.println("这是一个接口的静态方法!");
 }
}

接着创建它的实现类，这里实现类因为接口中没有抽象方法，所以不需要覆盖重写任何方法哦，像这样：

public class MyInterfaceStatic01 implements MyInterfaceStatic{
}

最后，咱们在主方法里调用这个静态方法，示例代码如下：

public class DemoInterfaceStatic {
 public static void main(String[] args) {
 MyInterfaceStatic.methosStatic();
 }
}

通过上述代码，大家就能清晰地看到在实际编程中，接口静态方法是如何定义以及正确调用的啦，按照这样的方式，就可以在合适的场景下利用接口静态方法为我们的程序开发助力哦，比如可以把一些常用的工具型方法定义成接口静态方法，方便在不同地方通过接口名直接调用呢。

四、默认方法的优先级规则

（一）类优先原则

在 Java 中，当一个类扩展了超类同时又实现了接口，若超类和接口中存在相同方法时，就会遵循类优先原则。这意味着只会考虑超类中的方法，接口里的默认方法会被直接忽略。

比如说，我们有如下代码示例：

class SuperClass {
 public void printInfo() {
 System.out.println("这是超类中的方法");
 }
}
interface MyInterface {
 default void printInfo() {
 System.out.println("这是接口中的默认方法");
 }
}
class SubClass extends SuperClass implements MyInterface {
 // 这里无需对接口中的默认方法做任何处理，因为遵循类优先原则，会使用超类的方法
}

在上述代码里，SubClass类继承了SuperClass类并且实现了MyInterface接口，两个里面都有printInfo这个方法。但根据类优先原则，当我们创建SubClass类的对象并调用printInfo方法时，实际执行的是SuperClass类中定义的printInfo方法，输出的会是 “这是超类中的方法”，接口里的默认方法实现就相当于被 “屏蔽” 掉了。这个原则可以很好地保证 Java 7 代码与后续加入默认方法的代码之间的兼容性，避免因为接口新增默认方法而对已有代码逻辑造成意外影响。

（二）接口冲突时的规则

当出现一个接口提供了一个默认方法，另一个接口也提供了同名且参数类型相同的方法这种情况时，就产生了接口冲突。例如下面这样的代码：

interface InterfaceA {
 default void commonMethod() {
 System.out.println("这是InterfaceA接口中的默认方法");
 }
}
interface InterfaceB {
 default void commonMethod() {
 System.out.println("这是InterfaceB接口中的默认方法");
 }
}

如果此时有一个类同时实现了这两个接口，像这样：

class ImplementClass implements InterfaceA, InterfaceB {
 // 这里如果不做处理，编译器会报错，提示存在方法冲突的二义性
}

就会出现编译错误，因为编译器不知道该使用InterfaceA还是InterfaceB接口里的默认方法了。解决这个冲突的办法就是在实现类中覆盖这个同名的方法，比如：

class ImplementClass implements InterfaceA, InterfaceB {
 @Override
 public void commonMethod() {
 // 可以选择调用其中一个接口的默认方法，比如这里调用InterfaceA的默认方法
 InterfaceA.super.commonMethod();
 // 也可以添加自己独特的实现逻辑
 System.out.println("这是在实现类中添加的额外处理逻辑");
 }
}

在上述修改后的ImplementClass类中，通过重写commonMethod方法，并使用 “接口名.super. 方法名” 的形式（如InterfaceA.super.commonMethod()）来明确调用指定接口的默认方法，或者添加符合实际需求的实现逻辑，以此来解决接口间默认方法冲突的问题，让代码可以顺利编译并按照期望的逻辑执行。

五、默认方法的优势总结

（一）不破坏现有代码

在 Java 的编程世界里，接口默认方法有着一个极为重要的优势，那就是不破坏现有代码。在 Java 8 之前，如果要给一个已经被广泛使用且存在众多实现类的接口添加新方法，那可是个 “大工程”。因为接口里原本定义的方法都是抽象方法，实现类必须去实现这些抽象方法，所以一旦新增方法，所有实现该接口的类都得去实现这个新添加的方法，不然代码就会报错，原有的代码结构也就被破坏了。

而接口默认方法的出现巧妙地解决了这个难题。比如有一个已经在项目里大量应用的接口，众多类都实现了它，现在要对这个接口进行功能扩展，添加新的方法时，通过将新方法定义为默认方法，那些已经实现了该接口的类就不需要强制去重写这个默认方法了。如果它们不需要特殊的逻辑处理，完全可以直接使用接口里默认提供的实现方式，原有的代码依然能够正常运行，不会出现报错等情况，让接口在功能扩展时更加平滑，保障了代码体系的完整性，极大地提升了接口演化的便捷性和兼容性，也使得整个项目的代码维护和扩展变得更加轻松、高效。

（二）提供可选功能

接口默认方法的另一个显著优势就是提供了可选功能。以往，接口中的方法不管是否是每个实现类都需要的，实现类都得有相应的实现，哪怕只是一个空的实现占位。

但有了默认方法后，情况就不一样了。接口里定义的默认方法对于实现类来说变成了可选的操作。实现类可以根据自身实际的业务需求，选择是否重写默认方法。如果默认方法的实现刚好满足需求，那就可以直接使用，无需额外编写代码；要是有特殊的业务逻辑要求，实现类则可以重写该默认方法，按照自己的要求来定制具体的实现逻辑。

例如在一些业务场景中，对于数据的处理接口，可能有一个默认的排序方法作为默认方法存在于接口中。部分实现类如果直接使用这个默认的排序逻辑就能满足业务需求，那就不用重写；而另外一些对排序有特殊要求，比如按照不同字段、不同规则排序的实现类，就可以重写这个默认的排序方法，来满足自己独特的业务场景。这种可选的功能大大增加了编程的灵活性，让代码可以更好地适配多样化的业务需求，提升了代码的复用性以及整个项目的可扩展性。