As interfaces são um tipo de dado abstrato para especificarmos comportamentos que uma classe deve seguir. As características de interfaces estão listadas abaixo:

Características

1. Não possuem implementação
2. Possuem apenas de métodos abstratos
3. Não possuem construtor
4. Não podem ser instanciadas
5. Permitem utilizar herança múltipla

A declaração de uma interface é feita utilizando a sintaxe abaixo. A palavra reservada interface para informar que a declaração de uma interface está sendo feita.

Sintaxe : import

interface Inome_interface {
    //corpo
}

Exemplo 1

interface nome_interface {
    //corpo
}

Saída

-

O corpo de uma interface deve conter apenas os protótipos/assinatura dos métodos que deverão ser seguidos podendo conter parâmetros e retornos se necessário.

Sintaxe

interface Inome_interface {

    nome_metodo1( <lista_parametros> ): tipo_retorno;
}

Exemplo 2

interface nome_interface {
    metodo1(p:number): number;
    metodo2():string;
    metodo3():void;
}

Saída

-

Os métodos que não possuem implementação são chamados de métodos abstratos. Diferente dos métodos de classes abstratas, não utilizam a palavra reservada abstract.

Para que seja possível o uso de uma interface, precisamos criar uma classe e informar que um determinada interface será herdada. Utilizando herança e a palavra reservada implements, informamos que nossa classe está herdando um interface.

Sintaxe

class nome_classe implements nome_interface {
    //corpo
}

Exemplo 3

interface nome_interface {
    metodo(p:number): number;
}

class minha_classe implements nome_interface{
    //corpo
}

Saída

-

A implementação dos métodos de uma interface é feita normalmente com qualquer nos métodos já exemplificados.

Os nomes dos parâmetros utilizados pelos métodos implementados não precisam necessariamente coincidir com os nomes declarados na assinatura dos métodos de uma interface, mas suas tipagem devem ser mantidas.

Exemplo 4

interface nome_interface {
    metodo(p:number): number;
}

class minha_classe implements nome_interface{
    //corpo
    public metodo(p:number):number {
        return p*2;
    }
}

Saída

-

Com o uso de interface, podemos ter N classes herdando de uma mesma interface realizando as mesmas tarefas de forma diferente de acordo com cada necessidades.

Exemplo 5

interface nome_interface {
    metodo1(p:number): number;
}

class minha_classe1 implements nome_interface{
    //corpo
    public metodo1(p:number):number {
        return p*2;
    }
}

class minha_classe2 implements nome_interface{
    //corpo
    public metodo1(p:number):number {
        return p*4;
    }
}

Saída

-

Para que seja possível o uso de mais de uma interface, precisamos criar uma classe e informar que quais interfaces serão utilizadas como na sintaxe abaixo:

Sintaxe

class minha_classe implements <lista_interfaces> {
    //corpo
}

Onde

<lista_interfaces>: lista de interfaces separadas por (,)

Exemplo 6

interface nome_interface1 {
    metodo1(p:number): number;
}

interface nome_interface2 {
    metodo2(p:number): number;
}

class minha_classe implements nome_interface1, nome_interface2 {
    //corpo
    public metodo1(p:number):number {
        return p*2;
    }
    
    public metodo2(p:number):number {
        return p*3;
    }
}

Saída

-

A linguagem TS permite também que a herança múltipla seja mista. Podemos utilizar a herança de interfaces e classe concretas. Para tal, precisamos utilizar as palavras reservadas extends e implements.

Exemplo 7

interface nome_interface 
{
    metodo1(p:number): void;
}

class minha_classe1 
{
    public metodo2():void 
    {
        console.log("metodo2");
    }
}

class minha_classe2 extends minha_classe1 implements nome_interface 
{
    public metodo1(p:number):void 
    {
        console.log(p);
    }
    public metodo3(p:number):number {
        return p*3;
    }
}

Saída

-

A lingugem TS permite que seja feita a extensão de uma interface adicionando mais métodos. Assim, precisamos apenas herdar uma interface que irá contemplar todos os métodos abstratos desejados.

Para que a extensão de interface seja feita, utilizamos a palavras reservada extends como pode ser observado na sintaxe a seguir.

Sintaxe

interface interface_filha extends interface_pai {
    //corpo
}

Exemplo 8

interface nome_interface1 //interface pai
{
    metodo1(p:number): void;
}
//interface filha
interface nome_interface2 extends nome_interface1
{
    metodo2(p:number): void;
}

class nome_classe implements nome_interface2 //interface pai
{
    metodo1(p:number):void{}
    metodo2(p:number):void{}
}

Saída

-

É importante observar que a extensão de interface não pode ser confundida com a segregação de interface. Essa foi vista de forma superficial em herança múltipla de interfaces.

1. 28/08/2025 - revisão 2 - Ajustes: pontuais, objetivos e sintaxes
2. 13/09/2024 - revisão 1 - correção em link 'Próximo', intro 'Herança de interface', ajustes gerais
3. 29/02/2024 - versão inicial