Depois de no primeiro artigo ter dado a conhecer a linguagem e ter introduzido os conceitos de objecto e mensagem, nesta 2ª parte, falando-vos ainda a título introdutório, vou começar por falar de algumas boas práticas da programação em Java para, em seguida, mostrar-vos os básicos para começarem a escrever os vossos programas (tipos de variáveis e operadores, estruturas condicionais, ciclos, etc..). E tenham em atenção que hoje vai haver trabalho de casa!
Boas Práticas a Programar
Muito importante em qualquer LP, não fugindo o Java à regra, são os standards que se devem seguir quando se programa e que, diferem um pouco de linguagem para linguagem. Seguir este tipo de normas, acima de tudo, facilita quem mais tarde vai agarrar no nosso código pois, para além de tornar o código “mais limpo”, torna mais fácil a sua compreensão. É também, pelas razões que iremos ver, uma forma de tornar o nosso trabalho mais produtivo.
Vou-vos falar das “boas regras” específicas do Java e de como programar numa LP object-oriented (OO).
Programar por Objectos
É um erro algo frequente utilizar-se uma LP object-oriented para programar como faríamos recorrendo a uma LP dum paradigma imperativo (como a linguagem C). No tutorial anterior expliquei o que era um objecto, agora vamos imaginar um objecto no mundo real.
Suponhamos, o Objecto Computador. O Objecto Computador, poderia-se dizer, é constituído por outros tantos objectos – Rato, Monitor, Teclado, Colunas, etc. Cada um desses objectos, funciona independentemente do contexto em que estão inseridos, ou seja, seja qual for o Computador (Objecto no global com todos os seus componentes) a que “pertençam” cumprem a sua função. O fabricante, aquando da construção do Rato, não pensa que é para funcionar “naquele” Computador mas, em qualquer Computador. Isto exemplifica como o programador deverá programar numa LP OO.
O código por nós produzido, quando se utiliza uma linguagem OO, deverá ser modular pensando sempre na sua reutilização. Quer isto dizer que, quando nos propomos a construir o objecto “ComputadorTipoA” (ou seja, desenvolver a classe “ComputadorTipoA”), devemos construir os objectos (definir as classes) Rato, Monitor, Teclado, etc como módulos separados e independentes. Desta forma quando estamos a construir o “Rato”, não temos de nos preocupar com as funções, por exemplo, do teclado. Só temos de definir que o nosso Rato tem o comportamento que se esperaria de um objecto com esse nome e funcionalidade se, receber X como entrada, tendo nesse caso Y como saída/resultado.
Se procedermos desta forma para todos os objectos em causa, na classe ComputadorTipoA, dizemos que sempre que fôr construido um ComputadorTipoA, deve ser adicionado um Rato, um Monitor, etc, não havendo necessidade de estar a definir novamente esses objectos. As vantagens, como já devem ter percebido tem a ver com o facto de que, quando quisermos construir um objecto ComputadorTipoB, TipoC, etc, apenas haverá necessidade de definir os pormenores relativos ao Computador do tipo em causa, os componentes do mesmo já estão definidos, podendo ser reutilizados. A isto chama-se programação modular e, tem como mais valias:
· Abstracção e divisão de um problema maior, dividindo-o em pequenos problemas que, conjuntamente, resolverão a nossa questão inicial;
· Reutilização de código em projectos futuros, poupando desse modo tempo de desenvolvimento, o que leva a uma maior produtividade/lucro.
Convenção de nomes em java
É importante no nosso código, utilizar os standards de nomes para a LP na qual estamos a programar. Isso facilita a compreensão do nosso código. Para Java, utilizam-se as seguintes convenções:
· Nome de Ficheiros – estes deverão começar por maiúsculas e ter um nome o mais descritivo possível. Caso se deseje atribui um nome com várias palavras, a primeira letra de cada uma delas deverá ser maíuscula. Exs.: Automovel.java, AutomovelPesado.java, Circulo.java, FiguraGeometrica.java, etc;
· Nome de Classes – deverão ser idênticos ao nome dos ficheiros retirando, o “.java”. Exs.: Automovel, AutomovelPesado, Circulo, FiguraGeometrica, etc;
· Nome de Métodos – segue as regras dos ficheiros/classes com ligeiras modificações: a primeira letra é uma minúscula, caso seja um método de atribuição de um valor a uma variável deverá começar por “set”, caso seja um método para obter o valor atribuído a uma variável deverá começar por “get”. Exs.: getPesoAutomovel(), setCorAutomovel(), getRaioCirculo(), setTipoFiguraGeometrica();
· Nome de Variáveis – situação idêntica à dos métodos (no caso de variáveis não existirá gets nem sets). Exs.: contador, limiteMaximo, nomeGestorConta;
· Nome de Constantes – em maíusculas. Se contiver várias palavras, estas deverão ser separadas por underscore (‘_’). Exs.: CONSTANTE_GRAVITACIONAL, MAX_PESO_PERMITIDO;
Palavras Reservadas
Ao definir os nomes das variáveis e métodos nos nossos programas, à que ter em atenção as palavras reservadas existentes na LP. Tal como em outras, existem palavras que estão “proibídas” de ser utilizadas uma vez que estas são nomes de métodos/tipos pré-definidos. Em Java são as seguintes:
private, protected, public, abstract, class, extends, final, implements, interface, new, static, strictfp, synchronized, transient, volatile, break, case, continue, default, do, else, for, if, instanceof, return, switch, while, assert, catch, finally, throw, throws, try, import, package, boolean, byte, char, double, float, int, long, short, super, this, void, const, goto, null, true, false.
Comentários
Importante também em qualquer programa independentemente da LP utilizada para o desenvolver, são os comentários. Estes deverão ser feitos sempre que exista um qualquer passo menos óbvio nos nossos programas, facilitando assim a compreensão dos mesmos.
Uma ferramenta muito útil e que deve ser utilizada para fazer a documentação dos nossos projectos (a documentação técnica) é o Javadoc. Esta ferramenta já vem com o SDK que necessitamos de instalar para programar em Java, como demonstrado no anterior tutorial. Esta ferramenta, de uma forma simples, permite criar documentação no formato da API do Java, sendo por isso uma mais valia para todos os developers.
Para conseguir tal feito, os comentários nos nossos programas, ao invés de no formato normal, terão de estar num formato especial – muito simplista – que será reconhecido e compilado pelo próprio compilador do Java, tendo como output a API do nosso projecto em formato HTML. Vamos então ver como devemos construir os comentários nos nossos programas:
· Existem dois tipos de comentários no formato Javadoc: Class-level Comments e Member-level Comments, qualquer um deles começa por ‘/**’ e acaba em ‘*/’;
· Class-level comments são utilizados para descrever a classe e são colocados logo acima da linha de código que inicializa a classe:
Generalizando, ou comentários são construídos no seguinte formato:
As tags mais utilizadas em Javadoc – apesar de existirem outras mais – são as seguintes:
o @author: Autor da classe;
o @param: parâmetro do método ou do construtor;
o @return: o que o método retorna;
o @throws: descreve uma excepção que poderá ser lançada pelo método;
o @exception: descreve uma excepção;
o @version: versão de uma classe ou de um método
Depois de termos os nossos comentários num formato Javadoc, para construir a nossa API, temos de executar o seguinte comando (existem mais flags que podem ser adicionadas, estes são os parâmetros base):
javadoc –d directoria_destino_api –sourcepath path_src_projecto
Existe muito mais informações sobre Javadoc – tags, flags de compilação, etc –, o que aqui foi apresentado foi o básico para utilizar a ferramenta. Para os mais curiosos, podem obter mais informações nos seguintes links:
· http://pt.wikipedia.org/wiki/Javadoc
· http://java.sun.com/j2se/1.3/docs/tooldocs/win32/javadoc.html
· http://java.sun.com/j2se/javadoc/writingdoccomments/index.html
Operadores
Agora que já conhecem a linguagem, como deverão programar na mesma e como comentar os vossos projectos, vou passar a apresentar-vos os pormenores da mesma, de modo a que finalmente lancem mãos à obra. Vou começar por vos apresentar os operadores existentes em Java:
· Operadores Aritméticos:
o Soma: +
o Subtracção: –
o Multiplicação: *
o Divisão: /
o Resto da Divisão: %
· Operadores de Atribuição:
o += : op1 += op2 à op1 = op1 + op2
o -= : op1 -= op2 à op1 = op1 – op2
o *= : op1 *= op2 à op1 = op1 * op2
o /= : op1 /= op2 à op1 = op1 / op2
o %= : op1 %= op2 à op1 = op1 % op2
· Operadores Unários: O mais (+) e o menos (-). Para mudar o sinal do operando
· Operador Instanceof: Permite-nos saber se um objecto pertence a uma classe ou não:
o NomeObjecto instanceof NomeClasse
· Operadores de Incremento e Decremento: São os operadores que nos permitem incrementar ou decrementar uma unidade a uma variável:
o ++
o —
o Ex.: se a variável ‘int i = 10’ e fizermos ‘i++’, i ficará com o valor 11.
· Operadores de Comparação:
o Maior do que: >
o Menor do que: >
o Igual a: ==
o Diferente de: !=
o Maior do que: >=
o Menor do que: <=
· Operadores Lógicos:
o «E» Lógico: && (devolve true se ambos forem true)
o «Ou» Lógico: || (devolve true se um fôr true)
o Negação: ! (devolve true se fôr false e vice-versa)
o «E» Bitewise: & (devolve true se ambos forem true mas avalia ambos)
o «Ou» Bitewise: | (devolve true se um fôr true mas avalia ambos)
· Operador de concatenação de Strings: ‘+’
· Operadores de bits:
o Shift direita: >>
o Shift esquerda: <<
o And: &
o Or: |
Tipos de Dados Primários (página seguinte)
Tipos de Dados Primários
Em Java podemos definir as nossas variáveis como sendo do tipo Objecto – sendo esse objecto um dos já existentes na API ou um dos definidos por nós – ou, um dos denominados, tipos primários:
· boolean: admite os valores true ou false.
· char: Usa o código UNICODE
· Inteiros: Diferem nas precisões e podem ser positivos ou negativos.
o byte: 1 byte.
o short: 2 bytes.
o int: 4 bytes.
o long: 8 bytes.
· Reais em ponto flutuante: diferem nas precisões e podem ser positivos ou negativos.
o float: 4 bytes.
o double: 8 bytes.
Estruturas de Dados
Depois de vos apresentar os tipos primários de dados, vou-vos mostrar outro tipo de estruturas mais complexas onde também é possível armazenar informação.
Antes demais esta não pretende ser uma “aula” acerca de estruturas de dados, pois para tal muitos tutoriais teriam de ser feitos só sobre essa tema, mas sim uma apresentação de algumas estruturas já existentes na forma de classes na API do Java e que podem ser utilizadas pelo programador. São muito úteis uma vez que já possuem definidos um número elevado de métodos de grande funcionalidade sobre as mesmas.
Vamos ver algumas das mais úteis e mais utilizadas (na minha opinião, obviamente este tutorial poderia ser completado com muitas outras). Para cada uma, irei dar alguns exemplos de utilização mas, todas elas possuem muitas mais funcionalidades que poderão ser utilizadas, funcionalidades essas que poderão descobrir na API da classe em questão – cujo link indicarei em todas elas.
Array
Cada elemento do array pode ser acedido através do sua posição dentro do mesmo, sendo a primeira posição de um array de tamanho n a posição 0 e a última a posição n-1. O exemplo em seguida demonstra o funcionamento de um array:
Um método de grande utilidade quando se utiliza arrays é o método length que nos permite saber o tamanho do array. Utilizando o exemplo anterior, se quisessemos conhecer o tamanho do array anArray, bastava fazer anArray.length.
Também útil é o facto de podermos criar arrays bidimensionais (matrizes de dimensão N x M), podendo os mesmos serem inicializados e utilizados como demonstra o exemplo seguinte:
Vector
A classe Vector é possivelmente uma das mais úteis da API do Java e, talvez uma das mais utilizadas. Um vector, de um modo simplista, é um array dinâmico. Quer isto dizer que o tamanho deste não é fixo, podendo-se acrescentar ou remover posições com facilidade. No entanto, isto é um processo que poderá consumir muitos recursos do sistema se for utilizado incorrectamente uma vez que, sempre que a estrutura é alterada, o que o Java faz é criar uma nova estrutura com o tamanho desejado e copia os dados da anterior estrutura para a nova. O Vector apenas aceita como seus elementos Objectos, não podendo portanto guardar nele tipos primários de dados. Eis um exemplo de como utilizar a classe Vector:
O programa anterior teria como output o seguinte:
Linked List
A classe LinkedList é uma implementação da Interface List e, tal como o nome indica é uma lista ligada, ou seja, é uma lista em que cada nó da mesma tem informação sobre qual é o nó seguinte e o nó anterior. Esta também é uma estrutura dinâmica. Em comparação com o Vector, tem uma performance superior a nível de inserção/remoção de elementos no início e fim da lista, mas uma menor performance quando os elementos a remover/inserir são no meio da mesma.
HashMap
A classe HashMap implementa a interface Map e, é nada mais do que a representação Java da estrutura de dados Hash Table. Esta estrutura serve para guardar pares <chave,valor>, sendo chave e valor do tipo definido pelo programador. As chaves devem ser únicas e, dada uma chave conseguimos obter o seu valor correspondente.
Estruturas Condicionais e Ciclos
O código Java, por defeito, será executado sequencialmente. No entanto, programas – minimamente – mais avançados, requerem uma execução condicional do código por nós construído. Para efectuar esses “malabarismos” podemos utilizar as instruções que enunciarei em seguida.
If..Else
Esta instrução valida uma instrução. Se ela for verdadeira executa o bloco de código do if, caso contrário entra no bloco de código do else. Note-se que não é necessário haver um else, o que não pode é haver um else sem um if.
É também possível criar uma sequência de instruções:
?:
Uma forma muito útil e minimalista de introduzir uma condição algures no nosso código é utilizando o operador condicional ?:, utilizando-se na forma boolean_expr ? expr1 : expr2.Se o resultado da expressão booleana for true, o resultado é expr1, senão, o resultado é expr2.
Switch..Case
O switch..case serve para avaliar uma expressão inteira e dependendo do resultado, realizar uma acção.
Deverão sempre ser utilizados breaks para saltar para fora do switch e devemos fornecer sempre uma opção default onde a condição entrará quando der um resultado que não se enquadre em nenhum dos cases (útil para quando acontece um resultado inesperado).
While
Existem 3 ciclos condicionais em Java, o while é o mais simples dos 3. O bloco de execução do while é executado enquanto uma condição for/não for verdade.
Do..While
O ciclo do..while faz a avaliação da expressão no fim do ciclo e não no início.
For
O ciclo for é amplamente utilizado em Java. Consiste numa inicialização, numa condição de paragem do ciclo e dum iterador sobre a variável inicializada.
Continue e Break
Os ciclos, muitas vezes são utilizados em conjunto com as estruturas condicionais e, muitas vezes é útil definir uma de duas situações:
· Se se verificar uma determinada condição, o programa deverá sair do ciclo mesmo que este não tenha atingido o seu final – nesse caso deveremos utilizar o break;
· Se se verificar uma determinada condição, o ciclo deverá iterar de imediato, passando portanto à próxima iteração do mesmo – nesse caso utilizamos o continue.
Trabalho de Casa (Próxima Página)
Trabalho de Casa
Agora que já sabem os básicos da linguagem, está na hora de utilizar os vossos conhecimentos. No âmbito de todas as coisas que vos mostrei sintam-se à vontade para explorar mais sobre os assuntos apresentados. As sugestões de “trabalho de casa” que vos apresentarei, como qualquer programa informático tem N soluções distintas. O que vos peço é que, por agora – e isto para aqueles que já têm mais experiência –, não utilizem técnicas muito avançadas, limitem-se a utilizar ou, pelo menos não fugir mais do que o essencial, aos conhecimentos por mim apresentados nestes dois primeiros tutoriais. Seria interessante apresentarem as vossas soluções, para tal sugiro ziparem o vosso projecto, colocarem-no num qualquer free file server (aceito sugestões acerca de qual) e postem o link aqui. A minha sugestão de resolução, irei postar no próximo tutorial, ou seja, daqui a duas semanas.
Loja
A loja “Vendemos Tudo Baratinho – Pplware Shop” é a mais recente Loja da mundialmente conhecida multinacional “Vendemos Tudo Baratinho“.
Esta tem diversos funcionários. Estes funcionários são divididos por funções: caixa, armazém, limpeza, repositores, contabilidade, segurança, Team-Leader, Manager da Loja – cada secção tem no mínimo 2 e no máximo 3 funcionários e cabe-lhe a si contrata-los.
Cada uma dessas funções, corresponde a uma secção e cada secção tem um Team-Leader específico e único a essa secção – também caberá a si contratar os Team-Leaders, aplicando-se o mesmo ao Manager da loja.
A Loja tem a liberdade de escolher que produtos vender mas, tem de vender um mínimo de 15 produtos, de pelo menos 3 categorias diferentes: tecnologia, comida e vestuário – cabe-lhe a si definir com que produtos irá abastecer a loja.
Todos os produtos têm um stock mínimo de 5 unidades e máximo de 10 unidades, podendo este valor ser alterado. Quando se vender um produto, se este baixar do stock mínimo deverá ser automaticamente encomendado uma quantidade que faça com que o stock atinja o valor mínimo + 1.
A loja tem uma lista de clientes com os dados destes.
As vendas contêm a informação do produto, do vendedor e do cliente e são guardadas para consulta futura. Deve ser possível consultar as vendas por mês, por ano, por dia e entre duas datas, mostrando os produtos vendidos, quem os vendeu, quem os comprou e o total de euros conseguido.
As compras poderão ser feitas na loja ou online, caso sejam feitas online é necessário uma fila de espera em que só se procederá ao despacho da 2ª encomenda que chegou depois de despachar a 1ª, a 3ª depois de despachar a 2ª, etc.. ou seja, first in, first out (isto faz parte da política da empresa).
Bem, o exercício foi inventado por mim e nunca fiz nada do género que não sou professor mas, penso que dá para utilizar todos os conhecimentos adquiridos até agora. Poderá ainda ser útil o seguinte recurso: http://java.sun.com/javase/6/docs/api/java/util/GregorianCalendar.html.
Notas finais
Espero que tenham gostado deste segundo tutorial. Só vai haver mais um de iniciação, depois passarei a outros aspectos da programação em Java. O tempo para este tutorial não foi muito devido à época natalícia, ter uma família nesta altura não é fácil J ainda assim espero que corresponda ás expectativas de todos.