TypeScript Inheritance In Hindi

If tutorials available on this website are helpful for you, please whitelist this website in your ad blocker😭 or Donate to help us ❤️ pay for the web hosting to keep the website running.

Object-oriented programming का एक important concept है Inheritance .

इस topic में हम TypeScript inheritance के concepts को step-by-step explore करेंगे। ये topic beginners और intermediate developers के लिए helpful होगा जो TypeScript में inheritance को समझना चाहते हैं।

What is Inheritance ?

किसी class को या Class की properties / behavior को extend करना Inheritance कहते हैं। जिस class को extend किया गया है उसे Parent / Base Class , जिस class के द्वारा extend किया गया है उसे Child / Derived Class कहते हैं।

Inheritance object-oriented programming का एक core concept है जिसमे एक class दूसरी class के properties और methods को inherit करती है , इसका advantage यह होता है कि हम reusable और maintainable code लिख सकते हैं।

मतलब कि, अगर एक Parent class में कुछ common functionality है, तो Child class उससे inherit कर सकती है बिना दुबारा से code लिखने के।

For example : अगर आप एक Animal class बनाते हो जिसमे एक method makeSound() है, तो आप एक Dog class बना सकते हो जो Animal से inherit करेगी और अपनी specific functionality add कर सकती है जैसे bark().

●●●

Inheritance In TypeScript

TypeScript में inheritance implement करने के लिए हम extends keyword का use करते हैं।

एक class दूसरी class से inherit करने के लिए, हम simply child class को parent class का नाम extends keyword के साथ दे देते हैं।

Syntax

Copy
class ParentClass {
    // properties and methods
}

class ChildClass extends ParentClass {
    // properties and methods specific to ChildClass
}

TypeScript inheritance example

Copy
class Animal {
    name: string;

    constructor(name: string) {
        this.name = name;
    }

    makeSound() {
        console.log(`${this.name} is making a sound.`);
    }
}

class Dog extends Animal {
    constructor(name: string) {
        super(name); // parent class ka constructor call karte hain
    }

    bark() {
        console.log(`${this.name} is barking!`);
    }
}

const dog = new Dog('Tommy');
dog.makeSound(); // Output: Tommy is making a sound.
dog.bark();      // Output: Tommy is barking!

इस example में Dog class ने Animal class से makeSound() method inherit किया और अपना bark method add किया।

●●●

Types of Inheritance in TypeScript

TypeScript में inheritance के 4 primary types होते हैं जो object-oriented programming concepts के according काम करते हैं। इन inheritance types का use कर के हम classes के बीच relationship establish करते हैं।

1. TypeScript Single Inheritance

Single inheritance तब होती है जब एक class दूसरी एक ही class से inherit करती है , इसमें एक parent class होती है जो अपने child class को properties और methods provide करती है।

Single inheritance example

Copy
class Animal {
    move() {
        console.log("Animal is moving");
    }
}

class Dog extends Animal {
    bark() {
        console.log("Dog is barking");
    }
}

const dog = new Dog();
dog.move();  // Output: Animal is moving
dog.bark();  // Output: Dog is barking

Dog class Animal class से inherit करती है, तो Dog के पास move() और bark() दोनो methods available हैं।

2. TypeScript Multilevel Inheritance

Multilevel inheritance तब होती है जब एक class दूसरी class से inherit करे, और फिर वो class तीसरी class से inherit करे।

इसमें inheritance एक chain के form में होती है।

Multilevel inheritance example

Copy
class Animal {
    move() {
        console.log("Animal is moving");
    }
}

class Dog extends Animal {
    bark() {
        console.log("Dog is barking");
    }
}

class Puppy extends Dog {
    play() {
        console.log("Puppy is playing");
    }
}

const puppy = new Puppy();
puppy.move();  // Output: Animal is moving
puppy.bark();  // Output: Dog is barking
puppy.play();  // Output: Puppy is playing

यहाँ Puppy class ने Dog से inherit किया, और Dog class ने Animal से inherit किया। इस तरह के relationship को Multilevel Inheritance कहते हैं।

3. TypeScript Hierarchical Inheritance

Hierarchical inheritance तब होती है जब एक parent class से multiple child classes inherit करती हैं , मतलब एक ही parent के multiple children होते हैं।

Hierarchical inheritance example

Copy
class Animal {
    move() {
        console.log("Animal is moving");
    }
}

class Dog extends Animal {
    bark() {
        console.log("Dog is barking");
    }
}

class Cat extends Animal {
    meow() {
        console.log("Cat is meowing");
    }
}

const dog = new Dog();
dog.move();  // Output: Animal is moving
dog.bark();  // Output: Dog is barking

const cat = new Cat();
cat.move();  // Output: Animal is moving
cat.meow();  // Output: Cat is meowing

Dog और Cat classes दोनो ने Animal class से inherit किया है।

4. TypeScript Multiple Inheritance

Multiple inheritance का मतलब होता है एक class का एक से ज़्यादा classes से inherit करना। लेकिन TypeScript में directly multiple inheritance supported नहीं है।

TypeScript में एक class एक ही class को extends कर सकती है , हाँ आप interfaces का use करके कुछ extent तक multiple inheritance का behavior achieve कर सकते हैं।

Inheritance example using interfaces

Copy
interface CanRun {
    run(): void;
}

interface CanBark {
    bark(): void;
}

class Dog implements CanRun, CanBark {
    run() {
        console.log("Dog is running");
    }

    bark() {
        console.log("Dog is barking");
    }
}

const dog = new Dog();
dog.run();  // Output: Dog is running
dog.bark(); // Output: Dog is barking

यहाँ Dog class ने CanRun() और CanBark() interfaces को implement करके multiple behaviors achieve किये हैं , इस तरह से TypeScript में multiple inheritance को indirectly implement किया जा सकता है।

●●●

Why TypeScript does not support multiple inheritance?

complexity और ambiguity को avoid करने के लिए TypeScript Multiple / Hybrid Inheritance को support नहीं करती है। हम , जानते हैं कि parent class की सभी non-private और non-static variables और methods को super keywords के through child class में access कर सकते हैं।

अब suppose कीजिये कि किसी एक class ने एक साथ दो classes को inherit कर लिया और उन parent classes में same method / variable define किये हुए हैं तो को super के through access करने पर एक ambiguity create होगी।

और JS Engine confuse होगा कि उसे किस parent class से member access करना है। इसीलिए TypeScript Multiple / Hybrid Inheritance को support नहीं करती है।

I Hope अब आप TypeScript में Inheritance के बारे में अच्छे से समझ गए होंगे।