6.1 Constructores de clases
Los constructores y métodos de clases son elementos clave de la programación orientada a objetos en JavaScript. Permiten crear e inicializar objetos, así como definir su comportamiento. A continuación veremos cómo funcionan los constructores y métodos de clases, así como cómo usarlos.
¿Qué es un constructor?
Un constructor es un método especial de una clase que se llama al crear una nueva instancia de la clase. Se usa para inicializar el objeto, establecer valores de sus propiedades y realizar otras tareas iniciales.
Definición del constructor
El constructor se define usando la palabra clave constructor. Dentro del constructor, con la palabra clave this puedes acceder a las propiedades y métodos del objeto.
Sintaxis:
class ClassName {
constructor(parámetros) {
// Inicialización del objeto
}
}
Ejemplo:
En la clase Person el método constructor toma dos parámetros: name y age.
Estos parámetros se usan para inicializar las propiedades name y age del objeto creado.
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
}
const person1 = new Person('Alice', 30);
const person2 = new Person('Bob', 25);
console.log(person1.name); // Mostrará: Alice
console.log(person2.age); // Mostrará: 25
Constructor por defecto
Si el constructor no se define explícitamente, JavaScript crea automáticamente un constructor vacío por defecto.
Ejemplo:
class Animal {}
const animal = new Animal();
console.log(animal); // Mostrará el contenido de la clase Animal {}
6.2 Métodos de clases
Los métodos de clases se definen dentro del cuerpo de la clase y proporcionan funcionalidad para los objetos creados por esa clase. Los métodos se añaden automáticamente al prototipo de la clase, lo que permite que todas las instancias de la clase los hereden y utilicen.
Sintaxis:
class ClassName {
constructor(parámetros) { // Inicialización del objeto }
método1() { // Cuerpo del método }
método2() { // Cuerpo del método }
}
Ejemplo:
class Car {
constructor(brand, model) {
this.brand = brand;
this.model = model;
this.mileage = 0;
}
drive(distance) {
this.mileage += distance;
console.log(`${this.brand} ${this.model} drove ${distance} miles. Total mileage: ${this.mileage}`);
}
getDetails() {
return `${this.brand} ${this.model}, Mileage: ${this.mileage}`;
}
}
const myCar = new Car('Toyota', 'Camry');
myCar.drive(50); // "Toyota Camry drove 50 miles. Total mileage: 50"
console.log(myCar.getDetails()); // "Toyota Camry, Mileage: 50"
Explicación:
- En la clase
Carse definen dos métodos:drive()ygetDetails() - El método
drive()incrementa el kilometraje del coche y muestra información sobre la distancia recorrida - El método
getDetails()devuelve una cadena con información sobre el coche
6.3 Métodos privados
Con la introducción de las nuevas especificaciones ECMAScript, se tiene la capacidad de crear métodos y propiedades privadas que no están disponibles fuera de la clase. Para esto, se usa el símbolo # como parte del nombre.
Ejemplo de métodos y propiedades privadas:
class BankAccount {
#balance = 0;
constructor(initialBalance) {
this.#balance = initialBalance;
}
#validateAmount(amount) {
if (amount <= 0) {
throw new Error('Amount must be positive.');
}
}
deposit(amount) {
this.#validateAmount(amount);
this.#balance += amount;
console.log(`Deposited ${amount}. New balance: ${this.#balance}`);
}
withdraw(amount) {
this.#validateAmount(amount);
if (amount > this.#balance) {
throw new Error('Insufficient funds.');
}
this.#balance -= amount;
console.log(`Withdrew ${amount}. New balance: ${this.#balance}`);
}
getBalance() {
return this.#balance;
}
}
const account = new BankAccount(100);
account.deposit(50); // Mostrará: Deposited 50. New balance: 150
account.withdraw(30); // Mostrará: Withdrew 30. New balance: 120
console.log(account.getBalance()); // Mostrará: 120
// Intentar acceder a un método o propiedad privado causará un error
account.#balance; // SyntaxError
account.#validateAmount(50); // SyntaxError
GO TO FULL VERSION