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
class Person {
}
JavaScript compilado:
Ejemplo
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
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, mediante
this.fielddistinguirlos. - Usar
newla 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
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
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
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
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
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
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
// 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
}
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
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
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
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