બંને પદ્ધતિનાં નામનું પુનઃ ઉપયોગ કરે છે, પણ તે મૌલિક રીતે અલગ છે. ઓવરલોડિંગ = સમાન નામ, વિવિધ પરિમાણો, એક જ વર્ગમાં, સંકલન સમયે ઉકેલાય છે. ઓવરરાઇડિંગ = સબક્લાસ બદલી નાખે છે પેરેન્ટ પદ્ધતિને સમાન હસ્તાક્ષર સાથે, ઉકેલાય છે.
બંને પદ્ધતિનાં નામનું પુનઃ ઉપયોગ કરે છે, પણ તે મૌલિક રીતે અલગ છે. ઓવરલોડિંગ = સમાન નામ, વિવિધ પરિમાણો, એક જ વર્ગમાં, સંકલન સમયે ઉકેલાય છે. ઓવરરાઇડિંગ = સબક્લાસ બદલી નાખે છે પેરેન્ટ પદ્ધતિને સમાન હસ્તાક્ષર સાથે, ઉકેલાય છે.
| ઓવરલોડિંગ | ઓવરરાઇડિંગ | |
|---|---|---|
| હસ્તાક્ષર | ભિન્ન હોવું જોઈએ (params) | સમાન હોવું જોઈએ |
| સંબંધ | એક જ વર્ગ | અભિભાવક ↔ સબક્લાસ |
| ઉકેલાય | સંકલન સમય (સ્થિર) | રનટાઇમ (ગતિશીલ) |
| હેતુ | સુવિધા / ભિન્નતા | બહુરૂપતા |
class Printer {
void print(String s) { System.out.println(s); }
void print(int n) { System.out.println(n); } // same name, diff param
void print(String s, int times) { /* ... */ }
}
સંકલક દલીલોના પ્રકાર પર આધારે કયું print પસંદ કરે છે — કોઈ વારસો કે નહીં.
class Animal { String speak() { return "..."; } }
class Dog extends Animal {
@Override
String speak() { return "Woof"; } // replaces Animal.speak()
}
Animal a = new Dog();
a.speak(); // "Woof" — runtime picks Dog's version (dynamic dispatch)
વારંવાર ભૂલ એ છે કે તમે આકસ્મિક રીતે ઓવરલોડ કરો છો જ્યારે તમે ઓવરરાઇડ કરવા માગતા હતા (જેમ કે હસ્તાક્ષરમાં ટાયપો). હંમેશા @Override (Java) અથવા override (C#) ઉપયોગ કરો જેથી સંકલક તેને પકડી લે.
ઓવરરાઇડિંગ બહુરૂપતાનું એક ઇંજીન છે — રનટાઇમ પદ્ધતિ જે "એક ઇન્ટરફેસ, અनેક અમલીકરણ" કામ કરે છે.
તફાવત જાણવું એક શાસ્ત્રીય બગ અટકાવે છે: એવું વિચારવું કે તમે વર્તણૂક બદલી દીધી જ્યારે તમે ખરેખર એક બીજો, ક્યારેય-ક્યાલ્ડ પદ્ધતિ બનાવી દીધી.