Classes e objetos

Classes em TypeScript permitem estruturar código orientado a objetos, trazendo conceitos de propriedades, métodos, construtores e também itens estáticos.

Uma classe define um modelo para os objetos criados a partir dessa classe.

Definir Classes em TypeScript

Uma classe é uma estrutura que permite criar objetos com propriedades e comportamentos (métodos).

class Pessoa {
  nome: string;
  idade: number;

  constructor(nome: string, idade: number) {
    this.nome = nome;
    this.idade = idade;
  }

  apresentar(): void {
    console.log(`Olá, meu nome é ${this.nome} e eu tenho ${this.idade} anos.`);
  }
}

const p1 = new Pessoa("Ana", 25);
p1.apresentar(); // Olá, meu nome é Ana e eu tenho 25 anos.

Construtores

O constructor é chamado quando criamos uma nova instância da classe (new).
No exemplo acima, ele inicializa nome e idade.

Forma simplificada (usando modificadores de acesso)

O TypeScript permite declarar as propriedades diretamente no construtor:

class Carro {
  constructor(public marca: string, private ano: number) {}

  mostrarAno(): void {
    console.log(`Ano do carro: ${this.ano}`);
  }
}

const c1 = new Carro("Toyota", 2020);
console.log(c1.marca); // Toyota
c1.mostrarAno();       // Ano do carro: 2020

Propriedades e Métodos

• Propriedades: variáveis que pertencem a cada objeto.
• Métodos: funções ligadas ao comportamento da classe.

class ContaBancaria {
  saldo: number = 0;

  depositar(valor: number): void {
    this.saldo += valor;
  }

  levantar(valor: number): void {
    if (valor <= this.saldo) {
      this.saldo -= valor;
    } else {
      console.log("Saldo insuficiente.");
    }
  }

  consultarSaldo(): void {
    console.log(`Saldo atual: ${this.saldo}`);
  }
}

const conta = new ContaBancaria();
conta.depositar(100);
conta.levantar(30);
conta.consultarSaldo(); // Saldo atual: 70

Propriedades Estáticas

Propriedades estáticas pertencem à classe, não às instâncias.
São úteis quando precisamos de valores ou funções globais para todos os objetos da mesma classe.

class Matematica {
  static PI: number = 3.14159;

  static dobro(x: number): number {
    return x * 2;
  }
}

console.log(Matematica.PI);        // 3.14159
console.log(Matematica.dobro(10)); // 20

Matematica.PI e Matematica.dobro são acessados diretamente pela classe, sem necessidade de new.

Métodos e Propriedades de Instância vs. Estáticas

• Instância: precisam de um objeto criado com new.
• Estáticas: acessadas direto pela classe.

class Utilizador{
  static totalUtilizadores: number = 0;
  nome: string;

  constructor(nome: string) {
    this.nome = nome;
    Usuario.totalUtilizadores++;
  }

  info(): void {
    console.log(`Utilizador: ${this.nome}`);
  }
}

const u1 = new Utilizador("Carlos");
const u2 = new Utilizador("Marta");

u1.info(); // Utilizador: Carlos
u2.info(); // Utilizador: Marta

console.log(Utilizador.totalUtilizadores); // 2

Acessores: Getters e Setters

Getters e setters permitem controlar o acesso e as validações de propriedades.

class Produto {
  private _preco: number;

  constructor(preco: number) {
    this._preco = preco;
  }

  get preco(): number {
    return this._preco;
  }

  set preco(valor: number) {
    if (valor >= 0) {
      this._preco = valor;
    } else {
      console.log("Preço inválido.");
    }
  }
}

const p = new Produto(50);
console.log(p.preco); // 50
p.preco = 80;
console.log(p.preco); // 80
p.preco = -10;        // Preço inválido.

Resumo

• Classes definem modelos para objetos.
• Construtores inicializam propriedades ao criar instâncias.
• Propriedades & métodos são elementos de cada objeto.
• Estáticos pertencem à classe, não ao objeto.
• Getters e setters permitem controlar acesso a dados.