• Conceitos de P.O.O

Os métodos são funções que nossos objetos instanciados a partir de classes possuem e que estão disponíveis para troca de informações. Abaixo a sintaxe para declaração de métodos:

Sintaxe

modificador_acesso nome_metodo()
{
    //corpo
}

Por padrão, os métodos que não utilizam modificadores de acesso na declaração são públicos. Abaixo os modificadores discutidos anteriormente com seus respectivos acessos:

Exemplo 1

class classe
{
    metodo() 
    {
        //corpo
    }
}

Saída

-

Os métodos possuem as mesmas características utilizadas pelas funções vistas em Função , exceto por pertencer a objetos e utilizar os modificadores de acesso.

A chamada dos métodos de nossos objetos é feita utilizando o operador de acesso (.) já visto.

Sintaxe

nome_objeto.nome_metodo();

Exemplo 2

class classe
{
    metodo()
    {
        console.log("metodo");
    }
}

let obj1 = new classe();
obj1.metodo();

Saída

metodo

Assim como funções, os métodos possuem as mesmas características em relação ao uso de parâmetros, retorno e sobrecarga.

Sintaxe:

modificador_acesso nome_metodo( <lista_parametros> ) : tipo_retorno {
    //corpo
}

Caso um método não tenha retorno, podemos utilizar a palavra reservada void para indicar esse caso. Em relação aos parâmetros, não precisamos utilizar a mesma palavra reservada deixando a lista de parâmetros vazia.

Exemplo 3

class classe
{
    //construtor e atribtos omitidos
    metodo1(p:number) :void 
    {
        console.log(p);
    }
    metodo2(p:number,q:number): number
    {
        return p*q;
    }
    metodo3(){}
}

let obj1 = new classe();
obj1.metodo1(100);

Saída

100

O método construtor é um método especial. O método construtor, sem parâmetros, é invocados quando instanciamos objetos utilizando new e pode contér codificação para iniciar atributos de nossas classes.

Caso um método construtor sem parâmetros não seja definido, internamente um construtor é criado.

Sintaxe: construtor

constructor( <lista_parametros> ){
    //corpo
}

Exemplo 4

class classe
{
    atributo:number = 0;

    constructor(p:number){
        this.atributo = p;
    }

    metodo(p:number) :void 
    {
        console.log(p);
    }
}

let obj1 = new classe(100);
console.log(obj1.atributo);

Saída

100

A linguagem TypesScript, diferente de C# e Java por exemplo, aceita apenas um único construtor onde iniciamos os atribuitos de nossas classes.

Em Herança o uso de construtor com classes herdadas será visto com mais detalhes.

Os métodos estáticos são métodos declarados em uma classe utilizando o modificador de acesso static de forma a ficar "visível" sem que seja necessário instanciar um objeto para utilizar esses métodos.

Sintaxe

static nome_metodo(<lista_parametros>): tipo_retorno
{
  //corpo
}

O acesso aos métodos estáticos são feitos utilizando o nome da classe em conjunto com o operador (.) seguido do nome do métodos que desejamos invocar.

Sintaxe

nome_classe.nome_metodo(<lista_argumentos>)

Exemplo 5

class classe
{
    //construtor e atributos omitidos
    static metodo(p:string):void
    {
        console.log(p);
    }
}

classe.metodo("método static");

Saída

método static

Os modificadores de acesso podem ser vistos com mais detalhes em TypeScript: Encapsulamento

Os métodos Get e Set são métodos "especiais" vinculados a atributos de classes privados. São usados para atribuir e recuperar seus valores. A declaração desses métodos são feitos como na sintaxe abaixo:

Sintaxe

get Nome_atributo()
{
    return this.nome_atributo;
}
set Nome_atributo(parametro)
{
    this.nome_atributo = parametro;
}

Como pode ser visto na sintaxe acima, o método declarado como get deve retornar o valor de um atributo e o método set deve atribuir uma valor a um atributo. Não é necessário utilizar () ao invocar esses métodos.

Exemplo 6

class minhaClasse
{
  private atributo;

  get Atributo(){
    return this.atributo;
  }
  set Atributo(p){
    this.atributo = p;
  }
}

let x = new minhaClasse();
x.Atributo = "Teste";
console.log(x.Atributo);

Saída

Teste

A linguagem TS possui uma característica sobrecarga de métodos que nos permite realizar sua sobrecarga. O número de parâmetros do método devem ser os mesmos tendo seus tipos de retorno e parâmetros diferentes.

O último método que dá sentido a sobrecarga deve possuir parâmetros e retorno do tipo any.

Sintaxe

modificador_acesso nome_metodo( p1: tipo_dado1, p2: tipo_dado1 ): tipo_retorno1;

modificador_acesso nome_metodo( p1: tipo_dado2, p2: tipo_dado2 ): tipo_retorno2;

modificador_acesso nome_metodo( p1: any, p2: any): any {
    //corpo
}

Exemplo 5

class classe
{
    //construtor e atributos omitidos
    metodo(p:string):void;
    metodo(p:number):void;
    metodo(p:number[]):void;
    metodo(p:any) :void 
    {
        console.log(p);
    }

}

let obj1 = new classe();
obj1.metodo(100);
obj1.metodo("TypeScript!");
obj1.metodo([1,2,3]);

Saída

100 
"TypeScript!" 
[1, 2, 3] 

1. 28/08/2025 - revisão 3 - Ajustes: pontuais, exemplos, sintaxes, target de links; Adição: 'get' e 'set'
2. 13/09/2024 - revisão 2 - Correção em intro de 'Método com parâmetro e retorno' e 'Sobrecarga', ajustes gramaticais
3. 02/09/2024 - revisão 1 - Correção em link de objetivo: sobrecarga de métodos
4. 01/03/2024 - versão inicial