પોલીમોર્ફીઝમ શું છે?

Question

Accepted Answer

**પોલીમોર્ફીઝમ** ("ઘણાં રૂપો") એક પ્રથાને વિવિધ અંતર્ગત પ્રકારો સાથે કામ કરવા દે છે. *સમાન કૉલ* *વિવિધ કોડ* ચલાવે છે આધાર પર વાસ્તવિક ઓબ્જેક્ટ — રીટાઈમ પર પસંદ કર્યું. આ **સબટાઇપ પોલીમોર્ફીઝમ** છે.

## એક કૉલ, ઘણી વર્તણુક

```java
class Animal { String speak() { return "..."; } }
class Dog extends Animal { String speak() { return "Woof"; } }
class Cat extends Animal { String speak() { return "Meow"; } }

Animal[] zoo = { new Dog(), new Cat() };
for (Animal a : zoo) {
    System.out.println(a.speak());   // Woof, then Meow
}                                    // same call, different result per type
```

લૂપ `a.speak()` કોલ કરે છે કે જે પ્રાણી છે તેની વાધવા વિના — રીટાઈમ સાચી ઓવરાઇડ માટે ડિસ્પેચ કરે છે.

## તે શા માટે શક્તિશાળી છે

તમે પછીથી નવી `Animal` સબટાઇપ ઉમેરી શકો છો, અને ઉપરનો લૂપ **શૂન્ય પરિવર્તન** સાથે કામ કરવું ચાલુ રાખે છે. કોડ અમૂર્ત પ્રકાર પર આધારિત છે, મોટી કક્ષાઓ પર નહીં.

```text
caller → Animal.speak()  ──dispatch──▶  Dog.speak()  OR  Cat.speak()
            (one interface)                  (many implementations)
```

## પ્રધાન

તેને ઓવરલોડિંગ સાથે ભ્રમણ કરશો નહીં (સમાન પદ્ધતિ નામ, વિવિધ *પરિમાણો*, સંકલન સમયે હલ કર્યું). સાચું (સબટાઇપ) પોલીમોર્ફીઝમ *રીટાઈમ* પર ઓબ્જેક્ટ પર આધારિત છે.

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

પોલીમોર્ફીઝમ જે OOP વિસ્તારિત કરે છે તે છે: નવી વર્તણુક નવી કક્ષા તરીકે આવે છે, પ્રકાશિત `if/else` સાંકળો સાથે સંપાદન તરીકે નહીં.

તે ખુલ્લું/બંધ સિદ્ધાંત પાછળનું મેકેનિઝમ છે અને મોટાભાગે ડિઝાઇન પેટર્નો — તમે ઈન્ટરફેસ તરફ પ્રોગ્રામ કરો છો અને રીટાઈમ ડિસ્પેચ અમલીકરણ પસંદ કરે છે.