我所观察到的主要区别是抽象类为我们提供了一些已经实现的常见行为，而子类只需要实现与它们对应的特定功能。而接口只指定需要完成哪些任务，接口不会给出任何实现。我可以说它指定了它自己和实现的类之间的契约。

接口与抽象类的基本区别在于，接口支持多重继承，而抽象类不支持。

在抽象类中，你也可以提供所有的抽象方法，比如接口。

为什么需要抽象类?

在某些情况下，当处理用户请求时，抽象类并不知道用户的意图。在该场景中，我们将在类中定义一个抽象方法，并询问用户谁扩展了这个类，请在抽象方法中提供您的意图。在这种情况下，抽象类非常有用

为什么需要接口?

比如说，我有一份工作，但我在这方面没有经验。的例子, 如果你想建造一座建筑或大坝，那么在这种情况下你会怎么做?

你将确定你的需求是什么，并根据这些需求制定一份合同。 然后打电话给投标者来构建你的项目 无论谁建造这个项目，都应该满足你的要求。但是不同厂商的构造逻辑是不同的。

这里我不关心它们是如何构造的。最终的目标是否满足我的要求，这只是我的关键点。

在这里，你的需求称为接口，构造函数称为实现者。

接口由单例变量(公共静态final)和公共抽象方法组成。当我们知道要做什么但不知道如何做时，我们通常更喜欢实时使用接口。

这个概念可以通过以下例子更好地理解:

考虑一个支付类。支付方式有很多种，比如PayPal，信用卡等。因此，我们通常将Payment作为接口，其中包含makePayment()方法，CreditCard和PayPal是两个实现类。

public interface Payment
{
    void makePayment();//by default it is a abstract method
}
public class PayPal implements Payment
{
    public void makePayment()
    {
        //some logic for PayPal payment
        //e.g. Paypal uses username and password for payment
    }
}
public class CreditCard implements Payment
{
    public void makePayment()
    {
        //some logic for CreditCard payment
        //e.g. CreditCard uses card number, date of expiry etc...
    }
}

在上面的例子中，CreditCard和PayPal是两个实现类/策略。接口还允许我们在Java中实现多重继承的概念，这是抽象类无法实现的。

当我们知道某些特性该做什么，而其他特性又知道如何执行时，我们就会选择一个抽象类。

考虑下面的例子:

public abstract class Burger
{
    public void packing()
    {
        //some logic for packing a burger
    }
    public abstract void price(); //price is different for different categories of burgers
}
public class VegBerger extends Burger
{
    public void price()
    {
        //set price for a veg burger.
    }
}
public class NonVegBerger extends Burger
{
    public void price()
    {
        //set price for a non-veg burger.
    }
}

如果我们将来在给定的抽象类中添加方法(具体的/抽象的)，那么实现类将不需要更改其代码。但是，如果将来在接口中添加方法，则必须将实现添加到实现该接口的所有类中，否则会发生编译时错误。

还有其他不同之处，但这些都是面试官所期望的。希望这对你们有帮助。

在抽象类中，可以编写方法的默认实现!但是在Interface中你不能。基本上，在接口中存在纯虚方法，这些方法必须由实现接口的类来实现。

接口就像一组公开记录的具有某种影响的基因:DNA测试会告诉我是否有它们——如果我有，我可以公开让人们知道我是“携带者”，我的部分行为或状态将符合它们。(当然，我可能还有很多其他基因，这些基因提供的特征超出了这个范围。)

抽象类就像单性别物种的死去的祖先(*):她不能被复活，但一个活着的(即非抽象的)后代继承了她所有的基因。

为了扩展这个比喻，我们假设这个物种的所有成员都活到相同的年龄。这意味着一个死去的祖先的所有祖先也必须是死的——同样，一个活着的祖先的所有后代也必须是活着的。

我先给大家举个例子:

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

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