Desenvolvimento Código Aberto

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);
        }
    }
}