ਦੋਵੇਂ ਇੱਕ method ਨਾਮ ਨੂੰ ਮੁੜ ਵਰਤਦੇ ਹਨ, ਪਰ ਇਹ ਮੂਲ ਤੌਰ 'ਤੇ ਵੱਖ-ਵੱਖ ਹਨ। = ਇੱਕੋ ਨਾਮ, , ਉਸੇ class ਵਿੱਚ, 'ਤੇ ਹੱਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। = ਇੱਕ subclass ਇੱਕ parent method ਨੂੰ ਉਸੇ ਨਾਲ, 'ਤੇ ਹੱਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
ਦੋਵੇਂ ਇੱਕ method ਨਾਮ ਨੂੰ ਮੁੜ ਵਰਤਦੇ ਹਨ, ਪਰ ਇਹ ਮੂਲ ਤੌਰ 'ਤੇ ਵੱਖ-ਵੱਖ ਹਨ। = ਇੱਕੋ ਨਾਮ, , ਉਸੇ class ਵਿੱਚ, 'ਤੇ ਹੱਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। = ਇੱਕ subclass ਇੱਕ parent method ਨੂੰ ਉਸੇ ਨਾਲ, 'ਤੇ ਹੱਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
| Overloading | Overriding | |
|---|---|---|
| Signature | ਅਲੱਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ (params) | ਬਿਲਕੁਲ ਇੱਕੋ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ |
| Relationship | ਉਸੇ class ਵਿੱਚ | Parent ↔ subclass |
| ਹੱਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ | Compile time (static) | Runtime (dynamic) |
| Purpose | ਸੁਵਿਧਾ / variants | Polymorphism |
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) { /* ... */ }
}
Compiler argument ਕਿਸਮਾਂ ਦੇ ਅਧਾਰ 'ਤੇ ਕਿਹੜਾ print ਚੁਣਦਾ ਹੈ — ਕੋਈ inheritance ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।
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)
ਇੱਕ ਅਕਸਰ ਗਲਤੀ ਗਲਤੀ ਨਾਲ overloading ਕਰਨਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ override ਕਰਨਾ ਮੰਨਦੇ ਸੀ (ਜਿਵੇਂ signature ਵਿੱਚ ਗਲਤੀ)। ਹਮੇਸ਼ਾ @Override (Java) ਜਾਂ override (C#) ਵਰਤੋ ਤਾਂ ਜੋ compiler ਇਸ ਨੂੰ ਫੜ ਲਵੇ।
Overriding polymorphism ਦਾ ਇੰਜਣ ਹੈ — runtime ਵਿਧੀ ਜੋ "ਇੱਕ interface, ਬਹੁਤ implementations" ਨੂੰ ਕੰਮ ਕਰਦੀ ਹੈ।
ਅੰਤਰ ਜਾਣਨਾ ਇੱਕ ਕਲਾਸਿਕ ਬੱਗ ਨੂੰ ਰੋਕਦਾ ਹੈ: ਇਹ ਸੋਚਣਾ ਕਿ ਤੁਮਨੇ behavior ਨੂੰ ਬਦਲ ਦਿੱਤਾ ਹੈ ਜਦੋਂ ਤੁਮਨੇ ਅਸਲ ਵਿੱਚ ਇੱਕ ਦੂਸਰਾ, ਕਦੀ-ਕਦੀ-ਕਾਲ ਕੀਤਾ ਜਾਣ ਵਾਲਾ method ਬਣਾਇਆ ਹੈ।