Hva er de fire pilarene i OOP?

Question

Accepted Answer

Objektorientert programmering hviler på fire kjerneprinsipper — **Innkapsling, Arv, Polymorfisme og Abstraksjon**. Java er bygget rundt disse, og å forstå dem er grunnleggende for å designe Java-programmer.

## 1. Innkapsling — saml 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; }
}
```

Innkapsling skjuler intern tilstand (`private`) og eksponerer kontrollert tilgang (public metoder/getters/setters). Dette beskytter invarianter — du kan ikke sette en negativ balance direkte — og lar deg endre internals uten å ødelegge kallere.

## 2. Arv — gjenbruk via et "er-en" 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"); }
}
```

Arv lar en subklasse gjenbruke og utvide en superklasses oppførsel, og modellerer "er-en" forhold og unngår kodeduplisering.

## 3. Polymorfisme — ett grensesnitt, 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
```

Polymorfisme lar deg behandle ulike subklasser jevnt gjennom en felles type, med den **faktiske** objektets overstyrt metode kalt ved kjøretid — noe som muliggjør fleksibel, utvidbar kode.

## 4. Abstraksjon — eksponér hva, 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();
```

Abstraksjon (via grensesnitt/abstrakte klasser) eksponerer en forenklet kontrakt mens kompleks implementering skjules — slik at du kan bytte implementeringer og redusere koblingen.

## Hvorfor det betyr noe

De fire pilarene er grunnlaget for objektorientert design og for Java selv.

Innkapsling beskytter dataintegritet og gjør sikker endring mulig; arv fremmer gjenbruk; polymorfisme gir fleksibilitet og utvidbarhet (behandle mange typer jevnt, oppførsel løst ved kjøretid); abstraksjon reduserer koblingen og kompleksitet.

Å forstå dem er ikke bare terminologi — de veileder hvordan du strukturerer klasser, designer APIer, og bygger vedlikeholdbare, utvidbare systemer.

De er også blant de vanligste intervjuemner fordi de avslører om en utvikler tenker i ordentlige OOP-termer, noe som er essensielt for å arbeide effektivt i Javas klassesentriske økosystem.