22/12/2017 C# II: Aula 10 - Atividade 2 Interfaces | Alura - Cursos online de tecnologia

02

Interfaces

Nosso banco agora suporta Contas de Investimento. Já sabemos como fazer: basta herdar da classe Conta :

class ContaInvestimento : Conta

{
// comportamentos específicos da conta investimento
}

Por lei, uma vez por ano devemos pagar um tributo ao governo relacionado as contas de investimento e contas de poupança.
O mesmo não acontece com uma simples Conta Corrente.

Para resolver esse problema, podemos criar um método em ambas as classes que calcula o valor desse tributo. Por exemplo:

class ContaPoupanca : Conta

{
// outros metodos

public double CalculaTributo() {

return this.Saldo * 0.02;
}
}
class ContaInvestimento : Conta
{
// outros metodos

public double CalculaTributo() {

return this.Saldo * 0.03;
}
}

Excelente. Os métodos só cam nas Contas que realmente sofrem esse tributo.

Agora, a próxima funcionalidade é a geração de um relatório, onde devemos imprimir a quantidade total de tributos pagos
por todas as Contas Investimento ou Poupanca do nosso banco. Precisamos de uma classe que acumula o valor de todos os
tributos de todas as contas do banco. Esse é um problema parecido com o que já tivemos antes:

class TotalizadorDeTributos {
public double Total { get; private set; }

public void Acumula(ContaPoupanca cp) {

Total += cp.CalculaTributo();
}

public void Acumula(ContaInvestimento ci) {

Total += ci.CalculaTributo();
}
}

https://cursos.alura.com.br/course/csharp-orientacao-a-objetos/task/1708 1/4
22/12/2017 C# II: Aula 10 - Atividade 2 Interfaces | Alura - Cursos online de tecnologia

Pronto. Agora basta passarmos ContaInvestimento ou ContaPoupanca e nossa classe acumulará o valor do tributo. Mas esse
código não é legal. Repare que toda vez que uma nova conta sofrer um tributo, precisaremos lembrar de voltar na classe
TotalizadorDeTributos e criar um novo método Acumula() .

Nos capítulos anteriores, resolvemos isso usando polimor smo. Se a classe-pai possuir o método em comum, então basta
recebermos uma referência pro tipo pai:

class TotalizadorDeTributos {
public double Total { get; private set; }

public void Acumula(Conta c) {

Total += c.CalculaTributo();
}
}

Mas será que faz sentido colocar o método CalculaTributo() na classe Conta ?

abstract class Conta {

// resto da classe aqui
public abstract double CalculaTributo();
}

Nem todas as Contas são tributáveis. Se zermos isso, a classe ContaCorrente ganhará esse método, mas ela não sofre
tributo!

Precisamos achar uma maneira de "achar um pai em comum" apenas para a ContaPoupanca e ContaInvestimento . Classes
em C# não podem ter dois pais. Mas o que podemos fazer é dizer para o compilador que garantiremos a existência do método
CalculaTributo() nas classes que chegarem para o método Acumula() .

Como fazemos isso? Simples. Fazemos a classe "assinar" um contrato! Nesse caso, queremos assinar o contrato que fala que
somos Tributáveis. A convenção de nomes do C# para uma interface é seguir a mesma convenção de nomenclatura de
classes porém com um I no começo do nome:

interface ITributavel
{
double CalculaTributo();
}

class ContaPoupanca : Conta, ITributavel

{
// resto da classe aqui

// método que sou obrigado a implementar

public double CalculaTributo()
{
return this.Saldo * 0.02;
}
}

A mesma coisa para a ContaInvestimento :

https://cursos.alura.com.br/course/csharp-orientacao-a-objetos/task/1708 2/4
22/12/2017 C# II: Aula 10 - Atividade 2 Interfaces | Alura - Cursos online de tecnologia

class ContaInvestimento : Conta, ITributavel

{
// resto da classe aqui

// método que sou obrigado a implementar

public double CalculaTributo()
{
return this.Saldo * 0.03;
}
}

Dessa forma, podemos dizer que a classe TotalizadorDeTributos recebe um ITributavel qualquer. E polimor smo
funciona com interfaces!

class TotalizadorDeTributos {
public double Total { get; private set; }

public void Acumula(ITributavel t) {

Total += t.CalculaTributo();
}
}

Excelente! Veja que com interfaces conseguimos fazer com que um conjunto de classes implemente os mesmos métodos.

Interfaces são bem mais simples do que classes. Elas não tem atributos e seus métodos não tem implementação. A interface
apenas nos garante que o método existirá naquela classe. Por esse motivo, apesar de C# não suportar herança múltipla (ser
lho de mais de uma classe), podemos implementar quantas interfaces quisermos. Basta colocar uma na frente da outra:

class ContaInvestimento : Conta, ITributavel, OutraInterfaceQualquer

{
// implementa os métodos das interfaces Tributavel e OutraInterfaceQualquer

Acostume-se com interfaces. Daqui pra frente, veremos as várias interfaces que existem no C#!

https://cursos.alura.com.br/course/csharp-orientacao-a-objetos/task/1708 3/4
22/12/2017 C# II: Aula 10 - Atividade 2 Interfaces | Alura - Cursos online de tecnologia

https://cursos.alura.com.br/course/csharp-orientacao-a-objetos/task/1708 4/4