Inheritance:
It is one of the key feature of OOPS.
It enables code extensibility and allows loosely coupled architecture.
It is the process of creating a new class that extends existing class.
The newly created class is known as derived class and existing class is known as super class.
typescript is providing "extends" to work with inheritanceSyntax:
class Super
{
//Super Class Members
}
class Derived extends Super {
//Derived class Members
}
The code can be reused by using Inheritance which is known as Has a Relation
The members of super class are accessible in derived class by using the keyword "this"
Syntax with constructor
syntax:
class <derv|sub classname> extends <base|super classname>
{
constructor(--)
{
super(--); //calling base constructor to initialize base class fields
initialize derv class fields
}
<methodname>(--)
{
super.<methodname>(--);
...
}
...
}class Base
{
public x:number=10;
}
class Derived extends Base{
public y:number=20;
public print():void {
console.log("x=" + this.x + "\n" + "y=" + this.y);
}
}
let objderived=new Derived();
objderived.print();
Output:
x=10
y=20
Will typescript supports multiple inheritance for a class
No
Why multiple inheritance is not supported for classes.
Inheritance depends on constructor, when you create a derived class object, first
base class constructor is called than followed by derived. If they are multiple base
classes then there will be conflicts between the constructors. Hence multiple inheritance
is not supported.
MultiLevel Inheritance
It is the process, where in derived class can be extended by new class , so that
it can be access both derived and super class members.
Example
class ProductId {
public Id:number;
}
class Details extends ProductId
{
public Name:string;
public Price:number;
}
class ProductInfo extends Details
{
public print():void {
console.log("Id="+ this.Id);
console.log("Name="+ this.Name);
console.log("Price="+ this.Price);
}
}
let objproductInfo=new ProductInfo();
objproductInfo.Id=1;
objproductInfo.Name="Samsung";
objproductInfo.Price=4353;
objproductInfo.print();
Output:
Id=1
Name=Samsung
Price=4353
Example 2
class Department {
name: string;
constructor(name: string) {
this.name = name;
}
}
class Employee extends Department {
empCode: number;
constructor(empcode: number, name:string) {
super(name);
this.empCode = empcode;
}
displayName():void {
console.log("Department Name = " + this.name + ", Employee Code = " + this.empCode);
}
}
let emp = new Employee(100, "IT");
emp.displayName();
Output:
Department Name = IT, Employee Code = 100
Note: In the above example
The constructor of the Employee class initializes its own members as well as the parent class's properties using a special keyword 'super'. The
super keyword is used to call the parent constructor and passes the property values.Class implements Interface
interface IPerson {
name: string;
display():void;
}
interface IEmployee {
empId: number;
}
class Employee implements IPerson, IEmployee {
empId: number;
name: string;
constructor(empId: number, name:string) {
this.empId = empId;
this.name = name;
}
display(): void {
console.log("Name = " + this.name + ", Employee Id = " + this.empId);
}
}
let per:IPerson = new Employee(100, "Uday");
per.display(); // Name = Bill, Employee Code = 100
let emp:IEmployee = new Employee(100, "Uday");
emp.display(); //Compiler Error: Property 'display' does not exist on type 'IEmployee'
