Hvad er de fire søjler i objektorienteret programmering?

Question

Accepted Answer

Objektorienteret programmering hviler på fire grundlæggende principper — **Encapsulation, Inheritance, Polymorphism og Abstraction**. Java er bygget omkring disse, og at forstå dem er fundamental for at designe Java-programmer.

## 1. Encapsulation — bundel data + skjul internals

```java
public class Account {
    private double balance;          // hidden — can't be accessed directly outside

public void deposit(double amount) {   // controlled access via methods
        if (amount > 0) balance += amount;  // can enforce rules
    }
    public double getBalance() { return balance; }
}
```

Encapsulation skjuler intern tilstand (`private`) og eksponerer kontrolleret adgang (offentlige metoder/getters/setters). Dette beskytter invarianter — du kan ikke sætte en negativ balance direkte — og lader dig ændre internals uden at bryde eksisterende kode.

## 2. Inheritance — genbrug via et "is-a" forhold

```java
class Animal {
    void eat() { System.out.println("eating"); }
}
class Dog extends Animal {   // Dog IS-A Animal — inherits eat()
    void bark() { System.out.println("woof"); }
}
```

Inheritance lader en subklasse genbruge og udvide en superklasses adfærd, modellerer "is-a" forhold og undgår kodeduplikering.

## 3. Polymorphism — et interface, mange former

```java
Animal a = new Dog();     // a Dog treated as an Animal
a.makeSound();            // calls Dog's overridden version at RUNTIME (dynamic dispatch)

// the same method behaves differently depending on the actual object:
List<Animal> animals = List.of(new Dog(), new Cat());
for (Animal animal : animals) animal.makeSound(); // each makes its own sound
```

Polymorphism lader dig behandle forskellige subklasser ensartet gennem en fælles type, med den **aktuelle** objekts overridden metode kaldt ved runtime — muliggørende fleksibel, udvidbar kode.

## 4. Abstraction — eksponér hvad, skjul hvordan

```java
interface PaymentProcessor {
    void pay(double amount);   // WHAT it does, not HOW
}
class StripeProcessor implements PaymentProcessor {
    public void pay(double amount) { /* complex implementation hidden */ }
}
// callers depend on the abstraction, not the concrete implementation
PaymentProcessor processor = new StripeProcessor();
```

Abstraction (via interfaces/abstrakte klasser) eksponerer en forenklet kontrakt mens kompleks implementering skjules — lader dig bytte implementeringer og reducere coupling.

## Hvorfor det betyder noget

De fire søjler er grundlaget for objektorienteret design og for Java selv.

Encapsulation beskytter dataintegritet og muliggør sikker ændring; inheritance promoverer genbrug; polymorphism giver fleksibilitet og udvidelsesmulighed (behandl mange typer ensartet, adfærd løst ved runtime); abstraction reducerer coupling og kompleksitet.

At forstå dem er ikke blot terminologi — de styrer hvordan du strukturerer klasser, designer API'er og bygger vedligeholdelse, udvidelsesbare systemer.

De er også blandt de mest almindelige interviewemner fordi de afslører om en udvikler tænker i ordentlige OOP-termer, hvilket er væsentligt for at arbejde effektivt i Javas klassecentriske økosystem.