Outro conceito de O.O que vamos aplicar na linguagem TS é o conceito de herança, que pode ser resumido como um relacionamento é-um em que uma classe herda características de uma classe pai podendo utilizar os recursos dessa classe e também estendê-la.

A sintaxe para a utilização de herança entre classes na Linguagem TS é feita da forma simples como mostrado abaixo utilizando a palavra reservada extends:

Sintaxe

<modificador_acesso> class classe_filha extends classe_pai
{
  //corpo
}

Onde

extends: Palavra reservada para definir o uso de herança

Não há diferença na instanciação de um objeto utilizando uma classe que usa o conceito de herança, a palavra reservada new é utiliza da mesma forma.

Os termos Pai e Filha acima serão utilizados ao longo deste trecho do tutorial em que vamos estudar a herança entre classes para facilitar a compreensão.

Exemplo 1

class classe_pai
{
    //corpo
}

class classe_filha extends classe_pai
{
    //corpo
}

Saída

-

Os métodos construtores tipo padrão, sem parâmetros, são chamados implicitamente quando instanciamos um objeto da classe Filha que utiliza herança.

Exemplo 2

class classe_pai
{
    //corpo
}

class classe_filha extends classe_pai
{
    //corpo
}

let pai = new classe_pai();
let filha = new classe_filha();

Saída

-

Ao ser chamado o construtor padrão da classe Filha, o construtor da classe Pai é chamado implicitamente sem a necessidade codificação. Porém, caso seja necessário iniciar a classe pai com valores, o construtor super da classe Pai é chamado ou invocado explicitamente.

Exemplo 3

class classe_pai
{
    atributo:number = 0;
    //corpo omitido
    constructor(p:number)
    {
        this.atributo = p;
    }
}

class classe_filha extends classe_pai
{
    atributo2:number = 0;

    constructor(p:number,q:number){
        super(p) //chamando construtor da classe pai
    }
    //corpo omitido
}

let filha = new classe_filha(1,2);

Saída

-

Com o uso de herança vamos aprender um novo modificador de acesso chamado protected. Esse modificador permite que o acesso aos atributos é métodos de uma classe Pai seja feita apenas por suas classes filhas.

Sintaxe

modificador_acesso class <class_pai>
{
    protected atributo: number;
     //omitido
}

Para que a classe Filha tenha acesso aos atributos de sua classe Pai, precisamos utilizar a palavra reservada this ou super em conjunto com o operador de acesso (.). Esse acesso deve ser feito dentro de um método.

Exemplo 4

class classe_pai
{
    protected atributo:number = 0;
    //corpo omitido
    protected metodo1():void
    {
        console.log("metodo");
    }
}

class classe_filha extends classe_pai
{
    public metodo2(){
        this.metodo1();
        console.log(this.atributo); //recurso protected
    }
}

let filha = new classe_filha();
//filha.metodo1(); //método protected acessado apenas por classes filhas
filha.metodo2();
//console.log(filha.atributo); //atributo protected acessado apenas por classes filhas

Saída

"metodo" 
0

O acesso aos métodos da classe Pai, de acordo com os seus modificadores utilizados, pode ser feito utilizando a palavra reservada super como pode ser visto na sintaxe abaixo:

Sintaxe

super.nome_metodo(<lista_argumentos>);

Exemplo 5

class classe_pai
{
    protected metodo1():void
    {
        console.log("metodo1");
    }
}

class classe_filha extends classe_pai
{
    public metodo2(){
        super.metodo1();
        console.log("metodo2");
    }
}

let filha = new classe_filha();
filha.metodo2();

Saída

"metodo1" 
"metodo2"

Polimorfismo consiste em uma classe Filha alterar a implementação de um método de sua classe Pai. Dessa forma, uma classe Filha pode utilizar uma mesma assinatura de método com comportamento diferente.

A sobrescrita do método pode ser indicada por override na declaração do método sobreescrito como pode ser visto na sintaxe abaixo:

Sintaxe

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

Exemplo 6

class classe_pai
{
    public metodo1():void
    {
        console.log("pai: metodo1");
        this.metodo2();
    }

    protected metodo2(){
        console.log("pai:metodo2")
    }
}

class classe_filha extends classe_pai
{
    public override metodo2(){
        console.log("filha: metodo2");
    }
}
let pai = new classe_pai();
pai.metodo1();
let filha = new classe_filha();
filha.metodo1();

Saída

pai: metodo1
pai:metodo2
pai: metodo1
filha: metodo2

1. 28/08/2025 - revisão 3 - Ajustes: pontuais, sintaxes, target de links
2. 13/09/2024 - revisão 2 - Correção em sintaxe 'modificador protected', ajustes gerais
3. 02/09/2024 - revisão 1 - Correção em link de objetivo: Construtores e herança
5. 01/03/2024 - versão inicial