A importância da Programação Orientada a Objetos – Parte I

Atualmente, é comum pessoas terem ideias inovadoras. Porém, esses insights não servem para nada se eles permanecerem somente no campo cerebral. Para começar a ver o valor de determinada percepção intelectual é necessário criar o produto que permita concretizar a ideia. Com a evolução dos computadores ao redor do mundo e a franca expansão destas máquinas, um dos caminhos para “materializar” a ideia é desenvolver software.

O algoritmo – uma sequência de passos finitos com o objetivo de solucionar um problema para desenvolver software – não é único e também não é trivial. É necessário entender de diversos conceitos que permeiam o estudo da computação. Dentre eles, destacam-se: Análise de Requisitos, Diagramas UML, Programação Orientada a Objetos (POO), Padrões de Projeto (Design Patterns), Design de Interface do Usuário (UI) e Experiência do Usuário (UX); e Testes Automatizados. Além disso tudo, é preciso realizar leitura de muito material (maioria em inglês) e atualizar-se quase que permanentemente.

Nesta primeira parte sobre a importância de POO, iremos falar exclusivamente dos principais conceitos deste paradigma de programação.

Existem diversas vantagens de se utilizar da POO para projetar e construir um sistema. As principais são:

• Esforço pequeno na manutenção/criação de novas funcionalidades: principal vantagem. Pode se tornar uma vantagem competitiva, pois como a única certeza que temos é que os clientes vão requerer mudanças, quanto mais rápido esta mudança for implementada no sistema, mais competente seremos (aos olhos do cliente).
• Reuso de código: o relacionamento entre classes e interfaces permite que um mesmo código seja utilizado por diversas outras classes.
• Organização do projeto: como o projeto POO tende a ficar “modularizado”, não é necessário percorrer o projeto todo para prestar manutenções. Basta localizar a(s) classe(s) a ser(em) modificada(s) e trabalhar nelas. Lógico que é necessário tomar cuidado com as dependências.
• Facilidade para realizar testes unitários: relacionado ao tópico anterior. É possível realizar testes unitários de maneira automatizada. Sendo assim, a qualidade do produto tende a crescer.

A POO está para o desenvolvimento de software atual assim como o verde e o amarelo estão para a bandeira do Brasil. É essencial, por exemplo, saber criar classes e declarar seus atributos e seus métodos/funções; instanciar objetos de determinada classe; entender como se realiza herança entre classes; conhecer sobre interfaces. Isto tudo por causa das vantagens apresentadas anteriormente e porque os Kits de Desenvolvimento de Software (Software Development Kit – SDK) já possuem diversas funcionalidades prontas para serem chamadas (reutilizadas) através do projeto que está em construção.

Outro conceito que está relacionado indiretamente à POO e que também auxilia no desenvolvimento, tornando o código mais legível e organizado, é o CamelCase. Vale lembrar que não são regras, apenas convenções. Tais conceitos básicos são:

1. O nome da classe deve sempre começar com letra maiúscula. Se a classe for composta por duas ou mais palavras, cada palavra deve começar com letra maiúscula. Por exemplo: Activity, DatePickerDialog.
2. O nome dos métodos deve sempre iniciar com letra minúsculas. Se o nome do método for formado por duas ou mais palavras, a partir da segunda palavra, deve-se usar letra maiúscula. Por exemplo: init(), onCreate().
3. O nome das constantes deve ser todo em letra maiúscula. Caso a constante seja constituída por duas palavras, elas são separadas através de underscore/underline. Por exemplo: RELEASE, TOKEN_ERROR.

Exemplificando… (baseado no livro SIERRA, Kathy; BATES, Bert. Use a Cabeça! Java, 2ª edição. Alta Books. ISBN: 9788576081739. 2005.)

Observe o diagrama de classes a seguir. Ele é fruto de um projeto para um sistema que vai rodar em um zoológico (para fins didáticos, irei considerar apenas classes de modelo. Em um ambiente real, teria classes de serviço, DAO, fachadas e demais).

Verifica-se no diagrama anterior as relações entre as classes:

1. Cachorro > Canino > Animal
2. Lobo > Canino > Animal
3. Gato > Felino > Animal
4. Leão > Felino > Animal

Para não nos tornamos repetitivos, vamos codificar apenas a relação 1):

classe Animal:

[code language=\\\”java\\\”]
abstract class Animal {
private double tamanho;
private double peso;
private int idade;

public void fazerBarulho() {
// corpo do método fazerBarulho() – classe Animal
}

public void vaguear() {
//corpo do método vaguear() – classe Animal
}

//outros métodos…

//métodos de acesso getters & setters
}
[/code]

classe Canino:

[code language=\\\”java\\\”]
abstract class Canino extends Animal {
void vaguear() {
//corpo do método vaguear() – classe Canino
}
}
[/code]

classe Cachorro:

[code language=\\\”java\\\”]
class Cachorro extends Canino {
public void fazerBarulho() {
// corpo do método fazerBarulho() – classe Cachorro
}

public void comer() {
//corpo do método comer() – classe Cachorro
}
}
[/code]

As classes Animal e Canino estão declaradas com a palavra reservada abstract: isto informa à Máquina Virtual Java (JVM) que estas classes não podem ser instanciadas, ou seja, não é possível criar objeto das mesmas. Por que isto? Imagine se fosse possível instanciar um objeto da classe Canino, qual formato este Canino teria? Não seria nem cachorro, nem lobo, nem qualquer outro canino da natureza. Portanto, por motivos de segurança, é importante vetar a utilização desta classe para criar objetos. O código a seguir geraria erro.

[code language=\\\”java\\\”]
class Programa {
public static void main(String args[]) {
Animal a1 = new Animal();
}
}
[/code]

Os atributos da classe Animal estão declarados como privados (private): esta prática estabelece o encapsulamento dos atributos da class. Isto significa que eles não podem ser acessados diretamente por outras classes clientes, e sim através dos métodos de configuração do tipo set() e get(). Tal prática torna a classe mais segura, já que podemos implementar regras no método set() para assegurar que nenhum valor estranho possa ser guardado em um atributo. Já pensou se um programador descuidado igualasse o atributo peso a zero? O código a seguir geraria erro, pois não é possível acessar atributos diretamente.

[code language=\\\”java\\\”]
class Programa {
public static void main(String args[]) {
Cachorro c1 = new Cachorro();
c1.idade = 3; //ferindo o encapsulamento…
}
}
[/code]

A palavra reservada extends indica relação de herança entre as classes. Isto quer dizer que tudo o que for público em uma classe pai pode ser acessado pela classe filha. O exemplo a seguir mostra o acesso do método setIdade() da classe Animal através de um objeto da classe Cachorro. Isto também pode ser feito através das classes Leão, Gato e Lobo. Percebe a reutilização de código? Outra reflexão a respeito da herança: se outro animal surgisse, seria só declarar a classe respectiva e herdar das classes corretas. Percebe a facilidade na manutenção do projeto?

[code language=\\\”java\\\”]
class Programa {
public static void main(String args[]) {
Cachorro c1 = new Cachorro();
c1.setIdade( 3 );
}
}
[/code]

Os métodos vaguear() fazem parte da classe Canino e da classe Animal. Os métodos fazerBarulho() e comer() fazem parte da classe Cachorro e Animal. Isto está sendo realmente reutilizado? Sim, pois cada animal, isto é, cada classe, faz barulho e come de forma diferente: um cachorro late e um gato mia. O nome deste princípio da POO é conhecido como sobrescrita (do inglês, override). Isto ajuda a organizar o projeto.

No próximo post iremos abordar o conceito de interface. Até lá!