OOP ના ચાર સ્તંભ શું છે?

Question

IT Interview Practice · Accepted Answer

ઑબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગ ચાર મૂળ સિદ્ધાંતો પર આધારિત છે — **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`) ને છુપાવે છે અને નિયંત્રિત વહેંચણી (જાહેર પદ્ધતિ/getters/setters) આવશ્યક કરે છે. આ અપરિવર્તનીયતા સુરક્ષિત કરે છે — તમે સીધું નકારાત્મક બેલેન્સ સેટ કરી શકતા નથી — અને તમને આંતરિક બદલી શકવા દે છે કોલર્સને તોડ્યા વિના.

## 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 સબક્લાસને સુપરક્લાસના વર્તનને ફરીથી વાપરી શકે છે અને વિસ્તૃત કરી શકે છે, "is-a" સંબંધોને મોડલ કરે છે અને કોડ ડુપ્લિકેશન ટાળે છે.

## 3. Polymorphism — એક ઈન્ટરફેસ, ઘણા સ્વરૂપો

```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 તમને સામાન્ય પ્રકાર દ્વારા વિવિધ સબક્લાસેસને સમાન રીતે કાર્ય કરવા દે છે, **વાસ્તવિક** ઑબ્જેક્ટની overridden પદ્ધતિ રનટાઇમ પર બોલાવવામાં આવે છે — લવચીક, વિસ્તૃત કોડ સક્ષમ કરે છે.

## 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 (ઈન્ટરફેસ/અમૂર્ત વર્ગો દ્વારા) સરળ અનુબંધ પ્રકાશિત કરે છે જ્યારે જટીલ અમલીકરણ છુપાવે છે — તમને અમલીકરણો સ્વેપ કરવા અને coupling ઘટાવવા દે છે.

## તે શા માટે મહત્વપૂર્ણ છે

ચાર સ્તંભ ઑબ્જેક્ટ-ઓરિએન્ટેડ ડિજાઇન અને Java નું પાયા છે.

Encapsulation ડેટા અખંડતા રક્ષણ કરે છે અને સુરક્ષિત પરિવર્તન સક્ષમ કરે છે; Inheritance પુનઃવહેંચણીને પ્રોત્સાહિત કરે છે; Polymorphism લવચીકતા અને વિસ્તારણશીલતા પ્રદાન કરે છે (ઘણા પ્રકારો સમાન રીતે કાર્ય કરો, વર્તન રનટાઇમ પર ઠરાવવામાં આવે છે); Abstraction coupling અને જટિલતા ઘટાવે છે.

તેમને સમજવું માત્ર પરિભાષા નથી — તે તમારે કક્ષાઓ કેવી રીતે રચવી, APIs કેવી રીતે ડિજાઇન કરવી, અને જાળવણીયોગ્ય, વિસ્તૃત સિસ્ટમ્સ બનાવવી તે માર્ગદર્શન આપે છે.

તે પણ સૌથી સામાન્ય મુલાકાત વિષયોમાંનો છે કારણ કે તે વણસે છે કે શું એક વિકાસક કર્તા યોગ્ય OOP શરતોમાં વિચાર કરે છે, જે Java ના વર્ગ-કેન્દ્રિત ઇકોસિસ્ટમમાં અસરકારક રીતે કાર્ય કરવા માટે આવશ્યક છે.

1. Encapsulation — ડેટા બંડલ કરો + આંતરિક કાર્યને છુપાવો

2. Inheritance — "is-a" સંબંધ દ્વારા ફરીથી વાપરો

3. Polymorphism — એક ઈન્ટરફેસ, ઘણા સ્વરૂપો

4. Abstraction — એક્સપોઝ શું, છુપાવો કેવી રીતે

તે શા માટે મહત્વપૂર્ણ છે

સંબંધિત પ્રશ્નો