正如在其他回答中提到的，添加实现到接口的能力是为了在Collections框架中提供向后兼容性。我认为，提供向后兼容性可能是向接口添加实现的唯一好的理由。

否则，如果您将实现添加到接口，那么您就违反了最初添加接口的基本规律。Java是一种单一继承语言，不像c++允许多重继承。接口提供了支持多重继承的语言所具有的类型优势，而不会引入多重继承所带来的问题。

更具体地说，Java只允许实现的单一继承，但它允许接口的多重继承。例如，以下是有效的Java代码:

class MyObject extends String implements Runnable, Comparable { ... }

MyObject只继承了一个实现，但它继承了三个契约。

Java传递了实现的多重继承，因为实现的多重继承带来了许多棘手的问题，这些问题超出了本文的讨论范围。添加接口是为了允许合约的多重继承(又名接口)，而不存在实现的多重继承问题。

为了支持我的观点，这里引用了Ken Arnold和James Gosling在《Java编程语言》(第4版)一书中的一句话:

Single inheritance precludes some useful and correct designs. The problems of multiple inheritance arise from multiple inheritance of implementation, but in many cases multiple inheritance is used to inherit a number of abstract contracts and perhaps one concrete implementation. Providing a means to inherit an abstract contract without inheriting an implementation allows the typing benefits of multiple inheritance without the problems of multiple implementation inheritance. The inheritance of an abstract contract is termed interface inheritance. The Java programming language supports interface inheritance by allowing you to declare an interface type

Remi Forax规则是不要用抽象类进行设计。你用界面来设计你的应用。无论Java的版本是什么，无论语言是什么。它以SOLID原理中的界面分离原理为依据。

稍后您可以使用抽象类来分解代码。现在有了Java 8，你可以直接在界面中完成。这只是个设施，仅此而已。

这两个是完全不同的:

默认方法是在不改变现有类状态的情况下向其添加外部功能。

抽象类是一种普通的继承类型，它们是用于扩展的普通类。

从业务用例上下文中，接口可用于定义特定的业务规则，其中抽象类将定义启动业务的公共结构。

假设某个企业所有者希望与Amazon和Walmart合作，那么这里定义的接口将是WalmartPartner, AmazonPartner将定义特定的业务规则，抽象类BusinessSetup将获得特定区域的业务设置。

// Interfaces
 
public interface WalmartPartner {
    public static boolean signUpForWalmartBusinessAccount(String BusinessId){
        System.out.println("Setting up Walmart Business Partner");
        return true;
    }
    public default  void  getWalmartDeals(){
        System.out.println("Default walmart deal executed !");
    }
    public abstract void setupShopifyForWalmart();
    public abstract  void setupWalmartProducts();

public interface AmazonPartner {
    public static boolean signUpAsAmazonServicePartner(String BusinessId){
        System.out.println("Setting up Amazon Business Partner");
        return true;
    }
    public default  void  paymentPlatformSetup(){
        System.out.println(" Amazon default payment platform is setup");
    }
    public abstract void setupPrimeMemberDealsByRegion();
    public abstract  void setupPrimeDeals();
}

 // Abstract class 

public abstract class BusinessSetup {
    String businessId ;
    public BusinessSetup(String businessId){
        this.businessId = businessId;
        System.out.println("1. Initial Business setup for BusienssID: "+this.businessId+" is Complete");
    }
    public final boolean getBusinessRegisteredInRegion(String region){
        System.out.println("2. Business got registered in "+region+ "!");
        return true;
    }
    public abstract void setupCustomerPlatform(String customerId);
    public abstract void setupVendorPlatform(String vendorId);

}

// Concrete Class 
public class WalMartPartnerImpl extends BusinessSetup implements WalmartPartner {
    public WalMartPartnerImpl(String businessId) {
        super(businessId);
    }
    @Override
    public void setupCustomerPlatform(String customerId) {
    }

    @Override
    public void setupVendorPlatform(String vendorId) {
    }

    @Override
    public void setupShopifyForWalmart() {
    }

    @Override
    public void setupWalmartProducts() {
    }
    public static void main(String args[]){
        WalMartPartnerImpl walMartPartner = new WalMartPartnerImpl("wal8989");
        walMartPartner.getBusinessRegisteredInRegion("california");
        walMartPartner.getWalmartDeals();
        walMartPartner.setupCustomerPlatform("wal8989");

    }
}

本文将对此进行描述。想想forEach of Collections。

List<?> list = …
list.forEach(…);

The forEach isn’t declared by java.util.List nor the java.util.Collection interface yet. One obvious solution would be to just add the new method to the existing interface and provide the implementation where required in the JDK. However, once published, it is impossible to add methods to an interface without breaking the existing implementation. The benefit that default methods bring is that now it’s possible to add a new default method to the interface and it doesn’t break the implementations.

Java接口中的默认方法支持接口演进。

对于现有的接口，如果希望在不破坏接口旧版本的二进制兼容性的情况下向其添加方法，有两个选择:添加默认方法或静态方法。实际上，添加到接口中的任何抽象方法都必须由实现该接口的类或接口来实现。

静态方法对于类来说是唯一的。默认方法对于类的实例是唯一的。

如果向现有接口添加默认方法，实现该接口的类和接口不需要实现它。他们可以

实现默认方法，它将覆盖已实现接口中的实现。 重新声明方法(没有实现)，使其抽象。 什么都不做(然后简单地继承实现接口的默认方法)。

更多关于这个话题的信息请点击这里。