Apakah empat pilar OOP?

Question

Accepted Answer

Pemrograman berorientasi objek berpijak pada empat prinsip inti — **Encapsulation, Inheritance, Polymorphism, dan Abstraction**. Java dibangun di sekitar ini, dan memahaminya adalah fundamental untuk merancang program Java.

## 1. Encapsulation — bundel data + sembunyikan internal

```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 menyembunyikan status internal (`private`) dan mengekspos akses terkontrol (metode publik/getters/setters). Ini melindungi invariant — Anda tidak dapat langsung mengatur saldo negatif — dan memungkinkan Anda mengubah internal tanpa merusak penelepon.

## 2. Inheritance — penggunaan kembali melalui hubungan "is-a"

```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 memungkinkan subclass untuk menggunakan kembali dan memperluas perilaku superclass, memodelkan hubungan "is-a" dan menghindari duplikasi kode.

## 3. Polymorphism — satu antarmuka, banyak bentuk

```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 memungkinkan Anda memperlakukan berbagai subclass secara seragam melalui tipe umum, dengan metode override objek **aktual** dipanggil pada waktu runtime — memungkinkan kode yang fleksibel dan dapat diperluas.

## 4. Abstraction — ekspos apa, sembunyikan bagaimana

```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 (melalui antarmuka/kelas abstrak) mengekspos kontrak yang disederhanakan sambil menyembunyikan implementasi kompleks — memungkinkan Anda menukar implementasi dan mengurangi coupling.

## Mengapa ini penting

Empat pilar adalah fondasi desain berorientasi objek dan Java itu sendiri.

Encapsulation melindungi integritas data dan memungkinkan perubahan yang aman; Inheritance mempromosikan penggunaan kembali; Polymorphism memberikan fleksibilitas dan ekstensibilitas (perlakukan banyak tipe secara seragam, perilaku diselesaikan pada waktu runtime); Abstraction mengurangi coupling dan kompleksitas.

Memahamianya bukan hanya terminologi — mereka memandu cara Anda menstruktur kelas, merancang API, dan membangun sistem yang dapat dipertahankan dan dapat diperluas.

Mereka juga termasuk topik wawancara paling umum karena mengungkapkan apakah pengembang berpikir dalam istilah OOP yang tepat, yang penting untuk bekerja secara efektif di ekosistem Java yang berpusat pada kelas.