Desenvolvimento Código Aberto

Programação orientada a objetos apela em vários níveis. Para os gestores, que promete um desenvolvimento e manutenção mais rápido e mais barato. Para analistas e designers, o processo de modelagem torna-se mais simples e produz um design claro e gerenciável.

Para os programadores, a elegância e clareza do modelo de objeto e do poder de ferramentas e bibliotecas orientadas a objetos faz programação de uma tarefa muito mais agradável, e programadores experimentam um aumento na produtividade. Todo mundo ganha, ao que parece.

Se há um lado negativo, é à custa da curva de aprendizado. Pensar em objetos é uma dramática partida de pensar processualmente, e o processo de criação de objetos é muito mais desafiador do projeto processual, especialmente se você está tentando criar objetos reutilizáveis​​.

A abordagem orientada a objetos dá um passo mais longe, fornecendo ferramentas para o programador representar elementos no espaço do problema. Esta representação é geral o suficiente para que o programador não é fique restrito a qualquer tipo particular de problema.

Objetos são mutáveis

Você pode alterar o conteúdo de um objeto, fazendo uma atribuição a uma de suas variáveis de instância.

Você pode escrever métodos que retornam objetos. Observe que você pode usar a palavra chave NEW para criar um novo objeto, e logo em seguida usar o RESULT (resultado) como valor de retorno.

Modificando objetos, passando-os como argumentos para métodos podem ser úteis, mas também pode tornar a depuração mais difícil, porque nem sempre são claras as invocações que o método faz ou não para modificar seus argumentos. Mais tarde, vamos discutir alguns prós e contras deste estilo de programação.

Passando e Retornando Objetos

Em programação orientada a objetos é possível criar métodos passando um objeto e retornando um objeto.

Alias de Objetos

Quando dois objetos referem-se ao mesmo objeto. Em outras palavras, este objeto tem dois nomes, Objeto1 e Objeto2. Quando uma pessoa usa dois nomes, é chamado de aliasing. A mesma coisa com os objetos. Quando duas variáveis são alias, todas as mudanças que afetam uma variável também afetara a outra.

Null

Quando você cria uma variável de objeto, lembre-se que você está criando uma referência a um objeto. Até você fazer variável apontar para um objeto, o valor da variável é nulo. null é um valor especial e uma palavra-chave que significa: nenhum objeto.

Garbage collector

Se ninguém se refere a um objeto, então ninguém pode ler ou gravar qualquer dos seus valores, ou chamar um método nele. Em efeito, ele deixa de existir. Poderíamos manter o objeto na memória, mas seria apenas um espaço de resíduos, assim como o seu programa é executado periodicamente, o sistema procura por objetos encalhados e tenta recupera-los, em um processo chamado de coleta de lixo. Posteriormente, o espaço de memória ocupado por o objeto estará disponível para ser utilizado como parte de um novo objeto. Você não tem que fazer nada para fazer a coleta de lixo acontecer, e em geral você não vai estar ciente disso. Mas você deve saber que é periodicamente executado em segundo plano.

Objetos e Primitivos

Existem dois tipos diferentes, tipos primitivos e tipos de objetos. primitivos, como int e boolean começam com letras minúsculas; tipos de objetos começam com letras maiúsculas. Esta distinção é útil porque nos lembra algumas das diferenças entre eles:

Quando você declara uma variável primitiva, você tem espaço de armazenamento para um valor primitivo. Quando você declara uma variável de objeto, você tem um espaço para uma referência a um objeto.

Se você não inicializar um tipo primitivo, é dado um valor padrão a ele que depende de cada tipo primitivo.

Variáveis primitivas são bem isoladas, no sentido de que não há nada você possa fazer em um método que vai afetar uma variável em outro método.

Há uma outra diferença entre primitivos e tipos de objetos. Você não pode adicionar novos primitivos, mas você pode criar novos tipos de objetos.

Exemplo:

Neste exemplo criamos dois objetos de classes distintas e usamos algumas técnicas de manipulação de objetos, como: métodos de referencias ao objeto, retorno de objetos, aliasing de objetos.

Java

Classe #1 – Principal

public class Objetos
 {
  public static Pontos achaCentro (Retangulo ret)
  {
   int rx = ret.x + ret.largura/2;
   int ry = ret.y + ret.altura/2;
   return new Pontos(rx,ry);
  }
 public static void main(String[] args)
 {

      // Instancia objeto
      Pontos pontos = new Pontos (10,15);
      Retangulo ret1 = new Retangulo (pontos.x, pontos.y, 150, 200);
      System.out.println("Objeto1:" + ret1.objeto());

      // Objetos são Mutaveis
      ret1.altura = 300;
      ret1.largura = 400;
      System.out.println("Objeto1:" + ret1.objeto());

      // Aliasing
      Retangulo ret2 = new Retangulo();
      ret2 = ret1;
      System.out.println();
      System.out.println("Aliasing:");
      System.out.println("Objeto2:" + ret2.objeto());
      ret1.altura = 100;
      ret1.largura = 200;
      System.out.println();
      System.out.println("Alterando Objeto1 e afetendo Objeto2");
      System.out.println("Objeto2:" + ret2.objeto());

      // passando e retornando objetos
      //  achando o centro do retangulo
      Pontos coordenadas = new Pontos();
      coordenadas =  achaCentro(ret1);
      System.out.println();
      System.out.println("Centro do Retangulo:");
      System.out.println("coordenada X=" + coordenadas.x);
      System.out.println("coordenada Y=" + coordenadas.y);
  }
}

Classe #2 – Pontos

public class Pontos {

public int x = 0;
public int y = 0;

Pontos ()
{
}

Pontos (int x, int y)
{
this.x = x;
this.y = y;
}
}

Classe #3 – Retangulo

public class Retangulo extends Pontos
{
      public int altura = 0;
      public int largura = 0;
   Retangulo ()
  {
  }
   Retangulo(int x, int y, int altura, int largura)
  {
   this.x = x;
   this.y = y;
   this.altura = altura;
   this.largura = largura;
  }

    public String objeto ()
  {
   String resultado = "x=" + x + " y=" + y + " altura=" + altura + " largura="+ largura;
   return resultado;
  }
}

C++

Arquivo – Principal

#include "stdafx.h"
#include <iostream>
#include <string>
#include "Retangulos.h"
using namespace std;

static Pontos achaCentro(Retangulo& ret)
 {
  int rx = ret.x + ret.largura / 2;
  int ry = ret.y + ret.altura / 2;
  return  Pontos(rx, ry); }

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

  Pontos pontos(10, 15);

  Retangulo ret1 (pontos.x, pontos.y, 150, 200);

  cout << "Objeto1:" + ret1.objeto() << endl;

  // Objetos são Mutáveis

  ret1.altura = 300;
  ret1.largura = 400;

  cout << "Objeto1:" + ret1.objeto() << endl;

  // Aliasing

  Retangulo ret2;

  ret2 = ret1;

  cout << endl;  cout << "Aliasing:" << endl;
  cout << "Objeto2:" << ret2.objeto() << endl;

  ret1.altura = 100;
  ret1.largura = 200;

  cout << endl;  cout << "Alterando Objeto1 e afetendo Objeto2" << endl;
  cout << "Objeto2:" + ret2.objeto() << endl;

  // passando e retornando objetos
  //  achando o centro do retângulo

  Pontos coordenadas ;
  coordenadas = achaCentro(ret1);

  cout << endl;  cout << "Centro do Retangulo:" << endl;
  cout << "coordenada X=" << coordenadas.x << endl;
  cout << "coordenada Y=" << coordenadas.y << endl;

  system("pause");

  return 0;
 }

Arquivo – pontos.h

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;

class Pontos
 {
 public:
  int x = 0;
  int y = 0;

  Pontos()
  {  }

  Pontos(int x, int y)
  {
   this->x = x;   this->y = y;
  }
 };

Arquivo – retângulo.h

#include "stdafx.h"
#include <iostream>
#include <string>
#include "Pontos.h"
using namespace std;

class Retangulo : public  Pontos
 {
 public:
  int altura = 0;
  int largura = 0;

  Retangulo()
  {  }

  Retangulo(int rx, int ry, int altura, int largura)
  {
   x = rx;   y = ry;
   this->altura = altura;
   this->largura = largura;
  }

  string objeto()
  {
     string resultado = "x=" + to_string(x) + " y=" + to_string(y)  + " altura="
                     + to_string(altura) + " largura=" + to_string(largura);   return resultado;
  }

};

C#

Classe #1 – Program

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

namespace DesenvolvimentoAberto
 {
     class Program
     {
         public static Pontos achaCentro(Retangulo ret)
         {
             int rx = ret.x + ret.largura / 2;
             int ry = ret.y + ret.altura / 2;
             return new Pontos(rx, ry);
         }
         static void Main(string[] args)
         {
             // Instancia objeto
             Pontos pontos = new Pontos (10,15);
             Retangulo ret1 = new Retangulo (pontos.x, pontos.y, 150, 200);
             Console.WriteLine("Objeto1:" + ret1.objeto());

            // Objetos são Mutaveis
            ret1.altura = 300;
            ret1.largura = 400;
            Console.WriteLine();
            Console.WriteLine("Mutando Objetos:");
            Console.WriteLine("Objeto1:" + ret1.objeto());

           // Aliasing
           Retangulo ret2 = new Retangulo();
           ret2 = ret1;

           Console.WriteLine();
           Console.WriteLine("Aliasing:");
           Console.WriteLine("Objeto2:" + ret2.objeto());
           ret1.altura = 100;
           ret1.largura = 200;

           Console.WriteLine("Alterando Objeto1 e afetendo Objeto2");
           Console.WriteLine("Objeto2:" + ret2.objeto());

           // passando e retornando objetos
           //  achando o centro do retangulo
           Pontos coordenadas = new Pontos();
           coordenadas =  achaCentro(ret1);

          Console.WriteLine();
          Console.WriteLine("Centro do Retangulo:");
          Console.WriteLine("coordenada X=" + coordenadas.x);
          Console.WriteLine("coordenada Y=" + coordenadas.y);
          Console.ReadKey();
         }
     }
 }

Classe #2 – Pontos

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

{
      public class Pontos
     {
         public int x = 0;
         public int y = 0;

         public Pontos()
         {
         }

         public Pontos(int x, int y)
         {
             this.x = x;
             this.y = y;
         }
     }
 }

Classe #3 – Retangulo

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
 {
     public class Retangulo : Pontos
     {
         public int altura = 0;
         public int largura = 0;

         public Retangulo()
         {
         }

         public Retangulo(int x, int y, int altura, int largura)
         {
             this.x = x;
             this.y = y;
             this.altura = altura;
             this.largura = largura;
         }

         public String objeto()
         {
             String resultado = "x=" + x + " y=" + y + " altura=" + altura + " largura=" + largura;
             return resultado;
         }
    }
 }

Um Stream pode ser definido como um fluxo de dados em um sistema computacional. Quando um arquivo é aberto para edição, todo ele ou parte dele fica na memória, permitindo assim alterações, por isto somente quando ele é fechado, tem-se a garantia de que nenhum dado se perderá ou será danificado.

Quando um arquivo é carregado na memória para ser editado, esta carga ocorre num fluxo “stream“, ou seja, byte a byte até o carregamento total do arquivo.

Stream

• Lê um byte após o outro, um byte é apenas um número.
• Os dados sobre o seu disco rígido é armazenado em bytes.
• Bytes podem ser interpretados como caracteres, números e etc.

Byte

Um byte (Binary Term), baite ou octeto, é um dos tipos de dados integrais em computação. É usado com frequência para especificar o tamanho ou quantidade da memória ou da capacidade de armazenamento de um certo dispositivo, independentemente do tipo de dados.

A codificação padronizada de byte foi definida como sendo de 8 bits. O byte de 8 bits é mais comumente chamado de octeto no contexto de redes de computadores e telecomunicações.

Instruções

FileReader (java) é para a leitura de streams dos caracteres.

ifstream (C++) define um fluxo a ser utilizado para ler dados de caracteres de byte único em série a partir de um arquivo.

StreamReader (C#) é usado para ler linhas de informações de um arquivo de texto padrão.

Exemplos:

Neste exemplo  vamos criar um stream para ler o arquivo chamado Leiame.txt.

Texto –  Leiame.txt

Desenvolvimento Aberto.

Input/Output (Entrada/saída)

é um termo utilizado quase que exclusivamente no ramo da computação (ou informática),
indicando entrada (inserção) de dados por meio de algum código ou programa,
para algum outro programa ou hardware, bem como a sua saída (obtenção de dados) ou retorno de dados,
como resultado de alguma operação de algum programa, consequentemente resultado de alguma entrada.

Java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class Bytes
 {

public static void main(String[] args) throws IOException
  {
   FileReader fr = new FileReader("./src/Leiame.txt");
   BufferedReader br = new BufferedReader(fr);
   String line = null;
   try
   {
    while ((line = br.readLine()) != null)
    {
       System.out.println(line);
    }
   }
   catch (IOException e)
   {
      e.printStackTrace();
   }
   br.close();
  }
 }

C++

#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
 {
  string linha;
  ifstream arquivo("C:/Desenvolvimento Aberto/Leiame.txt");
  if (arquivo.is_open())
  {
   while (getline(arquivo, linha))
   {
    cout << linha << endl;
   }
   arquivo.close();
  }

  else cout << "Erro ao abrir o arquivo.";

  system("pause");
  return 0;
 }

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
namespace DesenvolvimentoAberto
 {
     class Program
     {
         static void Main(string[] args)
         {

             try
             {
                 StreamReader sr = new StreamReader("C:/Desenvolvimento Aberto/Leiame.txt");
                 String line = sr.ReadToEnd();
                 Console.WriteLine(line);
                 sr.Close();
             }
             catch (Exception e)
             {
                Console.WriteLine( e.StackTrace);
             }

             Console.ReadKey();
         }
     }
 }

A Classe Exception, representa os erros que ocorrem durante a execução de aplicativos.

Um erro de aplicativo é um erro de tempo de execução que não pode necessariamente ser evitado escrevendo um código livre de erros.

Erros de tempo de execução podem ocorrer por uma variedade de razões. No entanto, nem todos os erros devem ser tratados como exceções em seu código.

Em alguns casos, um erro de programa pode refletir uma condição de erro esperada ou de rotina. Neste caso, você pode querer evitar o uso de tratamento de exceção para lidar com o erro do programa.

Em outros casos, um erro de programa reflete uma condição de erro inesperado que pode ser manipulado em seu código. Por exemplo, mesmo que você tenha verificado para garantir que existe um arquivo, ele pode ser excluído antes que você possa abri-lo, ou ele pode estar corrompido.

A falha do sistema é um erro de tempo de execução que não podem ser tratada por meio de programação de uma maneira significativa. Por exemplo, qualquer método pode lançar uma exceção OutOfMemory se o Runtime é incapaz de alocar memória adicional

Um modelo de tratamento de exceção que se baseia a representação de exceções como objetos, e a separação de código de programa e o código de tratamento de exceções em blocos TRY e blocos CATCH. Pode haver um ou mais blocos catch, cada um projetado para lidar com um determinado tipo de exceção, ou um bloco projetado para capturar uma exceção mais específica que outro bloco.

Exemplo:

Neste exemplo criamos uma classe para nosso erro herdada da classe Exception(Java, C++ e C#) e usamos o comando Try…Catch para manipular o erro e exibir uma mensagem mais amigável para o usuário.

Java

Classe #1 – Principal

public class Principal
 {
  static double saldo = 0.0;
  static void saque (double valor) throws MinhaExcecao
  {
   if ( valor <= saldo )
   {
    saldo -= valor;
   }
   else
   {
    double insuficiente = valor - saldo;
    throw new MinhaExcecao(insuficiente);
   }
  }
  public static void main(String[] args)
  {
   // Efetua Um deposito na conta
   System.out.println("Deposito de: R$ 500,00");
   saldo = 500.00;

   // Tenta efetuar um saque
   try
   {
    System.out.println("Saque de: R$ 1000,00");
    saque(1000.00);
   }
   catch (MinhaExcecao erro)
   {
    System.out.println("Desculpe mas seu pedido ultrapassa o saldo em: "
                       + erro.pegaValor() );

    // Imprime conteudo do erro
    erro.printStackTrace();
   }
}
}

Erro

public class MinhaExcecao extends Exception

{
  private  double valor;
  public  MinhaExcecao ( double valor )
  {
   this.valor = valor;
  }

  public double pegaValor ( )
  {
   return valor;
  }
}

C++

Programa – Principal

#include "stdafx.h"
#include <iostream>
#include <exception>
#include "minhaexcecao.h"

using namespace std;

static double saldo = 0.0;

static void saque(double valor)
 {
  if (valor <= saldo)
  {
   saldo -= valor;
  }
  else
  {
   double insuficiente = valor - saldo;
   throw  MinhaExcecao(insuficiente);
  }
 }

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

  // Efetua Um deposito na conta
  cout << "Deposito de: R$ 500,00" << endl;
  saldo = 500.00;

  // Tenta efetuar um saque
  try
  {
   cout << "Saque de: R$ 1000,00" << endl;   saque(1000.00);
  }
  catch (MinhaExcecao erro)
  {
   cout << "Desculpe mas seu pedido ultrapassa o saldo em: "    <<  erro.pegaValor() << endl;
  }
  system("pause");
  return 0;
 }

Erro – (.h)

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

using namespace std;

class MinhaExcecao : public exception
 {
private:

        double valor;

public:
    MinhaExcecao(double valor)
  {
   this->valor = valor;
  }

  double pegaValor()
  {
   return valor;
  }
 };

C#

Classe #1 – Principal

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

namespace DesenvolvimentoAberto
 {
     class Program
     {
         static double saldo = 0.0;
         static void saque (double valor)
         {
            if ( valor <= saldo )
            {
               saldo -= valor;
            }
            else
            {
               double insuficiente = valor - saldo;
               throw new MinhaExcecao(insuficiente);
             }
          }

         static void Main(string[] args)
         {
             // Efetua Um deposito na conta
             Console.WriteLine("Deposito de: R$ 500,00");
             saldo = 500.00;

             // Tenta efetuar um saque
             try
             {
               Console.WriteLine("Saque de: R$ 1000,00");
               saque(1000.00);
             }
             catch (MinhaExcecao erro)
             {
               Console.WriteLine("Desculpe mas seu pedido ultrapassa o saldo em: "
                                  + erro.pegaValor() );

               // Imprime conteudo do erro
               Console.WriteLine(erro.StackTrace);
             }

             Console.ReadKey();
            }
     }
 }

Classe #2 – Erro

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

namespace DesenvolvimentoAberto
 {
     class MinhaExcecao : Exception
     {
         private double valor;

         public MinhaExcecao(double valor)
         {
             this.valor = valor;
         }

         public double pegaValor()
         {
             return valor;

         }
     }
 }

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