在我的一次采访中，我被要求解释接口类和抽象类之间的区别。
以下是我的回答:
Methods of a Java interface are implicitly abstract
and cannot have implementations. A Java abstract class can have
instance methods that implements a default behaviour.
Variables declared in a Java interface are by default final. An
abstract class may contain non-final variables.
Members of a Java interface are public by default. A Java abstract
class can have the usual flavours of class members like private,
protected, etc.
A Java interface should be implemented using keyword “implements”; A
Java abstract class should be extended using keyword “extends”.
An interface can extend another Java interface only, an abstract class
can extend another Java class and implement multiple Java interfaces.
A Java class can implement multiple interfaces but it can extend only
one abstract class.
然而，面试官并不满意，他告诉我这种描述代表了“书本知识”。
他让我给出一个更实际的回答，用实际的例子解释我什么时候会选择抽象类而不是接口。
我哪里错了?
我将尝试用实际场景来回答，以说明两者之间的区别。
接口是零负载的，即不需要维护状态，因此将契约(能力)与类关联是更好的选择。
例如，说我有一个执行一些操作的任务类，现在在单独的线程中执行一个任务，我不需要扩展线程类，更好的选择是使任务实现可运行的接口(即实现其run()方法)，然后将此任务类的对象传递给线程实例并调用其start()方法。
现在你可以问，如果Runnable是一个抽象类呢?
从技术上讲，这是可能的，但从设计角度来看，这是一个糟糕的选择原因:
Runnable没有与之相关的状态，也没有“提供”任何状态
run()方法的默认实现
Task必须扩展它，因此它不能扩展任何其他类
Task没有提供任何专门化到Runnable类，它所需要的只是重写run()方法
换句话说，Task类需要在线程中运行的能力，这是通过实现Runnable接口而实现的，而扩展thread类则使其成为线程。
简单地把我们的接口定义为一种能力(契约)，而使用
的抽象类，用于定义的框架(公共/部分)实现
它。
免责声明:下面是愚蠢的例子，尽量不要判断:-P
interface Forgiver {
void forgive();
}
abstract class GodLike implements Forgiver {
abstract void forget();
final void forgive() {
forget();
}
}
现在你可以选择成为神一样的人，但你可以选择只成为宽恕者(即不成为神一样的人)，并做:
class HumanLike implements Forgiver {
void forgive() {
// forgive but remember
}
}
或者你可以选择像上帝一样去做:
class AngelLike extends GodLike {
void forget() {
// forget to forgive
}
}
P.S.与java 8接口也可以有静态以及默认(可重写实现)方法，因此区别b/w接口和抽象类甚至更窄。
接口与抽象类的基本区别在于，接口支持多重继承，而抽象类不支持。
在抽象类中，你也可以提供所有的抽象方法，比如接口。
为什么需要抽象类?
在某些情况下，当处理用户请求时，抽象类并不知道用户的意图。在该场景中，我们将在类中定义一个抽象方法，并询问用户谁扩展了这个类，请在抽象方法中提供您的意图。在这种情况下，抽象类非常有用
为什么需要接口?
比如说，我有一份工作，但我在这方面没有经验。的例子,
如果你想建造一座建筑或大坝，那么在这种情况下你会怎么做?
你将确定你的需求是什么，并根据这些需求制定一份合同。
然后打电话给投标者来构建你的项目
无论谁建造这个项目，都应该满足你的要求。但是不同厂商的构造逻辑是不同的。
这里我不关心它们是如何构造的。最终的目标是否满足我的要求，这只是我的关键点。
在这里，你的需求称为接口，构造函数称为实现者。
这个世界上没有什么是完美的。他们可能期待的是更实际的方法。
但在你解释之后，你可以用稍微不同的方法添加这些行。
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()方法的实现，否则编译器将抛出编译时错误。
From what I understand, an Interface, which is comprised of final variables and methods with no implementations, is implemented by a class to obtain a group of methods or methods that are related to each other. On the other hand, an abstract class, which can contain non-final variables and methods with implementations, is usually used as a guide or as a superclass from which all related or similar classes inherits from. In other words, an abstract class contains all the methods/variables that are shared by all its subclasses.
