[rotulo] Artigo do tipo Tutorial
Recursos especiais neste artigo:
Conteúdo sobre boas práticas. [/rotulo] [lead]Do que se trata o artigo
O artigo aborda a criação passo a passo de uma pequena aplicação GUI com acesso a banco de dados. Nesta primeira parte são criadas as classes do domínio da aplicação e as classes necessárias para a persistência.

Em que situação o tema é útil
O tema abordado é fundamental para quem precisa criar aplicações com GUI e que implementam acesso a banco de dados. Além disso, é útil para o desenvolvimento em camadas, que neste caso é a interface com o usuário, as classes do domínio de negócio e a camada de persistência.

Desenvolvendo uma aplicação passo a passo
A maneira de abordar a solução de um problema de desenvolvimento se inicia com o entendimento da questão, passando pela criação do modelo do domínio do problema e do diagrama de classes. Nessa etapa, um dos passos, caso a aplicação necessite implementar persistência, consiste em fazer o mapeamento objeto-relacional. Após isso, finalmente inicia-se a codificação, que é a última etapa do processo, antes de efetuar os testes junto com o usuário. Assim, nesta primeira parte da série de artigos buscamos apresentar um problema, cuja solução segue esses passos.[/lead]

Na Easy Java Magazine nº 4 foi proposta pelo autor uma metodologia simples para resolver problemas de programação, no artigo “Solucionando Problemas usando Java”. Na matéria que ora iniciamos será apresentada uma aplicação mais complexa que os exemplos usados no artigo citado, que demanda uma metodologia mais adequada à sua solução. No entanto, em linhas gerais, o processo é similar e tentaremos acompanha-lo, visto que foge do escopo deste artigo a utilização de processos estudados na Engenharia de Software.

Na implementação do programa optou-se por criar uma interface gráfica utilizando a API Swing, à qual já foi dedicado o artigo “Swing: O Desktop Java” na Esay Java Magazine nº 12. Com o objetivo de facilitar a criação das telas será empregado o plug-in WindowBuilder, disponível para o Eclipse. Entretanto, se o leitor tiver habilidade com o NetBeans, este também poderá ser usado. É importante observar que ambas as tecnologias já foram objeto de matérias também nesta revista.

A camada de persistência foi desenvolvida usando uma solução apresentada na Edição nº 4 da Easy Java, no artigo “Solucionando problemas usando Java”. Poderíamos ter optado por usar o padrão DAO (Data Access Object) ou um framework tal como Hibernate, mas isso traria uma complexidade maior ao desenvolvimento. Todavia, a solução adotada ainda consegue uma separação entre as camadas de persistência, regras de negócio e interface gráfica.

Seguindo esta linha, inicialmente será apresentado o problema. Depois disso será iniciado o processo de solução, começando com a análise do problema. Após a análise, o problema será dividido em partes que possam ser solucionadas individualmente e depois integradas na solução final. Em seguida será implementada cada uma das partes nas quais o problema foi separado.

Nesta primeira parte da matéria serão criadas as classes do domínio do problema e as classes necessárias para implementar a persistência.

[subtitulo]Definição do Problema[/subtitulo]

É um fato corriqueiro que pessoas que possuem uma biblioteca particular emprestem livros aos amigos. E infelizmente é bastante comum que os amigos dificilmente devolvam as obras, e as pessoas terminam mesmo por esquecer a quem foram emprestadas. Pensando nisso, o autor propõe o desenvolvimento de um pequeno aplicativo que registre as obras mantidas em uma biblioteca pessoal. E, para evitar o esquecimento, que os dados dos empréstimos sejam também registrados.

[subtitulo]Análise do Problema[/subtitulo]

O primeiro passo na análise é identificar o domínio do problema, que consiste em definir as classes e seus relacionamentos. A partir da descrição do problema, pode-se inferir que existem as entidades Livro e Emprestimo. Sabendo-se que um Livro possui pelo menos um autor, determinaremos também como parte do domínio, a entidade Autor. Quanto aos relacionamentos, pode-se afirmar que um livro tem um ou mais autores e um autor pode escrever mais de um livro. Define-se também que um livro pode ser emprestado mais de uma vez. Dessa maneira criamos um modelo do domínio, mostrado na Figura 1.

Utilizamos a UML (Unified Modeling Language) para criar o diagrama de classes que irá representar o modelo do domínio do problema. Assim, conforme a Figura 1, foram representadas as classes, seus relacionamentos e multiplicidades. Note que a multiplicidade do relacionamento entre Autor e Livro determina que um autor pode ter um ou mais livros publicados e um livro deve ter pelo menos um autor. Um livro pode ter um ou muitos empréstimos e um empréstimo é feito para um único livro.

O passo seguinte consiste em definir os dados relevantes a cada uma das classes identificadas. Na classe Autor, por exemplo, consideramos como importante o nom

...

[rotulo] Artigo do tipo Tutorial
Recursos especiais neste artigo:
Conteúdo sobre boas práticas. [/rotulo][lead]Entendendo Anotações

Neste artigo abordaremos as anotações, as quais foram introduzidas no revolucionário Java 5 – também chamado Tiger. Anotações é um recurso usado para anotar classes, campos e métodos, de tal maneira que essas marcações podem ser tratadas pelo compilador, ferramentas de desenvolvimento e bibliotecas. Três anotações, denominadas tipos anotação padrão, são parte do pacote java.lang, e podem ser usadas sem qualquer esforço adicional: @Override, @Deprecated e @SuppressWarnings. Além dessas, o texto trata das anotações de anotações – @Retention, @Documented, @Target e @Inherited – as quais são também parte da API juntamente com as anteriores, e da personalização de tipos anotação, mostrando como criar nossos próprios tipos. Para finalizar, é demonstrado um pequeno exemplo de reflexão de anotações, ou seja, a capacidade de observar dinamicamente esses tipos.

Em que situação o tema é útil

Este tema é útil quando desejamos anotar código não simplesmente para documentação, mas de maneira que essas marcações possam ser verificadas em tempo de compilação, ou utilizadas por ferramentas, tais como analisadores de código, frameworks de persistência ou de testes unitários, entre outras.[/lead]

Kent Beck, o criador da Programação Extrema e do Desenvolvimento Orientado a Testes, sugere que para criar um bom código deve-se seguir três valores básicos: comunicação, simplicidade e flexibilidade. Falando especificamente de comunicação, ele diz que os programas são lidos mais frequentemente do que escritos, e, por conseguinte deveriam comunicar claramente suas intenções. Beck completa afirmando que em um sistema empresarial, grande parte do código será modificada por vários programadores durante 5 a 10 anos, e, portanto estes deverão entendê-lo com facilidade.

Usamos estes ensinamentos de Kent Beck para reforçar a necessidade de que os programas sejam documentados. Em suma, documentação é importante, pois desenvolvedores que não fizeram parte do processo conseguem com facilidade entender o que foi escrito.

No entanto, Brett McLaughlin, um dos autores do livro “Java 5.0 Tiger – A Developer’s Notebook”, já afirmava em 2004 que o uso de metadados surgia com uma forte tendência na programação, particularmente em Java. Metadados consistem de dados que descrevem outros dados, e podem ser usados para criar documentação, para rastrear dependências no código fonte e até mesmo para fazer verificações rudimentares em tempo de compilação.

Antes do Java 5 (também denominado Tiger) ser lançado, o Javadoc – ferramenta usada para gerar documentação da API de Java em HTML – era o recurso usado para definir metadados. No entanto, sabe-se que é possível expressar algo de várias maneiras na documentação. Por exemplo, se desejarmos dizer que uma variável não pode ser nula, em Javadoc pode-se dizer “Não-nula”, “Esta variável não pode ser nula” ou ainda “Não atribua valor nulo a esta variável”, entre outras possibilidades todas válidas. Ou seja, Javadoc serve apenas para gerar a documentação, pois não existe uma ferramenta que possa analisá-lo de maneira a considerar todas as variadas formas que podemos usar para definir uma simples condição como a do exemplo anterior.

Em vista disso, a JSR (Java Specification Request) 175, denominada A Metadata Facility for the Java Programming Language, apresenta a justificativa e especificação oficiais para a incorporação de metadados na linguagem Java. JSR é um documento submetido ao PMO (Program Management Office) por um ou mais membros do JCP (Java Community Process) com a finalidade de propor o desenvolvimento de uma nova especificação ou revisão significativa de uma especificação Java existente. PMO, por sua vez, é o grupo dentro da Oracle encarregado de supervisionar a JCP, o qual é o mecanismo aberto para desenvolver e revisar especificações técnicas padrão para a tecnologia Java, onde qualquer pessoa pode tornar-se membro, desde que possua uma conexão com a internet.

Na descrição de sua finalidade, a JSR 175 afirma que tem havido uma tendência crescente no sentido de se anotar campos, métodos e classes, os quais devem ter atributos particulares que indicam que eles devem ser processados de forma especial por ferramentas de desenvolvimento, de implantação, ou bibliotecas runtime. O parágrafo da especificação conclui que tais anotações – ou annotations – são chamadas metadados.

Dessa forma, as anotações buscam resolver a situação apresentada anteriormente – que enfrentamos ao usar Javadoc – oferecendo um mecanismo bem definido de criar metadados. Deduz-se da especificação JSR 175 que anotações são modificadores que podem ser aplicados a pacotes, declarações de tipos, construtores, métodos, campos, parâmetros e variáveis, as quais serão estudadas a partir de agora.

[subtitulo]A importância dos metadados[/subtitulo]

A utilização mais comum de metadados é na documentação de código. No entanto, como vimos anteriormente, o Javadoc já cumpre com eficiência e simplicidade esse papel. Portanto, estamos interessados em outras justificativas para a aplicação de metadados ou anotações. Para fins deste artigo, vamos considerar as anotações como informação para o compilador e para utilização em testes de unidade. Entretanto elas podem ser empregadas em ferramentas de persistência, a exemplo do Hibernate, e de análise de código, tal como o Findbugs.

Vejamos então a primeira das características, a de que o compilador Java pode usar metadados para fazer uma verificação durante o processo de compilação. Por exemplo, veremos mais adiante a anotação @Override, a qual permite especificar que um método sobrescreve outro método da superclasse. Dessa forma, o compilador tem como assegurar que o comportamento indicado na anotação realmente acontece no código. Se o leitor considera sem sentido essa utilização de anotação, vamos analisar o exemplo mostrado na Listagem 1.

Listagem 1. Hierarquia de classes implementando erradamente a sobrescrita.

class Funcionario {
	protected double salario;
	
	public double getSalarioTotal(double bonus) {
		return this.salario + bonus;
	}
}

class Auxiliar extends Funcionario {
	protected double extra;
	
	public double getSalarioTotal(float bonus) {
		return this.salario + this.extra + bonus;
	}
}

A nossa intenção é sobrescrever o método getSalarioTotal(). No entanto, como já sabemos de nosso estudo sobre orientação a objetos, um método sobrescreve outro apenas se as assinaturas de ambos forem exatamente iguais. Ou seja, além do nome, quantidade e tipos dos parâmetros serem iguais, o tipo de retorno também deve ser o mesmo.

O compilador não possui mecanismos para checar isso e, provavelmente, a aplicação que usar essas classes deverá produzir algum resultado inesperado, visto que os tipos de dados do parâmetro usado nos dois métodos são diferentes, descaracterizando a sobrescrita. Agora, acrescente acima do método sobrescritor na classe Auxiliar, a linha @Override. Se você estiver usando NetBeans ou Eclipse, imediatamente o IDE irá sinalizar um erro. Ou seja, a inclusão dessa anotação irá alertar para uma falha caso o método da subclasse não sobrescreva o método da superclasse.

Outra característica de metadados é a capacidade de usar anotações para uso em testes de unidade. Como exemplo, vejamos o caso do JUnit, um framework de código aberto usado para escrever e executar testes repetíveis bastante explorado por desenvolvedores Java. Entendamos que a finalidade dos testes é executar um programa utilizando algumas entradas específicas e verificar se seu comportamento está de acordo com o esperado.

Listagem 2. Uso de JUnit com anotações.

import org.junit.*;
import static org.junit.Assert.*;
import java.util.*;

public class TesteSimples {
	
	@Test
	public void testeConjuntoVazio() {
		Collection conjunto = new ArrayList();
		assertTrue(conjunto.isEmpty());
	}
	
	public static void main(String args[]) {
	      org.junit.runner.JUnitCore.main
       ("TesteSimples");
	}
}

Não está no escopo deste artigo estudar o uso do JUnit, portanto não cabe aqui explicar o código da Listagem 2. Por ora, é suficiente sabermos que a anotação @Test foi empregada para identificar que testeConjuntoVazio() é um método de testes. Nesse método chamamos assertTrue() passando para ele uma expressão booleana que deve ser true se o teste for bem sucedido.

[subtitulo]Introdução às anotações[/subtitulo]

Agora que sabemos o quanto as anotações podem ser úteis, vamos estudar como elas funcionam em Java. Para definir uma anotação no código Java, usamos o símbolo arroba (@) seguido do nome da mesma. Dependendo da categoria da annotation, pode ser necessário incluir dados a ela, no formato de pares nome=valor. São três as categorias de anotações:

· Anotações marcadoras – são aquelas que não possuem membros. São identificadas apenas pelo nome, sem dados adicionais. Por exemplo, @Test na Listagem 2 é uma anotação marcadora;

· Anotações de valor único – são similares às anteriores, no entanto, possuem um único membro, chamado valor. Elas são representadas pelo nome da anotação e um par nome=valor, ou simplesmente com o valor, entre parênteses. Em outras palavras, quando a anotação possui um único membro, só é necessário informar o valor, além do nome da anotação. Por exemplo, @MinhaAnotacao(“valor”) é um exemplo de sintaxe deste tipo de anotação;

· Anotações completas – são aquelas que possuem múltiplos membros. Portanto, neste tipo, devemos usar a sintaxe completa para cada par nome=valor. Neste caso, cada par é informado separado do outro por uma vírgula. Por exemplo, @Version(major=1, minor=0, micro=0) é um caso de anotação completa.

Em uma classe podemos ter várias anotações, cada uma delas correspondente a algum tipo anotação, tal como @Override, que se utiliza para marcar os métodos sobrescritos, por exemplo. O tipo anotação é a definição da anotação e a anotação propriamente dita é um caso específico deste tipo. Explicando de uma maneira mais simples, e usando uma analogia, vamos imaginar os conceitos com os quais estamos familiarizados. Em uma aplicação temos uma classe – Funcionario, por exemplo – mas podemos ter várias instâncias – objetos – dela ao mesmo tempo. De maneira semelhante acontece com tipo anotação e anotação. Tipo anotação é como se fosse uma classe e a anotação é como se fosse uma instância da classe. Mais adiante, quando aprendermos a criar tipos anotação, mostraremos exemplos que tornarão mais claro esse conceito.

O desenvolvedor pode então definir suas próprias anotações a serem usadas em uma aplicação. Além disso, Java apresenta algumas anotações predefinidas, que veremos a seguir.

[subtitulo]Tipos anotação padrão[/subtitulo]

Os tipos anotação padrão são aquelas providas como parte do Java no pacote java.lang. Essas anotações podem ser utilizadas sem qualquer esforço adicional em suas aplicações, pois, visto que são parte de java.lang, nem mesmo precisam ser importadas.

@Override

É uma anotação marcadora que deve ser usada apenas com métodos. Serve para indicar que o método anotado está sobrescrevendo um método da superclasse, da maneira que se observa na Listagem 3.

Listagem 3. Classe Funcionario usando Override.

public class Funcionario {
	protected double salario;
	
	public double getSalarioTotal(double bonus) {
		return this.salario + bonus;
	}

	@Override
	public String toString() {
		StringBuilder builder = new StringBuilder();
		builder.append("Funcionario [salario=");
		builder.append(salario);
		builder.append("]");
		return builder.toString();
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		long temp;
		temp = Double.doubleToLongBits(salario);
		result = prime * result + (int) 
  (temp ^ (temp >>> 32));
		return result;
	}

}

Como já sabemos de artigos anteriores, a classe da Listagem 3 é derivada de Object, visto que ela explicitamente não estende qualquer outra classe. Sabemos também que as classes em Java deveriam sobrescrever métodos definidos em Object, tais como toString(), hashCode() e equals(). Dessa forma, no código, @Override anota que os métodos toString() e hashCode() sobrescrevem os métodos da sua superclasse. Tais métodos foram gerados automaticamente pelo Eclipse, o qual insere também a anotação, e o código da classe compila sem qualquer problema.

No entanto, a força desta anotação é percebida quando o programador faz algo errado como na Listagem 4.

Listagem 4. Classe Funcionario sobrescrevendo incorretamente um método.

public class Funcionario {
	protected double salario;
	
	public double getSalarioTotal(double bonus) {
		return this.salario + bonus;
	}

	@Override
	public int hasCode() {
		final int prime = 31;
		int result = 1;
		long temp;
		temp = Double.doubleToLongBits(salario);
		result = prime * result + (int) 
  (temp ^ (temp >>> 32));
		return result;
	}

}

Observe que a anotação indica que o método hasCode() deveria sobrescrever um método, mas durante a compilação será detectado que a classe Object não possui um método hasCode() que possa ser sobrescrito. Isso resulta em um erro, indicando que hasCode() deve implementar ou sobrescrever um método do supertipo.

Conclui-se então que é uma boa prática anotarmos os métodos sobrescritos para assegurar que estamos fazendo a coisa certa em nossas aplicações.

@Deprecated

@Deprecated, assim como @Override, é também uma anotação marcadora. Esta anotação é util

...

Nas duas partes iniciais desta série de artigos, foram introduzidos os elementos que permitem customizar o ambiente do Eclipse e as muitas maneiras de adicionar novas funcionalidades através da instalação de plugins. Além disso, logo no início, procuramos oferecer ao leitor o conhecimento básico para que ele pudesse de imediato começar a usar a ferramenta e desenvolver suas primeiras aplicações usando Java.

Dando continuidade à nossa matéria, nesta parte iremos apresentar o WindowBuilder, uma ferramenta desenvolvida pelo Google que tem a finalidade de facilitar a criação de aplicações com Interface Gráfica do Usuário (GUI) Java.

Com o surgimento dos ambientes com interface gráfica, um requisito tornou-se fundamental para o sucesso de uma aplicação – a usabilidade. A GUI não precisa apenas ter um visual agradável, mas também deve facilitar o trabalho do usuário. Principalmente, a interface gráfica de um programa deve considerar a experiência do usuário. Ou seja, deve levar em conta que o usuário já utiliza outros aplicativos e que alguns paradigmas foram criados, tais como a disposição das opções Copiar e Colar no menu Editar. Qualquer mudança em relação a isso pode prejudicar a utilização de uma aplicação. Por isso é tão importante o cuidado com a definição de uma boa interface gráfica e o aprendizado de ferramentas que facilitam esse trabalho, tais como o WindowBuilder.

O WindowBuilder foi criado como um plug-in do Eclipse, cuja instalação foi mostrada no artigo “O IDE Eclipse – Parte 2” na Easy Java Magazine nº 21. No entanto, mesmo que você já o tenha instalado, é aconselhável sempre verificar se há atualizações para o pacote. Para fazer isso, acesse o item de menu Help | Check for Updates. Se houver algo a ser atualizado, uma caixa de diálogo será apresentada e o usuário precisará selecionar os componentes desejados. Após isso você pressiona o botão Next e em seguida Finish. Pode ser necessário reiniciar o IDE após a atualização.

Interface do Usuário
A fim de nos familiarizarmos com o ambiente do WindowBuilder, vamos criar um novo projeto. Para isso, selecione o menu File | New > Java Project. Na caixa de texto Project name informe “Teste” e pressione o botão Finish. Agora expanda o projeto “Teste” na view Package Explorer. Clique com o botão direito do mouse sobre a pasta src e escolha New > Other. Veja na Figura 1 a caixa de diálogo que será executada.

Antes de prosseguir com a criação da aplicação, é necessário saber que o Swing oferece três contêineres de alto nível – JFrame, JDialog e JApplet. JFrame é uma janela com título e borda, adequada para a tela principal de uma aplicação, JApplet é uma janela para

...

Na primeira parte desta série buscamos oferecer aos desenvolvedores conhecimento suficiente para que eles pudessem de imediato começar a desenvolver suas primeiras aplicações usando o Eclipse. Por esse motivo foram apresentados com bastante ênfase recursos de criação e edição de código, e atividades de refatoração. No entanto, não deixamos de apresentar uma visão geral do ambiente, de maneira que o usuário se tornasse familiarizado com as particularidades do IDE.

Dando continuidade ao tema, nesta segunda parte, serão apresentados tópicos que possibilitarão ao programador avançar na utilização da ferramenta. Um desses tópicos é a customização do ambiente, possibilitando que o profissional adéque-o às suas necessidades. Em seguida será abordada a utilização de bibliotecas externas e finalmente o gerenciamento de extensões, ou plug-ins, que permitirá adicionar mais recursos e funcionalidades ao Eclipse.

Personalizando o Workbench
Uma das características mais importantes de um IDE é a personalização do ambiente, pois, como se sabe, cada pessoa tem preferências e necessidades que são particulares suas. Dessa forma, cada desenvolvedor pode precisar adaptar a aparência e o comportamento do ambiente às suas necessidades. Nesse sentido, o Eclipse também oferece tais recursos, permitindo, por exemplo, que a barra de ferramentas e os menus sejam modificados, que as teclas de atalhos sejam alteradas e que as fontes e cores usadas possam ser mudadas, entre outras possibilidades.

Barra de Ferramentas e de Menus
A barra de ferramentas do Eclipse é configurada com base nas perspectivas. De acordo com o que vimos no artigo anterior, as perspectivas são uma maneira do IDE agrupar o layout das diversas views, barras de ferramentas e menus conforme a tarefa que o desenvolvedor estiver fazendo. Sabe-se também que, por padrão, as perspectivas usadas para desenvolvimento e depuração de código são Java e Debug, respectivamente. A perspectiva Debug apresenta botões na barra de ferramentas que não são visíveis na perspectiva Java. Para alternar entre as diversas perspectivas, podemos usar o menu Window | Open Perspective > Other, ou então utilizando o botão Open Perspective da extremidade direita da barra de ferramentas.

Após relembrarmos o conceito de perspectiva, vejamos então como proceder para customizar a barra de ferramentas e os menus. Clique com o botão direito do mouse na barra de ferramentas e selecione Customize Perspective, ou ainda escolha o menu Window > Customize Perspective. Com isso, uma janela como aquela mostrada na Figura 2 será aberta, a qual possui quatro abas, descritas a seguir:
• Tool Bar Visibility – nesta aba podemos selecionar os itens que serão visualizados ou não na barra de ferramentas. Simplesmente marque a caixa de verificação para visualizar o item correspondente, ou desmarque se não quiser mais que ele esteja visível;
• Menu Visibility – da mesma forma que a aba anterior, nesta selecionam-se os itens de menus que estarão visíveis ou não. Para alternar a visualização ou não, proceda da mesma form

...

No final dos anos 90 a IBM iniciou o projeto de um ambiente que pudesse integrar ferramentas de desenvolvimento da própria IBM, de seus clientes e de terceiros. Este ambiente, que deveria prover compatibilidade entre as diversas ferramentas, tornou-se o embrião do que hoje é o Eclipse.

Esta ferramenta de desenvolvimento, chamada de Ambiente Integrado de Desenvolvimento (IDE), começou a ser criada em novembro de 1998. E, simultaneamente a isso, a IBM iniciou a preparação de equipes para criar novos produtos construídos sobre esta plataforma.
Diante da dificuldade inicial em encontrar parceiros comerciais que investissem no novo projeto, a IBM decidiu adotar o modelo open source. Assim, juntamente com outras oito organizações, a IBM criou o consórcio Eclipse. Para participar desse consórcio o único compromisso era usar a plataforma internamente e desenvolver produtos baseados nela.
A partir daí, o consórcio decidiu assumir as relações comerciais e o marketing, e deixou o código sob o controle da comunidade open source. A partir da abertura do código fonte, grande parte das contribuições ao desenvolvimento do Eclipse veio dos parceiros comerciais da IBM, que continuava sendo o maior colaborador, tanto em conteúdo quanto de recursos financeiros e de pessoal.

Em 2004, com o objetivo de desvincular o projeto da IBM, foi criada a Eclipse Foundation. Esta fundação é independente, não tem fins lucrativos, possui sua própria equipe e é mantida através de doações das próprias organizações que dela fazem parte como membros.
Após essa mudança, foi lançado o Eclipse 3.0 e em seguida o Eclipse 3.1, que atingiram um nível de aceitação muito maior que as versões anteriores. Atualmente o IDE está na versão 3.7, também denominado Eclipse Indigo.

O Eclipse é um IDE conhecido mais comumente para desenvolvimento em Java, no entanto, por meio de plug-ins, ele pode ser usado para desenvolver aplicações em várias linguagens, como C/C++, Python, PHP e inclusive para a plataforma Android.
Nesta primeira parte da série faremos inicialmente uma breve apresentação do ambiente e em seguida destacaremos com mais detalhes o uso do editor e seus recursos, finalizando com uma abordagem introdutória às atividades de refatoração oferecidas pelo Eclipse.


Como obter e instalar
Para usar o Eclipse para programação Java é necessário instalar antes o Java Development Kit (JDK), cujo download pode ser feito na página oracle.com/technetwork/java/javase/overview/index.html.
A versão mais recente – e mesmo versões anteriores – do Eclipse pode ser baixada no site eclipse.org. Na página de downloads você pode selecionar o pacote desejado para um dos três sistemas operacionais: Windows, Linux ou Mac OS X. Nesta série de artigos iremos trabalhar com a versão 3.7.0, também conhecida como Indigo.
O pacote do Eclipse não é um instalador, e sim um arquivo compactado – tanto em Windows quanto no Linux – que ao ser descompactado cria um diretório denominado eclipse, onde todos os arquivos da ferramenta são copiados. Após finalizar a extração dos arquivos, para executar o IDE, simplesmente chame o arquivo executável eclipse.exe (Windows) ou eclipse.sh (Linux), que está localizado no diretório principal da ferramenta – /eclipse.
Ao iniciar o Eclipse pela primeira vez, será solicitado que você defina o workspace, conforme vemos na Figura 1.


Workspace
Workspace ...

Sempre se ouviu dizer que Java é uma linguagem cujo paradigma é a orientação a objetos. No entanto, também se sabe que comumente lidamos nas aplicações com os tipos denominados primitivos. E lidar com tipos primitivos juntamente com objetos sempre foi uma necessidade do desenvolvedor. Mas, antes de Java 5, tais tipos não poderiam ser adicionados em um ArrayList, por exemplo, pois o método add() desse collection aceita apenas objetos como argumento. Assim, o código da Listagem 1 não funcionará em versões de Java anteriores a 1.5.

Listagem 1. Tentando adicionar um primitivo em um collection.
int i = 5;
ArrayList a = new ArrayList();
a.add(i);

A solução para isso é tratar os primitivos como objetos usando o que chamamos classes wrapper (empacotadora). Há uma classe wrapper correspondente a cada tipo primitivo em Java. Uma classe empacotadora encapsula um único valor de um tipo de dado primitivo. Por exemplo, a classe Integer deve tratar um valor int.

Uma outra situação em que as classes wrapper são úteis é quando precisamos converter um objeto em um tipo de dado primitivo. Por exemplo, digamos que em nossa aplicação, uma interface gráfica do usuário solicite que seja digitada a idade de uma pessoa em uma caixa de texto JTextField. Contudo, sabemos que caixas de textos retornam seu conteúdo em uma String, o que requer uma conversão para int de maneira que possamos realizar cálculos com a idade na aplicação.

Para completar os casos que justificam o uso de classes empacotadoras, citamos o fato de que os primitivos não têm métodos. Os métodos relacionados a um tipo primitivo encontram-se na classe wrapper correspondente. Dessa forma, se for necessário manipular um tipo primitivo em nossa aplicação, devemos consultar a documentação da classe empacotadora referente ao tipo, para verificar se a operação que desejamos é oferecida por algum método da classe.

As classes wrapper existem desde a versão 1.1 da linguagem, mas só a partir da versão 1.5 que foram implementados os recursos de boxing e unboxing, que estudaremos neste artigo. Além disso, iremos apresentar o uso dessas classes em situações como: instanciação, sobrecarga e conversão de tipos, entre outras. Veremos que os recursos de boxing e unboxing são os que permitem que o código da Listagem 1 funcione nas versões mais recentes de Java.

Visão geral das classes wrapper
Cada tipo primitivo em Java possui uma classe empacotadora correspondente. Por exemplo, a classe wrapper para int é Integer, para float é Float, e assim por diante, conforme pode ser visto na Tabela 1. Observe que o nome do tipo primitivo é simplesmente o mesmo nome da classe wrapper em minúsculas, exceto o tipo char, que corresponde a Character, e int, cuja classe correspondente é Integer. Na Tabela 1 podemos observar também quais os possíveis argumentos que podem ...

Nas partes iniciais desta série de artigos tratamos de classes – tanto concretas quanto abstratas – e de interfaces. Tais tipos são denominados classes de nível superior, ou top level class. Nesta edição iremos estudar outros tipos que podem ser declarados em Java – os tipos enum e as classes e interfaces aninhadas (nested).

Mas, o que são enums e classes aninhadas? Inicialmente vamos falar um pouco sobre enums. Antes de Java 5, era comum definir variáveis – geralmente int – que tinham um domínio restrito a poucos valores. Por exemplo, a classe Pessoa poderia ter um atributo sexo, do tipo int, onde 1 representaria o sexo masculino e 2, o feminino. E, em geral, isso levava a um código mais difícil de ler, o que poderia tornar a manutenção da aplicação um pouco mais complicada. Veremos a seguir como enums podem nos ajudar nesse aspecto e criar programas mais legíveis.

Por sua vez, as classes – ou interfaces – aninhadas são definições de classes dentro de outras. Essas classes são comumente conhecidas como classes internas, e consistem de um recurso que permite o agrupamento de classes que têm um relacionamento mais íntimo e singular. Em muitas situações um objeto só irá existir para a classe que estamos implementando, então faz pouco ou nenhum sentido criar uma classe separada para esse objeto único. A API de Java faz bastante uso desse recurso e, como exemplo, pode-se citar a classe Ellipse2D.Double. Esta classe interna, Double, é uma elipse definida em precisão double, dentro da classe Ellipse2D.

Existem quatro categorias de classes aninhadas e uma de interfaces aninhadas, que são:

• Classes e interfaces aninhadas de nível superior;
• Classes internas não-estáticas;
• Classes locais de métodos;
• Classes anônimas.

 

O grupo formado pelas classes internas não-estáticas, classes locais de métodos e classes anônimas são conhecidas como classes internas.

Nesta ordem, estudaremos primeiramente os enums e, em seguida, as classes aninhadas.

Tipos enum

Um enum é um tipo cujos atributos consistem basicamente de um conjunto fixo de constantes. No entanto, logo veremos que se pode declarar muito mais que isso em um enum. Um exemplo de campos constantes poderia ser os dias da semana (SEGUNDA, TERCA, QUARTA, QUINTA, SEXTA, SABADO e DOMINGO). Em Java, um tipo enum é definido usando-se a palavra-chave enum, como se pode ver na Listagem 1.

 

public enum DiaSemana {

  SEGUNDA, TERCA, QUARTA, QUINTA, SEXTA, SABADO, DOMINGO

}

 

Os tipos enum comportam-se na verdade como os tipos enumerados que também podem ser encontrados em outras linguagens de programação, tais como C++ e ObjectPascal. Tipos enumerados são constantes declaradas em vez dos números inteiros que frequentemente são usados para representar opções entre diversas alternativas. Por exemplo, suponha que declarássemos em uma classe a variável int dia para representar os dias da semana, onde Segunda = 1, Terça = 2, e assim por diante. Com isso poderíamos ter o trecho de código mostrado na Listagem 2, por exemplo.

 

for ( dia = 1; dia <= 7; dia++ ) {

  if ( dia == 7 ) {

    System.out.println("Dia de folga");

  }

}

 

Podemos ver na Listagem 2 que a utilização desta abordagem compromete a clareza do código, tornando a lógica mais difícil de entender. Por isso, o uso de enums, como aquele definido na Listagem 1, pode tornar o nosso código mais legível.

Na Listagem 3 mostramos um exemplo de utilização do enum DiaSemana.

 

public class Main {

 

  public static void main(String[] args) {

    DiaSemana dia1, dia2;  // inicialmente valem null

    dia1 = DiaSemana.SEGUNDA;

    dia2 = DiaSemana.SEXTA;

    if (dia1.equals(dia2)) {

      System.out.println(dia1 + " é igual a " + dia2);

    } else {

      System.out.println(dia1 + " não é igual a " + dia2);

    }

  }

 

}

 

Observe na Listagem 3 que as referências do tipo DiaSemana são inicializadas com valores enumerados, que são os atributos (SEGUNDA, TERCA, QUARTA, etc.) do tipo definido como mostra a Listagem 1. Isso acontece porque, quando um enum é criado, cada um dos valores constantes é na verdade uma instância do tipo. Por exemplo, no enum DiaSemana, o valor enumerado SEGUNDA é do tipo DiaSemana. Dessa forma podemos concluir que o número de instâncias de um enum é limitado pelo número de valores enumerados.

Além do método equals(), usado para comparar dois objetos, há outros que também podem ser chamados por uma instância de um enum. São eles:

...

Na Easy Java Magazine nº. 4 foi publicado o artigo Solucionando Problemas usando Java, onde propusemos uma metodologia mínima que pode ser adotada para resolver problemas de programação. Nessa mesma matéria foram apresentados alguns testes cujas soluções foram abordadas usando essa metodologia. O artigo que ora iniciamos irá apresentar mais alguns problemas e resolvê-los usando essa proposta de método. E para facilitar a leitura e o entendimento vamos rever brevemente a metodologia apresentada naquele artigo, que é composta de quatro passos:

Entenda o problema

Este primeiro passo é fundamental, pois não se resolve um problema que não entendemos. Para isso, é primordial entender o domínio do problema – aquelas áreas que são importantes para solução, excluindo o que for irrelevante. Geralmente, o entendimento do domínio passa pela criação de um modelo, expressado pelo diagrama de classes.

Se possível, tente resolver o problema manualmente

Procure dividir o problema em pequenas partes, que possam ser executadas mentalmente usando papel e caneta. É o processo que comumente chamamos de teste de mesa.

Defina com precisão o algoritmo

A utilização de pseudocódigo pode ser um caminho para esse passo. O pseudocódigo deve ser mapeado posteriormente para a linguagem de programação escolhida para o desenvolvimento. Geralmente, cria-se pseudocódigo para as pequenas partes nas quais o problema foi dividido no passo anterior.

Codifique o programa

O último passo do processo é a codificação. Durante essa etapa procure escrever código mais legível, utilize identação e comentários, de forma a facilitar a depuração e manutenção posterior da aplicação.

Agora, vejamos então alguns problemas que abordam temas de Java e suas respectivas soluções que utilizam a metodologia proposta.

Classes e Objetos

Problema: Escreva uma classe chamada Conta que encapsula uma conta de banco e define três variáveis de instância, o titular (String) da conta, o saldo (double) e o limite (double). Além dos construtores e dos métodos getters e setters, escreva os métodos depositar() e sacar(). O método sacar() deve retornar um boolean. Se houver saldo suficiente para o saque, o método deve retornar true, caso contrário, deve retornar false. Escreva um programa para instanciar essa classe e fazer depósitos e saques para validar a solução.

Análise do problema: Este é um problema relativamente simples. O que deve ser observado na criação da classe é que o campo saldo não deve ser alterado através de um método setter, e sim por meio dos métodos depositar() e sacar(). A implementação desses dois métodos requer maior atenção, devido à presença do limite. O limite é um valor que o titular da conta pode sacar no caso de não possuir saldo suficiente. Vejamos então o que acontece quando fazemos um saque. Se a conta possui limite maior que 0, então o saldo da conta pode ficar negativo com o mesmo valor absoluto do limite. Dessa maneira pode-se escrever o pseudocódigo da Listagem 1, para realizar saques na conta.

 

funcao sacar(valor: real): lógico;

declare

  resultado: lógico;

inicio

  se (saldo + limite >= valor) então

    saldo := saldo – valor;

    resultado := true;

  senão

    resultado := false;

  fim-se;

fim

 

Observe que a condição (saldo + limite >= valor) no pseudocódigo atende também a situação em que a conta possui limite igual a zero, pois nesta situação precisamos saber se apenas o saldo é suficiente para fazer o saque.

Por sua vez, o método depositar() é mais simples de implementar, necessitando apenas somar ao saldo o valor depositado. Assim, pode-se definir o pseudocódigo da Listagem 2 para este método.

 

procedimento depositar(valor: real);

inicio

  saldo := saldo + valor;

fim

 

Codificação da solução: A codificação da classe Conta é muito simples e pode ser vista na Listagem 3. Inicialmente são definidos os construtores. Nesta classe criamos um construtor sem argumentos e um segundo construtor que inicializa dois campos da classe – o nome do titular e o limite. No segundo construtor, o saldo foi deixado de fora, pois seu valor pode ser modificado apenas pela chamada aos métodos depositar()

...

Na primeira parte desta série comentamos que a reutilização é uma peça fundamental para o aumento da produtividade e melhoria da qualidade dos produtos de software. Finalizamos o artigo falando do relacionamento É-UM, também chamado de generalização/especialização, e mais comumente de herança. Vimos no artigo Modelagem de Software com UML – Parte 4, publicado na Easy Java Magazine 10, que reuso é o processo de utilizar um módulo – uma classe, por exemplo – várias vezes em uma aplicação ou em aplicações diferentes. Desta forma, podemos afirmar que herança é um conceito que possibilita o reuso. Estudaremos nesta parte da série que, assim como herança, o polimorfismo é outro conceito que dá suporte à reutilização.

No entanto, para que o polimorfismo seja utilizado, é necessário que os métodos definidos nas subclasses tenham exatamente a mesma assinatura dos métodos declarados na superclasse. Esse mecanismo da orientação a objetos é chamado de sobrescrita, ou overriding, e será estudado em seguida.

Após entendermos a sobrescrita, estaremos preparados para iniciar o estudo sobre polimorfismo, que é o tópico final desta parte do curso. Nesta seção aprenderemos a implementar polimorfismo tornando as aplicações mais facilmente extensíveis.

Mas, antes de apresentarmos polimorfismo, outro conceito que precisamos entender é a sobrecarga de métodos, ou overloading. Além da importância que a sobrecarga oferece de tornar os métodos mais flexíveis, é fundamental que fique muito clara a diferença entre sobrescrita e sobrecarga.

Sobrescrita

Se uma classe herda um método de uma superclasse, então este método poderá ser sobrescrito na subclasse. Ou seja, podemos escrever uma nova implementação para um método já implementado na superclasse. A vantagem disso é tornar possível a definição de um comportamento que seja específico de determinada subclasse – ou subtipo.

Para exemplificar este recurso, iniciamos apresentando a classe Empregado na Listagem 1. Na Listagem 2, mostramos um exemplo da classe Gerente que estende a classe Empregado, e sobrescreve o método calculaSalario(). No exemplo dado, a sobrescrita se torna necessária porque os cálculos dos salários de Empregado e do seu subtipo, Gerente, são diferentes.

 

public class Empregado {

  private int matricula;

  private String nome;

  private long cpf;

  private String cargo;

  private double salario;

  private double gratificacao;

 

  public Empregado() {

  }

 

  public Empregado(int matricula, String nome) {

    this.matricula = matricula;

    this.nome = nome;

  }

 

  public Empregado(int matricula, String nome, long cpf, String cargo,

                   double salario, double gratificacao) {

    this.matricula = matricula;

    this.nome = nome;

    this.cpf = cpf;

    this.cargo = cargo;

    this.salario = salario;

    this.gratificacao = gratificacao;

  }

 

  // método sobrescrito

  public double calculaSalario() {

    return this.getSalario() + this.getGratificacao();

  }

 

  public int getMatricula() {

    return matricula;

  }

 

  public void setMatricula(int matricula) {

    this.matricula = matricula;

  }

...

Conforme já estudamos em artigos anteriores, vimos que herança possibilita um alto grau de reutilização de código, na medida em que isola o que é comum entre as classes, separando-o do que é específico. Em termos de implementação, a utilização de herança torna o código mais legível, pois pode ser visualizada diretamente no código – simplesmente, através do uso da palavra-chave extends. Além disso, no entanto, algumas questões podem se apresentar quando estamos projetando uma aplicação. A primeira delas diz respeito à instanciação da superclasse da hierarquia, pois em muitas situações a classe pai é muito genérica e não justifica a criação de objetos do tipo correspondente. A segunda questão refere-se à implementação de comportamentos que são comuns a classes que não pertencem à mesma hierarquia, ou seja, como tratar isso de forma a manter o grau de reutilização de código.

Neste novo artigo estudaremos as respostas para essas perguntas, que serão dadas pela utilização de classes abstratas e interfaces. Além disso, estudaremos que o comportamento polimórfico é preservado mesmo quando implementamos os conceitos de classes abstratas e interfaces.

Antes de iniciar nosso estudo, precisamos observar que, neste artigo, sempre que nos referirmos a interfaces, estaremos falando genericamente do limite que separa dois componentes de software, e não de interface gráfica do usuário (GUI).

Classes Abstratas

Com o objetivo de iniciar a nossa discussão sobre classes abstratas, vamos analisar a hierarquia representada através de um diagrama de classes UML (Unified Modeling Language) da Figura 1.

Baseado em nosso conhecimento de geometria é possível afirmar que, em uma aplicação, podemos instanciar Circulo, Paralelogramo, Quadrado, Retangulo e Trapezio. Pois, dessas classes, conhecemos claramente suas características, que são definidas pelos atributos, e o seu comportamento, que é dado pelos métodos. Por outro lado, qual é a forma de uma Figura? E de um Quadrilatero? Sabemos como calcular sua área ou seu perímetro? Ou seja, uma Figura ou um Quadrilatero possuem definições muito vagas, levando-nos a concluir que não faz sentido instanciar objetos desses tipos. Mas sabemos que – pelo que vimos nos artigos anteriores – da maneira que estudamos as implementações de classes, é possível criar objetos do tipo Figura ou Quadrilatero.

Assim, nosso desafio agora é impedir que uma classe assim, com definições bastante genéricas, seja instanciada. E a resposta para esse problema está no uso de classes abstratas.

Classes abstratas são aquelas que não podem ser instanciadas, mas podem ser estendidas. Na verdade, a única finalidade de uma classe abstrata, é ser superclasse de uma hierarquia. Apenas através da especialização elas podem ser utilizadas.

Segundo a definição no site da Oracle, uma classe abstrata é uma classe declarada com o modificador abstract – podendo ou não incluir métodos abstratos. Isso nos leva à necessidade de definir método abstrato. Um método abstrato é aquele declarado com o modificador abstract e sem corpo – ou seja, sem as chaves e seguido de ponto-e-vírgula, conforme o exemplo que mostramos abaixo. Note que um método abstrato deve obrigatoriamente declarar o modificador abstract e não possuir implementação.

 

public abstract double area();

 

Antes de prosseguir, mostrando a implementação da hierarquia de classes que estamos apresentando, é importante observar que na UML as classes abstratas são representadas com seus nomes em itálico.

Assim, a implementação da classe Figura da h

...

Um parâmetro que pode ser usado para medir a complexidade de um software é o número de linhas de código. Por exemplo, o Windows Vista tem cerca de 50 milhões de linhas, o kernel do Linux 3.0 tem mais de 14 milhões de linhas, a versão 2.0 do OpenOffice já apresentava mais de 10 milhões de linhas de código.

Por essa perspectiva não é difícil concluir o quanto a complexidade do software vem aumentando a cada ano que passa. Isso acarreta alguns problemas. Um deles é a dificuldade em cumprir o cronograma do projeto. Quanto maior o tamanho do programa, maior é a distância entre a estimativa de tempo prevista e o real. Segundo, os custos de desenvolvimento e manutenção aumentam consideravelmente com o tamanho do software. Estima-se, atualmente, que o custo de manutenção de um software atinge de 70 a 80% do custo total. Uma terceira dificuldade não é consequência da complexidade, mas devido à dinâmica dos negócios do usuário: os requisitos mudam. Neste século, os processos nos negócios mudam a cada seis meses ou menos. Nas décadas de 60 e 70, essas mudanças ocorriam a cada cinco anos.

Uma das peças chave para solucionar essas dificuldades chama-se reutilização. A reutilização é fundamental para o aumento da produtividade e melhoria da qualidade. De maneira geral, reutilização consiste na utilização mais de uma vez de todos os tipos de informação e artefatos encontrados durante o processo de desenvolvimento, tais como requisitos, código e testes. Existem diversas técnicas que podemos lançar mão para conseguir a reutilização. Dentre elas podemos citar os repositórios dos sistemas de controle de versão e a orientação a objetos. E é sobre a orientação a objetos que pretendemos apresentar nesta matéria.

A Programação Orientada a Objetos (Object-Oriented Programming) foi concebida na década de 60 no Centro Norueguês de Computação. Nessa época, os conceitos de classe e herança foram introduzidos através da linguagem Simula 67. No entanto, somente após o lançamento da linguagem Smalltalk nos anos 70 – considerada a linguagem orientada a objetos (OO) mais pura que existe – é que a OO começou a se popularizar. Após isso surgiram linguagens chamadas híbridas, tais como C++ e Java.

Desta forma, neste artigo serão estudados os conceitos de orientação e de que forma podemos utilizar a linguagem Java para implementá-los.

Pacotes

Em geral, quando desenvolvemos pequenas aplicações, pode ser viável manter o código em um mesmo diretório. Entretanto, em aplicações maiores, colocar todos os arquivos em uma mesma pasta, sem organização, pode prejudicar principalmente a manutenção do sistema. Por isso sugere-se que o código seja agrupado, de forma que as classes relacionadas fiquem em um mesmo diretório. Esses diretórios – juntamente com os arquivos dentro deles – são chamados de pacotes, e tanto o código fonte das classes quanto os arquivos compilados – e mesmo outros pacotes – são organizados dentro desses diretórios. Por curiosidade, todo o código da API (Application Programming Interface) do Java também está organizado em pacotes. Por exemplo: o pacote java.io contém as classes referentes a I/O (Entrada/Saída) e o pacote java.net oferece o que é necessário para lidar com redes.

Supondo que uma classe chamada Pessoa pertença ao pacote br.com.nomeempresa.nomeprojeto, então seu nome completo será br.com.nomeempresa.nomeprojeto.Pessoa. Essa é uma forma de evitar conflitos de nomes, pois classes em pacotes diferentes têm nomes completos diferentes.

Considerando este mesmo exemplo, quando o compilador encontra uma referência à classe Pessoa, ele irá procurar o arquivo Pessoa.class no diretório br/com/nomeempresa/nomeprojeto. Tenha em mente que cada um desses diretórios é um pacote.

Para indicar que um arquivo fonte Java pertence a um dado pacote, a primeira linha de código deste arquivo deve ser a declaração:

 

package br.com.nomeempresa.nomeprojeto

 

No caso em que esta declaração não está presente, o arquivo fonte fará parte do pacote default, que é o próprio diretório corrente do projeto.

Para referenciar uma classe de um pacote, é possível usar o nome completo da classe. No entanto, o que se faz normalmente é usar a declaração import. Por exemplo, pode-se declarar o seguinte no início do código:

 

import br.com.nomeempresa.nomeprojeto.Pessoa;

 

A partir de então a classe pode ser referenciada apenas pelo nome Pessoa. Podemos também especificar no código do programa que todas as classes do pacote serão referenciadas somente pelo nome. Para obter esse efeito, declaramos:

 

import br.com.nomeempresa.nomeprojeto.*;

 

A exceção a essas regras é o uso das classes do pacote java.lang. Quando uma nova classe é criada na aplicação, implicitamente é declarado um import a este pacote. Ele contém classes essenciais para a interpretação de qualquer programa Java, tais como String, System e

...

A utilização de um Ambiente Integrado de Desenvolvimento (IDE) pressupõe investimento de tempo no projeto visual do aplicativo e na edição do código. O projeto visual consiste em posicionar e redimensionar componentes – tais como botões, caixas de texto e painéis – em um form. Por outro lado, a edição de código corresponde a programar respostas a eventos – tais como clique de botões ou pressionamento de uma tecla.

Essas são tarefas corriqueiras que podem ser realizadas usando um IDE. Tais tarefas serão apresentadas na prática nesta última parte da matéria, após termos explorado com algum detalhamento vários recursos oferecidos pelo NetBeans.

O conhecimento dos recursos, tais como complementação de código, gerência de conexão a diversos bancos de dados e integração de várias ferramentas em um único IDE, que foram analisados nas duas primeiras partes da matéria, são fundamentais para desenvolver aplicações com mais eficiência e maior produtividade.

A criação de um pequeno aplicativo com interface gráfica encerra esta série de artigos, possibilitando ao leitor a aplicação do conhecimento exposto nas duas primeiras partes do minicurso. Nesta parte, principalmente, serão explorados o GUI Builder e o uso do Group Layout, além do Editor de Código e da customização do código gerado pelo NetBeans. Com esta prática pretende-se dar o suporte necessário para que o programador possa usar o IDE com desenvoltura em seus futuros projetos.

Layouts

Em Java, layouts são abstrações que definem o comportamento e a maneira como os componentes ficam dispostos em uma interface do usuário. Gerenciadores de layout organizam o redimensionamento e o posicionamento dos widgets dentro de um contêiner, permitindo que as interfaces gráficas se adaptem às diversas resoluções de vídeo, aparência e comportamento desses componentes. Observe na Figura 1 uma GUI que não utiliza gerenciador de layout. São mostradas imagens de uma janela, antes e depois de um redimensionamento. Note que os botões não são reposicionados após o redimensionamento da janela. Os gerenciadores de layout é a técnica criada pelos projetistas do Java para garantir a portabilidade das aplicações em diferentes plataformas.

 O NetBeans agiliza o desenvolvimento de aplicações GUI, permitindo que os layouts sejam visualizados e configurados sem a necessidade de escrever código. O IDE suporta vários gerenciadores de layout de Java. Entretanto, não oferece suporte a OverlayLayout e SpringLayout. A seguir serão descritos brevemente os layouts suportados pelo ambiente:

Desenho livre (Free Design) – Esta é a denominação que o NetBeans utiliza para se referir ao gerenciador de layout GroupLayout, lançado junto com o Java SE 6. Com sua utilização pode-se posicionar e redimensionar os componentes livremente no form. À medida que os widgets são arrastados, arranjados, alinhados e redimensionados, o GUI Builder apresenta dicas visuais que ajudam no posicionamento dos componentes.

O desenho do form utilizando essas guias sugeridas pelo IDE permite que o redimensionamento da janela, a especificação da aparência ou a alteração de locais (Locale) não modifiquem o relacionamento entre os componentes. Ou seja, a janela da aplicação se ajusta à aparência e à funcionalidade do sistema operacional. A classe Locale é usada para representar uma região geográfica, política ou cultural. Por exemplo, a formatação de um número, provida pela classe NumberFormat, depende de Locale. Tal como no caso do número 123456, que é representado como 123.456 no Brasil e 123,456 nos Estados Unidos.

Na Figura 2 podemos ver as guias de alinhamento e ancoragem. Este é o gerenciador de layout padrão do NetBeans. Na aplicação exemplo que será criada mais adiante será detalhada a utilização do Free Design.

 Layout absoluto (AbsoluteLayout) – Usar este gerenciador ou Null Layout produz o mesmo resultado. AbsoluteLayout permite que os componentes sejam posicionados exatamente onde se deseja e redimensionados usando suas bordas. O NetBeans suporta esse layout por razões históricas, mas os desenvolvedores não devem usá-lo em aplicações de produção, pois a posição e/ou dimensão de um componente, quando a aplicação for executada, não irá se alterar mesmo que haja mudança de aparência no ambiente ou redimensionamento da interface. Este gerenciador de layout é útil para construir protótipos. Protótipo é um sistema normalmente sem funcionalidades. Isto é, criado apenas com a interface gráfica. Comumente, um protótipo é utilizado para aprovação do cliente ou para identificação dos requisitos (funcionalidades) do usuário, por exemplo. A ideia de usar AbsoluteLayout é que o protótipo deve ser criado rapidamente e depois descartado.

Layout de borda (BorderLayout) – Divide o contêiner em cinco regiões, onde os componentes são arranjados: norte, sul, leste, oeste e centro, como mostra a Figura 3. As posições são representadas por constantes definidas na classe BorderLayout, tais como CENTER, que posiciona um componente na região central do contêiner e NORTH, que posiciona um objeto na região superior.

Layout de caixa (BoxLayout) – Com este gerenciador os componentes são arranjados horizontalmente ou verticalmente. Os widgets são posicionados da esquerda para direita ou de cima para baixo à medida que são adicionados ao form. Os componentes não são deslocados para uma segunda linha ou coluna, mesmo que novos objetos sejam adicionados ou o form seja redimensionado. Veja nas Figuras 4 e 5 exemplos de utilização de BoxLayout.

 Layout de cartão (CardLayout) – Os componentes ficam arranjados em cartões (um tipo de painel) compartilhando a mesma área de um contêiner. Apenas um cartão é visível de cada vez. Para definir qual dos componentes será exibido, a classe CardLayout oferece métodos para navegação, tais como first() para acessar o primeiro cartão e next() para acessar o próximo, após o atual. Assemelha-se ao uso de abas, como no Firefox, por exemplo.

Layout de conjunto de grades (GridBagLayout) – Organiza os componentes colocando cada um em uma célula de uma grade. Um componente pode ocupar mais de uma célula. As linhas da grade podem ter alturas diferentes, assim como as larguras das colunas, ou seja, as células não precisam ter o mesmo tamanho. Uma classe chamada GridBagConstraints define como o componente irá se comportar dentro da célula. Por exemplo, o atributo insets dessa classe define o espaço ao redor do widget, que é nulo por padrão. Na Figura 6 pode ser visto um exemplo de utilização deste gerenciador de layout.

 

Layout de fluxo (FlowLayout) – Dispõe os componentes um ao lado do outro, formando uma linha. Se o contêiner não tiver espaço suficiente para acomodar todos os componentes em uma linha, o próprio gerenciador se encarrega de posicioná-los em uma nova linha. Veja o exemplo na Figura 7 e observe que o FlowLayout respeita o tamanho do componente, definindo uma largura para o botão, que seja necessária para acomodar o rótulo.

 Layout de grade (GridLayout) – Arranja os componentes em células de mesmo tamanho. O número de linhas e colunas pode ser configurado. Note no exemplo da Figura 8 que o gerenciador ajustou o tamanho das células tomando como base o maior componente.

 Null Layout – Consiste no desenho da interface sem utilizar layout. Em cada widget devem ser definidas as suas coordenadas e suas dimensões.

No NetBeans é muito simples selecionar um layout. Para definir um layout para um contêiner simplesmente clique com o botão direito sobre ele. Em seguida escolha Definir layout e então escolha a opção desejada. Clicar com o botão direito sobre o contêiner no Inspetor também permite definir um gerenciador de layout. Uma aplicação não precisa estar atrelada a um único gerenciador de layout. Em cada contêiner – tal como um JFrame ou JPanel – no software aplicativo é possível definir um gerenciador diferente.

Criando uma aplicação GUI

Com o objetivo de aplicar alguns dos conhecimentos sobre o NetBeans expostos até aqui, nesta seção será criada uma pequena interface gráfica. Mais do que simplesmente construir a interface, será mostrado como codificar o comportamento de alguns componentes, tais como botões, caixas de texto e botões de rádio.

A interface consiste de uma calculadora de quatro operações, onde duas caixas de texto (JTextField) serão usadas para entrada dos valores a serem calculados, quatro botões de rádio (JRadioButton) permitem a escolha da operação desejada (adição, subtração, multiplicação e divisão), um botão (JButton) faz o cálculo e o resultado é mostrado em uma terceira caixa de texto. Além destes, dois botões completam a interface: um que faz a limpeza das caixas de texto e outro que provoca a saída do programa.

A seguir, serão então mostradas as etapas necessárias para o desenvolvimento desta interface, começando pela criação do projeto.

Primeira etapa: Criar o projeto

Para criar o projeto siga os passos a seguir:

1.                  Com o NetBeans aberto, escolha Arquivo > Novo projeto, ou pressione CTRL + SHIFT + N;

2.                  Em Categorias, selecione Java, e em Projetos, escolha Aplicativo Java. Feito isso clique no botão Próximo;

3.                  Na tela seguinte digite “Calculadora” em Nome do projeto, desmarque a caixa Criar classe principal e deixe as demais opções como estão;

4.                  Clique no botão Finalizar.

 

Ao final, na janela Projetos haverá um projeto denominado Calculadora, como pode ser visto na Figura 9. Note que o nome do mesmo está em negrito, indicando que ele é o principal. Projeto principal é o ponto de entrada (módulo principal) de uma aplicação; é ele que contém a classe main.  Muitas opções de menu atuam por padrão sobre o projeto principal como, por exemplo, Executar > Construir projeto principal ou Executar > Executar projeto principal. No entanto, ter um projeto principal não é obrigatório. Por exemplo, vejamos o que acontece se você selecionar Executar > Definir como projeto principal > Nenhum. A partir daí, se houver um arquivo aberto no Editor de Código, as opções de menu Construir projeto principal e Executar projeto principal mudam para Construir projeto (nome do projeto) e Executar projeto (nome do projeto). Se não houver arquivo aberto no Editor estas opções estarão desabilitadas.

 

Segunda etapa: Criar e editar a interface

Para criar a interface gráfica é necessário um contêiner, onde serão colocados os componentes. Como vimos anteriormente, a Swing oferece várias opções de contêiner. Dentre elas, optamos por usar o componente JFrame. Ele será criado em um pacote dentro do nó Pacotes de código-fonte, seguindo estes passos:

1.                  Na janela Projetos, clique com o botão direito no nó Pacotes de código-fonte e escolha Novo > Formulário JFrame;

2.                  Digite “CalculadoraUI” em Nome da classe e “ui” em Pacote;

3.                  Clique em Finalizar.

 

Nesse momento o NetBeans cria um form e uma classe denominada CalculadoraUI. No GUI Builder é aberto o form recém-criado, pronto para ser desenhado a partir da Paleta. Antes de prosseguir com o exemplo, é importante destacar que, neste artigo, usaremos o termo “desenhar/desenho” como tradução de “design”, para não confundir com o termo “projetar/projeto”. Fazemos essa observação, porque a palavra “projeto” é usada para designar um plano ou esquema para criar um produto. Por outro lado, “desenho” diz respeito ao esboço ou rascunho de um objeto. Desta forma, para desenhar a interface, proceda desta maneira:

1.                  Na janela Propriedades localize title e digite “Calculadora”, para definir o título do JFrame;

2.                  Selecione então um JPanel da Paleta e arraste-o para o JFrame. Posicione-o próximo ao canto superior esquerdo do contêiner até que duas linhas guia apareçam indicando a posição preferencial, como podemos ver na Figura 10. Neste ponto solte o painel;

3.           Agora vamos redimensionar o JPanel para que ele possa acomodar os outros componentes. Deste modo, clique na alça de redimensionamento da margem direita do painel e o arraste até que a linha guia da margem direita apareça na borda do JFrame, conforme mostra a Figura 11. Solte nesse ponto a alça de redimensionamento;

4.                  Selecione um JButton da Paleta e posicione-o próximo ao canto inferior direito do JFrame. Assegure-se de posicionar o botão quando as linhas guias, semelhantes àquelas da Figura 10, aparecerem;

5.                  Clique na alça de redimensionamento da margem inferior do JPanel e arraste-a para baixo até que apareçam três linhas guia entre ele e o botão, como podemos ver na Figura 12. Você tem essas três opções de espaçamento entre os componentes. Optamos por deixar o espaçamento em três linhas, portanto solte a alça de redimensionamento nesse ponto;

 6.                  De uma maneira geral o JPanel reúne componentes que pertencem a um mesmo grupo, tal como no exemplo que está sendo criado. Nesta situação é aconselhável atribuir um título ao painel, que identifique o grupo de componentes. Para definir o título selecione o JPanel, vá para a janela Propriedades e clique no botão elipse (...) da propriedade border;

7.                  Na caixa de diálogo que é aberta, selecione Borda de título na lista e digite “Calculadora” na propriedade Título;

8.                  Clique em OK para salvar;

9.                  Neste exemplo, um JLabel será utilizado para identificar caixas de texto, principalmente. Então, clique em um JLabel na Paleta e posicione-o no canto superior esquerdo do JPanel, quando surgirem as duas linhas guia, semelhante ao que é exibido na Figura 13;

 

10.              Neste ponto será adicionada uma caixa de texto ao lado direito do rótulo anterior. Selecione então um JTextField na Paleta. Movimente o cursor à direita do rótulo recém-adicionado até que apareça a linha que indica que os dois componentes estão alinhados pela base, e as duas linhas que definem a margem entre eles, de acordo com o que pode ser visto na Figura 14. Clique nesse ponto para posicionar o componente;

 

11.              Agora clique na alça de alinhamento da caixa de texto, arraste-a até aparecer a linha guia da margem direita do painel e então solte-a. Dessa maneira, quando o form for redimensionado, a caixa de texto também será;

12.              Selecione novo rótulo (JLabel) e posicione-o conforme a Figura 15;

 

13.              Em seguida adicione um JTextField repetindo os passos 10 e 11;

14.              Adicione um JLabel repetindo o passo 12 e mais um JTextField repetindo os passos 10 e 11;

15.              E adicione mais um JLabel repetindo o passo 12;

16.              Neste momento vamos inserir quatro JRadioButtons abaixo do rótulo recém-adicionado e indentado em relação a ele. Deste modo, selecione um JRadioButton na Paleta e posicione-o abaixo do último rótulo, de forma que os dois fiquem alinhados pela esquerda. Movimente-o levemente para direita até que a linha guia de indentação apareça, como mostra a Figura 16, e clique no painel ao mesmo tempo em que pressiona a tecla SHIFT. O pressionamento desta tecla ao mesmo tempo em que solta o componente permite adicionar mais de um widget do mesmo tipo, sem a necessidade de selecioná-lo na Paleta a cada vez. Ao posicionar o último componente, não se deve mais pressionar SHIFT, para evitar que um próximo clique de mouse insira uma cópia adicional e desnecessária do objeto.

 

17.              Adicione então mais três JRadioButton no painel, um à direita do outro, respeitando sempre o espaçamento sugerido;

18.              Os botões que realizam os cálculos e a limpeza dos campos serão posicionados no canto inferior direito do painel. Adicione então um JButton no JPanel de acordo com a Figura 17;

19.              Adicione mais um JButton à esquerda do botão anterior, respeitando o alinhamento conforme a Figura 18;

20.              A fim de oferecer uniformidade, é aconselhável definir que os botões em um contêiner tenham o mesmo tamanho. Para obter isso, selecione os dois botões adicionados no painel pressionando ao mesmo tempo a tecla CTRL. Então clique com o botão direito em um deles, escolha a opção Mesmo tamanho e marque Mesma largura. Dessa forma os dois botões terão o mesmo tamanho daquele que tiver o texto maior;

Figura 17. Posicionamento de JButton no canto inferior direito do painel.

Figura 18. Posicionamento de um JButton em relação a outro.

21.              Para finalizar esta etapa, selecione o jRadioButton1 e marque a caixa de verificação da propriedade selected. Isso define a operação padrão da Calculadora, pois esta é a opção que estará selecionada sempre que o programa executar.

 

Ao adicionar um componente no form o NetBeans atribui a ele um nome de variável e, quando é o caso, um texto (text). Para um JButton, por exemplo, text identifica visualmente o objeto. Em um JTextField, o texto representa o conteúdo digitado pelo usuário. Essas propriedades devem ser modificadas para representar informações mais significativas, tanto para o usuário quanto para o desenvolvedor. Contudo, antes de editar o texto e alterar o nome da variável de cada componente é necessário agrupar os JRadioButtons de forma que apenas um esteja marcado de cada vez. Para conseguir essa funcionalidade é preciso adicionar os quatro botões a um ButtonGroup. Isto é obtido obedecendo os passos a seguir:

1.                  Selecione um ButtonGroup na Paleta e o coloque em qualquer lugar no form. Ele não é visível na interface, apenas em Inspetor, sob o nó Outros componentes;

2.                  Selecione o primeiro JRadioButton na interface;

3.                  Na janela Propriedades localize buttonGroup, clique na caixa combinada à direita e selecione buttonGroup1;

4.                  Repita os passos 2 e 3 para os demais JRadioButtons.

 

Após finalizar esse procedimento, irá aparecer uma linha indicando que os botões de rádio estão interligados formando um grupo.

Agora serão modificados o texto e o nome da variável dos componentes. Para fazer essas alterações, clique com o botão direito do mouse sobre o componente na interface e selecione cada uma das opções: Editar texto ou Alterar nome da variável. Guie-se pela Tabela 1 para fazer as alterações.

 

Componente

Editar texto

Alterar nome da variável

...

Embora as aplicações web estejam em alta, principalmente devido à chamada computação na nuvem (cloud computing), as aplicações desktop ainda mantêm sua importância, justificável notadamente pelo seu melhor desempenho. Desde a criação da tecnologia applet – mini-aplicativo GUI que executa no navegador web – Java tem crescido e amadurecido sua capacidade de criar sistemas desktop. Esse tipo de programa é construído usando as bibliotecas Swing e AWT do Java, e o NetBeans agiliza a sua criação através do uso do GUI Builder.

Alia-se a esta ferramenta, o poder que o IDE oferece para lidar com vários Sistemas Gerenciadores de Bancos de Dados (SGBDs), e o desenvolvedor terá à sua disposição recursos que possibilitam um aumento considerável na sua produtividade. É importante ressaltar que o NetBeans trás recursos não apenas para a criação da aplicações que acessam banco de dados, mas também para realizar diferentes tarefas que são fundamentais no trabalho do programador, tais como conectar-se ao banco de dados, criar e povoar tabelas, etc.

Estes são os recursos do NetBeans que focaremos neste artigo. Inicialmente falaremos do uso do Database Explorer – e todas as funcionalidades associadas – para gerenciar banco de dados no IDE, e em seguida iremos apresentar os elementos que o ambiente oferece para a criação de aplicações com interface gráfica, reunidos no GUI Builder.

Juntando este conhecimento, com o que foi estudado na primeira parte da matéria – configuração do IDE e Editor de Código – o desenvolvedor terá uma base fundamental para começar a usar o NetBeans e criar suas primeiras aplicações.

Trabalhando com bancos de dados usando o Database Explorer

Um dos principais componentes de uma aplicação é o banco de dados relacional. Dificilmente o desenvolvedor criará um sistema onde não seja necessário persistir (salvar) dados. Por isso, além de oferecer assistentes que facilitam o desenvolvimento de programas, o NetBeans dispõe de um recurso que pode fazer as mais variadas tarefas envolvendo bancos de dados: conectar-se, executar scripts, migrar esquemas entre bancos de dados de diferentes fabricantes, etc. Esta ferramenta encontra-se na janela Serviços. A janela Serviços possibilita acesso a serviços Web, tais como Google, por exemplo; servidores de aplicação, tais como GlassFish; servidores para desenvolvimento colaborativo, tais como java.net; além de bancos de dados. Nesta janela, o nó Banco de dados, e todos os seus nós filhos, é chamado Database Explorer.

 

Esquema de banco de dados: é um conjunto de objetos tais como: tabelas, visões, sequências, procedimentos armazenados, etc., disponíveis para um determinado grupo de usuários. Pode-se dizer que esquemas são semelhantes a diretórios em um sistema de arquivos, exceto que não se pode criar árvores de esquemas. Ou seja, não é possível criar esquemas em níveis inferiores ao primeiro. Um esquema é especificado por um grupo de comandos SQL chamado Data Definition Language (DDL), do qual faz parte CREATE TABLE, por exemplo.

Comumente, os fabricantes de SGBD oferecem, junto com seus produtos, ferramentas que auxiliam no projeto, desenvolvimento e administração de seus bancos de dados. Muitas dessas ferramentas possibilitam, por exemplo, criar tabelas visualmente – sem necessidade de conhecimento da linguagem SQL. Para os administradores de bancos de dados, o uso de tais ferramentas é uma necessidade, mas para os desenvolvedores, ferramentas mais leves são, geralmente, suficientes. O Database Explorer é um desses recursos, leve e que pode ajudar muito no trabalho do programador.

Através do Database Explorer o usuário pode realizar várias tarefas, tais como:

·         Conectar-se a um banco de dados;

·         Visualizar as conexões atuais;

·         Adicionar ou selecionar um driver Java Database Connectivity (JDBC);

...

O domínio de uma linguagem de programação pode não ser suficiente para que um desenvolvedor desempenhe com eficiência o seu trabalho. Considera-se tão importante quanto o conhecimento da linguagem, a habilidade em um Ambiente Integrado de Desenvolvimento (IDE). Esta afirmação baseia-se principalmente no fato que um ambiente de desenvolvimento pode aumentar muito a produtividade do programador, pois grande parte do trabalho manual é feita pela ferramenta, liberando o profissional para atividades que dependem mais de seus recursos mentais. Uma dessas ferramentas é o NetBeans, que será apresentada nesta matéria.

A origem do NetBeans é o projeto Xelfi, criado em 1996 por dois estudantes universitários tchecos. Em 1999, após se tornar um IDE proprietário denominado NetBeans DeveloperX2, foi adquirido pela Sun Microsystems. Seis meses depois da aquisição, a Sun decidiu tornar o NetBeans um projeto open source. Em 2009 a Oracle comprou a Sun Microsystems, mantendo até aqui o NetBeans como um projeto de código aberto. Atualmente a versão estável, disponível para download no site oficial, é a 6.9.1, mas pode ser baixada também a versão 7.0 beta.

Nas seções seguintes do artigo serão exploradas a configuração e características do ambiente, utilizando Java, sempre que possível, para mostrar a aplicação prática de cada recurso. No entanto, deve-se observar que o NetBeans pode ser usado com C/C++, PHP, JavaScript, Groovy e Ruby.

A tradução da interface do NetBeans para o português não é muito boa. No entanto, optou-se por usar este idioma pensando em facilitar o entendimento por parte do leitor. Mais adiante será mostrado como alterar o idioma da interface.

O artigo foi dividido em duas partes. A primeira focará na configuração do ambiente e do Editor de Código, e será finalizada com a criação de exemplos que mostram a aplicação de alguns recursos do IDE. Além disso, serão abordadas as maneiras de empacotar e distribuir aplicações desktop. Deixaremos para abordar na segunda parte o uso de banco de dados e a criação de aplicações usando o GUI Builder.

Adquirindo e instalando a ferramenta

O NetBeans está disponível para download no site netbeans.org. Ao acessar a página de downloads, automaticamente é selecionada a plataforma e o idioma do IDE, conforme o sistema operacional do usuário. No entanto, é possível alterar qualquer uma das opções. Selecione a distribuição desejada de acordo com as tecnologias que você deseja trabalhar. Se, depois de instalado, você precisar adicionar novos pacotes ao ambiente, pode fazer isso usando o Gerenciador de Plugins em Ferramentas | Plug-ins, como será visto mais adiante. Na Figura 1 é mostrada a página de downloads.

A instalação do NetBeans é muito simples. O único cuidado que se deve ter é instalar previamente o Java Development Kit 6.0. Para o ambiente Windows o instalador do IDE é um simples arquivo .exe sem necessidade de maiores explicações. Mesmo para o Linux, existe um instalador com Interface Gráfica do Usuário (GUI). No Ubuntu, após baixar o instalador, abra o Terminal, mude para o diretório onde está o arquivo e digite:

 

sudo ./netbeans-6.9.1-ml-javase-linux.sh

 

O nome do arquivo depende da distribuição e da versão que foi escolhida. Siga as orientações da interface e finalize. Encerrada a instalação, vamos conhecer alguns elementos que compõem o ambiente.

Familiarizando-se com o IDE

Ao executar o NetBeans pela primeira vez após a instalação, é mostrada a Página Inicial com três abas: Aprender & descobrir, Meu NetBeans e O que há de novo. Na aba Aprender & descobrir existem links para tutoriais e exemplos de projetos, que podem ser úteis principalmente para quem está iniciando seu aprendizado. Desmarque a caixa Exibir ao iniciar e feche a página. No entanto, se você preferir manter visível essa página, ela vai se manter como uma aba na área do Editor de Código.

Antes de começar a utilizar o IDE precisamos conhecer alguns elementos básicos da interface da ferramenta. Para fins didáticos a interface do NetBeans foi dividida em cinco grandes áreas. Na Figura 2 elas foram identificadas com os números de um a cinco. Em cada uma delas podem ser visualizadas diferentes janelas:

Área 1 – Onde podem ser apresentadas diversas janelas, cuja visualização pode ser ativada selecionando a opção correspondente no menu Janela. A janela Projetos apresenta uma visão lógica do conteúdo dos projetos. Em Arquivos é possível ter uma visão dos diretórios dos projetos, incluindo arquivos e pastas não mostrados na janela Projetos. Serviços é uma visão lógica de recursos tais como bancos de dados, servidores web, etc., que estão registrados no ambiente. Favoritos possibilita acessar arquivos no micro ou na rede, sem a necessidade de criar um projeto;

Área 2 – É onde estão o Editor de Código e o GUI Builder. GUI Builder é onde os formulários GUI são desenhados. Se em um projeto for criada uma classe GUI, por exemplo, na área do Editor de Código pode-se alternar entre o editor de código fonte (selecionando a guia Código-fonte) e o GUI Builder (selecionando a guia Projeto). Mais adiante o Editor de Código será tratado em uma seção específica, e na segunda parte do artigo o GUI Builder será descrito com mais detalhes;

Área 3 – Nesta área estão a Paleta e a janela Propriedades. Na Paleta estão os componentes disponíveis para diversos editores do IDE, tais como o GUI Builder e o Visual Mobile Designer. Para formulários GUI existem contêineres e outros componentes visuais, tais como botões, rótulos, painéis, etc. Em Propriedades são mostrados nomes e valores de propriedades de objetos que fazem parte de um projeto. Por exemplo, se for selecionado um arquivo Java, em Propriedades serão visualizados: nome, extensão, tamanho do arquivo, entre outras. No caso de uma GUI, se for selecionado um botão, por exemplo, serão visualizadas propriedades tais como rótulo, largura, altura, etc.;

Área 4 – Contém as janelas Navegador e Inspetor. Na primeira se pode navegar por diferentes partes do arquivo selecionado. Num arquivo Java, por exemplo, pode-se navegar por construtores, métodos e atributos. A janela Inspetor mostra a hierarquia de todos os compone

...

Na primeira parte deste artigo estudamos as APIs e os módulos que compõem o Hibernate, e de que forma esses componentes podem ser combinados para resolver problemas de persistência, usando tanto a solução tradicional quanto a Java Persistence API (JPA). Foram analisados com um pouco mais de detalhes os metadados de mapeamento suportados pelo framework e os mecanismos de geração de chaves primárias.

Nesta segunda parte será criada uma aplicação simples usando o Hibernate como mecanismo de persistência. Mais especificamente será utilizado o Hibernate JPA. Adotaremos o Integrated Development Environment (IDE) NetBeans como ambiente de desenvolvimento. A escolha deste ambiente se deu, não apenas por ele já trazer integradas as bibliotecas do Hibernate, da JPA e os drivers JDBC de diversos Sistemas de Gerenciamento de Banco de Dados (SGBDs), tais como o PostgreSQL e o MySQL, mas também, por disponibilizar diversos assistentes que facilitam o trabalho do desenvolvedor, como veremos adiante.

Desenvolvendo a Aplicação

Antes de iniciar o desenvolvimento usando o Hibernate é necessário analisar o cenário, pois, dependendo do problema a ser resolvido, a abordagem pode ser diferente. Pode-se iniciar um projeto a partir de uma análise orientada a objetos do domínio e um esquema de banco de dados recém-criado, a partir de uma aplicação legada onde o esquema será criado ou ainda, a partir de uma aplicação e esquema de banco de dados legados. Para quase todos esses cenários, o Hibernate oferece alternativas que podem ajudar o desenvolvedor.

Esquema de banco de dados é um conjunto de objetos tais como: tabelas, visões, sequências, procedimentos armazenados, etc., disponíveis para um determinado grupo de usuários. Um esquema é especificado por um grupo de comandos SQL chamado Data Definition Language (DDL), do qual faz parte CREATE TABLE, por exemplo.

Sistemas legados – incluem aplicações e esquemas de banco de dados – são sistemas antigos, geralmente sem documentação, mas que são fundamentais para uma organização. É comum que esses sistemas permaneçam ativos, devido à dificuldade e ao custo elevado para efetuar a sua modernização.

O roteiro que será seguido para o desenvolvimento da aplicação exemplo é o que foi proposto por Gavin King no livro Java Persistence with Hibernate:

·         Escolher o processo de desenvolvimento. Entre os processos possíveis tem-se: top-down, bottom-up, middle-out e meet-in-the-middle. No top-down inicia-se uma aplicação a partir do modelo de domínio e sua implementação. Usa-se bottom-up quando já existe um esquema de banco de dados. Quando o desenvolvedor inicia a aplicação criando os arquivos de mapeamento em XML para então gerar o esquema de banco de dados o processo é chamado Middle-out. Meet-in-the-middle ocorre quando já existem as classes Java e o esquema de banco de dados;

·         Definir a infraestrutura do projeto. Esta etapa corresponde a criar o projeto no ambiente de desenvolvimento e adicionar as bibliotecas necessárias. Como foi comentado anteriormente, o IDE NetBeans facilita bastante esta e outras etapas da criação da aplicação;

·         Criar o modelo de domínio e os mapeamentos. Isto implica em escrever o código das classes persistentes e definir seus mapeamentos, seja usando XML ou anotações;

·         Configurar o Hibernate. Quando o mapeamento é utilizado através de arquivos XML, a configuração é feita através de um arquivo chamado hibernate.cfg.xml ou de um arquivo de configuração chamado hibernate.properties. No entanto, como usaremos Hibernate Annotations, será utilizado o arquivo persistence.xml, pois este é o arquivo de configuração em uma aplicação JPA;

·         Executar a aplicação. Nesta etapa é criada a classe principal da aplicação responsável por armazenar e ler os objetos. No entanto, é aconselhável que a responsabilidade por essas e outras operações sobre os objetos seja atribuída a uma classe controller ou Data Access Object (DAO), por exemplo.

 

No exemplo que será criado optamos por usar o processo top-down, visto que estamos iniciando um projeto totalmente novo. Como ambiente de desenvolvimento foi escolhido o NetBeans 6.9.1 e elegemos o PostgreSQL (PG) como SGBD. Além disso, optamos por escrever a aplicação utilizando JPA, ou seja, será utilizado Hibernate Annotations e Entity Manager.

Controller é um dos objetos do padrão Model-View-Controller (MVC). É a classe que converte as ações do usuário que ocorrem no View em tarefas que serão realizadas pelo Model. Os outros dois objetos do padrão são o Model, que mantém as regras de acesso a dados, e o View, que especifica como o Model deve ser apresentado.

DAO é um padrão de persistência. É um objeto responsável pelas operações no modelo de dados – criar, destruir, atualizar e ler – que permite separar as regras de negócio das regras de acesso a dados. Deve haver um DAO para cada tabela ou entidade no banco de dados.

Definindo a infraestrutura do projeto

Inicialmente será criado um novo projeto no NetBeans. Para isso pressione o botão New Project na barra de ferramentas. Na primeira tela de criação escolha a categoria Java, projeto do tipo Java Application e clique em Next, como pode ser visto na Figura 1. Em seguida atribua um nome ao projeto e deixe marcada apenas a opção Set as Main Project, definindo que esse será o projeto principal do IDE. Pressionar F6 no IDE executa o projeto principal. Confirme a criação do projeto.

Agora é o momento de adicionar as bibliotecas necessárias para a aplicação. Na aba de projetos, como é mostrado na Figura 2, clique com o botão direito na pasta Libraries do projeto recém-criado. Escolha a opção Add Library. Selecione e confirme as bibliotecas Hibernate, Persistence e PostgreSQL JDBC Driver, que são a API nativa, a API para JPA e o driver JDBC, respectivamente.

 

Criando o modelo de domínio e os mapeamentos

Modelo de domínio são as classes persistentes definidas a partir da análise do domínio do negócio. E classes persistentes são aquelas que são mapeadas para tabelas de banco de dados. Nosso exemplo consiste de uma única classe e seu mapeamento – a classe Cidade. Esta classe tem os atributos nome e uf do tipo String. Além deles, ela necessita de um identificador, que foi definido como sendo do tipo Long e será denominado id. Para a criação da classe, na aba de projetos

...

Solucionando problemas usando Java
Como abordar problemas de programação usando Java




Muito já foi discutido sobre o tema “programação é arte ou ciência”. Não é pretensão do autor entrar na discussão, mas usar como ponto de partida deste artigo uma afirmação daquele que consideramos o pai da matéria – Donald Knuth. No artigo “Computer Programming as an Art”, ele afirma que “programação de computadores é uma arte, porque aplica conhecimento acumulado, porque requer habilidade e engenhosidade e, especialmente, porque produz objetos de beleza”.
Note que Knuth não fala sobre talento, inspiração ou coisas do gênero. De onde pode-se concluir que é necessário se preparar, conhecer as ferramentas que serão utilizadas e ter entendimento sobre o domínio do problema.
Para reforçar o exposto acima, Steven Skiena, no prefácio do livro “The Algorithm Design Manual”, diz que a criação de algoritmos corretos e eficientes que solucionem problemas reais exige o conhecimento de técnicas e recursos. Ele considera que a técnica mais importante é a modelagem. Modelagem é a arte de analisar um problema e abstrair uma solução adequada para ser abordada por um algoritmo. E os recursos são formados pela base de conhecimento de algoritmos clássicos, que servem de ponto de partida para a solução do problema.
Desta forma, na seção seguinte será sugerida uma metodologia simples e prática a ser seguida na solução de problemas de programação.
Donald Knuth é um cientista da computação, autor de uma das principais referências na área – a série de livros entitulados “The Art of Computer Programming”. Em reconhecimento à sua contribuição, a Universidade de Stanford o agraciou com o título “Professor Emeritus of The Art of Computer Programming”.
Abstrair significa concentrar-se nos aspectos essenciais do domínio de um problema, ignorando características irrelevantes. Por exemplo: na análise de um Sistema Acadêmico Escolar, as classes Aluno, Professor e Disciplina são casos de abstração.
Como abordar um problema de programação
Descreveremos aqui alguns passos, não necessariamente imprescindíveis, que poderão ajudar-nos a produzir soluções de programação corretas e eficientes.
Entenda o problema
O problema deve ser bem definido com o máximo de detalhes. Entender o domínio do problema é fundamental. A especificação dos dados que representam as entradas e as informações que a solução do problema deve produzir devem ser também descritas minuciosamente. Se julgar necessário, crie um modelo de domínio preliminar. Leia a seção “Introdução ao modelo de domínio” para um pouco mais de detalhes.
Se for possível, tente resolver o problema manualmente
Execute pequenas partes da solução mentalmente, usando como auxílio papel e caneta. Procure usar valores de entrada diferentes e variados para ver o que acontece. Esse procedimento é o que chamamos teste de mesa.
Defina com precisão o algoritmo
É sempre bom escrever algum pseudocódigo descrevendo o que o programa irá fazer. Certamente que, em se tratando de algo que você já escreveu várias vezes ou algo de nítida simplicidade, isso não seria necessário.
Escreva a versão final do algoritmo que será utilizado na solução e que deverá ser mapeado para a linguagem de programação escolhida.
Codifique o programa
Escreva o programa na linguagem escolhida. Comente o código à medida que vai codificando. Utilize identação para tornar o código fonte mais legível. Use nomes sugestivos e não muito longos para variáveis e métodos e, sempre que possível, divida seu programa em partes menores – ou seja, modularize.
Lembre-se que passamos a maior parte do tempo em programação corrigindo e/ou modificando o código. Portanto gaste tempo escrevendo código mais legível, pois é mais fácil de depurar e manter.
Nas seções seguintes serão apresentados problemas e suas respectivas soluções. Cada seção irá focar em um ou mais temas do universo da programação em Java.
Introdução ao modelo de domínio
Domínio do problema é um termo usado para definir as áreas que precisam ser examinadas para solucionar o problema. Significa que deve-se olhar apenas para os tópicos de interesse, excluindo tudo que for irrelevante.
Modelo de domínio é uma visão conceitual preliminar do problema e normalmente é chamado diagrama de classes conceitual. O modelo conceitual representa as entidades, seus atributos e relacionamentos. Por exemplo, no modelo de domínio Acadêmico Escolar identificamos as seguintes entidades: Curso, Disciplina, Professor, Aluno e Matrícula; e os seguintes relacionamentos: Professor ministra Disciplina, Curso é composto de Disciplina, Aluno matricula-se em Disciplina. Avançando um pouco mais, pode-se definir uma entidade Pessoa que tem como entidades derivadas o Professor e o Aluno.
Para representar um modelo de domínio geralmente usamos o diagrama de classes. Num diagrama de classes, as classes são representadas por retângulos divididos em três partes, como mostra a Figura 1. ...

Introdução à Persistência com Hibernate – Parte 1
Introdução ao desenvolvimento em Java com Hibernate



Atualmente, a maioria das aplicações utiliza uma linguagem orientada a objetos na construção do software, e um banco de dados relacional para a persistência – armazenamento – dos dados. Mesmo que haja outras soluções, esta ainda é a mais utilizada e, infelizmente, ela precisa lidar com o que é comumente chamado diferença de impedância entre o modelo de objetos e o modelo relacional. Esta diferença existe porque o paradigma orientado a objetos baseia-se em princípios de engenharia de software, enquanto o paradigma relacional baseia-se em princípios matemáticos – a álgebra relacional. Para juntar os dois modelos em uma aplicação é necessário entendê-los e conhecer suas diferenças. E, principalmente, é fundamental entender o processo de mapear objetos para o modelo relacional e como implementar esse mapeamento. A técnica de mapear uma representação de dados de um modelo de objetos para um modelo relacional é chamada Mapeamento Objeto-Relacional (ORM), que será mais amplamente discutida na próxima seção. Em projetos de desenvolvimento atuais, cada vez mais complexos, isso pode se tornar uma tarefa pesada e exigir muito tempo do programador.
O padrão Enterprise JavaBeans (EJB) de Java 2 Enterprise Edition (J2EE) já apresentava mecanismos de persistência baseados em contêineres ou baseados em beans, nas classes chamadas entity beans. No entanto essa proposta ainda sofria em certo grau com o descompasso entre modelo relacional e o modelo orientado a objetos.
Como uma alternativa ao modelo proposto pelo EJB2, surgiu o Hibernate – um framework de Mapeamento Objeto-Relacional. Seu objetivo era oferecer uma capacidade de persistência melhor e mais simples do que o proposto pelo EJB2. Em razão de ser uma solução simples, prática e de código aberto, logo o Hibernate se popularizou, tornando-se “de fato” o padrão de persistência em Java.
Uma consequência do sucesso do Hibernate como solução em ORM foi a participação ativa de Gavin King – o criador da ferramenta – no comitê da Java Specification Requests (JSR) 220. A JSR 220 descreve uma padronização de ORM, chamada Java Persistence API (JPA), que foi incluída na versão 3 do EJB. A especificação da JPA passou a ser implementada no Hibernate a partir da versão 3 do framework.
Soluções que oferecem suporte à JPA são denominadas provedores de persistência. Além do Hibernate, TopLink (Oracle) e EclipseLink (Eclipse.org) são exemplos de provedores de persistência.
Este artigo está divido em duas partes. Na primeira estudaremos os conceitos relacionados ao Hibernate, sua arquitetura e uma introdução à configuração das opções disponíveis para o mapeamento objeto-relacional. A aplicação prática do que será apresentado aqui deixaremos para a segunda parte da matéria.
Mapeamento Objeto-Relacional
De uma maneira bem simples, pode-se afirmar que Mapeamento Objeto-Relacional é a persistência, ou seja, o armazenamento de objetos criados em uma aplicação, para tabelas em um banco de dados relacional, usando metadados que descrevem tal mapeamento. Metadados são dados que descrevem outros da ...

Utilizando Collections

Desde as primeiras versões, Java dispõe das estruturas de arrays e as classes Vector e Hashtable. No entanto, além da dificuldade em implementar estruturas de dados utilizando arrays, os desenvolvedores sentiam falta de classes que implementassem estruturas como listas ligadas e tabelas de espalhamento (hash). Para atender a essas necessidades, a partir de Java 1.2, foi criado um conjunto de interfaces e classes denominado Collections Framework, que faz parte do pacote java.util.
O que é Collections Framework?
Collections Framework é um conjunto bem definido de interfaces e classes para representar e tratar grupos de dados como uma única unidade, que pode ser chamada coleção, ou collection. A Collections Framework contém os seguintes elementos:
•    Interfaces: tipos abstratos que representam as coleções. Permitem que coleções sejam manipuladas tendo como base o conceito “Programar para interfaces e não para implementações”, desde que o acesso aos objetos se restrinja apenas ao uso de métodos definidos nas interfaces;
•    Implementações: são as implementações concretas das interfaces;
•    Algoritmos: são os métodos que realizam as operações sobre os objetos das coleções, tais como busca e ordenação.

A Figura 1 mostra a árvore da hierarquia de interfaces e classes da Java Collections Framework que são derivadas da interface Collection. O diagrama usa a notação da UML, onde as linhas cheias representam extends e as linhas pontilhadas representam implements.
A hierarquia da Collections Framework tem uma segunda árvore. São as classes e interfaces relacionadas a mapas, que não são derivadas de Collection, como mostra a Figura 2. Essas interfaces, mesmo não sendo consideradas coleções, podem ser manipuladas como tal.
Interfaces
Neste momento vamos apresentar uma breve descrição de cada uma das interfaces da hierarquia:
•    Collection – está no topo da hierarquia. Não existe implementação direta dessa interface, mas ela define as operações básicas para as coleções, como adicionar, remover, esvaziar, etc.;
•    Set – interface que define uma coleção que não permite elementos duplicados. A interface SortedSet, que estende Set, possibilita a classificação natural dos elementos, tal como a ordem alfabética;
•    List – define uma coleção ordenada, podendo conter elementos duplicados. Em geral, o usuário tem controle total sobre a posição onde cada elemento é inserido e pode recuperá-los através de seus índices. Prefira esta interface quando precisar de acesso aleatório, através do índice do elemento;
•    Queue – um tipo de coleção para manter uma lista de prioridades, onde a ordem dos seus elementos, definida pela implementação de Comparable ou Comparator, determina essa prioridade. Com a interface fila pode-se criar filas e pilhas;
•    Map – mapeia chaves para valores. Cada elemento tem na verdade dois objetos: uma chave e um valor. Valores podem ser duplicados, mas chaves não. SortedMap é uma interface que estende Map, e permite classificação ascendente das chaves. Uma aplicação dessa interface é a classe Properties, que é usada para persistir propriedades/configurações de um sistema, por exemplo.
Observe que usamos acima os termos ordenação e classificação. Dizemos que uma estrutura está ordenada se ela pode ser percorrida (iterada) em uma certa ordem, tal como os itens de um ArrayList podem ser percorridos através de seus índices. Por sua vez, a classificação diz respeito à ordenação na essência dos dados, tal como a classificação em ordem alfabética de Strings ou ordem numérica das classes wrapper, como Integer e Double, por exemplo. Podemos afirmar que uma estrutura classificada é uma estrutura ordenada, mas o inverso não é verdadeiro.
A API oferece também interfaces que permitem percorrer uma coleção derivada de Collection. Neste artigo falaremos de:
•    Iterator – possibilita percorrer uma coleção e remover seus elementos;
•    ListIterator – estende Iterator e suporta acesso bidirecional em uma lista, modificando e/ou removendo elementos.
Implementações
As interfaces apresentadas anteriormente possuem diversas implementações que são utilizadas para armazenar as coleções. Na Tabela 1 estão resumidas as implementações mais comuns.

    










    
    


    
    


                


    
    

A seguir apresentamos algumas características das implementações que podem ajudar a decidir qual delas utilizar em uma aplicação:
•    ArrayList – é como um array cujo tamanho pode crescer. A busca de um elemento é rápida, mas inserções e exclusões não são. Podemos afirmar que as inserções e exclusões são lineares, o tempo cresce com o aumento do tamanho da estrutura. Esta implementação é preferível quando se deseja acesso mais rápido aos elementos. Por exemplo, se você quiser criar um catálogo com os livros de sua biblioteca pessoal e cada obra inserida receber um número sequencial (que será usado para acesso) a partir de zero;
•    LinkedList – implementa uma lista ligada, ou seja, cada nó contém o dado e uma referência para o próximo nó. Ao contrário do ArrayList, a busca é linear e inserções e exclusões são rápidas. Portanto, prefira LinkedList quando a aplicação exigir grande quantidade de inserções e exclusões. Um pequeno sistema para gerenciar suas compras mensais de supermercado pode ser uma boa aplicação, dada a necessidade de constantes inclusões e exclusões de produtos;
•    HashSet – o acesso aos dados é mais rápido que em um TreeSet, mas nada garante que os dados estarão ordenados. Escolha este conjunto quando a solução exigir elementos únicos e a ordem não for importante. Poderíamos usar esta implementação para criar um catálogo pessoal das canções da nossa discografia;
•    TreeSet – os dados são classificados, mas o acesso é mais lento que em um HashSet. Se a necessidade for um conjunto com elementos não duplicados e acesso em ordem natural, prefira o TreeSet. É recomendado utilizar esta coleção para as mesmas aplicações de HashSet, com a vantagem dos objetos estarem em ordem natural;
•    LinkedHashSet – é derivada de HashSet, mas mantém uma lista duplamente ligada através de seus itens. Seus elementos são iterados na ordem em que foram inseridos. Opcionalmente é possível criar um LinkedHashSet que seja percorrido na ordem em que os elementos foram acessados na última iteração. Poderíamos usar esta implementação para registrar a chegada dos corredores de uma maratona;
•    HashMap – baseada em tabela de espalhamento, permite chaves e valores null. Não existe garantia que os dados ficarão ordenados. Escolha esta implementação se a ordenação não for importante e desejar uma estrutura onde seja necessário um ID (identificador). Um exemplo de aplicação é o catálogo da biblioteca pessoal, onde a chave poderia ser o ISBN (International Standard Book Number);
•    TreeMap – implementa a interface SortedMap. Há garantia que o mapa estará classificado em ordem ascendente das chaves. Mas existe a opção de especificar uma ordem diferente. Use esta implementação para um mapa ordenado. Aplicação semelhante a HashMap, com a diferença que TreeMap perde no quesito desempenho;
•    LinkedHashMap – mantém uma lista duplamente ligada através de seus itens. A ordem de iteração é a ordem em que as chaves são inseridas no mapa. Se for necessário um mapa onde os elementos são iterados na ordem em que foram inseridos, use esta implementação. O registro dos corredores de uma maratona, onde a chave seria o número que cada um recebe no ato da inscrição, é um exemplo de aplicação desta coleção.

Cada uma das implementações tem todos os métodos definidos em suas interfaces. Em qualquer uma delas é possível inserir elementos null. Em mapas, tanto chaves quanto valores podem ser null. Diferente de Vector e Hashtable, não são seguras para serem usadas com threads (não são Thread-safe). Ou seja, o acesso concorrente a esses objetos pode produzir resultados imprevisíveis. Além disso, são serializáveis – isto é, seus estados podem ser salvos – e suportam o método clone(), que cria uma cópia de um objeto.
Thread-safe é o termo designado a objetos seguros para serem usados com threads.
Seguindo as boas práticas de orientação a objetos, você deve programar para interfaces e não para implementações. A recomendação é escolher uma implementação para instanciar o objeto e atribuir a nova coleção ao tipo de interface correspondente. Ou ainda, passar o objeto coleção para um método que espera um argumento do tipo interface. Seguindo essas práticas você conseguirá o que chamamos de baixo acoplamento, ou seja, poderá mudar facilmente de implementação sem que isso acarrete alteração no código da aplicação. Desta forma você fica livre para mudar a implementação sempre que questões relacionadas a desempenho ou detalhes de comportamento exigirem a mudança.
Não confunda a interface Collection com a classe Collections. Essa classe oferece métodos estáticos utilitários que podem manipular coleções. Outra classe utilitária é Arrays, cujos métodos estáticos são aplicados a arrays.
Após uma visão geral da Collections Framework, vamos por as mãos na massa e desenvolver uma aplicação exemplo a partir de situações do dia-a-dia, nas quais são analisadas as necessidades apresentadas pelo problema para decidir a interface a ser utilizada.
Como aplicar adequadamente a Collections Framework
Vimos então que temos sete interfaces: Collection, List, Set, SortedSet, Map, SortedMap e Queue. A pergunta que geralmente se faz é: Qual delas usar? Para selecionar adequadamente uma interface devemos analisar o problema e verificar como ele se enquadra nas características de cada interface. Somente após isso devemos decidir.
Iniciaremos com um problema simples. Queremos manter uma lista de nomes de alunos de uma escola que oferece cursos de Informática básica. Essa lista será percorrida na ordem em que os elementos são inseridos. Além disso, queremos poder acessar um nome de aluno aleatoriamente.
Analisando os requisitos do problema (lista na ordem de inserção e recuperação aleatória) e as características das interfaces disponíveis, optamos por utilizar List. Elementos não duplicados é um requisito que pode ser inferido na descrição do problema e isso poderia nos levar a escolher Set, mas vamos manter nossa decisão inicial por questões didáticas.
A interface List
List tem duas implementações – ArrayList e LinkedList. ArrayList oferece acesso aleatório rápido através do índice. Já em LinkedList o acesso aleatório é lento e necessita de um objeto nó para cada elemento, que é composto pelo dado propriamente dito e uma referência para o próximo nó, ou seja, consome mais memória. Além dessas considerações, se for necessário inserir elementos no início e deletar elementos no interior da lista, a melhor opção poderia ser LinkedList. Para apoiar a decisão de usar uma ou outra implementação é melhor fazer testes de desempenho. Um teste simples é mostrado na Listagem 1. Execute o programa e anote o tempo. Substitua ArrayList por LinkedList e repita o teste. Ao final escolha a implementação mais eficiente.
Optamos então por usar ArrayList. Uma implementação básica pode ser vista na Listagem 2. Esta aplicação instancia um ArrayList e o atribui a uma referência do tipo List. Insere alguns nomes de alunos com o método add() e finalmente imprime a lista – as implementações de coleções sobrescrevem o método toString(), por isso podemos imprimir a lista passando apenas a referência para o método println().

Listagem 1. Teste simples de desempenho.
import java.util.*;
public class Teste {

  public static void main(String[] args) {
    final int MAX = 20000;
    long tInicio = System.currentTimeMillis();
    List lista = new ArrayList();
    for (int i = 0; i < MAX; i++) {
      lista.add(i);
    }
    
    for (int i = 0; i < MAX; i++) {
      lista.contains(i);
    }
    long tFim = System.currentTimeMillis();
    System.out.println("Tempo total: " + (tFim - tInicio));
  }

}

Listagem 2. Classe ListaAluno utilizando uma implementação da interface List.
import java.util.*;

public class ListaAluno {

  public static void main(String[] args) {
    List lista = new ArrayList();
    lista.add("João da Silva");
    lista.add("Antonio Sousa");
    lista.add("Lúcia Ferreira");
    System.out.println(lista);
  }

}

Neste exemplo, a primeira consideração a fazer é que, tendo em mente a ...