Jaký je rozdíl mezi rozhraním (interface) a abstraktní třídou?

Question

Accepted Answer

Obě definují abstraktní typy, které nelze přímo instancovat a jsou určeny k implementaci/rozšíření — ale slouží různým účelům návrhu. Klíčové rozdíly jsou **vícenásobná dědičnost**, **stav** a vztah, který reprezentují.

## Rozhraní — smlouva ("může dělat" / schopnost)

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

Rozhraní definuje **smlouvu** chování. Třída může implementovat **vícenásobná** rozhraní — takto Java dosahuje formu vícenásobné dědičnosti. Rozhraní (tradičně) nemají stav instance.

## Abstraktní třída — částečná báze ("je-a" se sdíleným kódem)

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

Abstraktní třída může obsahovat **stav (pole)**, **konstruktory** a konkrétní metody se sdílenou implementací — ale třída může rozšiřovat pouze **jednu** abstraktní třídu (jednotná dědičnost).

## Klíčové rozdíly

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

## Kdy použít který

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

## Proč to je důležité

Volba mezi rozhraním a abstraktní třídou je základní rozhodnutí návrhu v Javě.

Rozhraní definují **smlouvy/schopnosti** a umožňují třídě implementovat mnoho z nich (Javaova odpověď na vícenásobnou dědičnost) — ideální pro křížící se schopnosti.

Abstraktní třídy poskytují **sdílenou bázi se stavem a částečnou implementací** pro úzce související podtřídy, ale omezují vás na jednotnou dědičnost.

Porozumění kompromisům (vícenásobná implementace vs. sdílený stav/konstruktory, schopnost vs. vztah "je-a") vede dobrý API a návrh hierarchie tříd.

S Java 8+ výchozími metodami rozmazávajícími hranici, vědění kdy se každý hodí — a základní omezení (jedna abstraktní třída ale mnoho rozhraní, stav pouze v abstraktních třídách) — je nezbytné pro navrhování flexibilního, dobře strukturovaného kódu.