Apakah empat tiang OOP?

Question

Accepted Answer

Pemrograman berorientasi objek berpijak pada empat prinsip inti — **Enkapsulasi, Warisan, Polimorfisme, dan Abstraksi**. Java dibangun di sekitar ini, dan memahaminya adalah asas untuk merancang program Java.

## 1. Enkapsulasi — bundel data + sembunyikan pedalaman

```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; }
}
```

Enkapsulasi menyembunyikan keadaan internal (`private`) dan menampilkan akses terkontrol (metode publik/getter/setter). Ini melindungi invarian — anda tidak boleh menetapkan baki negatif secara langsung — dan memungkinkan anda mengubah pedalaman tanpa memecahkan panggilan.

## 2. Warisan — gunakan semula 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"); }
}
```

Warisan membenarkan subkelas menggunakan semula dan memperluas tingkah laku superkelas, memodelkan hubungan "is-a" dan mengelak pendua kod.

## 3. Polimorfisme — satu antara muka, 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
```

Polimorfisme membenarkan anda menganggap subkelas yang berbeza secara seragam melalui jenis biasa, dengan kaedah **sebenar** objek dipanggil pada masa larian — membolehkan kod yang fleksibel dan boleh diperluaskan.

## 4. Abstraksi — paparkan 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();
```

Abstraksi (melalui antara muka/kelas abstrak) memaparkan kontrak yang dipermudahkan sambil menyembunyikan pelaksanaan yang kompleks — membenarkan anda menukar pelaksanaan dan mengurangkan gandingan.

## Mengapa ia penting

Empat tiang adalah asas reka bentuk berorientasi objek dan Java itu sendiri.

Enkapsulasi melindungi integriti data dan membolehkan perubahan yang selamat; warisan mempromosikan penggunaan semula; polimorfisme memberikan fleksibiliti dan kebolehan diperluaskan (menganggap banyak jenis secara seragam, tingkah laku diselesaikan pada masa larian); abstraksi mengurangkan gandingan dan kerumitan.

Memahaminya bukan hanya istilah — mereka membimbing cara anda menstruktur kelas, merancang API, dan membina sistem yang boleh diselenggara dan boleh diperluaskan.

Mereka juga antara topik temu duga yang paling biasa kerana ia menunjukkan sama ada pembangun berfikir dalam istilah OOP yang tepat, yang penting untuk bekerja dengan berkesan dalam ekosistem berpusat kelas Java.