1. Introdução:
O que é um ambiente de desenvolvimento?
Um IDE – Integrated Development
Environment (Ambiente de desenvolvimento integrado) - consiste em um software
que contém um conjunto de funcionalidades embutidas, cuja finalidade é prover
um modo mais fácil e interativo de construir e manipular seus programas. Entre
estas ferramentas geralmente figuram:
· Um editor de texto com facilidades especialmente
desenhadas para a linguagem;
· Um compilador (e um interpretador, no caso de Java e
outras linguagens interpretadas) ;
· Um editor gráfico, com facilidades
para criação e edição da interface gráfica do programa a ser desenvolvido;
· Um debugger, uma
ferramenta especialmente feita para se tirar os bugs do código. Ela possibilita um monitoramento mais elegante do
funcionamento do seu programa, facilitando a detecção e remoção dos erros.
Perceba que não estamos falando em erros de sintaxe, mas erros na própria
lógica do programa, que fazem seu programa gerar resultados indesejados ou
travar (apesar de ele compilar), e que geralmente são difíceis de se encontrar
simplesmente analisando o código.
O Eclipse
O Ambiente de desenvolvimento que
escolhemos trabalhar até agora tem sido o BlueJ, que tem o propósito de ser um
software pedagógico mais do que propriamente uma ferramenta que agilize tarefas
e aumente a segurança e a produtividade do seu projeto. Nesta aula,
aprenderemos a utilizar o Eclipse, um programa voltado para desenvolvimento
tanto acadêmico quanto profissional.
O Eclipse possui facilidades que
vão desde a rápida visualização de todos os arquivos contidos no projeto até
ferramentas de gerenciamento de trabalho coletivo. Além das ferramentas
mencionadas no tópico anterior, o Eclipse possui:
· Um Class browser ou Package Explorer,
que permite visualizar toda a estrutura de diretórios e arquivos contidos no
projeto
· Wizards,
que são "programas" que auxiliam na construção rápida de aplicações
com características iniciais já conhecidas.
2. Iniciando no Eclipse:
Ao abrir o Eclipse
3 será exibida uma janela de boas-vindas(welcome). Feche-a.
2.1.Criando
um projeto
· Primeiramente clique em File > New > Project.
Um wizard de criação de projetos aparecerá.
· Em seguida,
selecione a opção Java > Java Project e clique em Next. A seguinte tela
aparecerá:
· Digite
um nome para o seu projeto e em seguida marque a opção "Create project at
external location", especificando o diretório onde o projeto será ser
armazenado. Marque também a opção “Create separate source and output folders”
na caixa “Project Layout”. Essa opção permite que você não misture os arquivos
que contém o código-fonte(source) com os arquivos gerados pelo
compilador(output ou saída) , criando pastas diferentes para cada um desses
tipos de arquivos.
· Clique em Next.
· Agora você terá a oportunidade de escolher os
diretórios do source e de saída. Para deixar os valores default clique em
Finish, ou então altere os valores de acordo com sua conveniência.
· Quando tiver terminado, clique
em Finish. Possívelmente aparecerá uma janela pedindo para confirmar uma
mudança de perspectiva. Se aparecer, clique em "Yes".
Agora, seu
projeto já está criado, mas ainda não possui nenhuma classe. Para criar uma
classe:
· Clique em File > New > Class. A seguinte tela
aparecerá.
· A
parte superior da janela dá algumas indicações sobre o preenchimento - como
campos obrigatórios, a sugestão de usar inicial maiúscula para nomes de
classes, etc.
· Em "Source Folder", determine de que
projeto sua classe fará parte.
· Selecione o nome da sua classe no campo
"Name".
· Opcionalmente
você pode pré-determinar os modificadores de acesso da sua classe e deixar
prontos os esqueletos de alguns métodos, no campo Modifiers e nos campos abaixo
de “Which method stubs would you like to create?”. Escolha "public static void main(String[]
args)".
· Clique em Finish. Sua classe
será criada e parecerá com a da imagem abaixo.
· Perceba
que um campo de comentários comum e um de comentários javadoc foram automaticamente
inseridos no inicio da sua classe. Para alterar os templates destes e outros
comentários clique em Window > Preferences > Java > Code Generation na
aba Code and Comments.
· O Eclipse gerou também um método main, conforme nós
havíamos pedido na janela anterior.
3. Visão Geral do Ambiente
O Eclipse já
inicia com inovações em relação à maioria das IDEs: ele possui a funcionalidade
de customização do ambiente de
trabalho. Trata-se de um programa open-source, originalmente escrito para ser uma IDE
versátil e possível de ser adaptada para qualquer propósito relacionado ao
desenvolvimento de software, desde a produção de plug-ins para ele mesmo e/ou outros programas, passando pela
integração de ferramentas ao ambiente Eclipse e culminando no desenvolvimento
do software final em si. Esta adaptabilidade já começa pela estética do
ambiente. Na Java Perspective (o
conjunto de modificações para tornar o ambiente familiar ao desenvolvedor
Java), o layout do ambiente é como na imagem abaixo:
Esta tela,
como podemos ver, não se parece nem de longe com a interface do BlueJ. Mas a
esmiuçaremos frame a frame, seguindo a legenda numérica da imagem.
3.1 Package Explorer (1)
O Package
Explorer é um visualizador simples e elegante dos seus projetos. Um projeto
representa toda a estrutura do seu programa, armazenando os arquivos-fonte
(.java), os bytecodes (.class), as configurações gerais do ambiente para o
projeto, eventuais arquivos de backup e outros arquivos inerentes ao escopo do
programa (por exemplo, quaisquer possíveis imagens relacionadas ao
projeto).
A navegação é
semelhante à do Windows Explorer, bastante intuitiva e respeitando a hierarquia
do projeto, com a qual ficaremos mais familiarizados com a prática, ao longo do
desenvolvimento do projeto.
3.2 Editor de Texto (2)
O editor de
textos do Eclipse, assim como o do BlueJ, ConText e outros, denota as
palavras-chave de Java™ em letras destacadas para facilitar a leitura do código.
No entanto, este é uma das funcionalidades mais triviais desta
ferramenta, como veremos a seguir.
Suponha que estejamos escrevendo o método “transferir” da classe Conta,
bastante conhecida por nós. Este método é composto de uma chamada ao método
“debitar” e outra chamada ao método “creditar”, como podemos ver abaixo.
Durante a
implementação deste método, quando digitarmos o nome de alguma variável que
denote um objeto e o ponto para chamada de método, o editor de textos do Eclipse
nos mostrará uma janela com uma relação completa de todos os métodos e
atributos que este objeto pode acessar em seu contexto, e a medida em que
escrevermos as letras, ele filtrará tudo o que puder ir sendo descartado, como
ilustra a imagem abaixo.
Uma grande
funcionalidade das principais IDEs atuais é a detecção de erros de compilação
em tempo de implementação. O editor de textos do Eclipse, ao perceber um erro
de sintaxe (e até alguns poucos erros de lógica), imediatamente marca em
vermelho o trecho que ele supõe estar errado, além de indicar as possíveis
causas do erro e sugerir algumas soluções. Como podemos ver na figura abaixo,
ele sublinha o trecho e errado e marca as linhas que apresentam problema de
sintaxe no lado direito da janela:
Ele também separa
os trechos de código contido entre chaves, no lado esquerdo da janela, em azul.
Podemos clicar nos triângulos azuis para exibir/esconder trechos entre chaves,
facilitando a visualização do arquivo e sua navegação.
Por último, o editor do eclipse nos poupa bastante tempo de pesquisa em
documentação de classes nas
APIs das mesmas com um recurso muito simples e interessante. Ao mantermos
o mouse por cima de nomes de classe ou métodos, uma caixa de texto aparecerá na
tela com toda a documentação da classe / método em questão. Ex:
3.3 Console (3)
O Eclipse, assim
como o BlueJ, oferece um terminal de console para a entrada de dados do teclado
pela stream de entrada padrão e a saída de dados que o programa escreve na
stream de saída padrão, exatamente como estamos habituados no BlueJ ou usando o
JDK.
3.4 Outline (4)
A janela Outline funciona semelhantemente ao Package Explorer, sendo que voltada para
a estrutura interna do seu arquivo .java - frequentemente a sua classe. Como podemos observar, existem
ícones diferentes para cada parte do arquivo.
4 .Compilando e executando programas com
o Eclipse
· Clique em Project > Build Project.
Como alternativa, clique com o botão direito sobre o projeto que deseja
compilar no Package Explorer e então
clique em Build Project.
· Para
rodar o seu programa, clique com o botão direito sobre o arquivo que contém o
main que você deseja rodar(no Package
Explorer) e clique em Run > Java Application. Automaticamente será
criada uma configuração de execução para o seu projeto. Para gerenciar as
congifurações(alterar, inserir, remover...), clique em Run > Run...
· A seguinte tela aparecerá:
A classe que contém o main que deverá ser executado
inicialmente é especificada em "Main class". Você pode especificar
argumentos para a execução(o famoso String[] args), para a máquina virtual,
configurar o classpath, etc.
A partir da primeira vez que você configurar uma rotina de
execução, basta clicar no botão Run na barra de ferramentas ou
utilizar o atalho Ctrl+F11 para rodar o programa.
5. Adicionando Bibliotecas à projetos no Eclipse
Para adicionar uma biblioteca externa ao
projeto, clique com o botão direito sobre a pasta do projeto no Package Explorer e selecione a opção Properties. A seguinte janela surgirá:
· No
menu da esquerda, selecione a opção Java
Build Path (como está selecionado na figura). A parte da direita mudará
para mostrar o que está na figura.
· Selecione
a aba Libraries para visualizar as
bibliotecas utilizadas pelo seu projeto. Provavelmente você poderá ver a
biblioteca JRE System Library, que é a biblioteca padrão que vem com o JDK
instalado na sua máquina, e que praticamente todo projeto Java deve
utilizar.
· Para adicionar mais bibliotecas, clique no botão Add
External JARs (Java ARchives ou, extra-oficialmente,
Java Application Resources, o
último menos usado).
· Por último, selecione o caminho da biblioteca a ser
adicionada e clique em Open.
6. Importando/Exportando arquivos ao seu projeto
1.
Para importar arquivos no seu projeto:
· Clique em File > Import > File system.
Na janela que aparecerá, simplesmente selecione a pasta de onde virão os
arquivos a serem importados. Uma lista dos arquivos importáveis aparecerá.
Marque os que você deseja importar ao projeto e no campo "Into
Folder" selecione em que pasta os arquivos devem ser copiados.
Na figura acima estamos para importar
o arquivo Console.java no nosso projeto, portanto poderemos passar a usá-lo
quando clicarmos em "Finish"
2.
Para importar projetos no seu Workspace:
· Clique em File
> Import > External project into workspace. Especifique o caminho do
projeto a ser importado. O nome do projeto deve aparecer logo acima do seu
caminho.
OBS.: Perceba que o
Import external project into workspace não
copia o projeto para o Workspace, ele apenas cria um projeto que referencia o projeto importado.
7. Depurando (debugging) programas com o
Eclipse
Quando um
programa, não esta funcionando corretamente você precisa corrigi-lo(depurá-lo).
O Eclipse oferece um depurador para auxiliá-lo na correção do programa. Com
esse depurador você pode acompanhar passo a passo seu programa para ver se ele
esta funcionando da maneira esperada.
· Com um duplo-click à esquerda da
numeração das linhas (ou pelo atalho Ctrl+Shift+B) você insere um Break-Point
(um ponto onde a execução do programa para, e podemos ver os valores das
variáveis, dos atributos e coisas do tipo).
· Clique com o botão direito no
arquivo de onde deseja começar a depuração e clique em Debug > Java
Application.
Perceba que o
layout das janelas será alterado após o início da depuração(talvez ele peça
primeiro uma confirmação). Isso se deve à versatilidade do Eclipse e ao
conceito de Perspectivas (perspectives)
visto no início do roteiro. Quando desejamos depurar um programa, o Eclipse
automaticamente troca da Java Perspective
para a Debug Perspective, que muda
totalmente o layout do programa para adaptá-lo às necessidades em tempo de
depuração.
Repare que quando código chegar no
Break-Point o programa pára de executar.
Em (1) temos uma relação dos
processos em execução e os encerrados no momento;
Em (2) temos a relação das
variáveis do programa, cada uma com o valor contido nela no momento do
Break-Point;
Em (3), temos a tela normal do editor de texto; Em (4) temos a tela normal do outline;
Em (5) temos o terminal normal de Console.
A partir da pausa na
execução do programa, podemos andar passo-a-passo ao longo da execução do
programa, observando a cada passo o que acontece com os valores das variáveis.
Temos três funções para “andar” pelo código:
· Step Into, que entra
no método chamado pela linha de código (Atalho: F5);
· Step Over, que executa a linha indo para a próxima
(Atalho: F6);
· Step Return, que
executa todo o resto do método no qual você está e para novamente imediatamente
depois disso (Atalho : F7).
Como exemplo,
vamos depurar a classe Conta:
· Insira um break-point na linha “String u =
conta1.getNumero()”;
· Inicie a depuração;
· Observe que o programa rodou normalmente até o
break-point;
· Observe que as
variáveis estão com seus devidos valores na janela Variables na parte superior
direita da tela;
· Aperte
F5 (Step Into)para entrar no método
getNumero() da classe conta e veja como o método é feito, passo-a-passo,
utilizando o Step Over (F6);
· Verifique se as variáveis são alteradas
corretamente;
· Quando você se der
por satisfeito, pode continuar caminhando passo-a-passo ou clicar no botão
quadrado(Terminate) na janela entitulada Debug, na parte superior esquerda da
tela para encerrar bruscamente a execução do programa.
Para concluir,
vamos depurar a classe Cliente:
· Insira
um break-point na linha “Cliente c = new Cliente ("Sylvia",
"5047021", "Rua
48", "52071-361",
"Itu")”;
· Inicie a depuração;
· Acompanhe a mesma e perceba que os atributos estão
setados da maneira que queremos;
· Entre no construtor com o Step Into (F5);
· Continue dando Step Overs (F6) até o programa acabar,
acompanhando as mudanças nas variáveis, caso haja.
A gerência das configurações de debug é bastante similar à
de execução, sendo acessada em Run > Debug...
8. Exercícios de fixação
1. Digite
a classe Hora, conforme visto na lista de exercícios, e compile-a;
2. Escreva
um programa no Eclipse que lê 3 números reais do teclado e imprime o maior
deles;
3. Altere este
programa para que ele imprima também a soma e a média aritmética dos 3 números.
0 comentários:
Postar um comentário