Quand doit-on utiliser une interface et quand une classe abstraite?

Nous utilisons une classe abstraite pour créer des fonctionnalités de base et un état général que les sous-classes peuvent hériter. Elle convient lorsque vous avez des méthodes communes avec une implémentation et des méthodes qui doivent être redéfinies. La classe abstraite peut avoir des champs et des constructeurs.

// Classe abstraite
abstract class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
    }

    abstract void makeSound(); // Méthode abstraite

    void eat() { // Méthode avec implémentation
        System.out.println(name + " mange.");
    }
}

Nous utilisons une interface pour définir un contrat décrivant un ensemble de méthodes que les classes doivent implémenter. Elle est adaptée pour atteindre un comportement multiple (héritage multiple de fonctionnalités). L'interface ne peut pas avoir d'état (champs d'instance, sauf constantes) ni de constructeurs (avant Java 8).

// Interface
interface Flyable {
    void fly(); // Méthode abstraite
}

Tableau comparatif des différences:

Caractéristique	Classe abstraite	Interface
Type de membres	Champs, méthodes abstraites et concrètes, constructeurs	Constantes, méthodes abstraites (par défaut), méthodes statiques et default (depuis Java 8)
Implémentation des méthodes	Peut avoir des méthodes avec implémentation	Seulement des méthodes abstraites jusqu'à Java 8, avec Java 8 - static et default
État	Peut avoir un état (champs)	Ne peut pas avoir d'état (champs d'instance)
Héritage	Héritage simple	Mise en œuvre multiple
Utilisation	"est un" (is-a) - type de base	"a" (has-a) - contrat de comportement