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.


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.


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.


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.


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”.


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.


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


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.


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.


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:


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.


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.


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”.


• 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.


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/

http://www.eclipse.org/documentation/

intro eclipse ide

Documents

projeto eclipse

projeto java do eclipse

workbench do eclipse

downloads do eclipse

eclipse na perspectiva

assistente de projeto

assistente de nova classe

nova classe no editor