Os objetos definem sua interação com o mundo exterior através dos métodos que eles expõem. Métodos formam a interface do objeto com o mundo exterior; os botões na parte frontal do seu aparelho de televisão, por exemplo, são a interface entre você e a fiação elétrica do outro lado do seu invólucro de plástico. Você aperta o botão “Power” para ligar e desligar a televisão.
Na sua forma mais comum, uma interface é um conjunto de métodos relacionados com corpos vazios
A implementação de uma interface permite que uma classe se torne mais formal sobre o comportamento que promete proporcionar. Interfaces formam um contrato entre a classe e o mundo exterior, e este contrato é imposto em tempo de compilação.
Se sua classe reivindica implementar uma interface, todos os métodos definidos por essa interface deve aparecer em seu código-fonte antes da classe ser compilada com sucesso.
Uma Interface obriga a classe na qual foi implementada a cumprir o que nela foi declarado. Caso não cumpra o determinado pela interface obterá o seguinte erro de compilação:
Java: The type [Classe] must implement the inherited abstract method [Metodo da interface] [Classe.java]
C++: Error 1 error C2259: ‘Classe’ : cannot instantiate abstract class.
C#: Error 1 ‘namespace.classe’ does not implement interface member ‘namespace.classe.metodo(tipo).
Conceito de interfaces
- Não pode ser instanciada (não podemos criar objetos com new).
- Só pode possuir assinaturas de métodos de instância, públicos e abstratos (sem corpo).
- Não pode possuir métodos concretos (com corpo), nem métodos estáticos.
- Não pode conter variáveis de instância ou de classe (Static);
- Pode conter declarações de constantes.
- Pode ser criada como sub interface de outra interface já existente.
Uso Comum de Interface
Na linguagem de programação C++ pode se utilizar uma interface abstrata como o exemplo abaixo, mas este uso não é muito comum, pois a convenção de classes C++ já contempla que a interface seja separada da implementação na criação da própria classe, utilizando arquivos diferentes (.h e .cpp). Além da linguagem C++ permitir múltiplas heranças tornando raro a necessidade do uso de interfaces abstratas.
Java e C# utilizam a interface pois não permitem múltiplas heranças, então a interface se torna necessária para criar um efeito deste tipo, por exemplo, imagine que temos a classe Casa e queremos que esta classe herde as classes Portas e Janelas, isto não será possível em Java e C#, mas é possível em C++.
Para garantir que teremos os métodos paras portas e janelas na classe Casa, precisamos utilizar a interface Portas e a Interface Janelas, ainda não garantindo como em C++ os tipos de portas e janelas já que as interfaces são abstratas e não métodos concretos, Mas este recurso permite que a classe Casa tenha obrigatoriamente, portas e janelas de qualquer tipo.
Este também é o motivo de uso de uma interface abstrata em C++, quando precisar utilizar métodos abstratos para uma classe dizendo que você permite portas e janelas de qualquer tipo. Nota-se assim que C++ é uma linguagem mais flexível em termos de recursos na criação de objetos.
Exemplos:
Neste exemplo uma pequena empresa fictícia de desenvolvimento de jogos esta escrevendo um novo jogo, um desenvolvedor defini a logica do jogo e cria as interfaces para as classes primitivas. Cria uma interface chamada: Ação, que defini todas as ações do personagem. Enquanto ele desenvolve outras interfaces do jogo, outros desenvolvedores escrevem as classes para os personagem, implementando a interface na classe primitiva do personagem. O programador que criou a interface garante que as classes terão todas as ações definidas por ele obrigatoriamente na classe: Personagem Primitivo, do qual será herdado outros personagens.
Java
Arquivo #1 – Principal
package org.desenvolvimentoaberto;
public class Principal {
public static void main(String[] args)
{
PersonagemPrimitivo Cidadao = new PersonagemPrimitivo();
Cidadao.nome = "Jim James";
Cidadao.classe = "Trabalhador";
Cidadao.andar (false);
Cidadao.correr(true);
Cidadao.largar(false);
Cidadao.pegar (true);
Cidadao.atacar(true);
System.out.println("Status ------>>>> ");
System.out.println("O personagem:" + Cidadao.nome);
System.out.println("Classe: " + Cidadao.classe);
Cidadao.mostraPersonagem();
}
}
Arquivo #2 – Interface
package org.desenvolvimentoaberto;
public interface Acao
{
void pegar(boolean pega);
void largar (boolean larga);
void andar (boolean anda);
void correr (boolean corre);
void atacar (boolean ataca);
}
Arquvio #3 – Classe Personagem Primitivo
package org.desenvolvimentoaberto;
public class PersonagemPrimitivo implements Acao
{
private boolean pega = false;
private boolean larga = false;
private boolean anda = false;
private boolean corre = false;
private boolean ataca = false;
public String nome;
public String classe;
public void pegar (boolean pega)
{
this.pega = pega;
}
public void largar (boolean larga)
{
this.larga = larga;
}
public void andar (boolean anda)
{
this.anda = anda;
}
public void correr (boolean corre)
{
this.corre = corre;
}
public void atacar (boolean ataca)
{
this.ataca = ataca;
}
public void mostraPersonagem()
{
System.out.println("Esta andando: " + anda);
System.out.println("Esta correndo: " + corre);
System.out.println("Esta pegando: " + pega);
System.out.println("Esta largando: " + larga);
System.out.println("Esta atacando: " + ataca);
}
}
C++
Arquivo #1 – Principal
#include "stdafx.h"
#include <iostream>
#include <string>
#include "personagemprimitivo.h"
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
PersonagemPrimitivo Cidadao;
Cidadao.nome = "Jim James";
Cidadao.classe = "Trabalhador";
Cidadao.andar(false);
Cidadao.correr(true);
Cidadao.largar(false);
Cidadao.pegar(true);
Cidadao.atacar(true);
cout << "Status ------>>>> " << endl;
cout << "O personagem:" + Cidadao.nome << endl;
cout << "Classe: " + Cidadao.classe << endl;
Cidadao.mostraPersonagem();
system("pause");
return 0;
}
Arquivo #2 – Interface
#include "stdafx.h"
__interface Acao
{
public:
virtual void pegar(bool pega);
virtual void largar(bool larga);
virtual void andar(bool anda);
virtual void correr(bool corre);
virtual void atacar(bool ataca);
};
Arquvio #3 – Classe Personagem Primitivo
#include "stdafx.h"
#include <iostream>
#include "acao.h"
using namespace std;
class PersonagemPrimitivo : public Acao {
private:
bool pega = false;
bool larga = false;
bool anda = false;
bool corre = false;
bool ataca = false;
public: string nome; string classe;
void pegar(bool pega)
{
this->pega = pega;
}
void largar(bool larga)
{
this->larga = larga;
}
void andar(bool anda)
{
this->anda = anda;
}
void correr(bool corre)
{
this->corre = corre;
}
void atacar(bool ataca)
{
this->ataca = ataca;
}
void mostraPersonagem() {
cout << "Esta andando: " << anda << endl;
cout << "Esta correndo: " << corre << endl;
cout << "Esta pegando: " << pega << endl;
cout << "Esta largando: " << larga << endl;
cout << "Esta atacando: " << ataca << endl;
}
};
C#
Arquivo #1 – Principal
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto {
class Program {
static void Main(string[] args) {
PersonagemPrimitivo Cidadao = new PersonagemPrimitivo();
Cidadao.nome = "Jim James";
Cidadao.classe = "Trabalhador";
Cidadao.andar (false);
Cidadao.correr(true);
Cidadao.largar(false);
Cidadao.pegar (true);
Cidadao.atacar(true);
Console.WriteLine("Status ------>>>> ");
Console.WriteLine("O personagem:" + Cidadao.nome);
Console.WriteLine("Classe: " + Cidadao.classe);
Cidadao.mostraPersonagem();
Console.ReadKey();
}
}
}
Arquivo #2 – Interface
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
{
interface Acao {
void pegar(Boolean pega);
void largar(Boolean larga);
void andar(Boolean anda);
void correr(Boolean corre);
void atacar(Boolean ataca);
}
}
Arquvio #3 – Classe Personagem Primitivo
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
{
class PersonagemPrimitivo : Acao
{
private Boolean pega = false;
private Boolean larga = false;
private Boolean anda = false;
private Boolean corre = false;
private Boolean ataca = false;
public String nome;
public String classe;
public void pegar(Boolean pega)
{
this.pega = pega;
}
public void largar(Boolean larga)
{
this.larga = larga;
}
public void andar(Boolean anda)
{
this.anda = anda;
}
public void correr(Boolean corre)
{
this.corre = corre;
}
public void atacar(Boolean ataca)
{
this.ataca = ataca;
}
public void mostraPersonagem()
{
Console.WriteLine("Esta andando: " + anda);
Console.WriteLine("Esta correndo: " + corre);
Console.WriteLine("Esta pegando: " + pega);
Console.WriteLine("Esta largando: " + larga);
Console.WriteLine("Esta atacando: " + ataca);
}
}
}
Ricardo Mantovani
Desenvolvimento Código Aberto 