Uma das formas de se projetar objetos de software é pensar em suas responsabilidades. Essas responsabilidades podem se tratar de um pequeno objeto a uma divisão macro do sistema.
Essas responsabilidades devem descrever o que um objeto deve fazer e o que o deve saber.

História do dia-a-dia

Suponhamos que você tenha que entregar um relatório para seu chefe sobre uma fórmula química de um produto de limpeza. Mas você não conhece nada de química.
Fácil, não é?
Você delega esta atividade a um químico, para que ele escreva o relatório da fórmula química para você.
Pronto, sem mistério ou complicação.

Atribuindo responsabilidade

O desenvolvimento de software deve ser tão fácil quando a história acima.
As responsabilidades devem ser atribuídas aos objetos que tem a informação necessária para satisfazer as responsabilidade.
Vejamos o modelo seguinte, qual é o melhor objeto para informar a quantidade de tomadas de um quarto?

Sabemos que o Quarto tem conhecimento das suas paredes, e que cada Parede tem o conhecimento da quantidade de suas suas tomadas.
Desta forma a melhor solução para aplicamos a responsabilidade de obter a quantidade de tomadas é através do objeto Quarto, que delega a cada Parede que informe sua quantidade de tomada. Assim a quantidade total de tomadas é a soma das tomadas presente em cada parede.

O método TotalTomadas() do objeto Quarto:

1
2
3
4
5
6
7
8
9

public int TotalTomadas()
{
     int ret = 0;
     foreach(Parede parede in paredes)
     {
          ret += parede.GetQtdTomadas();
     }
     return ret;
}

Para melhorar ainda mais esse trabalho, podemos criar um objeto chamado Paredes que estenda o Array (Collection) de paredes presente no objeto quarto, e criarmos um método GetTomadas() que faça o trabalho da soma das tomadas.
Assim, a nossa lista de Paredes presente no objeto Quarto ficaria com a responsabilidade de obter o total de tomadas de cada item interno e somá-los.
Desta forma o método TotalTomadas() fica assim:

1
2
3
4

public int TotalTomadas()
{
     return paredes.GetTomadas();
}

O método GetTomadas() do objeto Paredes:

1
2
3
4
5
6
7
8
9

public int GetTomadas()
{
     int ret = 0;
     foreach(Parede parede in this)
     {
          ret += parede.GetQtdTomadas();
     }
     return ret;
}

Isso nos permite reaproveitar código, pois se no projeto existisse objetos como Galpão, Prédio, etc. Poderíamos utilizar o mesmo objeto Paredes para ambos (dependendo do contexto), pois certamente, Galpão e Prédio têm paredes. Assim estaríamos evitando a duplicação de código e facilitando sua manutenção.

Várias pessoas ainda se confundem ou não sabem diferenciar o que é uma classe, um objeto ou instância.

Resumidamente podermos dizer que:

Classe é o molde de um objeto.

Objeto é a instância de uma classe.

E instância é uma classe inicializada e alocada na memória do computador.

Classe

A classe é um tipo pré definido pelo usuário. Ela é um molde da representação de um objeto existente na vida real.

Quando codificamos uma classe, atribuímos a ela as características e funções do objeto na vida real, sendo que as características são representadas pelos atributos (o que o objeto contém) e funções pelos seus métodos (o que o objeto faz).

Exemplo de uma classe em C#.NET:

Exemplo de uma classe em Java:

Objeto

Para se criar um objeto é necessário inicializá-lo. Fazemos isso por meio do operador new que invoca o construtor da classe a ser instanciada. Com isso podemos ter múltiplos objetos da mesma classe, cada um assumindo sua característica.

Imagina a classe Carro descrita acima. No mundo real existem vários carros de várias marcas. Representamos isso no código por meio da criação (ou instanciação) de vários objetos.

Exemplo da criação de vários objetos em C#.NET:

Exemplo da criação de vários objetos em Java:

Observações:

Em C#, a palavra reservada new pode ser usada como um operador ou um modificador.

• new operador – usado para criar um objeto invocando o construtor.
• new modificador – usado para esconder um membro herdado de uma classe base.

Instância

A instância é a representação da classe durante a execução do programa, pois a classe é a especificação do objeto, ela não pode ser utilizada diretamente.

São as instâncias que permitem o funcionamento do programa através das modificações de atributos e execuções dos métodos. Um objeto existente durante o tempo de execução de um programa é uma instância de uma classe.

Este blog surgiu a partir da idéia de criar algo onde pudesse documentar meus conhecimentos sobre programação. Nele escreverei artigos sobre o que estou aprendendo ou já aprendi. O objetivo principal é proporcionar uma troca de experiência, sendo um canal aberto para receber sugestões, dúvidas e críticas.

Os principais assuntos que quero abordar são:

• Características e sintaxe das linguagens de programação como C#.NET, Java, PHP, ASP.NET, JavaScript e outras que podem me apresentar curiosidade.
• Ambientes de desenvolvimento (IDE – Integrated Development Environment) para utilização das linguagens descritas, como o Visual Studio para C#.NET, Eclipse ou NetBeans para Java, Aptana para PHP, dentre outras tecnologias utilizadas para desenvolvimento.
• Conceitos e técnicas de desenvolvimento utilizando Orientação a Objetos (O.O.) e UML.
• E conceitos e técnicas de banco de dados nas tecnologias SqlServer, Oracle e PostgreSQL.
• Também escreverei sobre ferramentas que nos auxiliam nas atividades relacionadas à programação como o Trac no gerenciamento de projeto, Subversion no controle de versão, entre outros. Mas não é o foco principal nem meu forte no momento. No entanto, conforme for aprendendo sobre o assunto será também documentado.