Objetos – Mutable, Reference, Return, Aliasing – Garbage Collector – Java, C++ e C#

Publicado: 1 de março de 2014 em C#, C/C++, Java

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;
         }
    }
 }
Anúncios

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair /  Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair /  Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair /  Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair /  Alterar )

Conectando a %s