Criação de Classes e Objetos

No post sobre o Paradigma Orientado a Objetos, vimos qual era a idéia por trás de classes e objetos:

  • A classe encapsula em um único lugar dados e as funções que atuam sobre esses dados; ela representa uma abstração. No exemplo dado, a classe representava a abstração aluno. Em outras palavras, ela representa a coleção dos possíveis alunos existentes em nosso sistema.
  • Já o objeto representa um indivíduo de uma determinada classe (coleção). No exemplo dado, criamos um objeto (ou instância) da classe aluno cujos dados serão informados pelo usuário. Também é com os objetos que “conversamos”, ou seja, enviamos mensagens. No exemplo, “pedimos” para o aluno calcular a sua média e verificar se ele passou. Em outras palavras, enviamos a mensagem calculaMedia() e a mensagem verificaSePassou().

Neste post, vamos ver como é feita a construção de classes e qual a nomenclatura que usamos nas suas diversas partes.

Para começar, vamos pegar o exemplo do último post:

[wptabs]
[wptabtitle]C#[/wptabtitle][wptabcontent]

[code language=”csharp”]
public class Aluno
{
public string nome;
public double p1, p2;

public double calculaMedia()
{
double media = (p1 + p2) / 2;

return media;
}

public bool verificaSePassou()
{
bool passou;

double media = calculaMedia();

if (media >= 7)
{
passou = true;
}
else
{
passou = false;
}

return passou;
}
}[/code]

[/wptabcontent]
[wptabtitle]Java[/wptabtitle][wptabcontent]

[code language=”java”]
public class Aluno {

public String nome;
public double p1, p2;

public double calculaMedia() {
double media = (p1 + p2) / 2;

return media;
}

public boolean verificaSePassou() {
boolean passou;

double media = calculaMedia();

if (media >= 7) {
passou = true;
} else {
passou = false;
}

return passou;
}

}[/code]

[/wptabcontent]
[/wptabs]

No código, vemos que, para definir uma classe, usamos as palavras reservadas public e class seguida do nome que queremos para a nossa classe. Além disso, usamos chaves para delimitar o seu conteúdo. Observações importantes:

  • Nos exemplos que estão no outro post, não colocamos o public na frente de class porque criamos a classe Aluno junto com uma outra classe que representa o nosso algoritmo principal, chamada Program, essa sim com o public na frente. E, em Java, não podemos ter duas classes públicas no mesmo arquivo. Em C# é possível, mas é interessante seguirmos esse padrão.
  • Em nossos exercícios, iremos criar um arquivo para cada classe e, assim, é importante que coloquemos o public para que ela possa ser acessada em outros lugares do sistema. Especialmente em Java, o nome do arquivo deve ser igual ao da classe pública que ele contém. Assim, se criamos uma classe chamada Aluno, ela deve estar em um arquivo chamado Aluno.java. Em C# isso não é necessário, mas, da mesma forma que no ponto anterior, é interessante seguirmos esse padrão.

Continuando, uma vez que declaramos a existência da classe, colocamos em seu interior (dentro das chaves) as variáveis que constituem os dados da abstração em questão; no nosso caso, os dados do aluno: o nome dele e as notas de duas provas. No Paradigma Orientado a Objetos, essas variáveis se chamam atributos. Em alguns textos, os nomes campos e propriedades também são usados.

Também podemos ver que colocamos as funções que trabalham com aqueles dados dentro da classe. O que muda em relação ao Paradigma Procedimental é que:

  • Não colocamos a palavra reservada static. Iremos ver o que o static faz em outro post.
  • E não precisamos mais passar os dados como entrada para as funções, uma vez que eles já estão disponíveis dentro da classe.

No Paradigma Orientado a Objetos, as funções que estão dentro das classes são chamadas de métodos.

Modelagem de Sistemas

Toda vez que vamos desenvolver um sistema, temos que pensar no problema que estamos resolvendo e levar para dentro do computador as peças que compõem esse problema. Essa atividade chama-se modelagem. No exemplo dado, estamos modelando um aluno dentro do sistema. Estamos vendo quais os dados e algoritmos que precisamos para calcular sua média e verificar se ele passou ou não.

No Paradigma Orientado a Objetos, mais que em outros, a modelagem se aproxima muito do mundo real, pelo fato de “traduzirmos” os objetos que existem em nosso dia-a-dia para objetos do sistema.

Em termo de modelagem, os atributos de uma classe representam as características do objeto que estamos modelando (nome, notas, situação, endereço, etc.). Também podemos dizer que eles representam o estado do objeto, pois indicam como o objeto está em determinado momento da execução do nosso sistema.

Por outro lado, os métodos de uma classe representam as ações que o objeto que estamos modelando é capaz de realizar (calcular média, verificar se passou, se matricular, etc.). Outro termo muito utilizado para indicar os métodos é comportamento.

E os objetos?

Uma vez que uma classe foi criada, podemos criar um ou mais objetos dessa classe. Isso se faz usando o comando new seguido do nome da classe da qual queremos criar o objeto seguido de (). Assim, para criarmos um objeto da classe Aluno, usamos o comando new Aluno()

Uma vez que esse objeto é criado, precisamos de uma variável para armazená-lo (iremos ver, mais para frente, que, na verdade, armazenamos uma referência para ele). Para criarmos uma variável, usamos o comando que já estamos acostumados: tipo do dado que queremos seguido do identificador da variável. Ou seja, para criarmos uma variável que irá armazenar um objeto da classe Aluno, fazemos Aluno aluno, onde aluno (com ‘a’ minúsculo) é o identificador.

Só falta atribuirmos para o comando ficar completo: Aluno aluno = new Aluno();

Uma vez que temos uma variável com um objeto criado, podemos enviar mensagens para ela por meio do operador . (ponto). O comando fica: nome da variável seguido de . (ponto) seguido da mensagem. O envio de uma mensagem é, na verdade, a chamada (execução) de um método. Assim, se a classe Aluno tem o método calculaMedia(), podemos enviar essa mensagem para um objeto dessa classe e ele irá nos “responder” com o valor da média calculada. No nosso caso, o comando completo fica: aluno.calculaMedia()

Resumindo, no exemplo do post anterior vimos cada uma dessas etapas:

[code language=”csharp”]
// Criação da variável e do objeto:
Aluno aluno = new Aluno();

// Preenchimento dos dados (futuramente iremos fazer isso de forma bem diferente):
aluno.nome = …
aluno.p1 = …
aluno.p2 = …

// Envio de mensagens (chamada de métodos):
double media = aluno.calculaMedia();

// Envio de outra mensagem
if (aluno.verificaSePassou()) {

}
[/code]

Um Paralelo com Banco de Dados

Para quem está aprendendo ou já conhece um pouco de banco de dados, vale fazer um paralelo:

[table id=”5″/]

Por favor, isso é apenas um paralelo, uma forma de começar a entender o Paradigma Orientado a Objetos por meio de uma outra coisa que você já sabe. De maneira nenhuma uma classe é uma tabela, etc. Certo? 😉

UML

A UML (Unified Modelling Language) é uma linguagem que nos permite conversar sobre classes e outros assuntos ligados à modelagem de sistemas por meio de diagramas. Um dos diagramas mais conhecidos é o Diagrama de Classes. Nele, uma classe é representada por meio de um retângulo dividido em três partes: na primeira parte fica o nome da classe, na segunda ficam seus seus atributos e, na terceira, seus métodos. Dessa forma, a nossa classe Aluno ficaria assim, em UML:

[wptabs]
[wptabtitle]C#[/wptabtitle][wptabcontent]

Classe em UML (C#)

Exemplo de uma classe em UML (tipos de dados do C#)

[/wptabcontent]
[wptabtitle]Java[/wptabtitle]

Classe em UML (Java)

Exemplo de uma classe em UML (tipos de dados do Java)

[wptabcontent]
[/wptabcontent]
[/wptabs]

Note que o símbolo “+” é colocado na frente dos atributos e métodos para indicar que eles são públicos. E, que os tipos são colocados após “:” (dois-pontos).


Antes de terminar esse post, gostaria de dar uma palavrinha sobre convenções de nomes: cada linguagem possui uma forma padrão convencionada de escrever os nomes de suas classes, atributos, métodos, variáveis, etc. Assim, é bom seguir esse padrão para que o código fique mais legível. Nas linguagens que adotamos, o estilo de nomes é o chamado Camel Case em que, quando um nome tem mais de uma parte, a primeira letra pode ser maiúscula ou minúscula, dependendo do caso, e as demais partes ficam com a primeira letra em maiúscula. Exemplo: AlunoDeMestrado, telefoneResidencial, etc.

A tabela abaixo mostra como deve ser a primeira letra:

[table id=”6″/]

Essas são apenas algumas das convenções. Conforme formos avançando em outros tópicos, a gente vê as convenções pertinentes.

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *