我相信面试官想要了解的可能是界面和实现之间的区别。

代码模块的接口——不是Java接口，更通用的说法是“接口”——基本上是与使用该接口的客户端代码之间的契约。

代码模块的实现是使模块工作的内部代码。通常，您可以以多种不同的方式实现特定的接口，甚至可以在客户机代码不知道更改的情况下更改实现。

A Java interface should only be used as an interface in the above generic sense, to define how the class behaves for the benefit of client code using the class, without specifying any implementation. Thus, an interface includes method signatures - the names, return types, and argument lists - for methods expected to be called by client code, and in principle should have plenty of Javadoc for each method describing what that method does. The most compelling reason for using an interface is if you plan to have multiple different implementations of the interface, perhaps selecting an implementation depending on deployment configuration.

A Java abstract class, in contrast, provides a partial implementation of the class, rather than having a primary purpose of specifying an interface. It should be used when multiple classes share code, but when the subclasses are also expected to provide part of the implementation. This permits the shared code to appear in only one place - the abstract class - while making it clear that parts of the implementation are not present in the abstract class and are expected to be provided by subclasses.

在Java中选择接口是为了避免多重继承中的菱形问题。

如果你想让你所有的方法都由你的客户端实现，你可以选择接口。这意味着你要抽象地设计整个应用程序。

如果您已经知道它们的共同点，那么您就可以选择抽象类。例如，取一个抽象类Car。在更高的级别上实现常见的car方法，如calculateRPM()。这是一种常见的方法，你让客户端实现他自己的行为，比如 calculateMaxSpeed()等。也许你会举几个你在日常工作中遇到的真实例子来解释。

当我试图在两个密切相关的类之间共享行为时，我创建了一个包含公共行为的抽象类，并作为两个类的父类。

当我试图定义Type(对象的用户可以可靠地调用的方法列表)时，我创建了一个接口。

例如，我绝不会创建一个只有一个具体子类的抽象类，因为抽象类是关于共享行为的。但是我很可能创建一个只有一个实现的接口。我的代码的用户不会知道只有一个实现。实际上，在未来的版本中可能会有几个实现，它们都是一些新的抽象类的子类，这些抽象类在我创建接口时甚至还不存在。

这似乎也有点太书生气了(尽管我在记忆中从未见过这样的说法)。如果面试官(或OP)真的想要更多关于这方面的个人经验，我早就准备好了关于界面是出于必要而进化的轶事，反之亦然。

One more thing. Java 8 now allows you to put default code into an interface, further blurring the line between interfaces and abstract classes. But from what I have seen, that feature is overused even by the makers of the Java core libraries. That feature was added, and rightly so, to make it possible to extend an interface without creating binary incompatibility. But if you are making a brand new Type by defining an interface, then the interface should be JUST an interface. If you want to also provide common code, then by all means make a helper class (abstract or concrete). Don't be cluttering your interface from the start with functionality that you may want to change.

这个世界上没有什么是完美的。他们可能期待的是更实际的方法。

但在你解释之后，你可以用稍微不同的方法添加这些行。

Interfaces are rules (rules because you must give an implementation to them that you can't ignore or avoid, so that they are imposed like rules) which works as a common understanding document among various teams in software development. Interfaces give the idea what is to be done but not how it will be done. So implementation completely depends on developer by following the given rules (means given signature of methods). Abstract classes may contain abstract declarations, concrete implementations, or both. Abstract declarations are like rules to be followed and concrete implementations are like guidelines (you can use it as it is or you can ignore it by overriding and giving your own implementation to it). Moreover which methods with same signature may change the behaviour in different context are provided as interface declarations as rules to implement accordingly in different contexts.

编辑:Java 8简化了在接口中定义默认方法和静态方法。

public interface SomeInterfaceOne {

    void usualAbstractMethod(String inputString);

    default void defaultMethod(String inputString){
        System.out.println("Inside SomeInterfaceOne defaultMethod::"+inputString);
    }
}

现在，当一个类将实现SomeInterface时，并不强制为interface的默认方法提供实现。

如果我们有另一个具有以下方法的接口:

public interface SomeInterfaceTwo {

    void usualAbstractMethod(String inputString);

    default void defaultMethod(String inputString){
        System.out.println("Inside SomeInterfaceTwo defaultMethod::"+inputString);
    }

}

Java不允许扩展多个类，因为这会导致“钻石问题”，即编译器无法决定使用哪个超类方法。如果使用默认方法，接口也会出现菱形问题。因为如果一个类同时实现这两个

SomeInterfaceOne and SomeInterfaceTwo

并且没有实现常见的默认方法，编译器不能决定选择哪一个。 为了避免这个问题，在java 8中必须实现不同接口的通用缺省方法。如果任何类实现了上述两个接口，它必须提供defaultMethod()方法的实现，否则编译器将抛出编译时错误。

简而言之，我想这样回答:

通过类层次结构进行继承意味着状态继承; 而通过接口继承则代表行为继承;

抽象类可以被视为介于这两种情况之间的东西(它引入了一些状态，但也迫使你定义一个行为)，完全抽象类是一个接口(据我所知，这是c++中仅由虚拟方法组成的类的进一步发展)。

当然，从Java 8开始，事情发生了轻微的变化，但思想仍然是一样的。

我想这对于一个典型的Java面试来说已经足够了，如果你不是被编译器团队面试的话。

我所观察到的主要区别是抽象类为我们提供了一些已经实现的常见行为，而子类只需要实现与它们对应的特定功能。而接口只指定需要完成哪些任务，接口不会给出任何实现。我可以说它指定了它自己和实现的类之间的契约。