Uso de extends, sobreescritura de métodos en TypeScript

Class inheritance in TypeScript is a powerful feature that allows you to extend the functionality of existing classes without modifying their original code. This fundamental technique of object-oriented programming allows you to create more organized class hierarchies and reuse code efficiently, saving time and reducing the possibility of errors in your projects.

How to extend classes in TypeScript?

Class extension in TypeScript allows us to create a new class that inherits all the properties and methods of a base class, adding new functionality without modifying the original class. This is achieved by means of the keyword extends.

To illustrate this concept, we will start with a base class called Person that contains basic properties such as name, age and whether it is a developer:

export class Person { constructor( public name: string, public age: number, public isDeveloper: boolean ) {}}

Now, to extend this class and create a new one called Employee, we follow these steps:

1. Create a new file called employee.ts
2. Import the base class Person
3. We use the extends keyword to inherit from Persona

import { Persona } from './persona';
export class Employee extends Persona { constructor( name: string, age: number, isDeveloper: boolean, public job: string ) { super(name, age, isDeveloper); }    
 greet() { return `Hello, I work as ${this.job}`; }    
 getInfo() { return `Iam ${this.age} years old and work as ${this.job}`; } }}

What happens in the constructor of the derived class?

The constructor of the derived class(Employee) must call the constructor of the base class(Person) using the super() keyword. This call is mandatory and must be made before accessing any property with this inside the constructor.

In our example:

• We receive the original parameters (name, age, isDeveloper).
• We add a new parameter (position)
• We call super() with the parameters needed by the base class
• We define the new post property as public

It is important to note that the derived class inherits all the properties and methods of the base class, but it can also:

• Add new properties (such as post)
• Add new methods (such as greet() and getInfo())
• Override methods of the base class (if necessary).

How to use extended classes?

Once we have created our class hierarchy, we can use them in our main code. To do this, we create a main.ts file:

import { Employee } from './employee';
const employee = new Employee('John', 30, true, 'Frontend Developer');
console.log(employee.greet());console.log(employee.getInfo());console.log(employee.name);

When executing this code, we will get:

• "Hi, I work as a Frontend Developer".
• "I am 30 years old and I work as a Frontend Developer."
• "Juan"

Cascading compilation

An interesting feature of TypeScript is cascading compilation. When we compile a file that imports other files, TypeScript automatically compiles all dependent files.

For example, when you run:

tsc main.ts

TypeScript will compile:

1. main.ts (the file we specify).
2. employee.ts (because main.ts imports it)
3. person.ts (because employee.ts imports it)

This generates the corresponding JavaScript files(main.js, employee.js, person.js) without the need to compile each one manually. This feature saves time and ensures that all dependencies are correctly compiled.

Why use class inheritance?

Class inheritance offers multiple benefits:

• Code reuse: avoids duplicating common properties and methods.
• Hierarchical organization: allows the creation of logical object structures
• Maintainability: facilitates changes in the base class that propagate to all derived classes
• Extensibility: allows you to add functionality without modifying the original code

Inheritance is especially useful when working with objects that share common characteristics but need specific additional functionality.

Class inheritance in TypeScript is a powerful tool that allows you to create more organized, maintainable and extensible code. Mastering this technique will help you develop more robust applications and take full advantage of object-oriented programming in your TypeScript projects.

Have you used class inheritance in your projects? What other object-oriented programming techniques do you consider fundamental? Share your experience in the comments.