在实用性方面（JAVA），抽象类和接口之间的主要区别是抽象类可以保存状态。除了保持状态，我们还可以使用Interface实现其余操作。

实际上并不是最初问题的答案，但一旦你找到了它们之间的区别的答案，你就会进入何时使用每一个困境：何时使用接口或抽象类？何时同时使用两者？

我对OOP的了解有限，但将接口视为语法中形容词的等价物对我来说一直有效（如果这个方法是假的，请纠正我！）。例如，接口名称类似于可以赋予类的属性或功能，并且类可以具有许多属性或功能：ISerializable、ICountable、IList、ICacheable、IHappy。。。

我正在建造一座300层的大楼

建筑的蓝图界面

例如，Servlet（I）

建筑高达200层-部分完工-摘要

部分实现，例如泛型和HTTPservlet

建筑施工完成混凝土

完整实现，例如，自己的servlet

界面

我们对实现一无所知，只知道需求。我们可以去找一个接口。默认情况下，每个方法都是公共的和抽象的这是一个100%纯抽象类如果我们宣布公开，我们就不能宣布隐私和受保护如果我们声明抽象，我们就不能声明final、static、synchronized、strictfp和native每个接口都有公共的、静态的和最终的序列化和瞬态不适用，因为我们无法在接口中创建实例非挥发性，因为它是最终的每个变量都是静态的当我们在接口内声明变量时，我们需要在声明不允许实例和静态块

摘要

部分实施它有一个抽象的方法。此外，它使用混凝土对抽象类方法修饰符没有限制抽象类变量修饰符没有限制除了abstract，我们不能声明其他修饰符初始化变量没有限制

摘自DurgaJobs网站

代表实际实现的抽象类和接口之间的差异。

接口：它是一个关键字，用于定义对象的模板或蓝图，它强制所有子类遵循相同的原型，作为实现，所有子类都可以根据其要求自由实现功能。

我们应该使用接口的一些其他用例。

两个外部对象（应用程序中的第三方集成）之间的通信通过此处的接口完成。

抽象类：抽象，它是一个关键字，当我们在任何类之前使用这个关键字时，它就成为抽象类。它主要用于我们需要定义模板以及所有子类后面的对象的一些默认功能时，这样它就删除了多余的代码和一个可以使用抽象类的用例，例如，我们不希望其他类可以直接实例化该类的对象，只有派生类可以使用该功能。

抽象类示例：

 public abstract class DesireCar
  {

 //It is an abstract method that defines the prototype.
     public abstract void Color();

  // It is a default implementation of a Wheel method as all the desire cars have the same no. of wheels.   
 // and hence no need to define this in all the sub classes in this way it saves the code duplicasy     

  public void Wheel() {          

               Console.WriteLine("Car has four wheel");
                }
           }


    **Here is the sub classes:**

     public class DesireCar1 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red color Desire car");
            }
        }

        public class DesireCar2 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red white Desire car");
            }
        }

接口示例：

  public interface IShape
        {
          // Defines the prototype(template) 
            void Draw();
        }


  // All the sub classes follow the same template but implementation can be different.

    public class Circle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Circle");
        }
    }

    public class Rectangle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Rectangle");
        }
    }

其实很简单。

您可以将接口视为一个类，它只允许有抽象方法，而不允许有其他方法。

因此，接口只能“声明”而不能定义您希望类具有的行为。

抽象类允许您声明（使用抽象方法）和定义（使用完整方法实现）您希望类具有的行为。

常规类只允许您定义而不是声明您希望类具有的行为/动作。

最后一件事，

在Java中，可以实现多个接口，但只能扩展一个（抽象类或类）。。。

这意味着定义行为的继承被限制为每个类只允许一个。。。例如，如果你想要一个从类a、B和C中封装行为的类，你需要执行以下操作：类a扩展B，类C扩展a。。这是一个有点迂回的方式来拥有多重继承。。。

另一方面，您可以简单地执行接口：接口C实现A、B

因此实际上，Java只在“声明的行为”（即接口）中支持多重继承，并且只支持具有定义行为的单一继承。。除非你像我描述的那样。。。

希望这是合理的。

接口

接口是一个契约：编写接口的人说，“嘿，我接受这样的东西”，而使用接口的人则说“好的，我编写的类是这样的”。

接口是一个空壳。只有方法的签名，这意味着方法没有主体。接口无法执行任何操作。这只是一种模式。

例如（伪代码）：

// I say all motor vehicles should look like this:
interface MotorVehicle
{
    void run();

    int getFuel();
}

// My team mate complies and writes vehicle looking that way
class Car implements MotorVehicle
{

    int fuel;

    void run()
    {
        print("Wrroooooooom");
    }


    int getFuel()
    {
        return this.fuel;
    }
}

实现一个接口只消耗很少的CPU，因为它不是一个类，只是一堆名称，因此不需要进行任何昂贵的查找。在重要的时候，比如在嵌入式设备中，这是非常棒的。

抽象类

与接口不同，抽象类是类。它们的使用成本更高，因为从它们继承时需要进行查找。

抽象类看起来很像接口，但它们有更多：您可以为它们定义行为。这更像是一个人说，“这些课程应该看起来像那样，而且它们有共同点，所以填空吧！”。

例如：

// I say all motor vehicles should look like this:
abstract class MotorVehicle
{

    int fuel;

    // They ALL have fuel, so lets implement this for everybody.
    int getFuel()
    {
         return this.fuel;
    }

    // That can be very different, force them to provide their
    // own implementation.
    abstract void run();
}

// My teammate complies and writes vehicle looking that way
class Car extends MotorVehicle
{
    void run()
    {
        print("Wrroooooooom");
    }
}

实施

虽然抽象类和接口被认为是不同的概念，但实现有时会使该语句不真实。有时，他们甚至不是你想象的那样。

在Java中，这个规则是强制执行的，而在PHP中，接口是没有声明方法的抽象类。

在Python中，抽象类更多地是一种编程技巧，您可以从ABC模块中获得，并且实际上使用元类，因此使用类。接口与这种语言中的duck类型更为相关，它混合了约定和调用描述符的特殊方法（__method__方法）。

与编程一样，还有另一种语言的理论、实践和实践：-）