Como usar classes TypeScript com exemplos simples

TypeScript traz recursos poderosos para JavaScript, incluindo o conceito de classes, que permite programação orientada a objetos. Classes fornecem um modelo para criar objetos, encapsular dados e definir comportamentos. Este guia o guiará pelos conceitos básicos de classes TypeScript com exemplos simples.

O que é uma classe?

Uma classe é um modelo para criar objetos com propriedades e métodos predefinidos. Ela ajuda a organizar o código, promover a reutilização e criar aplicativos escaláveis. As classes em TypeScript funcionam de forma semelhante às classes em outras linguagens de programação orientadas a objetos.

Definindo uma classe básica

Para definir uma classe em TypeScript, use a palavra-chave class seguida pelo nome da classe e um conjunto de chaves contendo propriedades e métodos.

Exemplo de classe básica

Abaixo está um exemplo de uma classe simples Person com propriedades e um método:

class Person {
  name: string;
  age: number;

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

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

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

Neste exemplo, a classe Person tem duas propriedades: name e age. O método construtor inicializa essas propriedades, e o método greet emite uma mensagem de saudação.

Modificadores de acesso

O TypeScript fornece três modificadores de acesso para controlar a visibilidade dos membros da classe:

• public: Os membros podem ser acessados ​​de qualquer lugar (padrão).
• private: Os membros são acessíveis somente dentro da classe.
• protected: Os membros são acessíveis dentro da classe e suas subclasses.

Usando modificadores de acesso

Veja como você pode usar modificadores de acesso em uma classe TypeScript:

class Animal {
  public name: string;
  private age: number;

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

  public getAge(): number {
    return this.age;
  }
}

const dog = new Animal("Buddy", 5);
console.log(dog.name); // Output: Buddy
console.log(dog.getAge()); // Output: 5
// console.log(dog.age); // Error: 'age' is private and only accessible within class 'Animal'.

Neste exemplo, nome é uma propriedade pública, acessível de fora da classe, enquanto idade é uma propriedade privada, acessível somente dentro da classe.

Herança em TypeScript

TypeScript suporta herança, o que permite que uma classe herde propriedades e métodos de outra classe. Isso ajuda a reutilizar código e criar uma hierarquia de classes.

Exemplo de herança

Abaixo está um exemplo de uma classe Cachorro que herda de uma classe base Animal:

class Animal {
  constructor(public name: string) {}

  makeSound(): void {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name); // Call the constructor of the base class
  }

  makeSound(): void {
    console.log(`${this.name} barks.`);
  }
}

const dog = new Dog("Buddy");
dog.makeSound(); // Output: Buddy barks.

Neste exemplo, a classe Dog estende a classe Animal e substitui o método makeSound.

Getters e Setters

O TypeScript permite que você defina getters e setters para propriedades, fornecendo acesso controlado aos membros da classe.

Exemplo de Getters e Setters

class Person {
  private _name: string;

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

  get name(): string {
    return this._name;
  }

  set name(newName: string) {
    if (newName) {
      this._name = newName;
    } else {
      console.log("Name cannot be empty.");
    }
  }
}

const person = new Person("Alice");
console.log(person.name); // Output: Alice
person.name = "Bob";
console.log(person.name); // Output: Bob

Neste exemplo, a propriedade name é acessada e modificada usando métodos getter e setter.

Conclusão

As classes TypeScript são uma maneira poderosa de escrever código orientado a objetos de forma limpa e eficiente. Elas fornecem uma maneira estruturada de definir propriedades, métodos, modificadores de acesso, herança e muito mais. Ao entender como usar classes TypeScript, você pode escrever código mais robusto e sustentável para seus aplicativos.