વારસો એક વર્ગને (સબક્લાસ અથવા બાળક) બીજા વર્ગ (સુપરક્લાસ અથવા પિતા) ના ક્ષેત્ર અને પદ્ધતિઓ ફરીથી વાપરવા અને વિસ્તૃત કરવા દે છે. તે છે-એક સંબંધ મોડેલ કરે છે: Dog છે Animal.
વારસો એક વર્ગને (સબક્લાસ અથવા બાળક) બીજા વર્ગ (સુપરક્લાસ અથવા પિતા) ના ક્ષેત્ર અને પદ્ધતિઓ ફરીથી વાપરવા અને વિસ્તૃત કરવા દે છે. તે છે-એક સંબંધ મોડેલ કરે છે: Dog છે Animal.
class Animal:
def __init__(self, name):
self.name = name
def eat(self):
return f"{self.name} is eating"
class Dog(Animal): # Dog inherits everything from Animal
def bark(self): # ...and adds new behavior
return "Woof!"
d = Dog("Rex")
print(d.eat()) # "Rex is eating" → inherited, not rewritten
print(d.bark()) # "Woof!" → Dog-specific
Dog ને __init__ અને eat મફતમાં મળ્યું અને તેણે bark ઉમેર્યું. સબક્લાસ વારસામાં મળેલ પદ્ધતિઓને ઓવરરાઇડ પણ કરી શકે છે વર્તન બદલવા માટે.
| લાભ | જોખમ |
|---|---|
| શેર કરેલ કોડનો ફરીથી વપરાશ | પિતાને ચુસ્ત જોડાણ |
| વાસ્તવિક હવાલો મોડેલ કરો | નાજુક આધાર વર્ગ — પિતાના ફેરફાર બાળકોને તોડે છે |
| સામાન્ય પ્રકાર દ્વારા બહુરૂપતા | ગહરું વૃક્ષો અનુસરવું મુશ્કેલ બને છે |
સામાન્ય માર્ગદર્શન: જ્યારે સંબંધ ખરેખર "છે-એક" નથી તો રચના પર વારસો તરફેણ કરો.
વારસો સૌથી દુર્વપરાશ OOP લક્ષણ છે: કોડ શેર કરવા માટે તેનો ઉપયોગ કરવો મોહક છે, જે સંબંધિત વર્ગોને જોડે છે.
યોગ્ય રીતે ઉપયોગ કરવામાં આવે તો — માત્ર સાચા છે-એક સંબંધો માટે — તે તમને પુનઃઉપયોગ વત્તા બહુરૂપતા આપે છે, તમને તેમના સામાન્ય પિતા દ્વારા એકીકૃત રીતે ઘણા સબટાઇપ્સ સાથે વર્તવા દે છે.