OOP-இன் நான்கு தூண்கள் யாவை?

Question

Accepted Answer

Object-oriented programming நான்கு அடிப்படை கொள்கைகளை அடிப்படையாகக் கொண்டது — **Encapsulation, Inheritance, Polymorphism, மற்றும் Abstraction**. Java இவற்றைச் சுற்றியே கட்டமைக்கப்பட்டுள்ளது, மேலும் இவற்றைப் புரிந்துகொள்வது Java programs-ஐ வடிவமைப்பதற்கு அடிப்படையானது.

## 1. Encapsulation — data-ஐ ஒன்றாக இணைத்து 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 என்பது உள் நிலையை (`private`) மறைத்து, கட்டுப்படுத்தப்பட்ட அணுகலை (public methods/getters/setters) வெளிப்படுத்துகிறது. இது invariants-ஐ பாதுகாக்கிறது — நீங்கள் நேரடியாக ஒரு எதிர்மறை balance-ஐ அமைக்க முடியாது — மேலும் callers-ஐ உடைக்காமல் internals-ஐ மாற்ற உங்களை அனுமதிக்கிறது.

## 2. Inheritance — "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 ஒரு subclass-ஐ ஒரு superclass-இன் behavior-ஐ மறுபயன்படுத்தவும் விரிவாக்கவும் அனுமதிக்கிறது, "is-a" உறவுகளை மாதிரியாக்கி, code duplication-ஐ தவிர்க்கிறது.

## 3. Polymorphism — ஒரு interface, பல வடிவங்கள்

```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 ஒரு பொதுவான type மூலம் வெவ்வேறு subclasses-ஐ ஒரே மாதிரியாக நடத்த உங்களை அனுமதிக்கிறது, அதே சமயம் **உண்மையான** object-இன் overridden method runtime-இல் அழைக்கப்படுகிறது — இது நெகிழ்வான, விரிவாக்கக்கூடிய code-ஐ சாத்தியமாக்குகிறது.

## 4. Abstraction — என்ன என்பதை வெளிப்படுத்தி, எப்படி என்பதை மறைத்தல்

```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 (interfaces/abstract classes மூலம்) சிக்கலான implementation-ஐ மறைத்து, எளிமைப்படுத்தப்பட்ட contract-ஐ வெளிப்படுத்துகிறது — implementations-ஐ மாற்றவும் coupling-ஐ குறைக்கவும் உங்களை அனுமதிக்கிறது.

## இது ஏன் முக்கியம்

நான்கு தூண்களும் object-oriented design-இன் மற்றும் Java-வின் அடித்தளமாகும்.

Encapsulation data integrity-ஐ பாதுகாத்து பாதுகாப்பான மாற்றத்தை சாத்தியமாக்குகிறது; inheritance மறுபயன்பாட்டை ஊக்குவிக்கிறது; polymorphism நெகிழ்வுத்தன்மையையும் விரிவாக்கத்தையும் வழங்குகிறது (பல types-ஐ ஒரே மாதிரியாக நடத்துதல், behavior runtime-இல் தீர்மானிக்கப்படுகிறது); abstraction coupling-ஐயும் சிக்கலையும் குறைக்கிறது.

இவற்றைப் புரிந்துகொள்வது வெறும் சொற்களஞ்சியம் மட்டுமல்ல — அவை நீங்கள் classes-ஐ எவ்வாறு கட்டமைக்கிறீர்கள், APIs-ஐ வடிவமைக்கிறீர்கள், மற்றும் பராமரிக்கக்கூடிய, விரிவாக்கக்கூடிய systems-ஐ உருவாக்குகிறீர்கள் என்பதை வழிநடத்துகின்றன.

ஒரு developer சரியான OOP சொற்களில் சிந்திக்கிறாரா என்பதை அவை வெளிப்படுத்துவதால் அவை மிகவும் பொதுவான interview தலைப்புகளில் ஒன்றாகும், இது Java-வின் class-centric ecosystem-இல் திறம்பட வேலை செய்வதற்கு அவசியமானது.