Interfaces e tipos

name: inverse
layout: true
class: center, middle, inverse
---
name: exercise
layout: true
class: exercise
---
name: normal
layout: true
class: none
---
template: normal

<div>

# Interfaces e tipos

---

# Interfaces (programação)

---

# Interface

> Em programação, **interface** é uma **especificação**, contendo **declarações** de funções (nome, parâmetros, tipo de retorno) e variáveis/constantes que podem ser usadas por outros módulos de um programa

Em geral, diferencia-se a **interface** (declaração) da **implementação** (corpo da função). Exemplo em C:

```c
// Esta função calcula...
int divisao(int a, int b);
```]
.right-50[
### Implementação

```c
int divisao(int a, int b) {
    // implementação:
*   return a / b;
}
```
]

---

# A interface define um contrato

- Uma interface define um **contrato** entre a pessoa que escreveu a função (**fornecedor**) e a pessoa que vai usar a função (**cliente**)
- O contrato define as obrigações do cliente (**pré-condições**) e as garantias do fornecedor (**pós-condições**)
- Lógica: se, ao usar a função, o cliente obedecer às pré-condições, o fornecedor garante que o resultado respeitará as pós-condições
- Parte desse contrato é especificada pela declaração, parte é especificada em texto, na documentação da função

---

# A interface define um contrato

```c
// Esta função calcula...  <-- ISTO É PARTE DO CONTRATO
int divisao(int a, int b);
```

**Pré-condições**:

1. devem ser fornecidos dois números\*
  2. os números devem ser do tipo `int`\*
  3. o segundo número não pode ser zero
--

**Pós-condições**:

4. o resultado será a parte inteira do quociente entre os dois números
  5. o resultado será do tipo `int`\*
--

As condições com \* são especificadas na **declaração** da função e são checadas pelo **compilador**.

As demais condições são especificadas na **documentação** da função e é responsabilidade do **programador** checar se elas estão sendo atendidas.

---

# Interface

A mesma ideia pode ser aplicada a classes:

### Interface pública (declarações)

```java
public class Orcamento {
    private Produto[] produtos;
    private Servico[] servicos;
*   public double getValorTotal() {
        double total = 0.0;
        for (Produto produto : produtos) {
            total += produto.getValor();
        }
        for (Servico servico : servicos) {
            total += servico.getValor();
        }
        return total;
    }
*   public void imprimir() {
        System.out.println("Orçamento");
    }
}
```

---

# Interface

A mesma ideia pode ser aplicada a classes:

### Implementação

```java
public class Orcamento {
    private Produto[] produtos;
    private Servico[] servicos;
    public double getValorTotal() {
*       double total = 0.0;
*       for (Produto produto : produtos) {
*           total += produto.getValor();
*       }
*       for (Servico servico : servicos) {
*           total += servico.getValor();
*       }
*       return total;
    }
    public void imprimir() {
*       System.out.println("Orçamento");
    }
}
```

---

# Exemplo fora da programação

.left-column[
<img src="/aulas/poo/images/plugue.webp" style="width: 200px" /></img>
]
.right-column[
- O padrão de tomadas do Brasil define uma interface para conexão de aparelhos elétricos a pontos de energia elétrica
- Esse padrão define o formato e posição dos pinos, a função de cada pino (terra, fase, neutro), entre outras coisas
- Você não consegue ligar um plugue norte-americano na tomada brasileira
- Nada impede de você inverta a polaridade (o que seria uma quebra do contrato e pode causar problemas)
]

---

# Exemplo motivador

---

# Exemplo: orçamento

Estamos criando um sistema para gerenciar **orçamentos** de obras. Um orçamento pode conter tanto **produtos** (tinta, tijolo etc.) quanto **serviços** (pintura, assentamento de piso etc.). Cada produto e serviço possui um valor.

<div class="uml">
class Produto {
    - descricao
    - valorUnitario
    - quantidade
    + getDescricao()
    + getValor()
}

class Servico {
    - descricao
    - dataAgendada
    - valor
    + getDescricao()
    + getValor()
}

class Orcamento {
    - produtos
    - servicos
    + imprimir()
    + getValorTotal()
}
Orcamento --> Produto
Orcamento --> Servico
</div>

---

# Exemplo: orçamento

```java
public class Orcamento {
    private Produto[] produtos;
    private Servico[] servicos;
*   public double getValorTotal() {
        double total = 0.0;
        for (Produto produto : produtos) {
*           total += produto.getValor();
        }
        for (Servico servico : servicos) {
*           total += servico.getValor();
        }
        return total;
    }
}
```
--

- Percebeu uma certa **duplicação** de código?
- Do ponto de vista da classe `Orcamento`, a distinção entre produtos e serviços é irrelevante: ambos são coisas que têm valor (`getValor()`)
- Como pertencem a classes diferentes, precisam ficar em listas separadas e são tratados separadamente

---

# Exemplo: orçamento

O que queremos é escrever um código mais ou menos assim (pseudocódigo):

```java
public class Orcamento {
*   private ProdutoOuServico[] itens;

public double getValorTotal() {
        double total = 0.0;
*       for (ProdutoOuServico item : itens) {
*           total += item.getValor();
*       }
        return total;
    }
}
```

Ao mesmo tempo, não queremos juntar as classes `Produto` e `Servico` em uma só (pois essa distinção pode ser importante em outras partes do sistema)

---

# Interfaces (Java)

---

# Interface em Java

Em Java, **interface** é uma estrutura que contém apenas a **declaração** de métodos públicos, **sem** as respectivas **implementações**

Assim como uma classe, uma interface define um **tipo de dados**

Diferentemente de uma classe, uma interface **não pode** ser **instanciada**

Interfaces são úteis para tratar objetos de diferentes classes de maneira **uniforme**

---

# Exemplos de interface

```java
// Nó de uma árvore
public interface No {
    No getPai();
    No[] getFilhos();
}

// Coisa que pode ser comprada ou contratada
public interface Pagavel {
    double getValor();
}

// Coisa que possui uma descrição
public interface Descrevivel {
    String getDescricao();
}
```

> Ao declarar os métodos de uma interface, não é preciso escrever `public` (isso está implícito)

---

# Classes implementam interfaces

- Podemos declarar que uma classe **implementa** uma interface.
- Para isso, escreve-se, depois do nome da classe, `implements NomeDaInterface`. Exemplo:

```java
*public class Produto implements Pagavel {
    // ...
}
```

Isso tem duas consequências:

- A classe `Produto` deve fornecer uma **implementação** para **todos os métodos** da interface `Pagavel` (do contrário, dá erro de compilação)
- Todo objeto do tipo `Produto` passa a ser também um objeto do tipo `Pagavel`

(A implementação pode até ser vazia, mas o programador deve criar essa implementação vazia, explicitamente)

---

# Classes implementam interfaces

De fato, uma classe pode implementar mais de uma interface:

```java
public class Pessoa implements Descrevivel, No {
    // ...
    public String getDescricao() { /* ... */ }

public No getPai()  { /* ... */ }
    public No[] getFilhos()  { /* ... */ }
}
```

---

# @Override

Convencionalmente, escreve-se `@Override` acima da implementação de métodos que foram especificados por interfaces que estamos implementando:

```java
public class Produto implements Pagavel {
    // ...
*   @Override
    public double getValor() {
        return precoUnitario * quantidade;
    }
}
```

A anotação `@Override` é opcional mas desejável. Ao usarmos `@Override`, se por acaso escrevermos o nome do método errado (ex.: `getVAlor()`), o compilador vai dar erro, informando que o método `getVAlor()` não está implementando nenhum método da interface. (Mais sobre isso quando estudarmos herança)

---

# Interfaces definem tipos de dados

Considerando o exemplo anterior, as seguintes linhas estão corretas:

```java
Produto p1 = new Produto();
Pagavel p2 = new Produto(); // uma instância de Produto é do tipo Pagavel
```
--

No entanto, a seguinte linha está **incorreta**:

```java
Pagavel p3 = new Pagavel(); // erro de compilação!
```

Interfaces **não podem ser instanciadas**! Se pudessem, o que aconteceria quando chamássemos um de seus métodos?

---