Quelle est la différence entre une interface et une classe abstraite ?

Question

Accepted Answer

Les deux définissent des types abstraits qui ne peuvent pas être instanciés directement et sont destinés à être implémentés/étendus — mais ils servent des objectifs de conception différents. Les distinctions clés sont l'**héritage multiple**, l'**état**, et la relation qu'ils modélisent.

## Interface — un contrat (« peut-faire » / capacité)

```java
public interface Drawable {
    void draw();                          // abstract method (implicitly public abstract)

default void render() {                // default method — has a body (Java 8+)
        System.out.println("rendering");
    }
    int MAX = 100;                         // implicitly public static final (constant only)
}

class Circle implements Drawable {
    public void draw() { /* must implement */ }
}
```

Une interface définit un **contrat** de comportement. Une classe peut implémenter **plusieurs** interfaces — c'est ainsi que Java réalise une forme d'héritage multiple. Les interfaces (traditionnellement) n'ont pas d'état d'instance.

## Classe abstraite — une base partielle (« est-un » avec code partagé)

```java
public abstract class Animal {
    protected String name;                 // ✅ can have instance FIELDS (state)

public Animal(String name) {           // ✅ can have a constructor
        this.name = name;
    }
    public abstract void makeSound();      // abstract — subclasses must implement
    public void sleep() {                   // ✅ concrete method with shared logic
        System.out.println(name + " sleeps");
    }
}

class Dog extends Animal {                 // can extend only ONE class
    public Dog(String n) { super(n); }
    public void makeSound() { System.out.println("Woof"); }
}
```

Une classe abstraite peut contenir un **état (champs)**, des **constructeurs**, et des méthodes concrètes avec implémentation partagée — mais une classe ne peut étendre qu'**une seule** classe abstraite (héritage simple).

## Différences clés

```text
                    Interface              Abstract class
Multiple inheritance ✓ (implement many)    ✗ (extend only one)
Instance fields/state ✗ (constants only)   ✓ (fields)
Constructor           ✗                    ✓
Method bodies         default/static only  ✓ (concrete methods)
Models                capability ("can-do") "is-a" with shared base
```

## Quand utiliser l'une ou l'autre

```text
Interface → define a capability multiple unrelated classes can have
            (Comparable, Runnable, Serializable); when you need multiple inheritance
Abstract class → share common state + code among closely related subclasses
            (a base class with fields and partial implementation)
```

## Pourquoi c'est important

Choisir entre une interface et une classe abstraite est une décision de conception Java fondamentale.

Les interfaces définissent des **contrats/capacités** et permettent à une classe d'en implémenter plusieurs (la réponse de Java à l'héritage multiple) — idéal pour les capacités transversales.

Les classes abstraites fournissent une **base partagée avec état et implémentation partielle** pour des sous-classes étroitement liées, mais vous limitent à l'héritage simple.

Comprendre les compromis (implémentation multiple par rapport à état/constructeurs partagés, capacité par rapport à relation « est-un ») guide une bonne conception d'API et de hiérarchie de classes.

Avec Java 8+ et les méthodes par défaut qui brouillent les frontières, savoir quand chacune convient — et les contraintes fondamentales (une classe abstraite mais plusieurs interfaces, état uniquement dans les classes abstraites) — est essentiel pour concevoir un code flexible et bien structuré.