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

O que é API?

Application Programming Interface (ou Interface de Programação de Aplicativos) é um conjunto de rotinas e padrões estabelecidos por um software para a utilização das suas funcionalidades por aplicativos que não pretendem envolver-se em detalhes da implementação do software, mas apenas usar seus serviços.

De modo geral, a API é composta por uma série de funções acessíveis somente por programação, e que permitem utilizar características do software menos evidentes ao utilizador tradicional.

Por exemplo, programas de desenho geométrico possuem uma API específica para criar automaticamente gráficos geométricos de acordo com padrões definidos pelo utilizador.

Introdução a API

Uma linguagem de programação é um método padronizado para comunicar instruções para um determinado hardware. As grandes empresas de tecnologia desenvolvem hardware e também desenvolvem linguagens de programação para que seu hardware possa ser controlado de um modo mais fácil e amigável do que linguagem de maquina.

Como a evolução do hardware as linguagens de programação também foram evoluindo, empresas começaram a disputar tecnologia de desenvolvimento de novos hardwares e esta historia é recheada de brigas por suas respectivas patentes, um exemplo de grandes disputas judiciais entre empresas que escrevem linguagens de programação foi a Oracle x Google, a  Oracle detentora das patentes do Java  e a Google criadora do sistema operacional Android, que usa Java (API) como parte do seu sistema operacional e base para a programação de softwares da plataforma Android.

• A maioria os softwares voltados para desenvolvedores possuem sua própria API.
• As APIs são usualmente específicas para uma determinada tecnologia.
•  Um framework pode ser baseado em várias bibliotecas de aplicação e  várias APIs.
• Uma API também pode ser uma implementação de um protocolo.
• Uma API pode ser desenvolvida para um grupo restrito de utilizadores, ou ela pode ser liberada para o público.
•  A prática de publicação de APIs permitiu comunidades na web criar uma arquitetura aberta para a partilha de conteúdos e dados entre as comunidades e aplicações.
• A Microsoft tem mostrado um forte compromisso com uma API compatível com versões anteriores, especialmente dentro de sua biblioteca API do Windows (Win32).
• A Microsoft tornou as APIs Microsoft Windows publicas.
• A Apple lança suas APIs Carbon e Cocoa, para que softwares possam ser escrito para suas plataformas.
• A Sony faz de suas API oficiais para PlayStation disponível apenas para desenvolvedores PlayStation licenciados.

Tipos de APIs – Coleções

Existem vários tipos de APIs, neste post especificamente vamos utilizar APIs chamadas de Containers ou Collections, estas APIs fornecem varias funções para se criar uma coleção de objetos e manipula-los de forma enumerada. A Coleção mais famosa no mundo da orientação a objeto é pertencente a biblioteca para C++ chamada STANDARD TEMPLATE LIBRARY, as coleção pertencentes ao JCF (Java Collection Framework) ou Generic Collections (.NET Framework) foram baseadas na STL para C++.

Diferenças entre APIs

Aqui vamos programar com uma API Java que possui sua equivalência na linguagem C++, mas não possui equivalência na linguagem .NET C#, para usar esta API em desenvolvimento Windows é necessário usar a própria API Java(Oracle), usando a linguagem J#, que permite usar Java na plataforma .NET. Para C# usaremos uma API compatível.

.NET J#: http://msdn.microsoft.com/en-us/library/aa986696(v=vs.80).aspx

Utilizando API

TreeSet  – Java

Uma classe que representa um conjunto classificado de elementos. Os elementos são classificados usando o comparador fornecido através de construtor ou usando os métodos de interface comparáveis ​​implementadas pelos elementos.

Pacote: java.util

set  – C++

O conjunto de classe container STL é usado para o armazenamento e recuperação de dados de uma coleção em que os valores dos elementos contidos são únicos e servem como os valores de chave de acordo com a qual os dados são automaticamente ordenados. O valor de um elemento em um conjunto não pode ser alterado diretamente. Em vez disso, você deve excluir valores antigos e inserir elementos com novos valores.

Include: <set>

SortedList – C#

Representa uma coleção de pares de chave / valor que são classificados por chaves e são acessíveis por chave e por índice.

Namespace: System.Collections

Exemplo:

Neste exemplo utilizaremos três APIs diferentes em linguagens diferentes para criar o mesmo programa, uma lista ordenada de bandas de rock dos anos 60, fica como nota, que a linguagem C# não possui uma API equivalente então vamos utilizar uma outra API compatível,  Para usar a API equivalente em .NET é necessário utilizar a linguagem J# que utiliza as patentes da Oracle.

Java

package org.desenvolvimentoaberto;

import java.util.TreeSet;

  public class Arvore {

  public static void main(String[] args) {

  TreeSet<String> paradas = new TreeSet<>();

  paradas.add("Beatles");
  paradas.add("Rolling Stones");
  paradas.add("The Doors");
  paradas.add("Jefferson Airplane");
  paradas.add("The Who");

  System.out.println("TOP " +  paradas.size() + " Anos 60");
  System.out.println();

  System.out.println("Primeiro Lugar: " + paradas.first());

  System.out.println("Ultimo Lugar: " + paradas.last());
  System.out.println();

  System.out.println("Cai uma posição: " + paradas.last());

  paradas.remove(paradas.last());  paradas.add("Beach Boys");

  System.out.println("Sobe " + paradas.size() + " posições: " + paradas.first());
  System.out.println();

  System.out.println("Paradas Anos 60:");

  for (String s : paradas)
  {
     System.out.println(s);
  }
 }
}

C++

#include "stdafx.h"
#include <iostream>
#include <string>
#include <set>

using namespace std;

int _tmain(int argc, _TCHAR* argv[]) {

  set <string> paradas;
  set <string>::iterator primeiroI;
  set <string>::iterator ultimoI;
  set <int>::size_type quantidadeI;

  paradas.insert("Beatles");
  paradas.insert("Rolling Stones");
  paradas.insert("The Doors");
  paradas.insert("Jefferson Airplane");
  paradas.insert("The Who");

  primeiroI = paradas.begin();
  ultimoI = paradas.end();
  ultimoI--;
  quantidadeI = paradas.size();

  cout << "TOP " << quantidadeI << " Anos 60" << endl;  cout << endl;
  cout << "Primeiro Lugar: " << *primeiroI << endl;
  cout << "Ultimo Lugar: " <<  *ultimoI << endl;

  cout << endl;

  ultimoI = paradas.end();
  ultimoI--;

  cout << "Cai uma posicao: " << *ultimoI << endl;

  paradas.erase(*ultimoI);
  paradas.insert("Beach Boys");

  primeiroI = paradas.begin();
  quantidadeI = paradas.size();

  cout << "Sobe " << quantidadeI << " posicoes: " << *primeiroI << endl;
  cout << endl;

  cout << "Paradas Anos 60:" << endl;

  for (auto i : paradas)
  {
   cout << i << endl;
  }

  system("pause");
  return 0;
 }

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;

namespace DesenvolvimentoAberto {

class Program
{
  static void Main(string[] args)
  {
    SortedList paradas = new SortedList();

    paradas.Add("Beatles","");
    paradas.Add("Rolling Stones","");
    paradas.Add("The Doors","");
    paradas.Add("Jefferson Airplane","");
    paradas.Add("The Who","");

    Console.WriteLine("TOP " +  paradas.Count + " Anos 60");
    Console.WriteLine();

    Console.WriteLine("Primeiro Lugar: " + paradas.GetKey(0));
    Console.WriteLine("Ultimo Lugar: " + paradas.GetKey(paradas.Count -1));
    Console.WriteLine();

    Console.WriteLine("Cai uma posição: " + paradas.GetKey(paradas.Count - 1));

    paradas.Remove(paradas.GetKey(paradas.Count - 1));

    paradas.Add("Beach Boys","");

    Console.WriteLine("Sobe " + paradas.Count + " posições: " +  paradas.GetKey(0));
    Console.WriteLine();

    Console.WriteLine("Paradas Anos 60:");

    for (int i = 0; i < paradas.Count; i++)
    {
       Console.WriteLine(paradas.GetKey(i));
    }

    Console.ReadKey();
   }
  }
}

Escopo refere-se à vida e acessibilidade de uma variável. Quão grande é o alcance depende de onde uma variável é declarada. Por exemplo, se uma variável é declarada na parte superior de uma classe, ela será acessível a todos os métodos de classe. Se for declarada num método, em seguida, só pode ser utilizada em tal método.

O escopo de uma variável é a parte do programa que pode acessar uma variável. Quando você tenta acessar uma variável que não está no escopo, você normalmente tém um erro do compilador. Aqui estão algumas das regras de escopo:

1. Variáveis ​​de classe (campos estáticos) estão no escopo em todos os lugares na classe.
2. Se uma variável de classe é declarada “pública”, está no escopo em todas as classes.
3. As variáveis ​​de instância (campos não-estáticos) estão no escopo em métodos não estáticos chamados em um objeto apropriado.
4. As variáveis ​​e parâmetros locais estão no escopo apenas dentro do método que os declarou.

Exemplo:

Neste exemplo veremos o alcance do escopo das variáveis estáticas, publicas e privadas em sua classe. Na classe principal vemos o resultado do escopo utilizado na classe planeta.

As variáveis privadas podem ser utilizadas somente dentro da classe planeta, a variável publica pode ser utilizada por todas as classes ou neste caso pelo objeto, a variável estática é utilizada globalmente e não precisa ser instanciada, todos os objeto que você criar, ou seja outros planetas irão compartilhar os dados desta variável, as variáveis locais criadas dentro do construtor só podem ser utilizadas dentro do método em que foi criada.

Criamos o objeto da classe planeta chamado Marte, experimente criar outros objetos com nome de planetas e imprima seus valores.

Java

Classe #1 – Principal

public class principal {

public static void main(String[] args)
  {
      Planetas marte = new Planetas(3.0, 1.5, 6.419e23);

      marte.apelido = "Marte";

      System.out.println("Quantidade de planetas: " + Planetas.numeroDePlanetas);
      System.out.println("Nome do Planeta: " + marte.apelido);
      System.out.println("As outras variaveis da classe não podem ser alcançadas devido ao escopo");
      System.out.println("mas podem ser utlizadas dentro da classe");
  }
 }
 

Classe #2 – Planetas

public class Planetas {

 // Variavel da classe é compartilhada por todos
 public static long numeroDePlanetas;

 // Variavel de intancias
 private double x, y;
 private double massa;
 public String apelido;

      // Construtor
      //  x e y são  variaveis instanciadas,
      //  mas newX and newY são variaveis locais
      //  O construtor incrementa o valor
    public  Planetas(double novoX, double novoY, double novaMassa)
    {
       x = novoX;
       y = novoY;

       massa = novaMassa;
       numeroDePlanetas++;
    }
}

C#

Classe #1 – Principal

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication53  {
      class Program
      {
          static void Main(string[] args)
          {
              Planetas marte = new Planetas(3.0, 1.5, 6.419e23);

              marte.apelido = "Marte";

              Console.WriteLine("Quantidade de planetas: " + Planetas.numeroDePlanetas);
              Console.WriteLine("Nome do Planeta: " + marte.apelido);
              Console.WriteLine("As outras variaveis da classe não podem ser alcançadas devido ao escopo");
              Console.WriteLine("mas podem ser utlizadas dentro da classe");

              Console.ReadKey();
          }
      }
  }

Classe #2 – Planetas

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication53 {

public class Planetas {

         // Variavel da classe é compartilhada por todos
          public static long numeroDePlanetas;

         // Variavel de intancias
          private double x, y;
          private double massa;
          public String apelido;

          // Construtor
          //  x e y são  variaveis instanciadas,
          //  mas newX and newY são variaveis locais
          //  O construtor incrementa o valor

          public Planetas(double novoX, double novoY, double novaMassa)
          {
              x = novoX;
              y = novoY;

              massa = novaMassa;
              numeroDePlanetas++;
          }
    }
} 

C++

Classe #1 – Principal

#include "stdafx.h"
#include <iostream>
#include <string>
#include "planetas.h"

using namespace std;

int _tmain(int argc, _TCHAR* argv[])  {

   Planetas marte(3.0, 1.5, 6.419e23);

   marte.apelido = "Marte";

   cout << "Quantidade de planetas: " << marte.numeroDePlanetas << endl;
   cout << "Nome do Planeta: " << marte.apelido << endl;
   cout << "As outras variaveis da classe não podem ser alcançadas devido ao escopo" << endl;
   cout << "mas podem ser utlizadas dentro da classe" << endl;

   system("pause");

   return 0;
}

Classe #2 – Planetas

#include "stdafx.h"
#include <iostream>
#include <string>

using namespace std;

class Planetas {

private:
    // Variavel de intancias
     double x, y;
     double massa;

public:

     // Variavel de intancias
     string apelido;

     // Variavel da classe é compartilhada por todos
     static int numeroDePlanetas;

     // Construtor
     //  x e y são  variaveis instanciadas,
     //  mas newX and newY são variaveis locais
     //  O construtor incrementa o valor

  Planetas(double novoX, double novoY, double novaMassa)
  {
    x = novoX;
    y = novoY;

    massa = novaMassa;
    numeroDePlanetas++;
   }
};

  int Planetas::numeroDePlanetas;