Classes no TypeScript

Este artigo explica as classes no TypeScript.

YouTube Video

Classes no TypeScript

As classes no TypeScript são baseadas nas classes ES6 do JavaScript e oferecem recursos adicionais, como anotações de tipo e modificadores de acesso. Isso permite que você aproveite os conceitos de programação orientada a objetos, garantindo maior robustez e segurança de tipos mais clara.

Abaixo estão explicações sobre o uso básico e os recursos das classes no TypeScript.

Definição Básica de Classe

 1class Person {
 2    name: string;  // Member variable
 3    age: number;   // Member variable
 4
 5    // Constructor
 6    constructor(name: string, age: number) {
 7        this.name = name;
 8        this.age = age;
 9    }
10
11    // Method
12    greet(): void {
13        console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
14    }
15}
16
17const person = new Person("Alice", 25);
18person.greet();  // Hello, my name is Alice and I am 25 years old.

• name e age são propriedades (variáveis membro) da classe.
• O constructor é um método chamado ao criar uma instância de uma classe, que recebe argumentos e atribui valores às propriedades.
• greet é um método da classe, que indica que não retorna nenhum valor ao ser do tipo void.

Modificadores de Acesso

No TypeScript, você pode usar modificadores de acesso (public, private, protected) para controlar o acesso às propriedades e métodos da classe.

public

Por padrão, todas as propriedades e métodos são public. Isso significa que eles podem ser acessados fora da classe.

 1class Animal {
 2    public species: string;
 3
 4    constructor(species: string) {
 5        this.species = species;
 6    }
 7
 8    public makeSound(): void {
 9        console.log(`${this.species} makes a sound.`);
10    }
11}
12
13const animal = new Animal("Dog");
14console.log(animal.species);  // Dog
15animal.makeSound();           // Dog makes a sound.

• A propriedade species e o método makeSound são declarados como public e podem ser acessados de fora da classe.

private

Usar o modificador private impede o acesso às propriedades ou métodos de fora da classe.

 1class Car {
 2    private brand: string;
 3
 4    constructor(brand: string) {
 5        this.brand = brand;
 6    }
 7
 8    public getBrand(): string {
 9        return this.brand;
10    }
11}
12
13const car = new Car("Toyota");
14// console.log(car.brand);  // Error: 'brand' is private and cannot be accessed.
15console.log(car.getBrand());  // Toyota

• A propriedade brand é declarada como private, portanto não pode ser acessada de fora da classe.
• O encapsulamento de dados pode ser alcançado ocultando propriedades usando o modificador private.

protected

O modificador protected restringe o acesso de fora da classe, mas permite em subclasses (classes derivadas).

 1class Vehicle {
 2    protected model: string;
 3
 4    constructor(model: string) {
 5        this.model = model;
 6    }
 7}
 8
 9class Truck extends Vehicle {
10    public getModel(): string {
11        return this.model;
12    }
13}
14
15const truck = new Truck("Ford F-150");
16console.log(truck.getModel());  // Ford F-150
17
18// console.log(truck.model);
19// Error: Property 'model' is protected and only accessible within class 'Vehicle' and its subclasses.

• A propriedade model é declarada como protected, portanto não pode ser acessada de fora da classe, mas pode ser acessada pelas subclasses.

Getters e Setters

No TypeScript, você pode definir getters e setters usando as palavras-chave get e set para obter e definir valores de propriedades.

 1class Employee {
 2    private _salary: number;
 3
 4    constructor(salary: number) {
 5        this._salary = salary;
 6    }
 7
 8    // Getter
 9    get salary(): number {
10        return this._salary;
11    }
12
13    // Setter
14    set salary(newSalary: number) {
15        if (newSalary > 0) {
16            this._salary = newSalary;
17        } else {
18            console.log("Salary must be positive.");
19        }
20    }
21}
22
23const employee = new Employee(50000);
24console.log(employee.salary);  // 50000
25employee.salary = 60000;
26console.log(employee.salary);  // 60000
27employee.salary = -100;        // Salary must be positive.

• Neste exemplo, um getter e um setter são usados para a propriedade salary para controlar o acesso externo e as atualizações. O setter realiza validação para evitar valores negativos e exibe uma mensagem de aviso se um valor inválido for fornecido.

Herança

No TypeScript, as classes podem ser herdadas. Usando a palavra-chave extends, você pode herdar funcionalidades de uma classe pai.

 1class Animal {
 2    constructor(public name: string) {}
 3
 4    public move(): void {
 5        console.log(`${this.name} is moving.`);
 6    }
 7}
 8
 9class Bird extends Animal {
10    public fly(): void {
11        console.log(`${this.name} is flying.`);
12    }
13}
14
15const bird = new Bird("Sparrow");
16bird.move();  // Sparrow is moving.
17bird.fly();   // Sparrow is flying.

• Neste exemplo, a classe Bird herda da classe Animal, o que permite que ela utilize o método move de Animal. Além disso, ela define seu próprio método fly, adicionando novas funcionalidades enquanto herda características da classe pai.

Classes Abstratas

Classes abstratas (abstract) não podem ser instanciadas diretamente e são usadas como modelos para fornecer implementações concretas em subclasses.

 1abstract class Shape {
 2    abstract getArea(): number;
 3
 4    public describe(): void {
 5        console.log("This is a shape.");
 6    }
 7}
 8
 9class Circle extends Shape {
10    constructor(private radius: number) {
11        super();
12    }
13
14    public getArea(): number {
15        return Math.PI * this.radius * this.radius;
16    }
17}
18
19const circle = new Circle(5);
20console.log(circle.getArea());  // 78.53981633974483
21circle.describe();  // This is a shape.

• Neste exemplo, Shape é definida como uma classe abstrata e getArea é um método abstrato que deve ser implementado pelas subclasses. A classe Circle herda esta classe abstrata e implementa seu próprio método getArea para calcular a área de um círculo. Além disso, métodos concretos como describe são herdados como funcionalidades comuns e podem ser usados como estão.

Relação com Interfaces

As classes podem implementar interfaces, garantindo que elas possuam propriedades e métodos específicos.

 1interface Flyable {
 2    fly(): void;
 3}
 4
 5class Airplane implements Flyable {
 6    public fly(): void {
 7        console.log("The airplane is flying.");
 8    }
 9}
10
11const airplane: Flyable = new Airplane();
12airplane.fly();  // The airplane is flying.

• Neste exemplo, a interface Flyable define a especificação para o método fly, e a classe Airplane implementa essa interface fornecendo uma definição concreta para o método fly. Com isso, qualquer objeto que pode ser tratado como do tipo Flyable é garantido de ter um método fly.

Membros Estáticos

Quando você define membros estáticos em uma classe, esses métodos e propriedades são associados à própria classe. Membros estáticos podem ser chamados sem instanciar a classe.

 1class MathUtils {
 2    static PI: number = 3.14;
 3
 4    static add(a: number, b: number): number {
 5        return a + b;
 6    }
 7}
 8
 9console.log(MathUtils.add(10, 20)); // 30
10console.log(MathUtils.PI); // 3.14

• Você define métodos estáticos usando a palavra-chave static.
• Neste exemplo, a classe MathUtils define um método estático add e uma propriedade estática PI.
• Membros estáticos não pertencem às instâncias da classe, mas podem ser chamados diretamente da própria classe.

Resumo

As classes do TypeScript adicionam recursos como segurança de tipos, modificadores de acesso e classes abstratas à funcionalidade de classes do JavaScript. Isso permite uma programação orientada a objetos mais poderosa e segura.

Você pode acompanhar o artigo acima usando o Visual Studio Code em nosso canal do YouTube. Por favor, confira também o canal do YouTube.

YouTube Video