Mitkä ovat OOP:n neljä pilaria?

Question

Accepted Answer

Olio-ohjelmointiin perustuu neljä ydinkäsitettä — **Kapselointi, Periytyminen, Polymorfismi ja Abstrahointi**. Java on rakennettu näiden perustalle, ja niiden ymmärtäminen on välttämätöntä Java-ohjelmien suunnittelussa.

## 1. Kapselointi — niputa data ja piilota sisäiset tiedot

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

Kapselointi piilottaa sisäisen tilan (`private`) ja tarjoaa hallitun pääsyn (julkiset metodit/getterit/setterit). Tämä suojaa invariantteja — et voi asettaa negatiivista saldoa suoraan — ja mahdollistaa sisäisten rakenteiden muuttamisen ilman kutsujien rikkoutumista.

## 2. Periytyminen — uudelleenkäyttö "on-a" -suhteen kautta

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

Periytyminen mahdollistaa alaluokan uudelleenkäyttää ja laajentaa yläluokan käyttäytymistä, mallintaen "on-a" -suhteita ja välttäen koodin toistamista.

## 3. Polymorfismi — yksi rajapinta, monta muotoa

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

Polymorfismi mahdollistaa eri alaluokkien yhtenäisen käsittelyn yhteisen tyypin kautta, kun **todellisen** objektin ylikirjoitettu metodi kutsutaan ajon aikana — mahdollistaen joustavan ja laajennettavan koodin.

## 4. Abstrahointi — paljasta mitä, piilota miten

```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();
```

Abstrahointi (rajapintojen ja abstraktien luokkien kautta) paljastaa yksinkertaistetun sopimuksen samalla kun piilottaa monimutkaisen toteutuksen — mahdollistaen toteutusten vaihtamisen ja kytkennän vähenemisen.

## Miksi se on tärkeää

Neljä pilaria muodostavat olio-ohjelmointityylisen suunnittelun ja itse Javan perustan.

Kapselointi suojaa tietojen eheyttä ja mahdollistaa turvallisen muutoksen; periytyminen edistää uudelleenkäyttöä; polymorfismi tarjoaa joustavuutta ja laajennettavuutta (käsittele monia tyyppejä yhtenäisesti, käyttäytyminen ratkaistaan ajon aikana); abstrahointi vähentää kytkentää ja monimutkaisuutta.

Niiden ymmärtäminen ei ole vain terminologiaa — ne ohjaavat sitä, kuinka jäsennät luokat, suunnittelet API:t ja rakennat ylläpidettäviä, laajennettavia järjestelmiä.

Ne ovat myös useimpia yleisiä haastattelukysymyksiä, koska ne paljastavat, ajatteleeko kehittäjä asianmukaisesti OOP-termeillä, mikä on välttämätöntä tehokkaan työskentelyn kannalta Javan luokka-keskeisessä ekosysteemissä.