Introdução a Classes

As classes são um pilar fundamental na programação orientada a objetos (OOP) e são amplamente utilizadas para criar objetos e gerenciar suas interações. Em TypeScript, as classes oferecem uma estrutura clara e concisa para definir e instanciar objetos com propriedades e métodos, além de adicionar tipagem estática para garantir a segurança do tipo durante o desenvolvimento.

Definindo e Instanciando Classes

Definição de uma Classe:

Em TypeScript, você define uma classe usando a palavra-chave class. Dentro da classe, você pode declarar propriedades e métodos. Aqui está um exemplo básico de uma classe Person:

class Person {
  // Propriedades
  name: string;
  age: number;

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

  // Método
  greet(): void {
    console.log(
      `Hello, my name is ${this.name} and I am ${this.age} years old.`
    );
  }
}

Neste exemplo, Person tem duas propriedades (name e age) e um método (greet). O construtor da classe é um método especial que é chamado quando uma nova instância da classe é criada, e é usado para inicializar as propriedades da classe.

Instanciando uma Classe:

Para criar uma instância de uma classe, você usa a palavra-chave new seguida do nome da classe e quaisquer argumentos necessários para o construtor:

const person1 = new Person("Alice", 30);
person1.greet(); // Saída: Hello, my name is Alice and I am 30 years old.

Neste exemplo, person1 é uma instância da classe Person, e o método greet é chamado nessa instância.

Propriedades e Métodos

Propriedades:

As propriedades são variáveis associadas a uma classe e representam os dados ou o estado da classe. Em TypeScript, você pode definir o tipo de uma propriedade diretamente na declaração da classe:

class Car {
  brand: string;
  model: string;
  year: number;

  constructor(brand: string, model: string, year: number) {
    this.brand = brand;
    this.model = model;
    this.year = year;
  }
}

Aqui, Car tem três propriedades (brand, model e year), cada uma com um tipo especificado.

Métodos:

Os métodos são funções associadas a uma classe que podem operar nas propriedades da classe e realizar ações. Métodos são definidos dentro da classe e podem acessar as propriedades da classe usando this:

class Car {
  brand: string;
  model: string;
  year: number;

  constructor(brand: string, model: string, year: number) {
    this.brand = brand;
    this.model = model;
    this.year = year;
  }

  // Método
  displayInfo(): void {
    console.log(`This car is a ${this.year} ${this.brand} ${this.model}.`);
  }
}

const car1 = new Car("Toyota", "Corolla", 2020);
car1.displayInfo(); // Saída: This car is a 2020 Toyota Corolla.

Modificadores de Acesso:

Em TypeScript, você pode controlar a visibilidade das propriedades e métodos usando modificadores de acesso:

• public: Propriedades e métodos são acessíveis de qualquer lugar.
• private: Propriedades e métodos são acessíveis apenas dentro da classe.
• protected: Propriedades e métodos são acessíveis dentro da classe e subclasses.

Exemplo com modificadores de acesso:

class Employee {
  private id: number;
  public name: string;
  protected department: string;

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

  public getDetails(): string {
    return `${this.name} works in ${this.department} department.`;
  }
}

const emp1 = new Employee(1, "John Doe", "HR");
console.log(emp1.getDetails()); // Saída: John Doe works in HR department.
// console.log(emp1.id);  // Erro: Propriedade 'id' é privada e só é acessível dentro da classe 'Employee'.

Neste exemplo, id é privado e não pode ser acessado fora da classe Employee, name é público e acessível de qualquer lugar, e department é protegido, acessível apenas dentro da classe e suas subclasses.

Conclusão

Classes em TypeScript proporcionam uma maneira poderosa e flexível de definir e trabalhar com objetos, aproveitando a tipagem estática para maior segurança e robustez do código. Compreender como definir, instanciar e utilizar propriedades e métodos é essencial para tirar o máximo proveito da programação orientada a objetos em TypeScript.