6.1 Construtores de Classes
Construtores e métodos de classes são elementos fundamentais da programação orientada a objetos em JavaScript. Eles permitem criar e inicializar objetos, além de definir seu comportamento. Abaixo, vamos dar uma olhada em como funcionam os construtores e métodos de classes, e como usá-los.
O que é um construtor?
Construtor é um método especial da classe chamado no momento da criação de uma nova instância da classe. Ele é utilizado para inicializar o objeto, definir valores de suas propriedades e realizar outras tarefas iniciais.
Definindo um construtor
O construtor é definido usando a palavra-chave constructor. Dentro do construtor, com a palavra-chave
this, você pode acessar as propriedades e métodos do objeto.
Sintaxe:
class ClassName {
constructor(parâmetros) {
// Inicialização do objeto
}
}
Exemplo:
No class Person o método constructor aceita dois parâmetros: name e age.
Esses parâmetros são usados para inicializar as propriedades name e age do objeto criado.
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); // Vai imprimir: Alice
console.log(person2.age); // Vai imprimir: 25
Construtor padrão
Se um construtor não for explicitamente definido, o JavaScript cria automaticamente um construtor padrão vazio.
Exemplo:
class Animal {}
const animal = new Animal();
console.log(animal); // Vai imprimir: Conteúdo da classe Animal {}
4.2 Métodos de Classes
Métodos de classes são definidos dentro do corpo da classe e fornecem funcionalidades para os objetos criados por essa classe. Métodos são automaticamente adicionados ao protótipo da classe, o que permite que todas as instâncias da classe os herdem e usem.
Sintaxe:
class ClassName {
constructor(parâmetros) {
// Inicialização do objeto
}
metodo1() {
// Corpo do método
}
metodo2() {
// Corpo do método
}
}
Exemplo:
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"
Explicação:
- Na classe
Carsão definidos dois métodos:drive()egetDetails() - O método
drive()aumenta a quilometragem do carro e imprime informações sobre a distância percorrida - O método
getDetails()retorna uma string com informações sobre o carro
6.3 Métodos Privados
Com a introdução das novas especificações do ECMAScript, surgiu a possibilidade de criar métodos e propriedades privadas, que não são acessíveis fora da classe. Para isso, é usado o símbolo # como parte do nome.
Exemplo de métodos e propriedades privados:
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); // Vai imprimir: Deposited 50. New balance: 150
account.withdraw(30); // Vai imprimir: Withdrew 30. New balance: 120
console.log(account.getBalance()); // Vai imprimir: 120
// Tentativa de acessar um método ou propriedade privado gerará um erro
account.#balance; // SyntaxError
account.#validateAmount(50); // SyntaxError
GO TO FULL VERSION