Différence entre une interface et une classe abstraite en Java

Quelle est la différence entre une interface et une classe abstraite? Les deux sont utilisées pour réaliser l’abstraction où nous pouvons déclarer des méthodes abstraites, et les deux ne peuvent pas être instanciées.
 
 

Qu’est-ce que une interface?

Une interface peut être utilisé pour implémenter une classe. L’interface ne contient aucune méthode qui comporte du code. Toutes les méthodes d’une interface sont des méthodes abstraites.
 
Une interface ne peut pas être instanciée. En revanche, les classes qui implémentent des interfaces peuvent être instanciées. Les interfaces ne contiennent jamais de variables d’instance, mais peuvent contenir des variables « public static final ».
 
Exemple d’une interface en Java:

interface Animal {
    public void manger();
}
class Chien implements Animal {
    public void manger() {
        System.out.println("Je mange");
    }
    public static void main(String args[]) {
        Animal animal = new Chien();
        animal.manger();
    }
}

Qu’est-ce qu’une classe abstraite?

Une classe dont le mot clé est « abstract » est appelée une classe abstraite. Les classes abstraites doivent avoir au moins une méthode abstraite, c’est-à-dire des méthodes sans corps. Il peut avoir plusieurs méthodes concrètes(méthodes qui ont du code).
 
Les classes abstraites vous permettent de créer des modèles pour des classes concrètes. Mais la classe qui hérite doit implémenter la méthode abstraite.
 
Les classes abstraites ne peuvent pas être instanciées.
 
Exemple d’une classe abstraite en Java:

abstract class Forme {
    int a = 10;
    abstract public void calculerSurface();
}

public class Rectangle extends Forme {
    public static void main(String args[]) {
        Rectangle rect = new Rectangle();
        rect.a = 20;
       rect.calculerSurface();
    }
    public void calculerSurface() {
        System.out.println("Surface est " + (rect.a * rect.a));
    }
}

Table de comparaison

interface Api extends i1, i2, i3 {  
  // méthodes
}

abstract class A {
   // méthodes
}
abstract class B extends A {
   // méthodes 
}

interface Api1{}
interface Api2 extends Api1{}
class MaClasse implements Api2{}

interface Api{
   public abstract void lire();
}

abstract class MaClasse {
  abstract void lire();
  public void afficher(){
    System.out.println("msg");
  }
}