Was sind die vier Säulen der OOP?

Question

Accepted Answer

Object-oriented programming basiert auf vier Kernprinzipien — **Encapsulation, Inheritance, Polymorphism und Abstraction**. Java ist um diese herum gebaut, und sie zu verstehen ist grundlegend für die Gestaltung von Java-Programmen.

## 1. Encapsulation — Daten bündeln + Interna verbergen

```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 verbirgt den internen Zustand (`private`) und stellt kontrollierten Zugriff (öffentliche Methoden/Getter/Setter) bereit. Dies schützt Invarianten — Sie können beispielsweise kein negatives Guthaben direkt setzen — und ermöglicht es Ihnen, die Interna zu ändern, ohne Aufrufer zu unterbrechen.

## 2. Inheritance — Wiederverwendung via eine "is-a"-Beziehung

```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 ermöglicht es einer Subklasse, das Verhalten einer Superklasse wiederzuverwenden und zu erweitern, modelliert "is-a"-Beziehungen und vermeidet Code-Duplikation.

## 3. Polymorphism — eine Schnittstelle, viele Formen

```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 ermöglicht es Ihnen, unterschiedliche Subklassen einheitlich über einen gemeinsamen Typ zu behandeln, wobei die **tatsächliche** überschriebene Methode des Objekts zur Laufzeit aufgerufen wird — wodurch flexibler, erweiterbarer Code ermöglicht wird.

## 4. Abstraction — zeige was, verberge wie

```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 (über Interfaces/abstrakte Klassen) stellt einen vereinfachten Vertrag zur Verfügung, während komplexe Implementierung verborgen ist — dies ermöglicht es Ihnen, Implementierungen auszutauschen und die Kopplung zu reduzieren.

## Warum es wichtig ist

Die vier Säulen sind das Fundament der objektorientierten Gestaltung und von Java selbst.

Encapsulation schützt die Datenintegrität und ermöglicht sichere Änderungen; Inheritance fördert Wiederverwendung; Polymorphism bietet Flexibilität und Erweiterbarkeit (viele Typen einheitlich behandeln, Verhalten zur Laufzeit aufgelöst); Abstraction reduziert Kopplung und Komplexität.

Sie zu verstehen ist nicht nur Terminologie — sie lenken, wie Sie Klassen strukturieren, APIs gestalten und wartbare, erweiterbare Systeme entwickeln.

Sie gehören auch zu den häufigsten Interview-Themen, da sie enthüllen, ob ein Entwickler in den richtigen OOP-Begriffen denkt, was für die effektive Arbeit in Javas klassenzentrischen Ökosystem unerlässlich ist.