抽象类不是纯粹的抽象，因为它是具体方法(已实现方法)和未实现方法的集合。 但 接口是纯抽象的，因为只有未实现的方法，没有具体的方法。

为什么是抽象类?

如果用户想为所有对象编写通用功能。 抽象类是未来重新实现的最佳选择，可以在不影响最终用户的情况下增加更多的功能。

为什么接口?

如果用户想要编写不同的功能，那将是对象上的不同功能。 一旦接口发布，如果不需要修改需求，接口是最好的选择。

你很好地总结了使用和实现方面的实际差异，但没有提到意义上的差异。

接口是实现类将具有的行为的描述。实现类确保它将拥有这些可以在其上使用的方法。它基本上是类必须做出的契约或承诺。

抽象类是不同子类的基础，这些子类共享不需要重复创建的行为。子类必须完成行为，并有覆盖预定义行为的选项(只要它没有被定义为final或private)。

你会在java中找到很好的例子。util包，它包含了List这样的接口和AbstractList这样已经实现了接口的抽象类。官方文档对AbstractList的描述如下:

该类提供了List接口的框架实现，以最大限度地减少实现该接口所需的工作，该接口由“随机访问”数据存储(例如数组)支持。

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

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

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()方法的实现，否则编译器将抛出编译时错误。

我先给大家举个例子:

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();
}

现在，在每个子类中，我们只需要实现一个方法——依赖于数据库的方法。

Many junior developers make the mistake of thinking of interfaces, abstract and concrete classes as slight variations of the same thing, and choose one of them purely on technical grounds: Do I need multiple inheritance? Do I need some place to put common methods? Do I need to bother with something other than just a concrete class? This is wrong, and hidden in these questions is the main problem: "I". When you write code for yourself, by yourself, you rarely think of other present or future developers working on or with your code.

接口和抽象类，虽然从技术的角度来看很相似，但它们的含义和目的完全不同。

总结

接口定义了一个契约，由某个实现为您实现。 抽象类提供了您的实现可以重用的默认行为。

以上两点正是我在面试时所寻求的，并且是一个足够紧凑的总结。阅读更多细节。

替代的总结

接口用于定义公共api 抽象类用于内部使用和定义spi

通过例子

To put it differently: A concrete class does the actual work, in a very specific way. For example, an ArrayList uses a contiguous area of memory to store a list of objects in a compact manner which offers fast random access, iteration, and in-place changes, but is terrible at insertions, deletions, and occasionally even additions; meanwhile, a LinkedList uses double-linked nodes to store a list of objects, which instead offers fast iteration, in-place changes, and insertion/deletion/addition, but is terrible at random access. These two types of lists are optimized for different use cases, and it matters a lot how you're going to use them. When you're trying to squeeze performance out of a list that you're heavily interacting with, and when picking the type of list is up to you, you should carefully pick which one you're instantiating.

On the other hand, high level users of a list don't really care how it is actually implemented, and they should be insulated from these details. Let's imagine that Java didn't expose the List interface, but only had a concrete List class that's actually what LinkedList is right now. All Java developers would have tailored their code to fit the implementation details: avoid random access, add a cache to speed up access, or just reimplement ArrayList on their own, although it would be incompatible with all the other code that actually works with List only. That would be terrible... But now imagine that the Java masters actually realize that a linked list is terrible for most actual use cases, and decided to switch over to an array list for their only List class available. This would affect the performance of every Java program in the world, and people wouldn't be happy about it. And the main culprit is that implementation details were available, and the developers assumed that those details are a permanent contract that they can rely on. This is why it's important to hide implementation details, and only define an abstract contract. This is the purpose of an interface: define what kind of input a method accepts, and what kind of output is expected, without exposing all the guts that would tempt programmers to tweak their code to fit the internal details that might change with any future update.

抽象类介于接口和具体类之间。它应该帮助实现共享常见或无聊的代码。例如，AbstractCollection提供了基于大小为0的isEmpty的基本实现，contains作为迭代和比较，addAll作为重复添加，等等。这使得实现将重点放在区分它们的关键部分:如何实际存储和检索数据。

另一个角度:api与spi

接口是代码不同部分之间的低内聚网关。它们允许库的存在和发展，而不会在内部发生变化时影响到每个库的用户。它被称为应用程序编程接口，而不是应用程序编程类。在较小的规模上，它们还允许多个开发人员在大型项目上成功协作，通过良好的文档接口分离不同的模块。

抽象类是在实现接口时使用的高内聚帮助器，假设有某种级别的实现细节。或者，抽象类用于定义服务提供者接口(spi)。

API和SPI之间的区别很微妙，但很重要:对于API，重点在于谁使用它，而对于SPI，重点在于谁实现它。

Adding methods to an API is easy, all existing users of the API will still compile. Adding methods to an SPI is hard, since every service provider (concrete implementation) will have to implement the new methods. If interfaces are used to define an SPI, a provider will have to release a new version whenever the SPI contract changes. If abstract classes are used instead, new methods could either be defined in terms of existing abstract methods, or as empty throw not implemented exception stubs, which will at least allow an older version of a service implementation to still compile and run.

关于Java 8和默认方法的说明

尽管Java 8为接口引入了默认方法，这使得接口和抽象类之间的界限更加模糊，但这并不是为了实现可以重用代码，而是为了更容易地更改既作为API又作为SPI(或者被错误地用于定义SPI而不是抽象类)的接口。

“书本知识”

OP回答中提供的技术细节被认为是“书本知识”，因为这通常是在学校和大多数关于语言的技术书籍中使用的方法:一个东西是什么，而不是如何在实践中使用它，特别是在大规模应用中。

打个比方:假设问题是:

舞会之夜租什么更好，一辆车还是一间酒店房间?

技术上的答案是这样的:

嗯，在车里你可以做得更快，但在酒店房间里你可以做得更舒服。另一方面，酒店房间只在一个地方，而在汽车里你可以在更多的地方这样做，比如，你可以去远景点看风景，或者在汽车电影院，或者很多其他地方，甚至不止一个地方。而且，酒店房间里有淋浴。

这都是真的，但完全忽略了一点，那就是它们是两种完全不同的东西，两者都可以同时用于不同的目的，“做”方面并不是这两种选择中最重要的事情。这个答案缺乏视角，它显示了一种不成熟的思维方式，而正确地呈现了真实的“事实”。

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

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

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