OOP ਦੇ ਚਾਰ ਸਤੰਭ ਕੀ ਹਨ?

Question

Accepted Answer

Object-oriented programming ਚਾਰ ਮੂਲ ਸਿਧਾਂਤਾਂ ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ — **Encapsulation, Inheritance, Polymorphism, ਅਤੇ Abstraction**। Java ਇਨ੍ਹਾਂ ਦੇ ਦੁਆਲੇ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਅਤੇ ਇਨ੍ਹਾਂ ਨੂੰ ਸਮਝਣਾ Java ਪ੍ਰੋਗ੍ਰਾਮ ਡਿਜ਼ਾਈਨ ਕਰਨ ਲਈ ਬੁਨਿਆਦੀ ਹੈ।

## 1. Encapsulation — ਡਾਟਾ ਨੂੰ ਬੰਡਲ ਕਰੋ + ਅੰਦਰੂਨੀ ਭਾਗਾਂ ਨੂੰ ਲੁਕਾਓ

```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 ਦੀ ਸੁਰੱਖਿਆ ਕਰਦਾ ਹੈ — ਤੁਸੀਂ ਸਿੱਧੇ ਨਕਾਰਾਤਮਕ ਬੈਲੇਂਸ ਸੈਟ ਨਹੀਂ ਕਰ ਸਕਦੇ — ਅਤੇ ਆਪਣੇ ਅੰਦਰੂਨੀ ਭਾਗਾਂ ਨੂੰ ਬਦਲਣ ਦਿੰਦਾ ਹੈ ਬਿਨਾ callers ਨੂੰ ਤੋੜੇ।

## 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 ਦੇ ਵਿਹਾਰ ਨੂੰ ਦੁਬਾਰਾ ਵਰਤਣ ਅਤੇ ਵਧਾਉਣ ਦਿੰਦਾ ਹੈ, "is-a" ਸਬੰਧਾਂ ਨੂੰ ਮਾਡਲ ਕਰਦੇ ਹੋਏ ਅਤੇ ਕੋਡ ਦੀ ਨਕਲ ਨੂੰ ਰੋਕਦੇ ਹੋਏ।

## 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 ਤੁਹਾਨੂੰ ਇੱਕ ਆਮ ਕਿਸਮ ਦੁਆਰਾ ਵੱਖ-ਵੱਖ subclasses ਨੂੰ ਇਕਸਾਰ ਤਰੀਕੇ ਨਾਲ ਵਰਤਣ ਦਿੰਦਾ ਹੈ, **ਅਸਲ** object ਦੀ overridden method runtime ਤੇ ਸੱਦੀ ਜਾਂਦੀ ਹੈ — ਲਚਕਦਾਰ, ਵਿਸਤਾਰਯੋਗ ਕੋਡ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦੀ ਹੈ।

## 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 ਦੁਆਰਾ) ਇੱਕ ਸਾਧਾਰਣ contract ਨੂੰ ਜ਼ਾਹਰ ਕਰਦਾ ਹੈ ਜਦੋਂ ਕਿ ਗੁੰਝਲਦਾਰ implementation ਨੂੰ ਲੁਕਾਉਂਦਾ ਹੈ — implementations ਨੂੰ ਸਵੈਪ ਕਰਨ ਦਿੰਦੇ ਹੋਏ ਅਤੇ coupling ਨੂੰ ਘਟਾਉਂਦੇ ਹੋਏ।

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

ਚਾਰ ਸਤੰਭ object-oriented design ਅਤੇ Java ਹੀ ਦੀ ਨਿਓ ਹਨ।

Encapsulation ਡਾਟਾ integrity ਦੀ ਸੁਰੱਖਿਆ ਕਰਦਾ ਹੈ ਅਤੇ ਸੁਰੱਖਿਤ ਪਰਿਵਰਤਨ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ; inheritance ਮੁੜ ਵਰਤੋ ਨੂੰ ਉਤਸਾਹਤ ਕਰਦਾ ਹੈ; polymorphism ਲਚਕਤਾ ਅਤੇ ਵਿਸਤਾਰਯੋਗਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ (ਬਹੁਤ ਸਾਰੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਇਕਸਾਰ ਤਰੀਕੇ ਨਾਲ ਵਰਤੋ, ਵਿਹਾਰ runtime ਤੇ ਹੱਲ ਕੀਤਾ); abstraction coupling ਅਤੇ ਗੁੰਝਲ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ।

ਇਨ੍ਹਾਂ ਨੂੰ ਸਮਝਣਾ ਸਿਰਫ ਸ਼ਬਦਾਵਲੀ ਨਹੀਂ ਹੈ — ਇਹ ਆਪਣੀਆਂ classes ਨੂੰ ਕਿਵੇਂ ਢਾਂਚਾ ਦੇਨਾ ਹੈ, APIs ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨਾ ਹੈ, ਅਤੇ maintainable, ਵਿਸਤਾਰਯੋਗ ਸਿਸਟਮ ਬਣਾਉਣੇ ਹਨ ਇਹ ਗਾਈਡ ਕਰਦੇ ਹਨ।

ਉਹ ਸਭ ਤੋਂ ਆਮ ਇੰਟਰਵਿਊ ਵਿਸ਼ਿਆਂ ਵਿਚ ਭੀ ਹਨ ਕਿਉਂਕਿ ਉਹ ਪਰਗਟ ਕਰਦੇ ਹਨ ਕਿ ਕੀ ਇੱਕ developer ਸਹੀ OOP ਸ਼ਬਦਾਂ ਵਿਚ ਸੋਚਦਾ ਹੈ, ਜੋ Java ਦੇ class-centric ecosystem ਵਿਚ ਪ੍ਰਭਾਵੀਤਾ ਨਾਲ ਕਾਨ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।