Hva er forskjellen mellom et grensesnitt og en abstrakt klasse?

Question

Accepted Answer

Begge definerer abstrakte typer som ikke kan instansieres direkte og er ment å implementeres/utvides — men de tjener forskjellige designformål. Nøkkeldistinksjoner er **multippel arv**, **tilstand** og relasjonen de modellerer.

## Grensesnitt — en kontrakt ("kan-gjøre" / evne)

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

Et grensesnitt definerer en **kontrakt** for atferd. En klasse kan implementere **flere** grensesnitt — dette er hvordan Java oppnår en form for multippel arv. Grensesnitt har (tradisjonelt) ingen forekomststilstand.

## Abstrakt klasse — en delvis base ("er-en" med delt kode)

```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 klasse kan holde **tilstand (felt)**, **konstruktører** og konkrete metoder med delt implementering — men en klasse kan bare utvide **én** abstrakt klasse (enkelt arv).

## Nøkkelforskjeller

```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 du skal bruke hvilken

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

## Hvorfor det er viktig

Å velge mellom et grensesnitt og en abstrakt klasse er en fundamental Java-designbeslutning.

Grensesnitt definerer **kontrakter/evner** og gjør det mulig for en klasse å implementere mange av dem (Javas svar på multippel arv) — ideelt for evner på tvers av hele systemet.

Abstrakte klasser gir en **delt base med tilstand og delvis implementering** for nært beslektede underklasser, men begrenser deg til enkelt arv.

Å forstå avveininger (multippel implementering mot delt tilstand/konstruktører, evne mot er-en relasjon) veileder god API- og klassearkitekturdesign.

Med Java 8+ standardmetoder som slører grensen, å vite når hver passer — og kjernebegrensninger (én abstrakt klasse men mange grensesnitt, tilstand bare i abstrakte klasser) — er viktig for å designe fleksibel, velstrukturert kode.