Vilka är de fyra pelarna inom OOP?

Question

Accepted Answer

Objektorienterad programmering vilar på fyra kärnprinciper — **Encapsulation, Inheritance, Polymorphism och Abstraction**. Java är byggt omkring dessa, och att förstå dem är grundläggande för att designa Java-program.

## 1. Encapsulation — bunta ihop data + dölj 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 döljer internt tillstånd (`private`) och exponerar kontrollerad åtkomst (publika metoder/getters/setters). Detta skyddar invarianter — du kan inte sätta ett negativt saldo direkt — och låter dig ändra internals utan att bryta för anropare.

## 2. Inheritance — återanvändning via ett "är-en"-förhållande

```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 låter en subklass återanvända och utöka en superklass beteende, modellera "är-en"-förhållanden och undvika kodduplicering.

## 3. Polymorphism — ett interface, många 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 låter dig behandla olika subklasser enhetligt genom en gemensam typ, med den **faktiska** objektets överskriven metod som anropas vid runtime — möjliggörande flexibel, utbyggbar kod.

## 4. Abstraction — exponera vad, dölj hur

```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/abstrakta klasser) exponerar ett förenklat kontrakt samtidigt som man döljer komplex implementering — låter dig byta implementeringar och reducera koppling.

## Varför det spelar roll

De fyra pelarna är grunden för objektorienterad design och Java själv.

Encapsulation skyddar dataintegritet och möjliggör säker ändring; inheritance främjar återanvändning; polymorphism ger flexibilitet och utbyggbarhet (behandla många typer enhetligt, beteende löst vid runtime); abstraction reducerar koppling och komplexitet.

Att förstå dem är inte bara terminologi — de vägleder hur du strukturerar klasser, designar API:er och bygger underhållbara, utbyggbara system.

De är också bland de vanligaste intervjuämnen eftersom de avslöjar om en utvecklare tänker i korrekt OOP-termer, vilket är väsentligt för att arbeta effektivt i Javas klasscentrerade ekosystem.