一些重要的区别：

以表格的形式：

正如Joe在javapapers中所说：

1.主要区别在于Java接口的方法是隐式抽象的，不能有实现。Java抽象类可以具有实现默认行为的实例方法。2.Java接口中声明的变量默认为final。抽象类可以包含非最终变量。3.默认情况下，Java接口的成员是公共的。Java抽象类可以具有类成员的通常风格，受保护等。。4.Java接口应使用关键字“implements”实现；Java抽象类应该使用关键字“extends”进行扩展。5.接口只能扩展另一个Java接口，抽象类可以扩展另一Java类并实现多个Java接口。6.Java类可以实现多个接口，但只能扩展一个抽象类。7.接口是绝对抽象的，不能实例化；Java抽象类也不能实例化，但如果main（）存在。8.与java抽象类相比，java接口速度较慢，因为它需要额外的间接寻址。

抽象类与接口的主题主要是语义。

抽象类在不同的编程语言中通常充当接口的超集，除了一点，即可以实现多个接口，但只能继承一个类。

接口定义了某件事情必须能够做的事情；类似于合同，但不提供其实现。

抽象类定义了什么是什么，它通常托管子类之间的共享代码。

例如，格式化程序应该能够格式化（）某些内容。描述这种情况的常见语义是创建一个接口IFormatter，该接口带有一个format（）声明，其作用类似于一个契约。但是IFormatter并不描述什么是什么，而是描述它应该能够做什么。在本例中，我们创建一个抽象类。。。因此，我们创建了一个实现接口的抽象类Formatter。这是一个非常描述性的代码，因为我们现在知道我们有一个格式化程序，我们现在知道每个格式化程序必须能够做什么。

还有一个非常重要的主题是文档（至少对某些人来说…）。在您的文档中，您可能希望在子类中解释Formatter实际上是什么。有一个抽象类Formatter非常方便，您可以链接到子类中的文档。这是非常方便和通用的。另一方面，如果您没有抽象类Formatter，而只有接口IFormatter，则必须在每个子类中解释Formatter实际上是什么，因为接口是一个契约，你不会在接口的文档中描述Formatter实际上是什么-至少这不是常见的事情，你会打破大多数开发人员认为正确的语义。

注意：使抽象类实现接口是一种非常常见的模式。

当您想在继承层次结构中提供多态行为时，请使用抽象类。

当您想要完全无关的类的多态行为时，请使用接口。

如果您有一些可供多个类使用的通用方法，请使用抽象类。否则，如果你想让类遵循某种明确的蓝图，就去寻找接口。

以下示例演示了这一点。

Java中的抽象类：

abstract class Animals
{
    // They all love to eat. So let's implement them for everybody
    void eat()
    {
        System.out.println("Eating...");
    }
    // The make different sounds. They will provide their own implementation.
    abstract void sound();
}
 
class Dog extends Animals
{
    void sound()
    {
        System.out.println("Woof Woof");
    }
}
 
class Cat extends Animals
{
    void sound()
    {
        System.out.println("Meoww");
    }
}

以下是Java中接口的实现：

interface Shape
{
    void display();
    double area();
}
 
class Rectangle implements Shape 
{
    int length, width;
    Rectangle(int length, int width)
    {
        this.length = length;
        this.width = width;
    }
    @Override
    public void display() 
    {
        System.out.println("****\n* *\n* *\n****"); 
    }
    @Override
    public double area() 
    {
        return (double)(length*width);
    }
} 
 
class Circle implements Shape 
{
    double pi = 3.14;
    int radius;
    Circle(int radius)
    {
        this.radius = radius;
    }
    @Override
    public void display() 
    {
        System.out.println("O"); // :P
    }
    @Override
    public double area() 
    { 
        return (double)((pi*radius*radius)/2);
    }
}

简而言之，一些重要的要点：

默认情况下，Java接口中声明的变量是final。抽象类可以有非final变量。默认情况下，Java接口中声明的变量是静态的。抽象类可以具有非静态变量。默认情况下，Java接口的成员是公共的。Java抽象类可以具有类成员的通常风格，如private、protected等。。

抽象类和接口的一般思想是由使用这些通用“设置”（某种模板）的其他类（不能单独构建）来扩展/实现，这使得为以后扩展它的所有对象设置特定的通用行为变得简单。

抽象类具有常规方法集和抽象方法。扩展类在被抽象类扩展后可以包括未设置的方法。当设置抽象方法时，它们由稍后扩展抽象方法的类定义。

接口与抽象类具有相同的财产，但只包含抽象方法，这些方法可以在其他类中实现（可以是多个要实现的接口），这就创建了一个更持久的方法/静态变量定义。与抽象类不同，您不能添加自定义的“常规”方法。

接口与抽象类的比较是错误的。应该有另外两个比较：1）接口与类，2）抽象与最终类。

接口与类

接口是两个对象之间的契约。例如，我是一名邮递员，而你是一个要递送的包裹。我希望你知道你的送货地址。当有人给我一个包裹时，它必须知道它的送货地址：

interface Package {
  String address();
}

类是一组遵守契约的对象。例如，我是“箱子”小组的一名箱子，我遵守邮递员要求的合同。同时，我遵守其他合同：

class Box implements Package, Property {
  @Override
  String address() {
    return "5th Street, New York, NY";
  }
  @Override
  Human owner() {
    // this method is part of another contract
  }
}

摘要与最终

抽象类是一组不完整的对象。它们不能使用，因为它们缺少一些部件。例如，我是一个抽象的GPS感知框-我知道如何检查我在地图上的位置：

abstract class GpsBox implements Package {
  @Override
  public abstract String address();
  protected Coordinates whereAmI() {
    // connect to GPS and return my current position
  }
}

这个类如果被另一个类继承/扩展，可能非常有用。但就其本身而言，它是无用的，因为它不能有对象。抽象类可以是最终类的构建元素。

Final类是一组完整的对象，可以使用，但不能修改。他们确切地知道如何工作和做什么。例如，我是一个盒子，它总是在构建过程中到达指定的地址：

final class DirectBox implements Package {
  private final String to;
  public DirectBox(String addr) {
    this.to = addr;
  }
  @Override
  public String address() {
    return this.to;
  }
}

在大多数语言中，如Java或C++，可能只有一个类，既不是抽象类也不是最终类。这样的类可以继承并实例化。不过，我认为这并不严格符合面向对象的范例。

同样，将接口与抽象类进行比较是不正确的。