在我的一次采访中，我被要求解释接口类和抽象类之间的区别。
以下是我的回答:
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.
然而，面试官并不满意，他告诉我这种描述代表了“书本知识”。
他让我给出一个更实际的回答，用实际的例子解释我什么时候会选择抽象类而不是接口。
我哪里错了?
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.
你的所有语句都是有效的，除了你的第一个语句(在Java 8发布之后):
Java接口的方法是隐式抽象的，不能有实现
从文档页:
接口是一种引用类型，类似于类，只能包含
常量、方法签名、默认方法、静态方法和嵌套类型
方法体只存在于默认方法和静态方法中。
默认的方法:
接口可以有默认方法，但与抽象类中的抽象方法不同。
默认方法使您能够向库的接口添加新功能，并确保与为这些接口的旧版本编写的代码的二进制兼容性。
当您扩展一个包含默认方法的接口时，您可以执行以下操作:
完全不要提及默认方法，这将使您的扩展接口继承默认方法。
重新声明默认方法，使其抽象。
重新定义默认方法，该方法将覆盖它。
静态方法:
除了默认方法外，还可以在接口中定义静态方法。静态方法是与定义它的类相关联的方法，而不是与任何对象相关联的方法。类的每个实例都共享它的静态方法。)
这让你更容易在你的库中组织帮助方法;
来自文档页的关于接口具有静态和默认方法的示例代码。
import java.time.*;
public interface TimeClient {
void setTime(int hour, int minute, int second);
void setDate(int day, int month, int year);
void setDateAndTime(int day, int month, int year,
int hour, int minute, int second);
LocalDateTime getLocalDateTime();
static ZoneId getZoneId (String zoneString) {
try {
return ZoneId.of(zoneString);
} catch (DateTimeException e) {
System.err.println("Invalid time zone: " + zoneString +
"; using default time zone instead.");
return ZoneId.systemDefault();
}
}
default ZonedDateTime getZonedDateTime(String zoneString) {
return ZonedDateTime.of(getLocalDateTime(), getZoneId(zoneString));
}
}
使用下面的指导原则来选择是使用接口还是抽象类。
接口:
定义一个契约(最好是无状态的——我的意思是没有变量)
将不相关的类链接到具有一种功能。
声明公共常量变量(不可变状态)
抽象类:
在几个密切相关的类之间共享代码。它建立了一种关系。
在相关类之间共享公共状态(状态可以在具体类中修改)
相关文章:
接口与抽象类(通用面向对象)
实现和扩展:什么时候使用?有什么不同?
通过这些例子，你可以理解
不相关的类可以通过接口具有功能，但相关类通过扩展基类来改变行为。
你很好地总结了使用和实现方面的实际差异，但没有提到意义上的差异。
接口是实现类将具有的行为的描述。实现类确保它将拥有这些可以在其上使用的方法。它基本上是类必须做出的契约或承诺。
抽象类是不同子类的基础，这些子类共享不需要重复创建的行为。子类必须完成行为，并有覆盖预定义行为的选项(只要它没有被定义为final或private)。
你会在java中找到很好的例子。util包，它包含了List这样的接口和AbstractList这样已经实现了接口的抽象类。官方文档对AbstractList的描述如下:
该类提供了List接口的框架实现，以最大限度地减少实现该接口所需的工作，该接口由“随机访问”数据存储(例如数组)支持。
我先给大家举个例子:
public interface LoginAuth{
public String encryptPassword(String pass);
public void checkDBforUser();
}
假设您的应用程序中有3个数据库。然后，该数据库的每个实现都需要定义上述2个方法:
public class DBMySQL implements LoginAuth{
// Needs to implement both methods
}
public class DBOracle implements LoginAuth{
// Needs to implement both methods
}
public class DBAbc implements LoginAuth{
// Needs to implement both methods
}
但是，如果encryptPassword()不依赖于数据库，并且对每个类都是相同的呢?那么上面的方法就不是一个好的方法。
相反，考虑以下方法:
public abstract class LoginAuth{
public String encryptPassword(String pass){
// Implement the same default behavior here
// that is shared by all subclasses.
}
// Each subclass needs to provide their own implementation of this only:
public abstract void checkDBforUser();
}
现在，在每个子类中，我们只需要实现一个方法——依赖于数据库的方法。
