Was ist der Unterschied zwischen einem Interface und einer abstrakten Klasse?

Question

Accepted Answer

Beide definieren abstrakte Typen, die nicht direkt instanziiert werden können und zur Implementierung/Erweiterung vorgesehen sind — dienen aber unterschiedlichen Designzielen. Die Schlüsselunterschiede sind **Mehrfachvererbung**, **Zustand** und die Beziehung, die sie modellieren.

## Interface — ein Vertrag ("kann tun" / Fähigkeit)

```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 */ }
}
```

Ein Interface definiert einen **Vertrag** für Verhalten. Eine Klasse kann **mehrere** Interfaces implementieren — so erreicht Java eine Form der Mehrfachvererbung. Interfaces haben (traditionell) keinen Instanzzustand.

## Abstrakte Klasse — eine Teillösung ("ist ein" mit gemeinsamen Code)

```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"); }
}
```

Eine abstrakte Klasse kann **Zustand (Felder)**, **Konstruktoren** und konkrete Methoden mit gemeinsamer Implementierung enthalten — aber eine Klasse kann nur **eine** abstrakte Klasse erweitern (Einfachvererbung).

## Schlüsselunterschiede

```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
```

## Wann man welches verwendet

```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)
```

## Warum es wichtig ist

Die Wahl zwischen einem Interface und einer abstrakten Klasse ist eine grundlegende Java-Designentscheidung.

Interfaces definieren **Verträge/Fähigkeiten** und ermöglichen einer Klasse, viele von ihnen zu implementieren (Javas Antwort auf Mehrfachvererbung) — ideal für übergreifende Fähigkeiten.

Abstrakte Klassen bieten eine **gemeinsame Basis mit Zustand und Teilimplementierung** für eng verwandte Unterklassen, beschränken Sie aber auf Einfachvererbung.

Das Verständnis der Kompromisse (Mehrfachimplementierung vs. gemeinsamer Zustand/Konstruktoren, Fähigkeit vs. "ist ein" Beziehung) leitet gutes API- und Klassenierarchie-Design.

Mit Java 8+ Default Methods, die die Grenze verschwimmen lassen, wissen zu müssen, wann jedes passt — und die Kerneinschränkungen (eine abstrakte Klasse aber viele Interfaces, Zustand nur in abstrakten Klassen) — ist wesentlich für die Gestaltung von flexiblem, gut strukturiertem Code.