Clases de TypeScript

Las clases son un concepto central de la programación orientada a objetos (POO). Son una plantilla o modelo para crear objetos con las mismas propiedades y métodos. TypeScript admite completamente la programación orientada a objetos y ofrece características como clases, herencia y modificadores de acceso.

Las clases encapsulan datos (propiedades) y comportamientos (métodos), lo que hace que el código sea más modular, reutilizable y fácil de mantener. A través de las clases, podemos crear múltiples objetos con la misma estructura; estos objetos se denominan instancias de la clase.


Definición de clases

TypeScript usaclassla palabra clave para definir clases. Una clase puede contener los siguientes miembros:

  • Campo (Field): variable declarada en la clase que representa las propiedades del objeto
  • Constructor (Constructor): método especial que se invoca al instanciar la clase, utilizado para inicializar el objeto
  • Método (Method): función definida en la clase que representa el comportamiento del objeto

Formato de sintaxis

class class_name {
    // 字段声明
    field1: type;
    field2: type;

    // 构造函数
    constructor(parameters) {
        // 初始化代码
    }

    // 方法
    methodName(): return_type {
        // 方法实现
    }
}

Ejemplo: crear una clase simple

Ejemplo

// Definir una clase vacía Person
class Person {
}

JavaScript compilado:

Ejemplo

var Person = /** @class */ (function () {
    function Person() {
    }
    return Person;
}());

Campos de clase y constructor

Los campos de la clase son el lugar donde se almacenan los datos del objeto; el constructor se llama automáticamente al crear el objeto para inicializar los campos.

Ejemplo

// Definir la clase Car
class Car {
// Campos: describen las propiedades del automóvil
    engine: string;

// Constructor: inicializa engine al crear el objeto
    constructor(engine: string) {
        this.engine = engine;
    }

// Método: muestra la información del motor
    disp(): void {
console.log("Modelo del motor: " + this.engine);
    }
}

// Crear una instancia de la clase
var car = new Car("Motor V8");

// Acceder al campo
console.log("Leyendo motor: " + car.engine);

// Llamar al método
car.disp();

Resultado de la ejecución:

读取发动机: V8 发动机
发动机型号: V8 发动机

Explicación:

  • thisLa palabra clave apunta a la instancia de la clase actual.
  • Los nombres de los parámetros del constructor pueden ser iguales a los nombres de los campos, mediantethis.fielddistinguirlos.
  • Usarnewla palabra clave para crear una instancia de la clase.

Nota:Las clases de TypeScript se convierten al patrón de prototipo del constructor de JavaScript después de la compilación; las interfaces no aparecen en el resultado compilado.


Modificadores de control de acceso

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

Modificador Descripción
public Miembro público, accesible desde cualquier lugar (por defecto)
private Miembro privado, solo accesible dentro de la clase
protected Miembro protegido, accesible dentro de la clase y en las subclases

public (por defecto)

Ejemplo

class Person {
public name: string; // Propiedad pública
public age: number; // Propiedad pública

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

    public introduce(): void {
console.log("Soy " + this.name + ", tengo " + this.age + " años");
    }
}

var person = new Person("Alice", 25);
console.log("Nombre: " + person.name); // Se puede acceder
person.introduce(); // Se puede acceder

private (privado)

Ejemplo

class Person {
    public name: string;
private secret: string; // Propiedad privada, no accesible directamente desde fuera

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

// Un método público puede acceder a propiedades privadas
    public revealSecret(): void {
console.log("Secreto: " + this.secret);
    }
}

var person = new Person("Alice", "Me gusta programar");

console.log("Nombre: " + person.name); // Se puede acceder
// console.log(person.secret); // Error: 'secret' es una propiedad privada

person.revealSecret(); // Accede a la propiedad privada mediante un método público

protected (protegido)

Ejemplo

class Person {
protected name: string; // Propiedad protegida

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

    protected sayHello(): void {
console.log("Hola, soy " + this.name);
    }
}

class Student extends Person {
    private grade: string;

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

    public introduce(): void {
// La subclase puede acceder a propiedades y métodos protegidos
console.log("Soy " + this.name + ", grado: " + this.grade);
        this.sayHello();
    }
}

var student = new Student("Bob", "Tercer año de secundaria");
student.introduce(); // Se puede acceder

// console.log(student.name); // Error: 'name' es una propiedad protegida

Resultado de la ejecución:

我是 Bob,年级: 高三
你好,我是 Bob

Herencia de clases

La herencia permite que una clase (subclase) obtenga propiedades y métodos de otra clase (clase padre). La subclase puede reutilizar el código de la clase padre y también puede extender o anular el comportamiento de la clase padre.

Sintaxis básica

class child_class extends parent_class {
    // 子类新增的属性和方法
}

Herencia única

Ejemplo

// Clase padre: forma
class Shape {
    area: number;

    constructor(a: number) {
        this.area = a;
    }
}

// Subclase: círculo, hereda de Shape
class Circle extends Shape {
    disp(): void {
console.log("Área del círculo: " + this.area);
    }
}

var circle = new Circle(223);
circle.disp();

Resultado de la ejecución:

圆的面积: 223

Herencia múltiple

TypeScript no admite la herencia múltiple (que una clase herede de varias clases), pero sí admite la herencia multinivel (A hereda de B, B hereda de C):

Ejemplo

// Clase raíz
class Root {
    str: string;
}

// Subclase: hereda de Root
class Child extends Root {
}

// Clase hoja: hereda de Child (herencia múltiple)
class Leaf extends Child {
}

var leaf = new Leaf();
leaf.str = "hello";
console.log("Valor de str: " + leaf.str);

Resultado de la ejecución:

str 值: hello

Anulación de métodos (Override)

La subclase puede anular (Override) métodos de la clase padre, es decir, definir en la subclase un método con el mismo nombre que el de la clase padre, para implementar su propio comportamiento.

Usarsuperla palabra clave permite llamar a los métodos de la clase padre.

Ejemplo

// Clase padre
class PrinterClass {
    doPrint(): void {
console.log("Método doPrint() de la clase padre");
    }
}

// Subclase: anula el método de la clase padre
class StringPrinter extends PrinterClass {
    doPrint(): void {
// Llama al método de la clase padre
        super.doPrint();

// Lógica propia de la subclase
console.log("Método doPrint() de la subclase");
    }
}

var obj = new StringPrinter();
obj.doPrint();

Resultado de la ejecución:

父类的 doPrint() 方法
子类的 doPrint() 方法

Miembros estáticos

Los miembros definidos con la palabra clave `static` pertenecen a la propia clase, no a las instancias de la clase. Se puede acceder directamente a través del nombre de la clase, sin necesidad de crear una instancia.staticEjemplo

Ejemplo

class StaticMem {
// Método estático
    static num: number;

console.log("El valor de num es " + StaticMem.num);
    static disp(): void {
// Acceder directamente a miembros estáticos mediante el nombre de la clase
    }
}

// Acceder directamente a los miembros estáticos mediante el nombre de la clase
StaticMem.num = 12;
StaticMem.disp();

Resultado de ejecución:

num 值为 12

Escenario de aplicación:Los miembros estáticos se usan comúnmente para definir constantes de clase, métodos de utilidad o el patrón singleton.


Operador instanceof

instanceofSe utiliza para determinar si un objeto es una instancia de una clase.

Ejemplo

class Person {
}

var obj = new Person();
var isPerson = obj instanceof Person;

console.log("¿Es obj una instancia de la clase Person? " + isPerson);

Resultado de ejecución:

obj 是 Person 类的实例吗? true

Clases que implementan interfaces

Las clases pueden usarimplementsla palabra clave implements para implementar interfaces, asegurando que la clase cumpla con el contrato definido por la interfaz.

Ejemplo

// Definir interfaz
interface ILoan {
interest: number; // Tasa de interés
}

// La clase implementa la interfaz
class AgriLoan implements ILoan {
    interest: number;
rebate: number; // Reembolso

    constructor(interest: number, rebate: number) {
        this.interest = interest;
        this.rebate = rebate;
    }
}

var loan = new AgriLoan(10, 1);
console.log("Tasa de interés: " + loan.interest + "%, Reembolso: " + loan.rebate);

Resultado de ejecución:

利率: 10%,回扣: 1

Clases abstractas

Las clases abstractas no pueden ser instanciadas, solo pueden servir como clase base para que las subclases hereden. Una clase abstracta puede contener métodos abstractos (métodos placeholder sin implementación), y las subclases deben implementar estos métodos.

Ejemplo

// Clase abstracta
abstract class Animal {
abstract makeSound(): void; // Método abstracto, las subclases deben implementarlo

    move(): void {
console.log("El animal se está moviendo");
    }
}

// Clase concreta: hereda de la clase abstracta
class Dog extends Animal {
    makeSound(): void {
console.log("¡Guau guau guau!");
    }
}

var dog = new Dog();
dog.move();
dog.makeSound();

Resultado de ejecución:

El animal se está moviendo
¡Guau guau!

Ejemplo integral

Uso integral de varias características de las clases:

Ejemplo

// Definición de interfaz
interface I Printable {
    print(): void;
}

// Clase abstracta
abstract class Item {
    protected name: string;
    protected price: number;

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

    abstract getDetails(): string;
}

// Clase concreta
class Product extends Item implements I Printable {
    private category: string;

    constructor(name: string, price: number, category: string) {
        super(name, price);
        this.category = category;
    }

// Implementar método abstracto
    getDetails(): string {
return `Producto: ${this.name}, Precio: ¥${this.price}, Categoría: ${this.category}`;
    }

// Implementar método de interfaz
    print(): void {
        console.log(this.getDetails());
    }

// Método estático
    static create(name: string, price: number): Product {
return new Product(name, price, "Categoría predeterminada");
    }
}

// Uso
var product = Product.create("Computadora portátil", 5999);
product.print();

// Método de descuento
class DiscountedProduct extends Product {
    private discount: number;

    constructor(name: string, price: number, category: string, discount: number) {
        super(name, price, category);
        this.discount = discount;
    }

    getDetails(): string {
        var discountedPrice = this.price * (1 - this.discount / 100);
return `Producto: ${this.name}, Precio original: ¥${this.price}, Descuento: ${this.discount}%, Precio actual: ¥${discountedPrice.toFixed(2)}`;
    }
}

var discountedProduct = new DiscountedProduct("Teléfono móvil", 2999, "Productos electrónicos", 20);
discountedProduct.print();

Resultado de ejecución:

产品: 笔记本电脑, 价格: ¥5999, 类别: 默认类别
产品: 手机, 原价: ¥2999, 折扣: 20%, 现价: ¥2399.20

Resumen

Las clases de TypeScript proporcionan soporte completo para la programación orientada a objetos:

  • Definición de clases: Usa la palabra clave class, incluye campos, constructor y métodos
  • Modificadores de acceso: public, private, protected controlan el acceso a los miembros
  • Herencia: Usa extends para implementar la herencia de clases, soporta herencia multinivel
  • Sobrescritura de métodos: Las subclases pueden sobrescribir métodos de la clase padre, usando super para llamar a la clase padre
  • Miembros estáticos: Usa la palabra clave static, pertenecen a la clase en sí, no a las instancias
  • Implementación de interfaces: Usa la palabra clave implements para implementar interfaces
  • Clase abstracta: Usa la palabra clave abstract, no se puede instanciar, sirve como clase base

Las clases son la base de la programación orientada a objetos en TypeScript; un uso adecuado de las clases puede hacer que el código sea más estructurado y mantenible.

Otras extensiones