Desenvolvimento Código Aberto

Iterator

Em português iterador, é um objeto que permite a um programador examinar uma coleção ou container. Vários tipos de iteradores são frequentemente fornecidos através de uma interface de container. Apesar da interface e semântica de um determinado iterador serem fixas, iteradores são frequentemente implementados em termos de estruturas subjacentes a uma implementação de container e são muitas vezes ligados intimamente ao container para permitir a semântica operacional do iterador.

Observe que um iterador percorre e também dá acesso aos elementos de dados em um container, mas não realiza iteração (isto é, não sem alguma liberdade significativa tomada com este conceito ou com uso trivial da terminologia). Um iterador é tem um comportamento semelhante a um cursor de banco de dados. Iteradores datam da linguagem de programação CLU de 1974.

Collection

É uma coleção, às vezes chamada de um recipiente(container), é simplesmente um objeto que agrupa vários elementos em uma única unidade. Coleções são usadas ​​para armazenar, recuperar, manipular e comunicar dados agregados, ou seja uma coleção é um objeto que contém outros objetos, existem outras coleções com diferentes capacidades.

Historicamente, o quadro de coleções têm sido bastante complexo, o que lhes deu uma reputação de ter uma grande curva de aprendizagem. Os exemplos mais conhecidos de frameworks de coleções são o C ++ Standard Template Library (STL). A nomenclatura das APIs e suas sintaxes podem mudar de uma linguagem de programação para outra.

O framework de coleção e as suas APIs:

Collection é a raiz da hierarquia do conjunto. A coleção representa um grupo de objetos conhecidos como seus elementos.

A interface Collection é o mínimo denominador comum que todos os conjuntos implementam e é usado para passar coleções para manipular objetos quando generalidade máxima é desejada. Alguns tipos de coleções permitem elementos duplicados, e outros não.

• SET – Está diretamente relacionada com a ideia de conjuntos. Assim como um conjunto, as classes que implementam esta interface não podem conter elementos repetidos.
• List –  É uma coleção ordenada, pode conter valores duplicados, o controle da posição de cada elemento é acessado pelo seu índice.
• Queue: é uma lista tipo FIFO (First-In-First-Out), também conhecida como fila.
• Map: é uma lista de relação de chave-valor entre os elementos. Cada chave pode conter apenas um único valor associado.(um mapa não é uma coleção verdadeira).

Exemplos:

Neste exemplo criamos uma collection do tipo List e a alimentamos com nomes de musicas dos Beatles, usamos o iterator para navegar no dentro dos objetos da coleção como cursores de banco de dados, registro a registro, e os alteramos manualmente, fator que as coleções não permitem por default.

Java

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Iterador
 {

 public static void main(String[] args)
 {
      List<String> colecao = new ArrayList<String>();

   // musicas dos Beatles
   colecao.add("Let it be");
   colecao.add("Dont let me down");
   colecao.add("Come togheter");
   colecao.add("Hey Jude");
   colecao.add("Twist and shout");

   // Usa iterator como um cursor de banco de dados
   Iterator<String>  iterador =  colecao.iterator();

   System.out.println("Cinco musicas dos Beatles:\n");

   while (iterador.hasNext())
   {
     Object item = iterador.next();
     System.out.println(item);
   }

   // Usa iterador como o result de um banco de dados.
   ListIterator<String>  iteradorLista = colecao.listIterator();

   // Update - altera lista
   while (iteradorLista.hasNext())
   {
     Object item = iteradorLista.next();
     iteradorLista.set("Beatles: " + item);
   }

   //Lista a coleção

   System.out.println("\nIverte a ordem da coleção:\n");
   while (iteradorLista.hasPrevious())
   {
     Object item = iteradorLista.previous();
     System.out.println(item);
   }
 }
}

C++

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

int _tmain(int argc, _TCHAR* argv[])
 {
  list<string> colecao;

  colecao.push_back("Let it be");
  colec}ao.push_back("Dont let me down");
  colecao.push_back("Come togheter");
  colecao.push_back("Hey Jude");
  colecao.push_back("Twist and shout");

  // Usa iterator como um cursor de banco de dados
  list<string>::const_iterator
  inicio(colecao.begin()),
  fim(colecao.end());

  list<string>::iterator altera;

  cout << "Cinco musicas dos Beatles:\n" << endl;
  for (; inicio != fim; ++inicio)
  {
   cout << *inicio << endl;
  }

// Usa iterador como o result de um banco de dados.
  // Update - altera lista
  for (altera = colecao.begin(); altera != colecao.end(); ++altera)
  {
    *altera =  "Beatles: " + *altera;
  }

  //Lista a coleção
  colecao.reverse();

  cout << "\nIverte a ordem da coleção:\n" << endl;

  for (altera = colecao.begin(); altera != colecao.end(); ++altera)
  {
   cout << *altera << endl;
  }
  system("pause");
  return 0;
 }

C#

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
 {
     class Program
     {
         static void Main(string[] args)
         {
             List<String> colecao = new List<String>();

        // musicas dos Beatles
       colecao.Add("Let it be");
       colecao.Add("Dont let me down");
       colecao.Add("Come togheter");
       colecao.Add("Hey Jude");
       colecao.Add("Twist and shout");

       // Usa iterator como um cursor de banco de dados
       Console.WriteLine("Cinco musicas dos Beatles:\n");
       foreach( string item in colecao)
       {
          Console.WriteLine(item);
       }

       // Usa iterador como o result de um banco de dados.
       // Update - altera lista
       int i = 0;
       while (i <= colecao.Count() -1)
       {
          colecao[i] = "Beatles: " + colecao.ElementAt(i);
          i = i + 1;
       }

       //Lista a coleção
       colecao.Reverse();
       Console.WriteLine("\nIverte a ordem da coleção:\n");
       foreach( string item in colecao)
       {
          Console.WriteLine(item);
       }
       Console.ReadKey();
}
    }
 }

Sim, está é a famosa palavra que traduzida para a língua inglesa da nome ao famoso filme Matrix onde as maquinas tomam conta do planeta terra escravizando a raça humana e a usando como fonte de energia. Mas ficção cientifica a parte, fica a pergunta,  o que é matriz?

Sinônimos de útero e mãe, na ciência da computação as matrizes são estruturas matemáticas organizadas na forma de tabela com linhas e colunas, utilizadas na organização de dados e informações. Nos assuntos ligados à álgebra, as matrizes são responsáveis pela solução de sistemas lineares.

Em C++ para utilizar matrizes dentro de classes é necessário alguns detalhes extras, o compilador Microsoft não permite inicializar arrays ou matrizes em uma classe fora do construtor, também possui regras sobre a ordem da declaração da matriz dentro da classe e requer a adição do parâmetro /c na hora da compilação. Para saber mais sobre o assunto use o link abaixo:

Compiler Error C2536: http://msdn.microsoft.com/en-us/library/9f53ks1w.aspx

Como C++ é uma linguagem hibrida e de paradigmas não é necessário utilizar objetos de classe e um código menor consegue obter um programa com o mesmo resultado que em Java e C#.

Exemplos:

Neste exemplo criaremos uma classe que contém uma matriz com as cartas do baralho. Em C++ teremos dois exemplos diferentes, o primeiro sem objetos de classe e o segundo com objetos de classe, mas não utilizando os requisitos da Microsoft.

Java

Classe #1 – Jogo

public class Jogo
 {

public static void main(String[] args)
{
  Cartas jogador1 =  new Cartas();

  // Cartas Disponiveis
  System.out.println("Naipes da Matriz");

  for (int naipes = 0; naipes <= jogador1.tNaipe()-1; naipes++ )
  {
    jogador1.jogaCartas(0, naipes);
  }

  System.out.println();
  System.out.println();
  System.out.println("Componentes da Matriz");

  for (int componentes = 0; componentes <= jogador1.tComponentes()-1; componentes++ )
  {
     jogador1.jogaCartas(1, componentes);
  }

  }
}

Classe #2 -Cartas

public class Cartas
{
private int naipe;
private int componetes;

private String cartas[][] =
{
{ "Paus",  "Ouros",  "Copas",  "Espadas", },
{ "Curinga", "As", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Valete", "Dama", "Rei" }

};

Cartas ()
{ }

Cartas (int naipe, int componentes)
{
this.naipe = naipe;
this.componetes = componentes;
}

public void jogaCartas(int naipe, int componentes)
{
System.out.print(cartas[naipe][componentes] + ", ");
}

public int tNaipe()
{
return this.cartas[0].length;
}

public int tComponentes ()
{
return this.cartas[1].length;
}
}

C#

Classe #1 – Jogo

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)
      {
       Cartas jogador1 =  new Cartas();

      // Cartas Disponiveis
      Console.WriteLine("Naipes da Matriz");

      for (int naipes = 0; naipes <= jogador1.tNaipe()-1; naipes++ )
      {
          jogador1.jogaCartas(0, naipes);
      }

      Console.WriteLine();

      Console.WriteLine();
      Console.WriteLine("Componentes da Matriz");

     for (int componentes = 0; componentes <= jogador1.tComponentes()-1; componentes++ )
      {
          jogador1.jogaCartas(1, componentes);
      }

      Console.ReadKey();
      }
    }
 }

Classe #2 -Cartas

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
 {
     public class Cartas
     {
      private int naipe;
      private int componetes;

         private string[][] cartas =
         {
             new string[]
             { "Paus",  "Ouros",  "Copas",  "Espadas", },

             new string[]

             { "Curinga", "As", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Valete", "Dama", "Rei" }
                                           };
      public Cartas ()
      { }

      public Cartas (int naipe, int componentes)
      {
       this.naipe = naipe;
       this.componetes = componentes;
      }

      public void jogaCartas(int naipe, int componentes)
      {
         Console.Write(cartas[naipe][componentes] + ", ");
      }

      public int tNaipe()
      {
         return this.cartas[0].Length;
      }

      public int tComponentes ()
      {
       return this.cartas[1].Length;
      }
   }
 }

C++

Arquivo #1:

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

using namespace std;

 const int tnaipe = 4;
 const int tcompo = 14;

const string cartas[tnaipe][tcompo] =
 {
  { "Paus", "Ouros", "Copas", "Espadas", },

  { "Curinga", "As", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Valete", "Dama", "Rei" }
 };

 void jogaCartas(int naipe, int componentes)
 {
  cout << cartas[naipe][componentes] << ", ";
 }

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

// Cartas Disponíveis

  cout << "Naipes da Matriz" << endl;

  for (int naipes = 0; naipes <= tnaipe - 1; naipes++)
  {
   jogaCartas(0, naipes);
  }

  cout << endl;  cout << endl;
  cout << "Componentes da Matriz" << endl;

  for (int componentes = 0; componentes <= tcompo - 1; componentes++)
  {
   jogaCartas(1, componentes);
  }

  cout << endl;  system("pause");
  return 0;
 }

C++ – exemplo 2

Arquivo #1 – Jogo

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

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

  cout << "Naipes da Matriz" << endl;

  for (int naipes = 0; naipes <= jogador1.tNaipe() - 1; naipes++)
  {
   jogador1.jogaCartas(0, naipes);
  }

  cout << endl;  cout << endl;
  cout << "Componentes da Matriz" << endl;

  for (int componentes = 0; componentes <= jogador1.tComponentes() - 1; componentes++)
  {
   jogador1.jogaCartas(1, componentes);
  }

  cout << endl;
  system("pause");

  return 0;
 }

Arquivo #2 – Classe Cartas (.h)

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

class Cartas
 {
 public:

  void jogaCartas(int naipe, int componentes)
  {
   cout << cartas[naipe][componentes] << ", " ;
  }

  int tNaipe()
  {
   return tnaipe;
  }

  int tComponentes()
  {
   return tcompo ;
  }

};

Arquivo #3 – da matriz  (.h)

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

const int tnaipe = 4;
const int tcompo = 14;

const string cartas[tnaipe][tcompo] =
 {
  { "Paus", "Ouros", "Copas", "Espadas", },

  { "Curinga", "As", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Valete", "Dama", "Rei" }
 };

Pure Function

Usa os objetos como argumentos, mas não os modifica. o valor de retorno é ou um primitivo ou um novo objeto criado dentro do método.

Um método é considerado uma função pura se o resultado depender apenas dos argumentos, e não ter efeitos colaterais, como modificar um argumento ou imprimir algo. O único resultado de chamar uma função pura é o seu valor de retorno.

Na transformação funcional pura, um conjunto de funções, chamadas funções puras, definem a forma de como transformar um conjunto de dados estruturados a partir de sua forma original para outra forma. A palavra “pura” indica que as funções são combináveis​​, que exige que elas sejam:

Auto-suficiente, de modo que elas podem ser livremente ordenada e rearranjada sem emaranhamento ou interdependências com o resto do programa. Transformações puras não têm conhecimento ou efeito sobre o meio ambiente. Ou seja, as funções utilizadas para a transformação não tem efeitos colaterais.

Sem mudança de estado, de modo que a execução da mesma função ou conjunto específico de funções na mesma entrada sempre resultará na mesma saída. Transformações puras não têm memória do seu uso anterior. Funções puras ajudar a gerenciar a complexidade dos grandes projetos.

Modifiers

Usa objetos como argumentos e modifica alguns elementos ou todos eles. Muitas vezes, retorna uma void. Um método modificador muda a forma como os objetos funcionam.

Fill-in

Um dos argumentos é um objeto vazio que é preenchido pelo método. Tecnicamente, este método também é um tipo de Modifier.

Melhores Praticas

É recomendado que você escreva funções puras sempre que for razoável, e recorra aos Modifiers e Fill-ins apenas se houver uma grande vantagem.

Métodos Modifiers e Fill-in  são eficientes porque eles não têm que criar novos objetos. Mas se torna mais difícil de isolar partes de um programa, e em grandes projetos podem causar erros que são difíceis de encontrar.

Em síntese estes conceitos passam a substituir a nomenclatura das funções e procedimentos das linguagens de programação procedural, por serem métodos integrantes de objetos e não mais procedimentos ou funções auto suficientes, porem ainda são estruturalmente iguais.

Exemplo:

Neste exemplo escrevemos três métodos diferentes: Pure function, Modifier e um fill-in, e manipulamos objetos utilizando estes métodos.

Java

Classe #1 – Principal

public class Metodos
 {

  // Método - Pure Function
  static boolean maxRet(Retangulo ret, int altura, int largura)
  {
     if ((ret.altura <= altura) && (ret.largura <= largura))
     {
         return true;
     }
   else
     {
        return false;
     }
  }

  // Método - Modifiers
  static void posicao(Retangulo ret, int x, int y)
  {
     ret.x = ret.x + x;
     ret.y = ret.y + y;
  }

  // Método - Fill-in
  static void modRet(Retangulo r1, Retangulo r2, Retangulo r3)
  {
     r1.x       =  r2.x      + r3.x;
     r1.y       =  r2.y      + r3.y;
     r1.altura  = r2.altura  + r3.altura;
     r1.largura = r2.largura + r3.largura;
  }

 public static void main(String[] args)
 {

   Retangulo ret1 = new Retangulo(50,50,200,300);
   Retangulo ret2 = new Retangulo(15,15,120,150);
   Retangulo ret3 = new Retangulo();
   ret1.imprimeRet();

   System.out.println("Retangulo está dentro do limite maximo:" + maxRet(ret1, 500, 600));
   System.out.println();
   System.out.println("Modifica posição do retangulo:");
   posicao(ret1, 20, 20);
   ret1.imprimeRet();

   System.out.println();
   System.out.println("Modifica tamanho do retangulo:");
   modRet(ret3, ret1, ret2);
   ret3.imprimeRet();
  }
}

Classe #2 – Retangulo

public class Retangulo
{
public int x;
public int y;
public int altura;
public int largura;

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 void imprimeRet()
 {
  System.out.println("X =" +  x +  " Y= " + y + " Altura="+ altura + " Largura=" + largura );
 }

}

C++

Classe #1 – Principal

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

static bool maxRet(Retangulo& ret, int altura, int largura)
{
  if ((ret.altura <= altura) && (ret.largura <= largura))
  {
     return true;
  }
  else
  {
     return false;
  }
}

 // Método - Modifiers
 static void posicao(Retangulo& ret, int x, int y)
 {
    ret.x = ret.x + x;  ret.y = ret.y + y;
 }

 // Método - Fill-in

 static void modRet(Retangulo& r1, Retangulo& r2, Retangulo& r3)
 {
    r1.x = r2.x + r3.x;
    r1.y = r2.y + r3.y;
    r1.altura = r2.altura + r3.altura;
    r1.largura = r2.largura + r3.largura;
 }

 int _tmain(int argc, _TCHAR* argv[])
 {
    Retangulo ret1 (50, 50, 200, 300);
    Retangulo ret2 (15, 15, 120, 150);
    Retangulo ret3 (0,0,0,0);
    ret1.imprimeRet();

    cout << "Retangulo está dentro do limite maximo:" << maxRet(ret1, 500, 600) << endl;

    cout << endl;
    cout << "Modifica posição do retangulo:" << endl;  posicao(ret1, 20, 20);
    ret1.imprimeRet();

    cout << endl;
    cout << "Modifica tamanho do retangulo:" << endl;  modRet(ret3, ret1, ret2);
    ret3.imprimeRet();

   system("pause");
   return 0;
 }

Classe #2 – Retangulo

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

using namespace std;

class Retangulo
{
 public:

  int x;
  int y;
  int altura;
  int largura;

  Retangulo()
  {  }

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

  void imprimeRet()
  {
     cout << "X =" << x << " Y= " << y << " Altura=" << altura << " Largura=" << largura << endl;
  }

};

C#

Classe #1 – Principal

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

namespace DesenvolvimentoAberto
 {
     class Program
     {
         // Método - Pure Function

         static Boolean maxRet(Retangulo ret, int altura, int largura)
         {
             if ((ret.altura <= altura) && (ret.largura <= largura))
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }

         // Método - Modifiers
         static void posicao(Retangulo ret, int x, int y)
         {
             ret.x = ret.x + x;
             ret.y = ret.y + y;
         }

         // Método - Fill-in

         static void modRet(Retangulo r1, Retangulo r2, Retangulo r3)
         {
             r1.x = r2.x + r3.x;
             r1.y = r2.y + r3.y;
             r1.altura = r2.altura + r3.altura;
             r1.largura = r2.largura + r3.largura;
         }

         static void Main(string[] args)
         {
             Retangulo ret1 = new Retangulo(50,50,200,300);
             Retangulo ret2 = new Retangulo(15,15,120,150);
             Retangulo ret3 = new Retangulo();

             ret1.imprimeRet();
             Console.WriteLine("Retangulo está dentro do limite maximo:" + maxRet(ret1, 500, 600));
             Console.WriteLine();

            Console.WriteLine("Modifica posição do retangulo:");
            posicao(ret1, 20, 20);
            ret1.imprimeRet();

           Console.WriteLine();
           Console.WriteLine("Modifica tamanho do retangulo:");
           modRet(ret3, ret1, ret2);
           ret3.imprimeRet();

           Console.ReadKey();
       }
     }
 }

Classe #2 – Retangulo

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

namespace DesenvolvimentoAberto
 {
     class Retangulo
     {
             public int x;
             public int y;
             public int altura;
             public int largura;

             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 void imprimeRet()
             {
                 Console.WriteLine("X =" +  x +  " Y= " + y + " Altura="+ altura + " Largura=" + largura );
             }
     }
 }

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;

         }
     }
 }