Orientação a Objetos - simples assim!

Antes de nos aventurarmos no universo dos Games ou da Web, precisamos conhecermos bem, alguns fundamentos básicos. A POO (Programação Orientada a Objetos) não é um paradigma ou conceito de desenvolvimento de software moderno.

Antes de nos aventurarmos no universo dos Games ou da Web, precisamos conhecermos bem, alguns fundamentos básicos. A POO (Programação Orientada a Objetos) não é um paradigma ou conceito de desenvolvimento de software moderno. Há algumas décadas esses conceitos existem, e aos poucos foram conquistando adeptos na Engenharia de Software. Esses adeptos são engenheiros de sistemas, programadores e analistas, preocupados com reusabilidade, legibilidade e uma significativa elevação no nível de abstração dos seus softwares.

Não é o foco desse artigo, entrar em detalhes históricos, nem mesmo fazer comparativos de tecnologias. Esse documento foi escrito especialmente para programadores ou curiosos que estejam estudando ou migrando para o mundo dos objetos. Trata-se de um artigo básico, técnico e prático. Programe seus objetos comparando com a vida real. Aparentemente isso é muito abstrato ou complicado a primeira vista. Mas estudaremos aqui, através de exemplos, como tornar essa analogia mais natural.

Bom, se você ainda está lendo, passou no filtro para o perfil de leitor desse artigo inicial. Vamos conceituar alguns tópicos, porém depois, faremos analogias , exemplos e exercícios de fixação com o intuito de deixar o mais claro possível. Afinal de contas, como diria um ex-professor meu, “nada na vida..., tudo é um exemplo” (Plácido, Unifor).

Classe

Nada mais é, do que a especificação do que um dia poderá vim a ser um objeto. Caaaaaaaaalma, vai já ficar bem claro num exemplo prático. Afinal de contas: “na prática a teoria é outra”.

Objeto

Trata-se da instância de uma classe. Ainda conto com sua paciência. Logo logo perceberás que isso é a coisa mais linda do mundo...

Nesse momento gostaria que você esquecesse por um minuto tudo que você sabe de programação. Tente. E isso não é simples, deletar (mas não com shift+del) sua experiência e vícios de linguagens de desenvolvimento de software. Além disso, um pouco de criatividade cairia bem:

Bom, vamos lá!

Imagine uma forma (molde) de bonecos de gessos. Pois bem, essa é nossa classe ou tipo, ou seja, define o formato, tamanho e diversos outros aspectos dos objetos fabricados, no caso, os bonecos de gesso. Percebeu a diferença? A classe é um molde para os objetos. Quando se diz: “Instância de uma classe ou tipo”, nada mais é do que o objeto dessa classe ou tipo.

Mundo Java
Molde Classe
Boneco de Gesso Objeto

O molde é sempre o mesmo, porém os objetos por ele gerados podem ter características das mais variadas, mas respeitando a estrutura básica do molde, ops!, da classe ou tipo.

Imagine um molde (classe ou tipo) de Samurai. Continue imaginando... Vamos, com esse molde, criar três objetos:

Samu1 Cor = Laranja Samu2 Cor = Rosa Samu3 Cor = Azul

Diz-se que, o samu1, samu2 e samu3 são objetos do tipo Samurai.

Observe que agora nossos pequenos objetos possuem característica, no caso, a cor. Mas poderíamos possuir várias outras, mais específicas, tais como, cor dos olhos, do cabelo, raça do indivíduo, etc. Tais características em OO (Orientação a Objetos) chamam-se atributos do objeto.

A tributos definem o estado do objeto em um determinado instante, por exemplo: Imagine um objeto do tipo Pessoa (é a classe ou tipo), com os seguintes atributos: corOlhos, corCabelo, sexo e tipoSanguineo. Então assuma também que os valores para esses atributos são respectivamente: azuis, preto, feminino e tipo A. Bom, nunca se sabe quando uma mulher vai trocar a cor do cabelo, mas podemos, nesse instante, assumir que o estado para esse objeto é (azuis, preto, feminino e tipo A) porém se amanhã tiver um casamento ou uma festa na agenda desse nosso objeto :), muito provavelmente seu estado será alterado, na cor do cabelo (corCabelo) ou mesmo dos olhos (corOlhos), nunca se sabe! Machismo a parte, o fato é, se um ou vários atributos forem alterados, diz-se que seu estado também foi.

Ok! Até agora, espero que estejam bem claros os seguintes conceitos:

Existe ainda, mais um detalhe interessante e bastante importante sobre objetos, que gostaria de explicar antes de “cairmos matando” no código.

Lembre-se da classe Pessoa citada anteriormente, pois bem, além dos atributos, os objetos dessa classe também possuem comportamentos, tais como: andar, dormir, acordar, etc. Esses comportamentos, em OO, chamam-se métodos.

Resumindo:

Agora vamos deixar um pouco as analogias de lado e pôr em prática (Projeto Piloto) o que aprendemos, porém, antes, precisamos definir algumas regras de sintaxe do Java, tais como:

Então...comecemos do começo:

Os tipos primitivos (não são classes) correspondem a dados mais simples (não são objetos) e independem da plataforma a qual “rodará”. Logo mais tudo ficará bem claro. Basta, por hora, entendermos quais são esses tipos e quais os valores que assumem:

Tipos Primitivos Descrição
boolean Poderão assumir os valores TRUE (verdadeiro) ou FALSE (falso).
byte Nesse caso, o domínio é o universo dos números INTEIROS. O que difere um dos outros é o limite desse número. Portanto o byte terá como valor máximo, 127, o short, 32.767 e cada qual com seu limite MAXIMO.
short
int
long
float Contemplam os números em notação de ponto flutuante normalizada em precisão simples. Em outras palavras: Os números decimais.
double
char Serve para a armazenagem de dados alfanuméricos (somente um caractere), que por sua vez são representados por inteiros.
Obs1.: Observe que todo tipo primitivo possui a primeira letra em minúsculo.Obs2.: Existe uma série de particularidades (“largura”, classificação, etc.) relacionadas a cada tipo desses, no entanto gostaria de abstraí-las do leitor por motivos didáticos. Na hora certa a gente “arrocha o nó”. ?

O que é variável e referência?

Relembre o conceito de objetos.

Agregue a esse conceito, o fato de que todo objeto criado ficará armazenado em memória principal, ou seja, a sua memória RAM.

Agora imagine: Como eu poderia acessar esse objeto? Quando falamos em acesso, nos referimos a poder acessá-lo de modo a alterar seu estado ou invocar um determinado comportamento desse objeto. Isso é possível graças as referencias, pois elas possuem um ponteiro (espécie de link) ao objeto em memória. Como isso seria em programação?

As variáveis têm a mesma funcionalidade, no entanto não apontam (ou não referenciam) objetos, e sim possuem um tipo primitivo.

Existem dois conceitos aqui: Declaração e Inicialização.

Veja como declaramos, em Java, uma variável chamada idade do tipo inteiro:

int idade;

Simples não?

Sempre seguirá esse padrão: primeiro o tipo, que pode ser um tipo primitivo ou um tipo de referência (classe), depois o nome da referencia ou variável.

Aqui um exemplo de declaração de uma referencia:

Samurai samu1;

Samurai é o tipo da referência, e samu1 é o nome dessa referencia;

A Inicialização, como o próprio nome já nos dá uma dica, nada mais é do que inicializar essa variável ou referência com alguma coisa, por exemplo:

int idade; Idade = 26;

Observe que para inicializarmos uma variável ou referencia, precisamos, antes, declará-la.

Podemos, ainda, em uma mesma linha declarar e inicializar ao “mesmo tempo”. É apenas uma maneira diferente de fazer a mesma coisa:

int idade = 26;

E para referencia?

Simples, veja a seguinte linha de comando. Lembre-se do tipo antes exemplificado: Samurai:

Samurai samu1 = new Samurai();

Explicando:

Essa é a maneira de instanciarmos (ou criarmos em memória) um objeto do tipo Samurai e ao “mesmo tempo” amarrá-lo a uma referência também do mesmo tipo, ou seja, diz-se que samu1 referencia esse objeto criado.

Primeiro vêem a tipo (Samurai) da referência, depois o nome da referência (samu1), depois o operador de atribuição (=), logo em seguida o operador de “instanciação” (new) e por ultimo, a chamada do construtor da classe do objeto que estamos criando (Samurai()). Abstraia-se, por enquanto, do que seria o construtor.

Nem sempre o “computador” executará os comandos da esquerda pra direita, assim como lemos. Nesse caso a primeira coisa a ser executada é o comando new Samurai(), o qual fará com que um objeto do tipo Samurai seja criado (ou instanciado) em memória, logo em seguida, esse objeto é atribuído a referencia samu1 (Samurai samu1 =), essa por sua vez será seu elo (do programador) de acesso ao objeto criado, pois é através dela, que poderemos manipular esse objeto.

Observe que, por convenção, toda classe em Java, vêem com a primeira letra em maiúsculo: Samurai

Preparando o ambiente para pôr a mão na massa.

Como criar uma classe?

Como ainda não utilizamos IDE, vamos usar o bloco de notas para fazermos nossa primeira classe.

  1. Crie a seguinte estrutura de pastas c:\projetos\hello. Abra o bloco de notas
  2. Vamos criar a classe Samurai. Para isso digite no bloco de notas:
public class Samurai {}

Pronto!!! Salve dentro de c:\projetos\hello com o nome Samurai.java, pois precisa ter o mesmo nome da Classe.

  1. Agora precisamos gerar o bytecode, ou seja, o binário do java (.class), arquivo que será interpretado (“executado”)
  2. No windows, vá em ‘iniciar’ -> ‘executar’ -> digite cmd. O Prompt será exibido.
  3. Vá em c:\projetos\hello.
  4. Digite dir. Será exibida, uma lista contendo os arquivos dessa pasta. Até o momento deverá constar somente o Samurai.java.
  5. Digite o comando para compilar do Java javac Samurai.java. Nesse momento você observará, se der outro dir, que um novo arquivo foi criado, o Samurai.class.

Parabéns a classe Samurai foi corretamente criada. É claro que ainda não acrescentamos, a ela, nenhuma funcionalidade. Por enquanto somente temos uma classe vazia.

Resumindo: O que aprendemos até agora:

Veremos a partir deste momento tópicos bastante importantes, tais como:

Inicialmente faremos um breve overview (visão geral) sobre OO, utilizando para isso a classe String. Dessa forma, além de revisarmos alguns conceitos, também aprenderemos um pouco mais sobre a famosa String. Conceitos tais como: operadores, construtores, coletor de lixo, wrapper class, modificadores, etc. Depois implementaremos uma classe contendo atributos e métodos, com o objetivo de criamos um pequeno projeto didático que chamamos de projeto piloto. Após mais algumas definições, amadureceremos nosso projeto piloto de forma a utilizar conceitos importantíssimos no universo OO, tais como: Herança, Override, Overload, classes concretas e abstratas, interfaces e polimorfismo.

O foco desse artigo não é abordar o uso de IDEs - Integrated Development Environment ou em português, ambiente integrado para desenvolvimento de softwares. Uma breve bibliografia sobre esse assunto foi abordada no capítulo anterior.

É importante que você tenha lido o artigo anterior, pois vou utilizar bastante, durante esse documento, a frase: “... no artigo anterior...” :)

String como desculpa para estudarmos construtores, objetos...

Lembra-se dos tipos primitivos mencionados no artigo anterior? Pois bem, ainda dentro desse contexto, lembra-se de um tipo chamado char? Bom, se a resposta é NÃO para as duas perguntas, vou refrescar sua memória.

Resumidamente o tipo char pode armazenar um caractere de cada vez, tal caractere é representado por um código na tabela ASCII - American Standard Code for Information Interchange é um conjunto de códigos para o computador – por exemplo:

Digamos que possuímos a seguinte variável do tipo char:

char letra;

Agora vamos atribuir um valor:

letra = ‘a’;

Observe que atribuímos uma letra entre aspas simples, é assim que se faz com char. Nos bastidores, essa variável letra armazena um valor inteiro, no caso do a (minúsculo) esse valor em decimal é 97.

Todo esse blá blá sobre char foi para agregar valor a uma frase que citarei agora, porém é claro, precisamos melhorá-la, no entanto, para efeitos didáticos, por hora basta: “String nada mais é do que um conjunto de CHARs”, ou seja, em vez de somente um caractere, poderei ter vários, exemplo: “I Love Java”.

String não é um tipo primitivo, e sim, uma classe, dentre tantas outras que acompanha o Java, por isso, inicia com letra maiúscula. E como toda classe, essa também possui seu estado e comportamentos, ou seja, respectivamente, atributos e métodos.

Lembra-se da analogia de classe e objeto? Uma classe é um molde ou forma de bonecos de gesso, e os bonecos em si, são os objetos!

Como uma classe é um molde do objeto, esse molde precisa prover uma forma de criamos seus objetos. Essa forma é através dos construtores que nada mais são do que métodos, com duas diferenças: o construtor é um método com o mesmo nome da classe e não possui retorno.

Bom, podemos observar que String é uma classe como outras, que possui construtores, atributos e métodos.

Se quisermos criar um objeto do tipo – molde -String, precisaremos utilizar o construtor desse molde, pois somente assim poderemos instanciar objetos desse tipo.

String autor = new String(“Fabio Santiago”);

Observe que diferentemente de char, String utiliza aspas duplas. Outra grande diferença quando se cria objetos, utiliza-se o operador new. Em seguida chama-se o construtor dessa classe. No caso, o construtor recebe um parâmetro do tipo String. “Fabio Santiago” é o parâmetro nesse caso.

Pronto, agora temos um objeto em memória referenciado por autor, confirme mostra a Figura 1.

Figura 1 – Referência e Objeto.

Outra maneira de fazermos a mesma coisa é assim:

String autor = “Fabio Santiago”;

Objetos String são os únicos em Java que podem ser criados sem o operador new, pois seu esse objeto é tão usado que os implementadores de Java disponibilizaram uma forma mais simples de instanciar objetos String. Mas quando você cria um objeto String dessa forma (String autor = “Fabio Santiago”;) implicitamente (nos bastidores) o compilador está fazendo isso: String autor = new String(“Fabio Santiago”);

Outra coisa importante que você precisa saber, é que objetos String são imutáveis, ou seja, seu estado é inalterável. Lembrando o objeto Pessoa que citamos no artigo anterior, podíamos, a qualquer momento, alterar seu estado, ou melhor, seus atributos, por exemplo: esse objeto tem um atributo chamado corCabelos, que por sua vez podemos alterar para loiros, moreno, etc. Na classe String isso não é possível. No exemplo que citamos agora, o objeto referenciado por autor não pode sofrer alteração no seu conteúdo, ou seja, onde tem o texto “Fabio Santiago” será eterno enquanto esse objeto “viver”, jamais esse conteúdo se modificará.

Você pode perguntar, e se eu fizer isso:

String autor = “Chuck Norris”;

Bom, como vimos, implicitamente isso ocorrerá assim: autor = new String(“Chuck Norris”). Ou seja, estaremos criando outro objeto, conforme mostrado na Figura 2.

Figura 2. Redirecionando referência

Observe que não alteramos o valor do objeto, o que fizemos, na realidade, foi criar um outro objeto em memória e apontar nossa referência autor a esse objeto. Perceba também que o objeto antigo ficou sem referência, ou seja, está “solto” na memória. Para casos como esses, o Java possui um recurso chamado “coletor de lixo” conhecido por Garbage Collection, o qual se responsabiliza de, eventualmente e isso é imprevisível, coletar da memória, objetos desnecessários.

A classe String também é final. Isso significa que nenhuma outra classe poderá herdá-la. Logo vamos comentar sobre herança. Mas voltando ao final, essa palavrinha poderá vim em:

Byte, Short, Integer, Long, Float, Double, Boolean, Character são conhecidas como Wrapper Class, elas representam os tipos primitivos: byte, short, int, long, float, double, boolean e char, respectivamente. Observe que classes possuem a primeira letra em maiúsculo.

Mas por que se chamam Wrapper Class e o que fazem? Depois, paciência! Por hora, basta saber quais são.

Quanto aos critérios: Imutável e Final, as Wrapper Class são iguais a classe String.

Outra coisa: A classe String também é public. O que é isso?

Seguinte, existem quatro tipos de modificadores de acesso:

Quando se fala em elemento, esse pode ser uma classe, método e até mesmo membros de instância ou de classe.

Tenha bastante paciência nesse momento, quando fizermos nosso projeto piloto você começará a entender tudo!

Resumindo, oque aprendemos até agora:

Projeto Piloto Ainda parafraseado um prezado professor de faculdade: “Nada na vida, tudo é um exemplo”.

Bom, até aqui temos bagagem suficiente para começamos nosso pequeno grande projeto.

Projeto: Sistema Bancário - $Bufunfa ®

Requisitos do projeto:

RF1 Permitir cadastro de contas.
O sistema possuirá um modelo de conta bancária (Poupança e Conta Corrente) a ser mantido (CRUD – Create, Read, Update e Delete, em português: cadastro :). O modelo de conta será representado pelo seu número de conta. Toda conta ao ser criada, seu número deverá ser informado.
RF2 Possibilitar Saques e Depósitos nas contas.
Toda Conta poderá sofre saques e/ou depósitos
RF3 Permitir geração de rendimentos para Conta Poupança.
A conta poupança sofrerá acréscimos de juros sobre seu saldo em períodos determinados.
RF4 Conta Corrente terá um saque diferenciado.
A Conta Corrente sofrer um desconto de CPMF a cada saque.
RF5 A Conta possuirá um responsável.
Toda Conta possuirá um titular único.
RF6 Possibilitar transferência entre contas
Uma conta poderá transferir uma determinada quantia à outra conta.

RF = Requisito Funcional (Listagem das funcionalidades do sistema)

Dado os requisitos do Bufunfa ®, vamos colocar a mão na massa. Porém nossa metodologia de desenvolvimento será a la Jack. Jack? É... O Jack Estripador, ou seja: “vamos por PARTES”.

Vamos criar um projeto chamado Bufunfa e um Package (pacote) chamado br.com.fw3, o qual conterá nossa classes.

O que é Package?

Nada mais é do que uma estrutura de pastas para organizar o projeto, ou seja, quando decidimos criar nossas classes no package br.com.fw3, na verdade se trata de uma pasta chamada br. Dentro dela uma outra chamada com, e adivinha quem está dentro de com? Exato, uma outra pasta chamada fw3. Quando dizemos que nossa Classe Conta está no pacote br.com.fw3, queremos dizer que ela está dentro da pasta fw3, que por sua vez está dentro da pasta com e... Já sacou né?

Quando criamos um Package utilizando uma IDE como o Eclipse, NetBeans, etc, essa por sua vez cria automaticamente essa estrutura de pasta, você nem precisa se preocupar com isso.

Criando o Projeto

A primeira coisa é criar o projeto. Vou explicar como se faz isso usando o Eclipse. Caso você já saiba ou está usando outra IDE, pule direto para a parte: Modelando a Classe Conta.

Criando o Pacote

  1. Clique com o botão direito do mouse sobre o projeto Bufunfa (na paleta Package Explorer) que você acabou de criar e escolha, no menu que aparece, a opção New >> Package;
  2. Aparecerá, nesse momento, uma janela chamada New Java Package, com um campo Name, digite: br.com.fw3 e clique em Finish.

Bom, nesse momento seu Eclipse deve está mais ou menos conforme mostrado na Figura 3.

Figura 3. Eclipse – Criando Projeto e Package

Modelando a Classe Conta

Construtor

Segundo o RF1 (Requisito Funcional 1) do Bufunfa, toda Conta ao ser criada, seu número deverá ser informado. Isso significa que deveremos ter um construtor assim:

Esse Construtor atende (contempla) parcialmente o RF1. Por que parcialmente? Por que mais funcionalidade são necessárias para contemplar o RF1 em sua totalidade. Obs.: Construtor não tem retorno.

Atributos

Revisão: Atributos de Instância são aqueles que definem o estado do objeto. O Próprio nome já diz, pois se chama atributo de instância ou objeto, ou seja, são atributos particulares a cada objeto.

Conforme definido nos requisitos de sistema, a classe Conta terá os seguintes atributos de instância:

Métodos

Os comportamentos do objeto são definidos pelos métodos:

A classe conta citada é mostrada na Figura 4, utilizando o Diagrama de Classe da UML (Unified Modeling Language) para representá-la graficamente.

Não é pré-requisito para esse artigo o conhecimento de UML, no entanto sugiro fortemente que estude, pois se trata de uma linguagem gráfica para sistemas amplamente utilizada no mundo inteiro, sem concorrências.

Figura 4. Diagrama de Classe (UML) de Conta

Observe que um sinal de menos (-) antecede os atributos. Isso significa que esses atributos são private, ou seja, somente serão “visíveis” por essa classe.

É sempre uma boa prática (mas não é uma regra) criar os atributos como private e disponibilizar seu acesso através de métodos. Isso se chama encapsulamento. Muita calma nesse momento... Tenha paciência, tudo começará a ficar claro num futuro breve. Afinal de contas, como diria Jack: “... por partes”, certo?

O mesmo acontece com os métodos, porém é um sinal de mais (+). Isso significa que os métodos são public.

Programando...

Agora, FINALMENTE, vamos codificar a classe Conta.

Se você está utilizando o eclipse faça assim:

  1. Basta clicar com o botão direito do mouse sobre o pacote no qual deseja criar a classe Conta, no caso é o br.com.fw3, e escolher, no menu que aparece, a opção new >> class.
  2. Aparecerá uma Janela chamada: New Java Class. Digite em Name: Conta. Esse campo representa o nome da classe.
  3. Desmarque a opção ‘public static void main(String[] args)’. Depois você entenderá melhor isso.
  4. Clique em Finish.

Nesse ponto temos o seguinte código:

package br.com.fw3; public class Conta { }

Agora vamos criar os atributos de Conta:

package br.com.fw3; public class Conta { private int numeroConta; private String titular; //representa o saldo atual dessa conta private double saldo; }

Pronto, esses são nossos atributos de instância.

Essas linhas com // são comentários. São úteis para explicar partes do código, assim torna-se mais organizado e legível. Esses comentários são ignorados pelo compilador, ou seja, tudo que estiver depois (na mesma linha) de // não será interpretado como código.

Agora vamos definir os comportamentos, ou seja, os métodos, conforme nossos requisitos e diagrama de classe:

package br.com.fw3; public class Conta { private int numeroConta; private String titular; //representa o saldo atual dessa conta private double saldo; //saca o valor da conta e retorna true se operação bem sucedida public boolean sacar (double valor) { } //deposita o valor na conta e retorna true se operação bem sucedida public boolean depositar (double valor) { } //recebe como parâmetro a contaDestino, a qual sofrerá um crédito do valor //ao mesmo tempo, esse mesmo valor deverá ser debitado da conta origem public boolean transferir(Conta contaDestino, double valor) { } }

Se você estiver usando o Eclipse ou outra boa IDE, perceberá que ele apontará 3 erros. Isso é por que ainda não definimos os retornos dos 3 métodos.

No próximo artigo vamos implementar esses métodos e criar as classes ContaPoupanca e ContaCorrente que herdarão de Conta.

Herança e Polimorfismo serão os focos do próximo e último artigo de OO.

Por hoje é só.

Resumindo. O que foi visto nesse artigo:

Demais partes desse curso:
Orientação a Objetos - simples assim! - Parte 2

Artigos relacionados