Introducción a las características avanzadas de las clases

TypeScript ofrece varias características avanzadas de las clases que le ayudan a escribir código modular, escalable y fácil de mantener orientado a objetos.

En esta lección aprenderá sobre los modificadores de acceso, las clases abstractas, los miembros estáticos y mucho más.

Introducción a las características avanzadas de las clases

TypeScript ofrece varias características avanzadas de las clases que le ayudan a escribir código modular, escalable y fácil de mantener orientado a objetos.

En esta lección aprenderá sobre los modificadores de acceso, las clases abstractas, los miembros estáticos y mucho más.

Modificadores de acceso

TypeScript proporciona tres modificadores de acceso para controlar la visibilidad de los miembros de una clase:

• public: accesible desde cualquier lugar (opción predeterminada).
• private: accesible únicamente dentro de la clase.
• protected: accesible dentro de la clase y sus subclases.

class Person {
  public name: string;
  private age: number;
  protected role: string;

  constructor(name: string, age: number, role: string) {
    this.name = name;
    this.age = age;
    this.role = role;
  }
}

class Employee extends Person {
  getRole(): string {
    return this.role; // Accessible because it's protected
  }
}

Clases abstractas

Las clases abstractas se usan como plantillas para otras clases. No se pueden instanciar directamente y pueden incluir métodos abstractos.

abstract class Shape {
  abstract getArea(): number;
}

class Circle extends Shape {
  constructor(public radius: number) {
    super();
  }

  getArea(): number {
    return Math.PI * this.radius ** 2;
  }
}

const circle = new Circle(5);
console.log(circle.getArea()); // 78.54

Miembros estáticos

Los miembros estáticos pertenecen a la propia clase, no a ninguna instancia de la clase. Se accede a ellos mediante el nombre de la clase.

class MathUtils {
  static PI = 3.14;

  static calculateCircleArea(radius: number): number {
    return this.PI * radius ** 2;
  }
}

console.log(MathUtils.PI); // 3.14
console.log(MathUtils.calculateCircleArea(5)); // 78.5

Getters y setters

Los getters y setters permiten controlar cómo se accede a las propiedades de una clase o cómo se modifican.

class Person {
  private _name: string;

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

  get name(): string {
    return this._name;
  }

  set name(newName: string) {
    this._name = newName;
  }
}

const person = new Person('Alice');
console.log(person.name); // Alice
person.name = 'Bob';
console.log(person.name); // Bob

Propiedades de solo lectura

El modificador readonly garantiza que una propiedad solo se pueda establecer durante la inicialización y no se pueda modificar posteriormente.

class Vehicle {
  readonly make: string;

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

const car = new Vehicle('Toyota');
console.log(car.make); // Toyota
// car.make = 'Honda'; // Error: Cannot assign to 'make' because it is a read-only property.

Constructores privados y protegidos

Las clases pueden tener constructores privados o protegidos para controlar cómo y dónde se crean sus instancias.

class Singleton {
  private static instance: Singleton;

  private constructor() {}

  static getInstance(): Singleton {
    if (!this.instance) {
      this.instance = new Singleton();
    }
    return this.instance;
  }
}

const singleton = Singleton.getInstance();
console.log(singleton);

Tarea práctica

Cree una clase con un constructor protected y extiéndala en una subclase. Añada métodos para acceder a las propiedades protegidas desde la subclase.

¡Enhorabuena!

Ha aprendido características avanzadas de las clases, como modificadores de acceso, clases abstractas, miembros estáticos y mucho más. Practique estos conceptos para escribir código TypeScript orientado a objetos limpio y eficiente.