这里似乎已经涵盖了几乎所有的东西。在抽象类的实际实现上再补充一点:

Abstract关键字也用于防止类被实例化。如果你有一个具体的类，你不想被实例化-让它抽象。

你的所有语句都是有效的，除了你的第一个语句(在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));
    }
}

使用下面的指导原则来选择是使用接口还是抽象类。

接口:

定义一个契约(最好是无状态的——我的意思是没有变量) 将不相关的类链接到具有一种功能。 声明公共常量变量(不可变状态)

抽象类:

在几个密切相关的类之间共享代码。它建立了一种关系。 在相关类之间共享公共状态(状态可以在具体类中修改)

相关文章:

接口与抽象类(通用面向对象)

实现和扩展:什么时候使用?有什么不同?

通过这些例子，你可以理解

不相关的类可以通过接口具有功能，但相关类通过扩展基类来改变行为。

不妨这样想:

类和抽象类之间的关系类型为“is- A” 类和接口之间的关系类型为“has-a”

当你有一个抽象类哺乳动物，一个子类人类，和一个接口驱动，然后你可以说

每个人都是哺乳动物 每个人都有一种驾驶(行为)

我的建议是，书本知识短语表明他想听到两者之间的语义差异(就像这里其他人已经建议的那样)。

嗯，现在人们渴望实用的方法，你说得很对，但大多数面试官看起来是按照他们目前的要求，想要一个实用的方法。

回答完你的问题后，你应该跳到例子上:

文摘:

例如，我们有一个工资函数，它有一些对所有员工共同的参数。然后我们可以有一个叫做CTC的抽象类，它带有部分定义的方法体，它将被所有类型的员工扩展，并根据他们的额外工资得到补偿。 对于公共功能。

public abstract class CTC {

    public int salary(int hra, int da, int extra)
    {
        int total;
        total = hra+da+extra;
        //incentive for specific performing employee
        //total = hra+da+extra+incentive;
        return total;
    }
}

class Manger extends CTC
{
}


class CEO extends CTC
{
}

class Developer extends CTC
{   
}

接口

Java中的接口允许在不扩展接口功能的情况下拥有接口功能，你必须清楚你想在应用程序中引入的功能签名的实现。它会迫使你做出定义。 不同的功能。

public interface EmployeType {

    public String typeOfEmployee();
}

class ContarctOne implements EmployeType
{

    @Override
    public String typeOfEmployee() {
        return "contract";
    }

}

class PermanentOne implements EmployeType
{

    @Override
    public String typeOfEmployee() {
        return "permanent";
    }

}

通过将methgos定义为抽象类，你也可以对抽象类进行这样的强制活动，现在一个扩展抽象类的类仍然是抽象类，直到它覆盖抽象函数。

我为工作做面试，我也会不看好你的答案(抱歉，但我很诚实)。听起来你确实读过不同之处并修改了答案，但也许你从未在实践中使用过。

一个好的解释为什么你会使用每一种，比一个精确的解释差异要好得多。雇主最终希望程序员做一些他们不了解的事情，而这些事情很难在面试中展示出来。如果你申请的是技术或文档相关的工作，而不是开发人员的职位，你给出的答案会很好。

祝你以后面试顺利。

另外，我对这个问题的回答更多的是关于面试技巧，而不是你提供的技术材料。或许可以考虑读一读。https://workplace.stackexchange.com/是做这类事情的好地方。

我将尝试用实际场景来回答，以说明两者之间的区别。

接口是零负载的，即不需要维护状态，因此将契约(能力)与类关联是更好的选择。

例如，说我有一个执行一些操作的任务类，现在在单独的线程中执行一个任务，我不需要扩展线程类，更好的选择是使任务实现可运行的接口(即实现其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接口和抽象类甚至更窄。