ഇൻഹെറിറ്റൻസ് (ഒബജക്ട് ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ്)

ഇംഗ്ലീഷ് വിലാസം

https://ml.wikipedia.org/wiki/Inheritance_(object-oriented_programming)

ഇൻഹെറിറ്റൻസ് കൊണ്ട് അർത്ഥമാക്കുന്നത്, ഒരു പുതിയ ക്ലാസ് (child) ഒരു പഴയ ക്ലാസിന്റെ (parent) ഗുണങ്ങളും പ്രവർത്തനങ്ങളും എടുക്കുന്നത് ആണ്. ഉദാഹരണത്തിന്, ഒരു പഴയ ക്ലാസിൽ ഉള്ളത് വീണ്ടും എഴുതാതെ അതിന്റെ എല്ലാ ഗുണങ്ങളും ഫീച്ചറുകളും ഉപയോഗിക്കാം. ഇത് പേരന്റ്-ചൈൽഡ് ബന്ധം പോലെയാണ്, ചൈൽഡിന് പേരന്റിന്റെ ചില ഗുണങ്ങൾ പകരം വെച്ചുകൊണ്ട് പുതിയവ ചേർക്കാൻ സഹായിക്കുന്നു. ഇൻഹെറിറ്റൻസ് പുതിയ ക്ലാസുകൾ സൃഷ്ടിക്കുമ്പോൾ പഴയ ക്ലാസിന്റെ ഗുണങ്ങളും പ്രവർത്തനങ്ങളും പുനരാവിഷ്കരിക്കാതെ തന്നെ ആവർത്തിച്ച് ഉപയോഗിക്കാൻ സഹായിക്കുന്നു. ഇതിലൂടെ കോഡ് പുനരുപയോഗവും ഭാവി വികസനവും എളുപ്പമാകും. ക്ലാസ് അടിസ്ഥാനമാക്കിയിട്ടുള്ള ഒബ്ജക്ട്-ഓറിയന്റഡ് ഭാഷയായ, സി++-ൽ, ഒരു ചൈൽഡ് ഒബ്‌ജെക്ട് ഇൻഹെറിറ്റൻസ് വഴി പേരന്റ് ഓബ്‌ജെക്ടിന്റെ എല്ലാ ഗുണങ്ങളും പ്രവർത്തനങ്ങളും ഏറ്റെടുക്കും. എന്നാൽ, കൺസ്ട്രക്ടറുകൾ, ഡിസ്ട്രക്റ്ററുകൾ, ഓവർലോഡഡ് ഓപ്പറേറ്ററുകൾ, ഫ്രണ്ട് ഫംഗ്ഷനുകൾ അടക്കം ചില പ്രത്യേകതകൾ ചൈൽഡിന് ലഭിക്കില്ല. ഇൻഹെറിറ്റൻസ് പ്രോഗ്രാമർമാർക്ക് പഴയ ക്ലാസുകൾ ഉപയോഗിച്ച് പുതിയ ക്ലാസുകൾ സൃഷ്ടിക്കാനും, പഴയ ഗുണങ്ങൾ നിലനിർത്തിക്കൊണ്ട് പുതിയ പ്രവർത്തനങ്ങൾ കൂട്ടിച്ചേർക്കാനും, കോഡ് വീണ്ടും ഉപയോഗിക്കാനും സഹായിക്കുന്നു. ഒബ്‌ജെക്ടുകൾ തമ്മിലുള്ള ഈ ബന്ധം ഒരു നിശ്ചിത ദിശയുള്ള ഗ്രാഫ് (directed acyclic graph) രൂപപ്പെടുത്തുന്നു, എളുപ്പത്തിൽ കാര്യങ്ങൾ ക്രമീകരിക്കാൻ ഇത് ഉപകരിക്കുന്നു^[1].

ഒരു ക്ലാസ് മറ്റൊരു ക്ലാസിന്റെ ഗുണങ്ങളും പ്രവർത്തനങ്ങളും എടുക്കുമ്പോൾ, പുതിയ ക്ലാസിനെ സബ്‌ക്ലാസ് (subclass) എന്നാണ് വിളിക്കുന്നത്, പഴയ ക്ലാസിനെ സൂപ്പർക്ലാസ് (superclass) എന്നാണ് പറയുന്നത്. ഇത് കൂടുതൽ മിക്കപ്പോഴും ക്ലാസ്-ബേസ്‌ഡ് പ്രോഗ്രാമിംഗിൽ കാണുന്ന രീതിയാണ്. എന്നാൽ പ്രോട്ടോട്ടൈപ്പ്-ബേസ്‌ഡ് പ്രോഗ്രാമിംഗിൽ, ക്ലാസുകൾക്ക് പകരം ഒരു ഒബ്ജക്റ്റ് മറ്റൊന്നിൽ നിന്നു പ്രവർത്തനങ്ങൾ "ഡെലിഗേറ്റ്" (delegation) ചെയ്യുകയാണ് ചെയ്യുന്നത്. ക്ലാസുകളിൽ ഉപയോഗിക്കുന്ന ഇൻഹെറിറ്റൻസ് മാതൃകകൾ (inheritance patterns) മുൻകൂട്ടി നിർവചിച്ച രൂപത്തിൽ ആസൂത്രണം ചെയ്താൽ, അതിലൂടെ വ്യത്യസ്ത പ്രോഗ്രാമിംഗ് ഭാഷകൾ തമ്മിൽ കോഡ് പങ്കിടാനും, ഒരു ഭാഷയിൽ നിന്നുള്ള ക്ലാസുകൾ മറ്റൊരു ഭാഷയിൽ ഉപയോഗിക്കാനും സാധ്യമായിത്തീരുന്നു. ഉദാഹരണത്തിന് ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയിൽ (ഉദാ: പൈത്തൺ) നിർമ്മിച്ച ക്ലാസുകൾ, മറ്റൊരു ഭാഷയിൽ (ഉദാ: സി അല്ലെങ്കിൽ സി++) ഉപയോഗിക്കാൻ കഴിയുന്ന രീതിയിൽ സാധാരണയുള്ള രീതികളും ഡാറ്റാ ഘടനകളും പ്രയോഗിക്കുന്നത്. ഇത് പ്രോഗ്രാമിംഗിൽ അന്തർഭാഷ അനായാസ സംവാദം (inter-language communication) സാധ്യമാക്കുന്നു^[2]^[3].‌

ഇൻഹെറിറ്റൻസ് എന്നത്, ഒരു ക്ലാസ് മറ്റൊരു ക്ലാസ്സിന്റെ ഗുണങ്ങൾ (ഫംഗ്ഷനുകൾ) എടുക്കലാണ്. ഉദാഹരണത്തിന്, `Dog` ക്ലാസ് `Animal` ക്ലാസ്സിലെ "eat()" പോലുള്ള ഫംഗ്ഷനുകൾ നൽകുന്നു. സബ്റ്റൈപ്പിംഗ് എന്നത്, ഒരു ക്ലാസ് മറ്റൊരു ക്ലാസ്സിന്റെ ഒരു പ്രത്യേക തരം അല്ലെങ്കിൽ വിഭാഗമായിരിക്കുകയാണ്. ഉദാഹരണത്തിന്, `Dog` ഒരു `Animal`-ന്റെ സബ്ടൈപ്പാണെങ്കിലും, അതിന് അതിന്റെ പ്രത്യേകതകൾ (പുതിയ ഫംഗ്ഷനുകൾ) ഉണ്ടാകും.

ഇൻഹെറിറ്റൻസ് (Inheritance) ജാവാസ്ക്രിപ്റ്റിൽ:

// Animal ക്ലാസ്
class Animal {
    eat() {
        console.log("Eating food");
    }
}

// Dog ക്ലാസ്, Animal ക്ലാസ്സിൽ നിന്നുള്ള ഇൻഹറിറ്റൻസ്
class Dog extends Animal {
    bark() {
        console.log("Barking");
    }
}

// Dog ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുക
let dog = new Dog();
dog.eat();  // Animal ക്ലാസ്സിൽ നിന്നുള്ള ഫംഗ്ഷൻ
dog.bark(); // Dog ക്ലാസ്സിന്റെ പ്രത്യേക ഫംഗ്ഷൻ
//Output
//Eating food
//Barking

ഇവിടെ, Dog ക്ലാസ് Animal ക്ലാസ്സ്‌ നിന്നുള്ള eat() മെത്തഡ് കോപ്പി ചെയ്ത് എടുത്തിരിക്കുന്നു.

സബ്ടൈപ്പിംഗ് (Subtype) ജാവാസ്ക്രിപ്റ്റിൽ:

// Animal ക്ലാസ്
class Animal {
    speak() {
        console.log("Animal speaks");
    }
}

// Dog ക്ലാസ്, Animal ക്ലാസ്സിന്റെ സബ്റ്റൈപ്പ്
class Dog extends Animal {
    speak() {
        console.log("Dog barks");
    }
}

// Cat ക്ലാസ്, Animal ക്ലാസ്സിന്റെ സബ്റ്റൈപ്പ്
class Cat extends Animal {
    speak() {
        console.log("Cat meows");
    }
}

// ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കുന്നു
let dog = new Dog();
let cat = new Cat();

dog.speak();  // Dog-specific speak
cat.speak();  // Cat-specific speak
//Output
//Dog barks
//Cat meows

ഇവിടെ, Dog ഒപ്പം Cat ക്ലാസുകൾ Animal ക്ലാസ്സിന്റെ സബ്ടൈപ്പുകൾ ആണ്, പക്ഷേ ഓരോ ക്ലാസ്സും അതിന്റെ പ്രത്യേക speak() ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നു^[4]^[5].

ഇൻഹെറിറ്റൻസ് എന്നാൽ ഒരു ക്ലാസ് മറ്റൊരു ക്ലാസിന്റെ കോഡ് പുനരുപയോഗിക്കുന്നതാണ്, പക്ഷേ അതു അനിവാര്യമായും അതേ പോലുള്ള പ്രവർത്തനങ്ങൾ ഉണ്ടാക്കുകയോ അതേ രീതിയിലുള്ള പെരുമാറ്റം ഉറപ്പാക്കുകയോ ഇല്ല. സബ്ടൈപ്പിംഗ് എന്നാൽ ഒരു ക്ലാസ് മറ്റൊരു ക്ലാസിന്റെ രൂപത്തിൽ പ്രവർത്തിക്കാൻ കഴിയും എന്ന് ഉറപ്പാക്കുകയാണ്. ഇൻഹെറിറ്റൻസ് ക്രമത്തിലുള്ള രചനയാണ്, ഒരു ക്ലാസ് മറ്റൊരു ക്ലാസിന്റെ ഘടന (structure) അല്ലെങ്കിൽ പ്രവർത്തനം (behavior) പൂർണമായും പകരം വയ്ക്കാൻ കഴിയും എന്നതാണ്. അതായത്, സബ്ടൈപ്പിംഗ് വഴി ഒരു ക്ലാസിന് രണ്ടാമത്തെ ക്ലാസിനെ പോലെ പ്രവർത്തിക്കാൻ കഴിയും, അതിന്റെ എല്ലാ ഫീച്ചറുകളും സ്വീകരിക്കാനും പകരം വയ്ക്കാനും കഴിയും. സബ്ടൈപ്പിംഗ് അല്ലെങ്കിൽ ഇന്റർഫേസ് ഇൻഹെറിറ്റൻസ് എന്നത്, ഒരു ടൈപ്പിന്റെ (methods, functions) നിയമങ്ങൾ മറ്റൊരു തരത്തിൽ ഉപയോഗിക്കാൻ സാധ്യമാകുന്നവയാണ്. എന്നാൽ, ഇത് കോഡിന്റെ ഘടനയിൽ മാറ്റം വരുത്തുന്നില്ല. ഇൻഹെറിറ്റൻസ് അല്ലെങ്കിൽ ഇംപ്ലിമെന്റേഷൻ ഇൻഹെറിറ്റൻസ് എന്നത്, ഒരു ക്ലാസിന്റെ മുഴുവൻ കോഡ്, ഫീച്ചറുകൾ, അല്ലെങ്കിൽ ഫംഗ്ഷനുകൾ മറ്റൊരു ക്ലാസ് ഉപയോഗിക്കുന്നത് എന്നാണ്^[6]. ഇൻഹെറിറ്റൻസ് വഴി ഒരു ക്ലാസ് മറ്റൊരു ക്ലാസിന്റെ ഫംഗ്ഷനുകൾ പുനരുപയോഗിക്കുന്നു. ഇതിലൂടെ സബ്ടൈപ്പിംഗ് ബന്ധം രൂപപ്പെടുന്നു. അതായത്, ഇൻഹെറിറ്റൻസ് ഉപയോഗിച്ച് സബ്ടൈപ്പ് ബന്ധങ്ങൾ സൃഷ്ടിക്കാം^[7].

ഇൻഹെറിറ്റൻസ് എന്നത്, ഒരു ക്ലാസ് മറ്റൊരു ക്ലാസിന്റെ ഫംഗ്ഷനുകൾ നേരിട്ട് ഉപയോഗിക്കുന്ന രീതി ആണ്. എന്നാൽ, ഒബ്ജക്റ്റ് കോംപോസിഷൻ എന്നത്, ഒരു ഒബ്ജക്റ്റ് മറ്റൊരു ഒബ്ജക്റ്റ് ഉൾക്കൊള്ളുന്ന രീതിയാണ്. അങ്ങനെ എങ്കിൽ, ഇൻഹെറിറ്റൻസ് "is-a" എന്ന ബന്ധം സ്ഥാപിക്കുന്നു, കോംപോസിഷൻ "has-a" എന്ന ബന്ധം ഉണ്ടാക്കുന്നു, അതായത് ഒരു ഒബ്ജക്റ്റ് മറ്റൊരു ഒബ്ജക്റ്റിന് ഉടമസ്ഥതപെട്ടിരിക്കുന്നു.

ഇവിടെ ഇൻഹെറിറ്റൻസും (inheritance) കോംപോസിഷനും (composition) പ്രദർശിപ്പിക്കുന്ന ജാവാസ്ക്രിപ്റ്റ് കോഡിന്റെ ഉദാഹരണം നൽകുന്നു:

// പാരന്റ് ക്ലാസ്
class Animal {
  speak() {
    console.log("Animal makes a sound");
  }
}
// ഡോഗ് ക്ലാസ്, Animal ൽ നിന്നും ഇൻഹെറിറ്റ് ചെയ്യുന്നു

class Dog extends Animal {
  speak() {
    console.log("Dog barks");
  }
}

const myDog = new Dog();
myDog.speak(); // ഔട്ട്പുട്ട്: Dog barks

ഇത് ഇൻഹെറിറ്റൻസ് ആണ് എങ്കിൽ Dog ക്ലാസ് Animal ക്ലാസിൽ നിന്നുള്ള പ്രത്യേകതകൾ (methods) പുനരുപയോഗിക്കുന്നു. ഇത് "is-a" ബന്ധം ആണ്.

കോംപോസിഷൻ (object composition)

// എഞ്ചിൻ ഒബ്ജക്റ്റ്
const engine = {
  start() {
    console.log("Engine started");
  }
};

// കാർ ഒബ്ജക്റ്റ്, എഞ്ചിൻ ഉൾപ്പെടുന്നു
const car = {
  engine: engine,
  drive() {
    this.engine.start();
    console.log("Car is driving");
  }
};

car.drive(); // ഔട്ട്പുട്ട്: Engine started, Car is driving

ഇത് കോംപോസിഷൻ ആണ് എങ്കിൽ കാർ ഒബ്ജക്റ്റ് എഞ്ചിൻ ഒബ്ജക്റ്റ് ഉൾക്കൊള്ളുന്നു. ഇത് "has-a" ബന്ധം ആണ്.

ഇൻഹെറിറ്റൻസ് ഒരു സിസ്റ്റത്തിൽ ക്ലാസുകൾക്കിടയിൽ ഒരു ക്രമം സൃഷ്ടിക്കുന്നു, ഇത് ഒരു ക്ലാസ് മറ്റൊരു ക്ലാസിന്റെ ഗുണങ്ങൾ കൈക്കൊള്ളുമ്പോൾ ഉണ്ടാകുന്നു. ഗണിതപരമായി, ഈ ഇൻഹെറിറ്റൻസ് ക്ലാസുകൾക്കിടയിൽ ഒരു "സ്ട്രിറ്റ് പാർഷ്യൽ ഓഡർ" സൃഷ്ടിക്കുന്നതാണ്, അഥവാ, ഓരോ ക്ലാസും ഒരു പ്രത്യേക രീതിയിൽ മറ്റൊരു ക്ലാസിന്റെ ഉപക്ലാസ്സ് ആകുന്നതിന്റെ അടിസ്ഥാനത്തിൽ ക്രമീകരിക്കപ്പെടുന്നു.

ചരിത്രം

1966-ൽ ടോണി ഹോയർ റെക്കോർഡുകൾ സംബന്ധിച്ച ചില അഭിപ്രായങ്ങൾ പങ്കുവച്ചു. അവയിൽ, സ്വതന്ത്രമായ ടാഗുകൾ ഉള്ള ഡിസ്‌ക്രിമിനേറ്റഡ് റെക്കോർഡ് ടൈപ്പുകൾ, അതായത് സാധാരണ ഗുണങ്ങൾ ഉള്ളവ, എന്നാൽ ഓരോ വേരിയന്റിനും പ്രൈവറ്റ് ഫീൽഡുകൾ ഉണ്ടാകുന്നു, എന്ന ആശയം അവതരിച്ചു. ഇത് പ്രോഗ്രാമിംഗിൽ ധാരാളം മേഖലകളിൽ ഉപയോഗിക്കുന്ന ഒരു സങ്കല്പമായി മാറിയിട്ടുണ്ട്^[8]. 1967-ൽ, ഒലെ-ജോഹാൻ ഡാലും ക്രിസ്റ്റൻ നൈഗാർഡും ചേർന്ന് ഒരു പുതിയ ഐഡിയ പങ്കുവച്ചു, വ്യത്യസ്ത ക്ലാസുകളിൽ ഉള്ള ഒബ്ജക്റ്റുകൾ തമ്മിൽ സാമാന്യമായ ഗുണങ്ങൾ ഉണ്ടാകാം. ഇത് പ്രോഗ്രാമുകൾ നിർമ്മിക്കുന്നതിൽ കൂടുതൽ സുഖപ്രദമായ രീതികൾ സൃഷ്ടിക്കാൻ സഹായിച്ചു. പുതിയ രീതിയിലൂടെയാണ് പുതിയ തരം ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കാനുള്ള കഴിവ് ലഭിച്ചത്. ഒരു സൂപ്പർക്ലാസ്സ് പൊതുവായ സ്വഭാവങ്ങൾ സൂക്ഷിക്കുന്നുവെന്നും അവ ചെറുതായി വിവിധ ക്ലാസ്സുകളിൽ ഉപയോഗപ്പെടുമെന്നും പറയാം. ഉദാഹരണത്തിന്, "വാഹനങ്ങൾ" എന്ന സൂപ്പർക്ലാസ്സിന്റെ ഭാഗമായുള്ള "കാർ" അല്ലെങ്കിൽ "ബസ്സ്" എന്ന ക്ലാസുകൾക്ക് പൊതുവായ സ്വഭാവങ്ങൾ ലഭിക്കും. ഈ എക്സ്റ്റൻഷൻ സംവിധാനം (inheritance) പുതിയ ക്ലാസുകൾക്ക് പഴയ ക്ലാസുകളിൽ നിന്നുള്ള സ്വഭാവങ്ങൾ പകരുന്നതിനാൽ, ക്ലാസ്സുകൾ തമ്മിൽ കൂടുതൽ കാര്യക്ഷമമായി പ്രവർത്തിക്കാം. ഒരു സബ്ക്ലാസിന്റെ മൂല്യങ്ങൾ സംയുക്ത വസ്തുക്കളായിരിക്കും, അവയിൽ ചില ഭാഗങ്ങൾ സൂപ്പർക്ലാസ്സുകളിൽ നിന്നുള്ളവയായിരിക്കും, പ്രധാന ഭാഗം സബ്ക്ലാസ്സിൽ നിന്നുള്ളതാണ്. ഈ ഭാഗങ്ങൾ എല്ലാം ചേർത്ത് ഒരു പൂർണ്ണമായ വസ്തു ഉണ്ടാക്കുന്നു, ഓരോ ഭാഗവും അതിന്റെ സവിശേഷതകൾ നൽകുന്നു. ഇതിലൂടെ, ഓരോ ക്ലാസ്സിന്റെയും സ്വഭാവങ്ങൾ തമ്മിൽ ചേർന്ന് ഒരു ഒറ്റ വസ്തുവിനെ സൃഷ്ടിക്കും^[9]. ഒരു സംയുക്ത വസ്തുവിന്റെ ഗുണങ്ങൾ ഡോട്ട് നോട്ടേഷനിലൂടെ ലഭ്യമാണ്. ഈ ആശയം ആദ്യം സിമുല 67 പ്രോഗ്രാമിംഗ് ഭാഷയിലാണ് സ്വീകരിച്ചിരുന്നത്. ഈ ആശയം, ക്ലാസ്സുകളിൽ ഉള്ള ഗുണങ്ങളും (attributes) ഒബ്ജക്ട്കളും (objects) എങ്ങനെ ആക്സസ് ചെയ്യാമെന്ന് കാണിക്കുന്നതാണ്. ഉദാഹരണത്തിന്, ഒരു ക്ലാസ്സിൽ ഒരു ഗുണം (attribute) `person.name` എന്നാണ് എങ്ങനെ ആക്സസ് ചെയ്യുന്നത് എന്നത്. ഇവിടെ, `person` ഒരു ഒബ്ജക്റ്റ് ആണെന്നും `name` എന്ന ഗുണം ആ ഒബ്ജക്റ്റിന്റെ ഭാഗമാണ്. ഡോട്ട് നോട്ടേഷൻ വഴി ഈ ഗുണങ്ങളിലേക്ക് പ്രവേശിക്കാം^[10]. ഈ ആശയം പിന്നീട് സ്മോൾടോക്ക്, സി++, ജാവ, പൈത്തൺ, മറ്റ് പല ഭാഷകളിലും വ്യാപിച്ചു. ഈ ഭാഷകളിൽ എല്ലാ ഒബ്ജക്റ്റുകളും അവയുടെ ഗുണങ്ങളും പ്രവർത്തനങ്ങളും ഡോട്ട് നോട്ടേഷനിലൂടെ ആക്സസ് ചെയ്യാവുന്നതായിരിക്കും.

ടൈപ്പുകൾ

ഇൻഹെറിറ്റൻസ് എന്നത്, ഒരാളുടെ ഗുണങ്ങൾ മറ്റൊരാളിലേക്ക് എത്തുന്ന ഒരു രീതിയാണ്. ഉദാഹരണത്തിന്, പിതാവിന്റെ ഗുണങ്ങൾ മക്കൾക്ക് പകർന്ന് കിട്ടുമെന്ന് കരുതാം. പ്രോഗ്രാമിംഗ് ലോകത്ത്, ഇതുപോലെയുള്ള ആശയം ഉപയോഗിച്ച് ഒരു കോഡിന്റെ ഗുണങ്ങൾ മറ്റൊരു കോഡിലേക്ക് പകരാൻ കഴിയും^[11].

സിംഗിൾ ഇൻഹെറിറ്റൻസ്: ഒരു ചെറിയ കുട്ടി അച്ഛന്റെ ഗുണങ്ങൾ എടുത്തു ജീവിക്കുന്നതിന് പോലെയാണ് ഇത്. ഒരു ക്ലാസ്, മറ്റൊരു ക്ലാസ്സിൽ നിന്നുള്ള നല്ല ഗുണങ്ങൾ എടുക്കുന്നു. ഇതിലൂടെ കോഡ് തിരികെ എഴുതേണ്ടിവരില്ല, നേരത്തെ ഉണ്ടാക്കിയവ ഉപയോഗിച്ച് പുതിയ കാര്യങ്ങൾ ചെയ്യാം.

ജാവാസ്ക്രിപ്റ്റിൽ സിംഗിൾ ഇൻഹെറിറ്റൻസ് എങ്ങനെ വർക്കു ചെയ്യുന്നു എന്ന് കാണിക്കുന്ന ഉദാഹരണത്തിൽ, ഒരു ക്ലാസ് മറ്റൊരു ക്ലാസ്സിൽ നിന്ന് ഫീച്ചറുകൾ എങ്ങനെ പരിമിതപ്പെടുത്തുന്നു എന്ന് കാണിക്കാൻ താഴെ കൊടുത്തിരിക്കുന്നു:

// Superclass - Vehicle
class Vehicle {
    start() {
        console.log("വാഹനം സ്റ്റാർട്ട് ചെയ്യുന്നു...");
    }
}

// Subclass - Vehicle class നെ extend ചെയ്യുന്ന Car
class Car extends Vehicle {
    drive() {
        console.log("കാർ സഞ്ചരിക്കുന്നുണ്ട്.");
    }
}

const myCar = new Car();  // Car class ൽ നിന്നും ഒരു ഒബജ്ക്ട് സൃഷ്ടിക്കുന്നു
myCar.start();  // Vehicle class-ൽ നിന്നുള്ള മെത്തേഡ് (inherit ചെയ്യപ്പെട്ടത്)
myCar.drive();  // Car class-ലുള്ള മെത്തേഡ്

കോഡ് വിശദീകരണം

Vehicle എന്ന ക്ലാസ്സ് ഒരു സൂപ്പർക്ലാസ് ആണ്, അതിൽ start() എന്ന ഫംഗ്ഷൻ ഉണ്ട്. Car എന്ന ക്ലാസ്സ് Vehicle ക്ലാസിൽ നിന്ന് start() എന്ന ഫംഗ്ഷൻ extends വഴി പകർത്തുന്നു. Car ക്ലാസ്സിൽ drive() എന്ന ഫംഗ്ഷൻ കൂടി ഉണ്ടാക്കുന്നു. myCar എന്ന ഒബ്ജക്ട് Car ക്ലാസ്സിൽ നിന്നാണ് ഉണ്ടാക്കിയത്, അതിനാൽ അത് Vehicle ക്ലാസ്സിൽ നിന്നും start() ഫംഗ്ഷനും, Car ക്ലാസ്സിൽ നിന്നുള്ള drive() ഫംഗ്ഷനും ആക്സസ് ചെയ്യാൻ കഴിയും. ഈ ഉദാഹരണത്തിൽ, Vehicle എന്ന ക്ലാസ്സ് പാരന്റ് ആയി പ്രവർത്തിക്കുന്നു, അതിന്റെ start() ഫംഗ്ഷൻ Car ക്ലാസ്സ് ഇൻഹെറിറ്റ് ചെയ്യുന്നു.

മൾട്ടിപ്പിൾ ഇൻഹെറിറ്റൻസ്: മൾട്ടിപ്പിൾ ഇൻഹെറിറ്റൻസ് എന്നത് ഒരു ക്ലാസ് മാത്രമല്ല ഒന്നിൽ കൂടുതൽ പാരന്റ് ക്ലാസ്സുകളിൽ നിന്നുമുള്ള ഗുണങ്ങളും പ്രവർത്തനങ്ങളും ഉൾക്കൊള്ളുന്ന രീതിയാണ്. ഇത്, ഒരുപാട് സാധ്യതകൾ നൽകുന്നു, കാരണം ഒറ്റ ക്ലാസ്സിൽ നിന്ന് മാത്രം കഴിവുകൾ നേടുന്നില്ല, നിരവധി പാരന്റുകളിൽ നിന്നുള്ള ഘടകങ്ങളും ഉപയോഗപ്പെടുത്താം. അതിലൂടെ, കൂടുതൽ ഫലപ്രദമായ, വൈവിധ്യപൂർണമായ കോഡ് എഴുതാനും എളുപ്പമാണ്.; "മൾട്ടിപ്പിൾ ഇൻഹെറിറ്റൻസ് ... കാര്യക്ഷമമായി നടപ്പിലാക്കാൻ വളരെ ബുദ്ധിമുട്ടുള്ളതായി കരുതപ്പെട്ടിരുന്നു. ഉദാഹരണത്തിന്, ഒബ്ജക്റ്റീവ് സിയെക്കുറിച്ചുള്ള തന്റെ പുസ്തകത്തിലെ സി++ന്റെ സംഗ്രഹത്തിൽ, സി++ലേക്ക് മൾട്ടിപ്പിൾ ഇൻഹെറിറ്റൻസ് ചേർക്കുന്നത് അസാധ്യമാണെന്ന് ബ്രാഡ് കോക്സ് അവകാശപ്പെട്ടു. അതിനാൽ, മൾട്ടിപ്പിൾ ഇൻഹെറിറ്റൻസ് കൂടുതൽ വെല്ലുവിളിയായി തോന്നി. 1982ൽ തന്നെ മൾട്ടിപ്പിൾ ഇൻഹെറിറ്റൻസ് പരിഗണിക്കുകയും 1984ൽ ലളിതവും കാര്യക്ഷമവുമായ ഒരു ഇംപ്ലിമെന്റേഷൻ ടെക്നിക് കണ്ടെത്തുകയും ചെയ്തതിനാൽ, എനിക്ക് ആ വെല്ലുവിളിയെ ചെറുക്കാൻ കഴിഞ്ഞില്ല."^[12]

— ബ്യാർനെ സ്ട്രോസ്ട്രപ്പ്

ലളിതമായ ജാവാസ്ക്രിപ്റ്റ് ക്ലാസ് ഉദാഹരണം:

// Person ക്ലാസ്
class Person {
    speak() {
        console.log("ഹലോ, ഞാൻ ഒരു വ്യക്തിയാണ്!");
    }
}

// Employee ക്ലാസ്
class Employee {
    work() {
        console.log("ഞാൻ ഒരു കമ്പനിയിൽ ജോലി ചെയ്യുന്നു.");
    }
}

// Manager ക്ലാസ്, Person എന്ന Employee നിന്നുള്ള method കളെ ചേർക്കുന്നു
class Manager {
    constructor() {
        // Person, Employee ക്ലാസ്സിൽ നിന്നുള്ള methods ഇവിടെ ചേർക്കുന്നു
        Object.assign(this, new Person(), new Employee());
    }
}

// Manager എന്ന object സൃഷ്ടിക്കുന്നു
const manager = new Manager();

// Person, Employee ക്ലാസ്സിലെ methods ഉപയോഗിക്കുന്നു
manager.speak();  // Output: ഹലോ, ഞാൻ ഒരു വ്യക്തിയാണ്!
manager.work();   // Output: ഞാൻ ഒരു കമ്പനിയിൽ ജോലി ചെയ്യുന്നു.

കോഡ് വിവരണം

Person ക്ലാസിൽ speak() മെത്തേഡ് ഉണ്ട്. Employee ക്ലാസിൽ work() മെത്തേഡ് ഉണ്ട്. Manager ക്ലാസ് ഒബജ്ക്ട് സൃഷ്ടിക്കുമ്പോൾ പേഴ്സൺ ആൻഡ് എംപ്ലോയി ക്ലാസ്സിൽ നിന്നുള്ള മേത്തേഡ്സ് Manager ഒബജക്ടിലേക്ക് Object.assign() ഉപയോഗിച്ച് ചേർക്കുന്നു. Manager ഒബജ്ക്ടിൽ നിന്നുള്ള സ്പീക്ക് ആൻഡ് വർക്ക് മെത്തേഡുകളെ ഉപയോഗിക്കാം.

അവലംബം

↑ Johnson, Ralph (August 26, 1991). "Designing Reusable Classes" (PDF). www.cse.msu.edu.
↑ Madsen, OL (1989). "Virtual classes: A powerful mechanism in object-oriented programming". Conference proceedings on Object-oriented programming systems, languages and applications - OOPSLA '89. pp. 397–406. doi:10.1145/74877.74919. ISBN 0897913337. S2CID 1104130.
↑ Davies, Turk (2021). Advanced Methods and Deep Learning in Computer Vision. Elsevier Science. pp. 179–342.
↑ Cook, William R.; Hill, Walter; Canning, Peter S. (1990). Inheritance is not subtyping. Proceedings of the 17th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). pp. 125–135. CiteSeerX 10.1.1.102.8635. doi:10.1145/96709.96721. ISBN 0-89791-343-4.
↑ Cardelli, Luca (1993). Typeful Programming (Technical report). Digital Equipment Corporation. p. 32–33. SRC Research Report 45.
↑ Mikhajlov, Leonid; Sekerinski, Emil (1998). A study of the fragile base class problem (PDF). Proceedings of the 12th European Conference on Object-Oriented Programming (ECOOP). Lecture Notes in Computer Science. Vol. 1445. Springer. pp. 355–382. doi:10.1007/BFb0054099. ISBN 978-3-540-64737-9. Archived from the original (PDF) on 2017-08-13. Retrieved 2015-08-28.
↑ Tempero, Ewan; Yang, Hong Yul; Noble, James (2013). What programmers do with inheritance in Java (PDF). ECOOP 2013–Object-Oriented Programming. Lecture Notes in Computer Science. Vol. 7920. Springer. pp. 577–601. doi:10.1007/978-3-642-39038-8_24. ISBN 978-3-642-39038-8.
↑ Hoare, C. A. R. (1966). Record Handling (PDF) (Technical report). pp. 15–16.
↑ Dahl, Ole-Johan; Nygaard, Kristen (May 1967). Class and subclass declarations (PDF). IFIP Working Conference on Simulation Languages. Oslo: Norwegian Computing Center.
↑ Dahl, Ole-Johan (2004). "The Birth of Object Orientation: the Simula Languages" (PDF). From Object-Orientation to Formal Methods. Lecture Notes in Computer Science. Vol. 2635. pp. 15–25. doi:10.1007/978-3-540-39993-3_3. ISBN 978-3-540-21366-6.
↑ "C++ Inheritance". www.cs.nmsu.edu. Archived from the original on 20230924. Retrieved 20180516. {{cite web}}: Check date values in: |accessdate= and |archivedate= (help); Unknown parameter |urlstatus= ignored (help)
↑ Stroustrup, Bjarne (1994). The Design and Evolution of C++. Pearson. p. 417. ISBN 9780135229477.