Classes - TypeScript

TypeScript implementa uma abordagem orientada a objetos e fornece suporte completo para classes. Uma classe representa um modelo para criar objetos e encapsula a funcionalidade que o objeto deve possuir. A classe define o estado e o comportamento que o objeto terá.

Para definir uma nova classe, utiliza-se a palavra-chave class. Por exemplo, definimos a classe User:

Depois de definir a classe, podemos instanciar objetos dela:

let tom: User = new User();
let alice = new User();

Aqui, dois objetos da classe User foram criados: tom e alice.

Campos da Classe

Para armazenar o estado de um objeto, definimos campos da classe:

class User {
  name: string;
  age: number;
}

Aqui, dois campos são definidos: name e age, que têm os tipos string e number, respectivamente. Na prática, os campos são variáveis no nível da classe, mas não se usa var ou let para declará-los.

Podemos acessar esses campos através do nome do objeto:

class User {
  name: string;
  age: number;
}

let tom = new User();
tom.name = "Tom";
tom.age = 36;
console.log(`name: ${tom.name}  age: ${tom.age}`);  // name: Tom  age: 36

Ao definir campos, podemos atribuir valores iniciais a eles:

class User {
  name: string = "Tom Smith";
  age: number = 18;
}

let user = new User();
console.log(`name: ${user.name}  age: ${user.age}`);    // name: Tom Smith  age: 18

Métodos

As classes também podem definir comportamentos, ou seja, ações que os objetos dessa classe devem executar. Para isso, são definidas funções dentro da classe, conhecidas como métodos.

class User {
  name: string;
  age: number;
  print() {
      console.log(`name: ${this.name}  age: ${this.age}`);
  }
  toString(): string {
      return `${this.name}: ${this.age}`;
  }
}

Nesta classe User, dois métodos são definidos: print() e toString(). O método print() exibe informações do objeto no console, enquanto toString() retorna uma representação do objeto como uma string.

Ao contrário das funções comuns, não usamos a palavra-chave function para definir métodos.

Dentro dos métodos, utilizamos a palavra-chave this para acessar os campos e outros métodos da classe; this refere-se ao objeto atual da classe.

class User {
  name: string;
  age: number;
  print() {
      console.log(`name: ${this.name}  age: ${this.age}`);
  }
  toString(): string {
      return `${this.name}: ${this.age}`;
  }
}

let tom = new User();
tom.name = "Tom";
tom.age = 36;
tom.print();                    // name: Tom  age: 36

console.log(tom.toString());    // Tom: 36

Construtores

Além dos métodos comuns, as classes possuem funções especiais chamadas construtores, definidos com a palavra-chave constructor. Os construtores realizam a inicialização do objeto. Por exemplo, vamos adicionar um construtor à classe User:

class User {
  name: string;
  age: number;
  constructor(userName: string, userAge: number) {
      this.name = userName;
      this.age = userAge;
  }
  print() {
      console.log(`name: ${this.name}  age: ${this.age}`);
  }
}

let tom = new User("Tom", 36);
tom.print();        // name: Tom  age: 36

Aqui, o construtor recebe dois parâmetros e usa seus valores para definir os campos name e age:

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

Em seguida, ao criar um objeto, passamos dois valores para os parâmetros do construtor:

Campos Somente Leitura

Durante a execução do programa, podemos atribuir diferentes valores aos campos da classe, desde que correspondam ao tipo dos campos. No entanto, o TypeScript também permite definir campos somente leitura, cujos valores não podem ser alterados (exceto no construtor). Para definir tais campos, usa-se a palavra-chave readonly:

class User {
  readonly name: string = "Default user";
  age: number;
  constructor(userName: string, userAge: number) {
      this.name = userName;
      this.age = userAge;
  }
  print() {
      console.log(`name: ${this.name}  age: ${this.age}`);
  }
}

O valor dos campos somente leitura pode ser definido ou na declaração:

Ou no construtor:

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

Em outras partes do programa, não é possível alterar o valor deste campo. Por exemplo, no caso a seguir, obteremos um erro de compilação porque estamos tentando atribuir um valor a um campo somente leitura:

class User {
  readonly name: string = "Default user";
  age: number;
  constructor(userName: string, userAge: number) {
      this.name = userName;
      this.age = userAge;
  }
  print() {
      console.log(`name: ${this.name}  age: ${this.age}`);
  }
}

let tom = new User("Tom", 36);
tom.name = "Bob";       // ! Erro - o campo name é somente leitura
tom.print();                    // name: Tom  age: 36