Intro Eclipse Ide
-
Upload
alexandreoneill2479 -
Category
Documents
-
view
51 -
download
1
Transcript of Intro Eclipse Ide
Programação Javapara o Mundo Real - 470
Introdução ao Eclipse IDE
www.4linux.com.br
- 2
Sumário
Introdução ao Eclipse IDE.........................................................................................................3
1.1. Objetivos:........................................................................................................................ 3
1.2. O Eclipse IDE.................................................................................................................. 4
1.2.1. Downloads do Eclipse............................................................................................................5
1.3. Primeiros Passos com o Eclipse......................................................................................7
1.4. Um Projeto Eclipse, por dentro.....................................................................................18
1.4.1. Copiando um projeto para outro Eclipse.............................................................................19
1.5. Depurando com o Eclipse..............................................................................................21
1.6. O scrapbook do Eclipse.................................................................................................25
1.7. Conclusão...................................................................................................................... 27
REFERÊNCIAS
BIBLIOGRÁFICAS.................................................................................................................... 29
Índice de tabelas
Índice de FigurasFigura 1: Escolha do dietório do espaço de trabalho.............................................................9
Figura 2: página de boas-vindas do Eclipse.........................................................................10
Figura 3: Área de trabalho (workbench) do Eclipse............................................................11
Figura 4: Área de trabalho do Eclipse, sem a visão de boas-vindas....................................12
Figura 5: menu para mudar de perspectiva.........................................................................13
Figura 6: Área de trabalho do Eclipse na perspectiva Java (sem projetos).........................13
Figura 7: menu de novo... Projeto Java................................................................................14
Figura 8: assistente para a criação de Projeto Java.............................................................14
Figura 9: segunda página do assistente de Projeto Java.....................................................15
Figura 10: menu de novo... Classe.......................................................................................16
Figura 11: primeira página do assistente de nova classe Java............................................17
Figura 12: área de trabalho do Eclipse com a nova classe no editor...................................18
Figura 13: visão de Console do Eclipse, exibindo a execução do programa mínimo...........19
Figura 14: arquivos ocultos em um Projeto Java do Eclipse................................................19
Figura 15: “importando” Projeto Java para o Eclipse..........................................................21
Figura 16: criando um ponto de interrução no código Java.................................................22
Figura 17: aviso para mudar da perspectiva Java para a perspectiva de Depuração..........23
- 3
Figura 18: depurador do Eclipse esperando em um ponto de interrupção.........................24
Figura 19: assistente para cria uma página do bloco de rascunho (scrapbook)..................27
Figura 20: janela de inspeção do bloco de rascunho...........................................................28
Índice de Listagens
Introdução ao Eclipse IDE - 4
Introdução ao Eclipse IDE
1.1. Objetivos:
• Entender qual download do Eclipse selecionar para um projeto
• Aprender a operar o IDE Eclipse para compilar, executar e depurar programas
Java
• Conhecer o bloco de notas (scapbook)
O Eclipse IDE - 5
1.2. O Eclipse IDE
O Eclipse IDE é um projeto de software livre fomentado inicialmente pela
IBM, e hoje mantido por uma ONG, a Eclipse Foundation, que inclui entre
patrocinadores e colaboradores praticamente todos os grandes nomes da indústria
de TI.
Ele foi bastante controverso no seu início, por abandonar a biblioteca de
componentes gráficos padrão do Java, o Swing, em função de uma biblioteca criada
pelo próprio projeto Eclipse, chamada SWT (Standard Wdiget Toolkit), e que utiliza
bastante código nativo. Esta abordagem permitiu ao Eclipse ter um desempenho, na
época, superior a outros ambientes de desenvolvimento Java, que eram baseados no
Swing, e também ofereceu uma integração maior com os ambientes gráficos nativos
do Windows, Linux e Mac, reduzindo a barreira de entrada e contribuindo com a
popularidade do IDE.
O Projeto Eclipse já nasceu bastante ambicioso. Seu objetivo não era apenas
fornecer um IDE para desenvolvimento de aplicações Java. Era sim fornecer uma
infra-estrutura genérica para a criação de ferramentas de desenvolvimento para
qualquer linguagem de programação e ambiente de programação. A plataforma Java
foi escolhida como o ambiente de desenvolvimento do próprio Eclipse porque ela é
coerente com os objetivos do projeto.
Inicialmente, o foco do Projeto Eclipse era o desenvolvimento do próprio
Eclipse, gerando o Eclipse SDK. Este produto permitia o desenvolvimento de plug-
ins para a Plataforma Eclipse, e cada plug-in acrescenta uma capacidade
específica, por exemplo:
• Editar código com destaque de sintaxe para uma linguagem de
programação;
• Executar o compilador desta linguagem e capturar os erros, indicando
visualmente sua localização no editor de código;
• Executar passo-a-passo um programa em um depurador;
O Eclipse IDE - 6
• Ou até desenhar visualmente uma página web ou janela de aplicação
gráfica.
Os componentes básicos do Eclispe SDK eram o Eclipse JDT (Java
Developent Tools) e o Eclipse PDE (Plug-in Development Environment). Com o
tempo foram se juntando a esses o VE (Visual Editor), WTP (Web Toos Platform)
DTP (Data Tools Project), EMF (Eclipse Modeling Framework), CDT (C/C++
Development Tools) e outros.
Hoje a Fundação Eclipse hospeda dezenas de projetos de software livre, a
grande maioria baseada na Plataforma Eclipse. O Eclipse se tornou o ambiente de
desenvolvimento mais popular não apenas entre desenvolvedores Java, mas também
entre desenvolvedores C, PHP, Python e outras linguagens. Também se tornou a base
de produtos proprietários, por exemplo toda a linha IBM / Rational de ferramentas
para modelagem e análise de sistemas.
Várias áreas específicas de desenvolvimento, por exemplo desenvolvimento
para celulares e outros tipos de hardware embarcado, que antes eram limitados a
ferramentas de linha de comando, ou então a ferramentas gráficas toscas, quando
comparadas com os IDEs “topo de linha” estilo Delphi e Visual Studio, passaram ter,
graças ao Eclipse, ambientes de desenvolvimento estado-da-arte. Toda a infra-
estrutura inclusa na Plataforma Eclipse para a construção de editores de código,
interface com compiladores, depuradores, empacotamento e editores visuais
permitira a construção, com pouco esforço, de ambientes de desenvolvimento
especializados para qualquer situação. E ainda melhor, o Eclipse SDK já fornecia um
ambiente de desenvolvimento customizado para a construção desses novos
ambientes de desenvolvimento!
1.2.1. Downloads do Eclipse
O Eclipse revolucionou o mercado de TI. Mas o seu sucesso crescimento
também trouxe problemas. Existiam tantos plug-ins para o Eclipse, tanto fornecidos
pela própria Eclipse Foundation, quanto por projetos open source de terceiros (isso
sem falar nos produtos comerciais) que se tornou complicado decidir quais plug-ins
usar e rastrear suas dependências, de modo a formar um ambiente de
desenvolvimento poderoso e adequado às necessidades de cada perfil de profissional
ou de projeto. Instalar um ambiente de desenvolvimento baseado no Eclipse se
O Eclipse IDE - 7
tornou uma especialização à parte para o profissional de TI. E esta dificuldade
impedia muitos de usufruir de todo o potencial dos projetos open source da Eclipse
Foundation.
Por isso foi iniciado o projeto de “releases simultâneos”. A idéia era que
projetos da fundação (ou até projetos externos que decidissem migrar para a
fundação) obedeceriam a um calendário comum para a liberação de versões
integradas do IDE, que usuários poderiam baixar e rodar sem se preocupar com
possíveis incompatibilidades entre os plug-ins, ou falta de dependências. Este projeto
foi chamado inicialmente de “Projeto Galileo” porque os releases foram nomeados
conforme as luas de Júpiter descobertas por Galileu: Calisto, Ganymede, Europa e
assim por diante. Depois os releases simultâneos se toraram parte integral dos
principais projetos da fundação e o nome Galileo foi adotado como o nome de um dos
releases simultâneos.
Como o Eclipse tem projetos que atendem a necessidades vastamente
diferentes, não exsite um único download para o release simultâneo. São oferecidos
vários pacotes para download, cada um focado em um perfil específico de
profissional. Mas os plugins de um pacote podem ser acrescentados interativamente
aos outros pacotes, tornando possível a criação de ambientes mistos, por exemplo
para Java e PHP, ou para Java e C++.
Estes são os principais pacotes oferecidos hoje pela Eclipse Foundation:
• Eclipse IDE for Java Developers – fornece basicamente o JDT, mais
suporte a arquivos XML e a integração com o CVS, um Sistema de
Controle de Versões. É o ambiente básico para quem quer desenvolver
aplicações Java e é o que estamos utilizando neste curso.
• Eclipse IDE for Java EE Developers – acrescenta ao JDT o WTP, o DTP
e vários outros plug-ins especializados para o desenvolvimento
utilizando tecnologias do Java EE, por exemplo: páginas JSP, EJB, JPA e
Web Services. Também inclui a capacidade de se depurar código dentro
de um servidor de aplicações.
• Eclipse Classic – é o antigo Eclipse SDK, que traz o JDT e o PDE.
O Eclipse IDE - 8
• Eclipse IDE for C/C++ Developers – é o ambiente básico para
desenvolvimento em C e C++, oferecendo o CDT e integração com o
CVS.
• Eclipse IDE for PHP Developers – fornece o necessário para o
desenvolvimento de aplicações PHP, incluindo o PDT (PHP Development
Tools) e o WTP para suporte à edição de código HTML, CSS e Javascript.
Também inclui a capacidade de executar código PHP passo-a-passo,
mesmo que ele esteja sendo executado via Apache ou outro servidor
web.
• Eclipse Modeling Tools – inclui vários componentes ainda imaturos,
mas está se transformando em uma ferramenta para CASE baseado na
UML e MDA (Model-Driven Architecture)
• Pulsar for Mobile Developers – é um ambiente de desenvolvimento
voltado para celulares, com recursos para desenvolvimento Java ME e
suporte aos SDK proprietários para vários fornecedores de celulares.
Ainda não suporta iPhone nem Android, mas já suporta o BlackBerry.
• Eclipse IDE for C/C++ Linux Developers – acrescenta o suporte a
ferramentas específicas do mundo GNU/Linux, como Autoconf e
empacotamento RPM.
Projetos de software livre de terceiros e até projetos comerciais se beneficiam
dos releases simultâneos, porque eles não precisam mais acompanhar a evolução e
dependências dos projetos individuais. Basta indicar que é compatível com o Galileo
(Eclipse Platform 3.5, de 2010), Helios (Eclipse Platform 3.6, de 2010) ou outro
release.
1.3. Primeiros Passos com o Eclipse
Se você já seguiu as instruções no bloco infra-estrutura no Netclass para a
instalação do JDK e do Eclipse, você deve ter um atalho para iniciar o Eclipse dentro
do menu de programas do Gnome, em Aplicativos > Desenolvimento > Eclipse, ou
então um atalho criado manualmente na sua área de trabalho.
Primeiros Passos com o Eclipse - 9
Outra alternativa, se foi feita a instalação manual do IDE, é executar
diretamente o executável eclipse (dentro da pasta também chamada eclipse) ou
eclise.exe em Windows. Tanto faz usar para isso um terminal ou pronto de comandos,
ou então usar um clique duplo no gerenciador de arquivos do seu ambiente gráfico.
Antes de abrir o IDE propriamente dito, é questionado sobre diretório para o
espaço de trabalho a ser utilizado (workspace). Se for informado um nome de
diretório inexistente, ele será criado. O checkbox permite que esta pergunta deixe de
ser feita a toda vez que o IDE for iniciado.
O diretório do espaço de trabalho armazena informações sobre projetos e
configurações do IDE, de modo que pode ser útil para um desenvolvedor trabalhando
em múltiplos projetos, separar cada um em um diretório de trabalho diferente.
Figura 1: Escolha do dietório do espaço de trabalho
Caso esta janela não apareça com o texto em português, por favor consulte as
instruções de instalação do Eclipse para ver como instalar as traduções. Elas já estão
inclusas no Fedora Linux, mas terão que ser instaladas manualmente em Ubuntu e
Windows.
Se você preferir utilizar o Eclipse em inglês, tudo bem. Entretanto nesta
apostila as capturas de tela e indicações de caminhos nos menus e assistentes usarão
os nomes traduzidos. Então você terá que localizar qual o item desejado por conta
própria
Na primeira execução do Eclipse, aparece uma página de boas-vidas ocupando
quase toda a janela do IDE.
Primeiros Passos com o Eclipse - 10
Figura 2: página de boas-vindas do Eclipse
Um clique duplo na aba “Bem-vindo” permite que se veja a área de trabalho
do Eclipse. Qualquer das abas pode ser maximizada e restaurada por um clique
duplo.
Primeiros Passos com o Eclipse - 11
Figura 3: Área de trabalho (workbench) do Eclipse
Ou, se preferir, pode clicar no “x” no canto da aba e remover completamente a
janela de boas-vindas, deixando mais espaço de trabalho útil para escrever
programas.
Os vários elementos que estão dispostos nas laterais, ou abaixo, da área de
trabalho do IDE podem ser movimentados à vontade. Então você pode criar o arranjo
de janelas que lhe for mais conveniente.
A área maior, no centro, é onde aparecem os editores de código, e são a
principal parte da área de trabalho. As laterais são áreas para “dock” de outras abas,
que podem fornecer barras de ferramentas, exibições de estrutura de classes, ou
saída da execução em terminal.
A documentação do Eclipse chama as várias abas de visões (view). Elas não
necessariamente estarão em abas. Este é apenas o arranjo padrão.
Primeiros Passos com o Eclipse - 12
Figura 4: Área de trabalho do Eclipse, sem a visão de boas-vindas
É possível salvar vários arranjos diferentes de visões dentro da área de
trabalho como diferentes perspectivas. Cada plug-in do Eclipse pode definir novas
perspectivas e arranjos iniciais para cada uma. Como esta é a primeira execução,
estamos na perspectiva de informações. Esta perspectiva fornece uma visão “bruta”
dos arquivos em disco que formam um projeto.
Observe o botão no canto superior esquerdo, onde a palavra aparece truncada
como “informaçõ...”, indicando o nome da perspectiva atual. O botão com o “+” a
lado deste permite listar todas as perspectivas disponíveis, e trocar para qualquer
uma delas.
Então vamos mudar para a perspectiva “Java”, que é a perspectiva de trabalho
mais utilizada do JDT. Clique no botão com o “+”, no canto superior esquerdo.
Primeiros Passos com o Eclipse - 13
Figura 5: menu para mudar de perspectiva
O resultado será uma arranjo ligeiramente diferente da área de trabalho do
Eclipse, e também da barra de ferramentas no topo. Caso você mude a disposição das
abas em uma perspectiva, esta mudança é salva, então você pode alternar entre
várias perspectivas e preservar o seu arranjo customizado para cada uma.
Figura 6: Área de trabalho do Eclipse na perspectiva Java (sem projetos)
Agora, clique no botão com um “+” no canto superior esquerdo. Este botão
permite criar novos projetos, classes, arquivos e quaisquer que sejam os artefatos
reconhecidos pelo conjunto de plug-ins ativos no seu Eclipse. Escolha a opção
“Projeto Java”.
Primeiros Passos com o Eclipse - 14
Figura 7: menu de novo... Projeto Java
Se você clicar mais à esquerda, ou mais à direita, você poderá receber ou um
menu com os artefatos mais comuns para a perspectiva corrente (figura anterior), ou
então um diálogo contendo todos os artefatos disponíveis, agrupados por categoria
(próxima figura). Ambos os caminhos servem para a criação de novos projetos e
outros tipos de artefatos. A primeira opção apenas poupa uma tela do assistente que
se segue.
Figura 8: assistente para a criação de Projeto Java
Forneça um nome para o projeto, no caso “Oi” (vamos usar novamente o
programa mínimo). A janela do assistente pode aparecer maior para você, exibindo
mais opções, de acordo com sua resolução de tela.
Primeiros Passos com o Eclipse - 15
O Eclipse não é muito amigável a telas “pequenas” de notebooks, e muitas
vezes não exibe uma barra de rolagem para informar que existem elementos que não
estão visíveis. A próxima captura é um exemplo deste comportamento, pois não exibe
o agrupamento “Working Sets”, que estaria no final da página do assistente.
Usuários de Linux podem usar a tecla Alt junto com o mouse para mover
janelas parcialmente para fora da área de trabalho do ambiente gráfico, e
assim conseguir redimensionar diálogos do Eclipse para exibir
componentes ocultos.
Figura 9: segunda página do assistente de Projeto Java
Clique em “Concluir” para encerrar o assistente. Não iremos modificar
nenhuma configuração da próxima página.
A aba “Explorador de Projetos” no canto superior esquerdo passará a exibir o
ícone do projeto “Oi”. Ele pode ser expandido para exibir classes, bibliotecas e outros
Primeiros Passos com o Eclipse - 16
artefatos dentro deste projeto, que por enquanto está vazio, incluindo apenas uma
paste de fontes (src) e uma pasta com as bibliotecas inclusas do JDK.
Clique novamente no ícone de “+” no canto superior esquerdo, mas desta vez
para criar uma Classe. Novamente, é possível usar a janela do assistente para fazer
esta seleção, e ainda há uma terceira opção: clicar no ícone com um “c” em verde,
superposto por um “+” na barra de ferramentas:
Figura 10: menu de novo... Classe
Informe como nome da casse “Oi”, ignorando a advertência de que “o uso do
pacote padrão não é aconselhável” e marque o checkbox para criar um stub do
método main.
Primeiros Passos com o Eclipse - 17
Figura 11: primeira página do assistente de nova classe Java
Clique em “Concluir” e a nova classe será imediatamente exibida no
“Explorador de Projetos” à esqueda, e também na aba “Estrutura”, à direita. Mais
importante, ela será exibida em um editor de código na região central da área de
trabalho do Eclipse.
Primeiros Passos com o Eclipse - 18
Figura 12: área de trabalho do Eclipse com a nova classe no editor
Note que o código já é gerado com comentários JavaDoc, e também com
comentários marcadores de pendências, como o “TODO”.
Substitua o comentário pelo código para exibir uma mensagem na tela (não
precisamos dizer qual é, certo?). Durante a digitação, o recurso de auto-completar do
editor de código poderá se manifestar, exibindo pop-ups com escolhas e informações
sobre nomes de classes, métodos e argumentos. Você irá apreciar muito esses popus
quando escrever programas mais complexos.
Caso sejam cometidos erros de digitação, gerando sintaxes inválidas para a
Linguagem Java, o editor de código irá imediatamente, ou em poucos segundos,
exibir um “x” vermelho na margem esquerda. Não havendo erros, você poderá salvar
suas edições clicando no botão do “disquete” ( ) na barra de ferramentas e em
seguida executar o programa clicando no botão do “play de VCR” ( ) também na
barra de ferramentas.
O resultado da execução será exibido em um a nova aba chamada “terminal”,
que será exibida na parte inferior da área de trabalho do Eclipse:
Primeiros Passos com o Eclipse - 19
Figura 13: visão de Console do Eclipse, exibindo a execução do programa mínimo
Com isto encerramos o cliclo básico de operação do Eclipse para um
desenvolvedor Java. Já sabemos criar projetos, criar classes, editar código e executar
este código.
Mas, quando foi que compilamos o código? O próprio Eclipse compila
automaticamente o código quando ele é salvo!
1.4. Um Projeto Eclipse, por dentro
Um projeto do Eclipse é por omissão um subdiretório do diretório do espaço
de trabalho. Então, se meu espaço de trabalho está em /home/aluno/workspace, meu
projeto “Oi” estará em /home/aluno/workspace/Oi. Abra este diretório com o
gerenciador de arquivos do seu sistema operacional e veja seu conteúdo:
Figura 14: arquivos ocultos em um Projeto Java do Eclipse
A pasta src contém o código Java das classes que fazem parte do projeto,
enquanto que a pasta bin contém os bytecodes resultantes da compilação destas
Um Projeto Eclipse, por dentro - 20
classes. Os subdiretórios e arquivos ocultos, como .settings, .classpath e .project
guardam as configurações completas do projeto dentro do IDE.
Então o projeto inteiro pode ser movido para outra pasta de arquivos, fora do
espaço de trabalho, para um pendrive, ou então compactado e enviado por e-mail. Se
o projeto for restaurado em outro computador, ele pode ser aberto dentro do Eclipse
e utilizado sem problemas. Inclusive, irá funcionar corretamente mover um projeto
criado em Windows para uma estação com Linux e vice-versa.
1.4.1. Copiando um projeto para outro Eclipse
Digamos que você tenha um arquivo Mao.zip, contendo a pasta de um projeto
eclipse e todo o seu conteúdo. Esta pasta foi descompactada dentro do diretório do
espaço de trabalho da sua instalação do Eclipse.
Inicie criando o projeto normalmente, mas na tela do assistente que pede o
nome do projeto, entre no grupo “Conteúdos” e selecione o radio button “Criar
projeto à partir de origem existente”. Use o botão procurar para entrar no diretório
do projeto, e então clique “Ok”.
O próprio assistente irá inspecionar os arquivos de configuração do projeto
dentro do diretório selecionado, e preencher o nome do projeto e outras
configurações, ou então exibir uma mensagem de erro informando que o projeto em
questão não é um projeto Eclipse.
Um Projeto Eclipse, por dentro - 21
Figura 15: “importando” Projeto Java para o Eclipse
Então clique em “Concluir”. O projeto estará disponível na área de trabalho do
Eclipse, pronto para uso.
É possível que um projeto copiado assim de outra instalação do Eclipse esteja
com código compilado que seja inválido – por exemplo, a instalação de origem está
usando uma versão do JDK mais nova do que a usada na instalação de destino, e
assim o Eclipse (na verdade o JDK) não reconhece os bytecodes produzidos.
Em caso de dúvida, realize uma limpeza do projeto, que obriga a reocmpilação
de todos os fontes, não aproveitando nenhum bytecode que tenha vindo na cópia.
Para isso, selecione no menu do Eclipse a entrada Projeto > Limpar.
Depurando com o Eclipse - 22
1.5. Depurando com o Eclipse
É fácil executar código Java dentro do depurador do Eclipse, e poder assim
definir pontos de interrupção (breakpoints) e inspecionar o valor de variáveis
durante a execução do programa.
O primeiro passo é definir um ponto de interrupção, caso contrário o
programa irá executar até o final sem que tenhamos a oportunidade de usar o
depurador.
Digamos que se deseje acompanhar a execução do loop dentro do método
temSequencia da classe Mao, vista na aula anterior. Abra a classe no editor de código do
Eclipse (basta dar um clique duplo no arquivo Mao.java, dentro do “Explorador de
Projetos”). Role o editor até encontrar a linha desejada, então dê um clique duplo na
marem esquerda desta linha. O resultado será uma bolinha azul, que marca a
presença de um ponto de interrupção.
Figura 16: criando um ponto de interrução no código Java
Colocando ponteiro do mouse por sobre a bolinha, é exibido um tooltip com
informações sobre o ponto de interrupção. Um clique duplo sobre a bolinha remove o
ponto de interrupção.
Se a classe for executada da maneira usual, os pontos de interrupções serão
ignorados. É necessário executar a classe dentro do depurador, o que é feito usando
o ícone da “barata” , que fica bem ao lado do botão normal de execução na barra
de ferramentas.
Depurando com o Eclipse - 23
A execução da classe se inicia imediatamente, e será atingido o ponto de
interrupção. Neste momento o Eclipse irá pedir permissão para mudar para a
perspectiva de depuração, que é otimizada para esta atividade. Aceite a mudança, e
se preferir marque a caixa “lembrar minha decisão”.
Figura 17: aviso para mudar da perspectiva Java para a perspectiva de Depuração
A nova perspectiva exibe, na parte superior, uma aba com os threads de
execução da JVM (no caso apenas um1) e as variáveis locais em escopo, Observe, a
figura, as variáveis this (instância da classe Mao que está sendo executada) e ok.
1 Na verdade uma JVM está sempre executando vários threads em paralelo, mas o deputador do Eclipse filtra a visão para não exibir as threads de sistema, deixando apenas as threads de aplicação que são o que realmente interessa.
Depurando com o Eclipse - 24
Figura 18: depurador do Eclipse esperando em um ponto de interrupção
Na parte central, está o editor de código, com a linha do ponto de interrupção
destacada, e uma seta verde indicando que esta mesma linha é a próxima a ser
executada.
Finalmente, na parte inferior temos o console, que exibe a saída da classe no
terminal até o momento.
Na aba de threads temos os botões para controle da execução passo-a-passo:
. Eles são, respectivamente:
• Avançar Para (F5), que executa a próxima linha, mas entrando dentro
de métodos que sejam chamados nela. O resultado pode ser o editor
mudar de fonte para exibir o novo método.
• Ultrapassar (F6), que executa a próxima linha sem entrar em métodos.
Então este botão é que realmente tem o efeito visual de “executar a
próxima linha”.
Depurando com o Eclipse - 25
• Retroceder (F7), que executa até o final do método corrente. É uma
boa forma de se retornar ao método original, depois de executar um
“Avançar Para”.
Então utilize o botão “Ultrapassar”, ou então clique F6 várias vezes, e observe
como a seta verde e a linha em destaque mudam dentro do editor de código. Observe
ainda, na aba “Variáveis”, que a linha da variável ok fica destacada em amarelo para
indicar que sei valor foi modificado pela última linha executada.
O primeiro cenário de teste da classe Mao não tem sequência, então logo o loop
for será interrompido pelo comando break, e então a execução passará para a linha
do comando return. Neste momento, não nos interessa mais prosseguir no passo-a-
passo, porque o código irá retornar para o método main, e passará para o próximo
teste.
Então utilize o botão da sete verde na aba de threads, chamado “Continuar
(F8)” . Este botão libera a execução do código para prosseguir até o próximo
ponto de interrupção.
A execução será interrompida novamente na linha do comando if, mas desta
vez estamos com um novo array cartas. É possível inspecionar o valor do array
expandindo o item this na aba de variáveis, e verificar que o segundo caso de estes
contém uma sequência.
Desta vez, será possível usar “Ultrapassar (F6)” para executar várias
interações do loop, e observar na aba “variáveis” as alterações no valor de i.
Ao fim desta execução de temSequencia, deixe novamente a execução
“Continuar (F8)” e, na próxima interrupção da execução da classe, observe a aba de
“Threads”. Ela exibe a sequência (ou pilha) de chamadas, partindo de main, passando
por testaMao e finalmente entrando em temSequencia.
Se for selecionado um dos itens que não o no topo da pilha de chamadas, o
editor é movimentado para este item, e a linha de código que realizou a chamada fica
destacada, com uma seta azul. Ou seja, sabemos exatamente onde o método testaMao
fez a chamada atual para temSequencia.
Depurando com o Eclipse - 26
A aba de “variáveis” segue o método selecionado na pilha de execução, então
em vez de ok e i, vemos a variável cartas. Na verdade esta não é uma variável, e sim
o argumento do método testaMao, entretanto a aba de “variáveis” exibe tudo junto.
Se mudar na pilha para o método main, veremos exatamente qual dos cenários
de teste está em execução.
É possível interromper a execução da classe sem esperar pelo seu término
usando o botão do quadrado vermelho “Finalizar” (Ctrl=F2). Neste caso, ou se a
execução da classe atingiu seu fim normalmente, o Eclipse permanecerá na
perspectiva de depuração.
É possível editar código nesta perspectiva, inclusive com o programa em
execução. Pequenas edições não irão necessariamente forçar o término da sessão de
depuração, e você poderá testar mudanças de código com efeito imediato, sem
precisar reiniciar a classe. Também é possível definir novos pontos de interrupção,
ou então remover os existentes.
Mas o provável é que o desenvolvedor prefira retornar à perspectiva Java para
continuar a edição de código.
1.6. O scrapbook do Eclipse
Um recurso prático do Eclipse é o scrapbook, ou bloco de rascunho. É um
arquivo (com extensão jpage) onde é possível digitar expressões Java soltas, sem
necessitar declarar uma classe nem um método, e então exibir ou inspecionar o seu
resultado. Ele traz a conveniência de um interpretador para testes rápidos de um
desenvolvedor.
Para criar uma página de rascunho, é necessário abrir o assistente de “Novo”
e expandir a categoria “Java”. Dentro dela, expandir a categoria
“Execução/Depuração Java” e finalmente encontramos o item que cria a página de
rascunho.
O scrapbook do Eclipse - 27
Figura 19: assistente para cria uma página do bloco de rascunho (scrapbook)
A página precisa receber um nome e ficará armazenada no seu projeto. Use
algum nome como “teste”. A página aparece aberta no editor de código. Então digite
uma expressão, por exemplo:
2+2
Selecione esta expressão, clique com o botão direito, e escolha no menu a
opção “Exibir”. O resultado será o acréscimo do texto “(int)4” ao lado da expressão
que foi executada:
2+2(int)4
O novo texto estará selecionado, facilitando sua remoção, cópia para outro
arquivo, ou então seu uso como parte de uma nova expressão.
Caso a expressão seja algo que exiba uma saída no terminal, é possível
escolher a opção “Executar” no menu do botão direito. Ou então, caso ela retorne um
O scrapbook do Eclipse - 28
objeto complexo, é possível usar a opção “Inspecionar”, que exibe uma janela
exibindo a estrutura do objeto em um outline.
Então, se estivermos com o projeto Mao aberto, e nossa página de rascunho
for parte dele, será possível digitar a expressão
new Mao(1,2,3,4,5)
e o resultado da sua inspeção será algo como:
Figura 20: janela de inspeção do bloco de rascunho
Podemos ver que a instância de Mao recém-criada inclui um atributo chamado
cartas que é um array de inteiros, e ver o valor de cada elemento do array.
1.7. Conclusão
Este tutorial apenas arranhou a superfície do que é possível fazer com o IDE
Eclipse. Vimos o suficiente para o desenvolvimento de aplicações básicas, e na
próxima aula veremos como usar os recursos de integração com o Subversion.
Várias “dicas” de uso do Eclipse irão aparecer ao longo deste curso,
misturadas a outros tópicos de programação Java. Mas não podemos pretender que
este curso vai mostrar todas as coisas úteis e interessantes que o Eclipse pode fazer
para o programador.
Conclusão - 29
Explore o IDE e busque artigos na Internet. Você poderá encontrar vários
vídeos de demonstração do que é hoje o IDE para desenvolvimento de software mais
popular do mercado. Não apenas entre as opções livres.
Conclusão - 30
REFERÊNCIAS BIBLIOGRÁFICAS
Eclipse Workbench User Guide & Java Development User Guide
http://www.eclipse.org/documentation/