CODIFICAÇÃO

BACK-END
Classe abstrata e Interface
 Codificação Back-End

Classe abstrata Generalização

Meios de
Comunicação

• Superclasse genérica com

subclasses mais específicas
• Ajuda a lidar com a
complexidade Carta Telefone Jornal
• Modelo para outras classes

Especialização
 Codificação Back-End

Classe abstrata

• Não tem instância ContaBancaria

• Tem pelo menos um método
abstrato
• Pode ter métodos concretos
também
• Abstrato = itálico

ContaCorrente ContaPoupanca
 Codificação Back-End

Classe abstrata Classe

abstrata

public abstract class ContaBancaria

{
ContaBancaria
protected String numero;
public ContaBancaria(){ } # numero: String
public abstract int getNumero{};
public abstract void setNumero(String
+ setNumero(numero: String): void
numero); + getNumero(): String Classe
} concreta

ContaCorrente ContaPoupanca
Classe # numero: String
concreta + setNumero(numero: String): void + setNumero(numero: String): void
+ getNumero(): String + getNumero(): String
 Codificação Back-End

Classe abstrata

• Não tem instância

• Superclasses / modelos
• Genéricas
• Assinatura: public abstract class NomeDaClasse

Palavra-chave que identifica a classe

abstrata
 Codificação Back-End

Métodos abstratos

• Método abstrato → implementado em classe concreta

• Método abstrato herdado → não precisa ser implementado
• Devem ser reescritos como concreto nas classes filhas (override)
• Método abstrato não tem corpo, então tem comportamento diferente quando reescrito nas
filhas

• Assinatura: public abstract tipoRetorno NomeDoMetodo();

Palavra-chave que Implementação

identifica o método indefinida
como abstrato
 Codificação Back-End

Exemplo de método abstrato Em UML o nome de uma

O nome de uma classe (ou
classe (ou método) abstrata
método) abstrata é escrito
Forma é escrito em itálico. Não
em itálico.
pode gerar objetos.
-base:double
//métodos de acesso
+area(): double As classes
+mostra(): void concretas
+perímetro(): double podem gerar Importante!
objetos.
As classes As classes abstratas não
concretas Quadrado Triangulo podem ser instanciadas.
podem gerar - altura: double
objetos.
+Quadrado(double b) +Triangulo(b:double. h
+area(): double double)
+perímetro(): double //métodos de acesso
+mostra(): void +area(): float
+mostra(): void
 Codificação Back-End

Classes abstratas
Conta
- agencia: String
- conta: String
Atributos da Classe Corrente: - saldo: double

• Limite (atributo exclusivo) +depositar(valor : double): void

• Agencia, saldo e conta +sacar(valor : double): void
(atributos da super classe).

Corrente Poupança
- limite: double - aniversario: inf
+sacar(valor : double): void +sacar(valor : double): void
 Codificação Back-End

Classes abstratas
namespace projeto // Corrente.cs – classe filha
{
1 reference namespace projeto
public abstract class Conta {
{ 2 references
0 references public class Corrente : Conta
public string agencia {get;set} {
0 references 0 references
public string conta {get;set} double limite {get;set}
6 references 1 reference
public double saldo {get;set} public override void Sacar(double valor)
1 reference {
public abstract void Sacar(double valor) base.saldo = base.saldo - valor;
} }
} }
}
 Codificação Back-End

Interfaces ou contrato da aplicação

Classe abstrata pura

Mecanismo de reuso de código

Funcionalidades especificadas, mas sem implementação

Não tem atributo (exceto constante), nem definição de método e nem construtor (não instancia)

Apenas constantes e métodos públicos, não precisa da palavra-chave abstract

Não podemos usar private / protected

Palavra-chave: interface → public interface nomeInterface {...}

 Codificação Back-End

Interface vs. Classe abstrata

Interface Classe abstrata

Não tem corpo Pode ter corpo

Implementada por outras classes Estendida por classes derivadas

Uma classe pode implementar Uma classe só pode ser derivada de

várias interfaces (herança múltipla) uma classe abstrata

Obriga a implementar todos os Não é obrigatório implementar

métodos todos os métodos
 Codificação Back-End

Implementação de Interfaces
• Interface → contrato
<<Cliente>>
• Classe deve implementar todos
getcodigo() Dependência
os métodos da interface
• Mecanismo para herança múltipla setcodigo()
Contrato

ClientePF CPF ClientePJ CNPJ

getcodigo() getcodigo()
setcodigo() setcodigo()
 Codificação Back-End

Vantagens da Interface

Implementa similaridades sem forçar hierarquia

Define métodos comuns a várias classes

Revela apenas a interface → esconde a complexidade da

arquitetura

Facilidade para implementar herança múltipla

Facilita entendimento → separa o que a classe “é” do que ela “faz”

 Codificação Back-End

Exemplos
Pessoa
- nome: String
- fone: String <<Seguranca>>

Pessoa() +validar(): boolean

Pessoa(n: String, f:String)
//Metodos de acesso
print(): void

Cliente Fornecedor
- valorDivida: float - valorCompra: float
Cliente() Fornecedor() A classe fornecedor implementa
Cliente(n: String, f: String, v: float) Fornecedor(n: String, f: String, vc: float) a interface segurança→ é
//Metodos de acesso //Metodos de acesso obrigada a implementar o
print(): void print(): void método validar();
calculaJuros (tx: float): float calculaImposto (imposto: float): float
 Codificação Back-End

Produto << Imprimivel >>

- descricao: String nlin: char Pessoa
- quantidade: int +formatoString():String # nomecompleto: String
+Produto(d: String, q: int) +formatoSystemOut(): void # idade: int
//metodos de acesso +Pessoa()
+formatoString(): String +fPessoa(nc: String, i: int)
+formatoSystemOut(): void //metodos de acesso
+validar(): boolean
Usuario
- nomeusuario: String
- senha: String
<< Seguranca >> Qualquer classe que implementa a interface
+Usuario()
Imprimível → obrigação de implementar seus
+Usuario(nu: String, s: String)
+validar(): boolean métodos
//metodos de acesso
+formatoString(): String
Classes Usuario e Produto → obrigadas a
+formatoSystemOut(): void
implementar todos os métodos das
+validar(): boolean
interfaces Segurança e Imprimível → padrão.
 Codificação Back-End

<< Interface >>

Caneta

+ escrever(texto: String) : void As classes CanetaEsferografica, Giz e

+ getCor() : String Lapis implementam a interface Caneta,
logo, implementam todos os métodos da
interface.

CanetaEsferografica Giz Lapis

- cor: String - cor: String - cor: String
 Codificação Back-End

Interface
<< Interface >>
Regras

Conta + sacar(valor: double) : void

- agencia: String
- conta: String
- saldo: double
+ depositar(valor: double): void

Superclasse herda da interface, e as

filhas implementam o método sacar
da interface.
Corrente Poupança
- limite: double - aniversario: int
- sacar(valor: double): void + sacar(valor: double): void
 Codificação Back-End

Interface
Classe abstrata Conta herda a interface Classe Corrente (filha de Conta) →
Regras → herda o método Sacar(); implementa o método Sacar()
// Conta.cs // Corrente.cs – classe filha
namespace projeto
{ namespace projeto
public abstract class Conta : Regras {
{ public class Corrente : Conta
public string agencia {get; set;}
public string conta {get; set;} {
public string saldo {get; set;} double limite {get;set}
pubic void Depositar (double valor) {
this.saldo = this.saldo + valor; public override void Sacar(double valor)
}
{
// método virtual pode ser substituído por qualquer classe base.saldo = base.saldo - valor;
que o herde }
public virtual void Sacar(double valor)
{ }
base.saldo = base.saldo - valor; }
}
}
}
 Codificação Back-End

Interface: implementação

• Criação da interface Regras • Classe Corrente

// Regras.cs // Program.cs

namespace projeto using projeto;

{
public interface Regras Corrente cc = new Corrente();
{ cc.Depositar(5000);
void Sacar(double valor); Console.WriteLine("O saldo é: "+ cc.saldo);
} cc.Sacar(1000);
} Console.WriteLine("O saldo é: "+ cc.saldo);
 Codificação Back-End

Interface vs. Classes abstratas

Classe abstrata Interfaces

Regra: contrato
Template:
independente
modelo para
da hierarquia
subclasses.
de classe.
Bons estudos!