Vad är skillnaden mellan ett interface och en abstrakt klass?

Question

Accepted Answer

Båda definierar abstrakta typer som inte kan instansieras direkt och är avsedda att implementeras/utökas — men de fyller olika designsyften. De viktigaste skillnaderna är **multipel arv**, **tillstånd** och den relation de modellerar.

## Interface — ett kontrakt ("kan-göra" / förmåga)

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

Ett interface definierar ett **kontrakt** för beteende. En klass kan implementera **flera** interface — på detta sätt uppnår Java en form av multipelt arv. Interface har (traditionellt) inget instanstillstånd.

## Abstrakt klass — en partiell bas ("är-en" med delad kod)

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

En abstrakt klass kan innehålla **tillstånd (fält)**, **konstruktörer** och konkreta metoder med delad implementering — men en klass kan endast utöka **en** abstrakt klass (enkelt arv).

## Viktiga skillnader

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

## När man ska använda vilket

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

## Varför det är viktigt

Att välja mellan ett interface och en abstrakt klass är ett fundamentalt designbeslut i Java.

Interface definierar **kontrakt/förmågor** och gör det möjligt för en klass att implementera många av dem (Javas svar på multipelt arv) — idealt för förmågor som sträcker sig över gränserna.

Abstrakta klasser tillhandahåller en **delad bas med tillstånd och partiell implementering** för närbesläktade underklasser, men begränsar dig till enkelt arv.

Att förstå avvägningarna (multipel implementering kontra delat tillstånd/konstruktörer, förmåga kontra är-en-relation) vägleder god API- och klassväghierarkidesign.

Med Java 8+ defaultmetoder som suddar gränsen, att veta när var och en passar — och kärnbegränsningarna (en abstrakt klass men många interface, tillstånd bara i abstrakta klasser) — är väsentligt för att designa flexibel, väl strukturerad kod.