Tutorial Introduo ao ambiente Eclipse

Rafael Santos
(revisto em 26/10/2003)
Introduo....................................................................................................................................................................................................................... 1
Instalando o Java Development Kit ................................................................................................................................................................................ 2
Instalando o Eclipse........................................................................................................................................................................................................ 4
Desinstalando o Eclipse.............................................................................................................................................................................................. 4
Passos para criao e execuo de uma classe ............................................................................................................................................................... 4
Primeira execuo do Eclipse..................................................................................................................................................................................... 4
Criando um novo projeto............................................................................................................................................................................................ 5
Criando um novo pacote em um projeto..................................................................................................................................................................... 6
Criando uma classe em Java em um pacote................................................................................................................................................................ 8
Notas sobre o cdigo criado ..................................................................................................................................................................................... 10
Editando a classe criada............................................................................................................................................................................................ 11
Compilando e executando a classe criada................................................................................................................................................................. 11
Criando, compilando e executando uma segunda classe .......................................................................................................................................... 12
Criando, compilando e executando Applets.............................................................................................................................................................. 15

Introduo
O Eclipse um ambiente integrado de desenvolvimento gratuito que pode ser usado para desenvolvimento de aplicaes em Java, sendo um dos
mais recomendados para isto. O Eclipse no contm mdulos para criao de interfaces grficas, o que considero vantajoso para iniciantes na
linguagem Java, pois o foco deve ser a linguagem e no o aspecto visual de uma aplicao. Verses do Eclipse existem para diversos sistemas
operacionais, o que outra vantagem. Mais informaes podem ser obtidas no site www.eclipse.org.
Este tutorial mostra, passo a passo, como instalar o Java Development Kit (JDK) e o ambiente Eclipse. Verses especficas do JDK e do Eclipse
sero usadas, mas como estes softwares so constantemente atualizados, possvel que existam pequenas diferenas na numerao das verses
mostradas no documento e as existentes nos sites.
Instalando o Java Development Kit
Para instalar o Java 2 Development Kit (J2SDK, tambm referenciado como JDK neste documento), faa o download do arquivo j2sdk-
1_4_2_01-windows-i586.exe do site da Sun (http://java.sun.com). Para instalar o JDK, basta clicar duas vezes no cone do executvel.
Aps umas janelas com informaes sobre o instalador (que desaparecero sem necessidade de interao), a janela mostrada na Figura 1
aparecer. Clique no boto I accept the terms in the license agreement e depois no boto Next (que ser ativado). A janela da Figura 2
aparecer, e nela voc poder selecionar quais componentes deseja instalar. Por default, todas as opes estaro selecionadas, aconselhvel
deixar assim a no ser que existam restries no espao em disco se houverem, os demonstrativos (Demos) e cdigo-fonte (Source Code) podem
ser desmarcados para instalao. Tambm aconselhvel manter o caminho de instalao para c:\j2sdk1.4.2_01.

Figura 1 - Licena do JDK

Figura 2 - Customizao da instalao
Aps a seleo dos componentes para instalao, clique em Next. A Figura 3 aparecer. Esta janela lista os navegadores instalados e
reconhecidos, e o instalador registrar o Java Plug-In (para execuo de applets) para estes navegadores. Clique em Install para prosseguir.
Dependendo da verso do sistema operacional sendo executado e/ou doa Service Packs instalados, voc ver a mensagem na Figura 4. Clique em
Continue para prosseguir. Durante a instalao vrias janelas com dilogos como o da Figura 5 aparecero. No necessrio tomar nenhuma
providncia neste passo. Ao final da instalao a janela mostrada na Figura 6 ser mostrada. aconselhvel reinicializar o computador aps a
instalao (uma janela aparece pedindo confirmao para reinicializao).

Figura 3 - Registro dos navegadores

Figura 4 - Aviso sobre verso do sistema operacional

Figura 5 - Processo de instalao

Figura 6 - Trmino da instalao do JDK
Voc pode testar a instalao do JDK de duas formas: uma atravs do Java Web Start, cujo cone deve ter sido instalado no desktop do
computador. Clique duas vezes neste cone para executar o programa, sua execuo sinal de que a instalao foi concluda com sucesso.
Alternativamente, abra um terminal (com o menu Iniciar/Programas/Acessrios/Prompt de comando) e digite nele java. No
terminal devero aparecer mensagens impressas pelo comando java.
Instalando o Eclipse
Primeiro, necessrio copiar o Eclipse do site www.eclipse.org. Neste site, clique em Downloads, e selecione um site para download. Selecione o
Latest Release (clique no Build Name). Aparecero vrias listas de arquivos para download. Localize as listas Platform Runtime Binary e JDT
Runtime Binary. Copie, da lista mostrada em Platform Runtime Binary, o arquivo correspondente ao sistema operacional que voc est usando.
Copie tambm o arquivo eclipse-JDT, que comum para todas as plataformas o nome do link para download ser dependente da verso do
Eclipse, mas somente um arquivo deve aparecer na lista JDT Runtime Binary. Por exemplo, para o Windows 2000 e verso 2.1.1 do Eclipse, os
arquivos que devem ser copiados so eclipse-platform-2.1.1-win32.zip e eclipse-JDT-2.1.1.zip.
Para instalar o Eclipse, basta descompactar os arquivos em uma localizao qualquer. sugerido descompactar os dois arquivos em
C:\Arquivos de Programas. O diretrio eclipse (em minsculas) ser criado automaticamente. Como alguns arquivos existem em
ambos os arquivos .zip a ser descompactados, o descompactador pode mostrar algumas advertncias ou pedir para sobreescrever arquivos, o que
pode ser feito sem problemas.
Desinstalando o Eclipse
Se por alguma razo voc quiser desinstalar o Eclipse, basta apagar o diretrio onde este foi instalado no existe um mecanismo especfico de
desinstalao.
Passos para criao e execuo de uma classe
Primeira execuo do Eclipse
Execute pela primeira vez o Eclipse, clicando no aplicativo C:\Arquivos de programas\eclipse\eclipse (assumindo que o Eclipse foi instalado no
diretrio sugerido). A mensagem Please wait completing the install aparecer por alguns segundos, e depois a janela do Eclipse (mostrada na
Figura 7) aparecer.
Criando um novo projeto
O primeiro passo criar um novo projeto Java no Eclipse. Um projeto poder conter vrios pacotes e classes relacionados com um tema. Para criar
um novo projeto, clique no boto New Wizard ( ), est localizado logo abaixo do menu File. A janela mostrada na Figura 8 aparecer.
No dilogo mostrado na Figura 8, selecione Java no painel esquerdo e Java Project no painel direito e clique no boto Next. A janela
mostrada na Figura 9 aparecer.
Na janela da Figura 9 entre o nome do projeto sendo criado. Como este nome de projeto ser usado para criar um diretrio, evite usar caracteres
inadequados para nomes de diretrios. Entre o nome de projeto e clique no boto Next. No exemplo, usei o nome de projeto Exercicios
1
.
Note que possvel especificar um diretrio diferente do default, desmarcando a caixa Use Default e escolhendo o diretrio manualmente.

1
desaconselhvel o uso de acentos em nomes de projetos, pacotes e classes a interpretao de acentos em nomes de arquivos depende da implementao do sistema
operacional e pode causar problemas.

Figura 7 - Janela inicial do Eclipse

Figura 8 - Janela do New Wizard
Clique em Next. Se esta for a primeira vez em que um projeto Java criado no Eclipse, uma janela perguntando se voc quer mudar para a
perspectiva
2
Java aparecer clique Yes. Aps isto, a janela da Figura 10 aparecer.

Figura 9 - Seleo do nome de projeto

Figura 10 - Configuraes do projeto
Na janela mostrada na Figura 10 no precisamos entrar nenhuma informao, mas ela poderia ser usada para indicar pacotes adicionais para o
projeto sendo criado. Para terminar a criao do projeto, clique no boto Finish.
Aps a criao do projeto, a janela principal do Eclipse dever estar como mostrada na Figura 11.
Criando um novo pacote em um projeto
Primeiro criaremos um novo pacote em um projeto. Pacotes so usados em Java para agrupar classes que tenham algo em comum (por exemplo,
que faam parte de uma aplicao). No caso de aplicaes que devem ser distribudas, o Eclipse facilita ainda mais a criao do arquivo para
distribuio se colocarmos todas as classes pertencentes a aplicao em um pacote.

2
Conjunto de janelas que tem determinada aparncia na tela do Eclipse e que facilita o trabalho com uma determinada ferramenta.
No lado esquerdo da janela principal do Eclipse temos um painel Package Explorer que mostra a hierarquia dos arquivos de projetos (a
rvore pode mostrar quais arquivos existem em quais projetos). Clique na entrada Exercicios para selecion-la, e clique novamente no boto
New Wizard ( ). A janela mostrada na Figura 8 aparecer. Desta vez, selecione Java no painel esquerdo e Package no painel direito.
Clique em Next para ir para o prximo passo, cuja janela mostrada na Figura 12.
Na Figura 12 devemos entrar o nome de um pacote antes de prosseguir. Nomes de pacotes so mais restritos que nomes de projetos: no podem
conter espaos nem caracteres especiais e sugerido que iniciem com letras minsculas. Para este exemplo, escolhemos o nome de pacote
capitulo01 (veja a nota de rodap 1 na pgina n 5). Aps entrar o nome clique em Finish. A janela principal do Eclipse aparecer novamente,
como mostrado na Figura 13. A Figura 13 mostra, no painel Package Explorer, que o pacote tambm usa as bibliotecas padro de Java
(JRE_LIB).

Figura 11 - Janela principal do Eclipse (depois de adicionar um projeto)

Figura 12 - Criao de um novo pacote

Criando uma classe em Java em um pacote
Com o projeto e o pacote criados, podemos adicionar novas classes no pacote. Para isso, selecione no Package Explorer o pacote no qual
voc quer adicionar uma classe e clique no boto New Wizard ( ). A janela mostrada na Figura 8 aparecer novamente. Desta vez, selecione
Java no painel esquerdo e Class no painel direito. Clique em Next para ir para o prximo passo, cuja janela mostrada na Figura 14.

Figura 13 - Janela principal do Eclipse (depois da criao de um pacote no projeto)


Figura 14 - Dilogo para criao de uma nova classe
O preenchimento do dilogo que aparece na Figura 14 depende da finalidade da classe a ser criada:
Em qualquer caso, o nome da classe deve ser fornecido aconselhvel usar os padres de nome sugeridos para classes (primeira letra
maiscula, alternando entre palavras, evitando acentos).
Para criar uma classe simples, que representar um conceito qualquer, no precisaremos selecionar mais nenhuma opo (por default, a
superclasse aparecer como java.lang.Object no dilogo mas esta no aparecer explicitamente no cdigo). Para criar uma classe
que herda de outra, devemos selecionar uma Superclasse (usando o boto Browse ou entrando o nome completo da casa no campo
correspondente) e, se for necessrio, selecionar a caixa Constructors from superclass. Para classes que implementam
interfaces, devemos usar o boto Add para adicionar as interfaces no campo correspondente. As declaraes de extends e
implements podem tambm ser escritas manualmente depois que o cdigo for gerado.
Para criar uma classe que contenha o mtodo main, podemos clicar na caixa prxima ao texto public static void
main(String[] args). Novamente, este trecho de cdigo pode ser escrito manualmente posteriormente.
Para continuar com o exemplo, vamos criar uma classe AloMundo com um mtodo main simples. O dilogo preenchido adequadamente aparece
na Figura 15. Aps o preenchimento devemos clicar no boto Finish.

Figura 15 - Dilogo para criao de uma nova classe (preenchido)

Figura 16 - A classe AloMundo criada no pacote capitulo01
A Figura 16 mostra a classe recm-criada o Eclipse automaticamente abre uma janela do editor que mostra o cdigo criado para a classe.
Os componentes bsicos da interface do Eclipse so mostrados na Figura 16. esquerda temos a janela Package Explorer, que mostra o
contedo do projeto e, hierarquicamente, pacotes no projeto, classes nos pacotes e mtodos nas classes. No centro temos a rea onde abriremos
editores para os arquivos (se clicarmos duas vezes no nome do arquivo no Package Explorer ele ser aberto em uma janela do editor). Na
rea direita temos a janela de Outline para a classe sendo editada esta janela mostra os elementos (campos, mtodos, etc.) da classe. Na parte
inferior temos a janela de Tasks que mostra quais so as tarefas associadas ao projeto uma maneira de marcar tarefas a executar pelo
programador.
Notas sobre o cdigo criado
O cdigo criado pelo Eclipse, mostrado de forma parcial na janela central na Figura 16, pode no estar formatado de acordo com as preferncias
do programador (o que o meu caso). Diversas opes de configurao do cdigo gerado podem ser alteradas, selecionando o menu
Window/Preferences e clicando, na rvore de opes do lado esquerdo, em Java/Code Formatter. As opes usadas por mim so
mostradas na Figura 17 elas se aproximam mais do estilo de cdigo ao qual estou acostumado, mas isto questo de preferncia pessoal.

Figura 17 - Preferncias do Eclipse para formatao de cdigo



Existem diversas opes no dilogo mostrado na Figura 17, sugerido que somente sejam modificadas as opes que sejam compreendidas para
evitar surpresas. Algumas opes que podem ser exploradas seguramente so as de gerao de cdigo, no menu Java/Templates do dilogo
mostrado na Figura 17. Estas opes permitem o ajuste fino da criao de cdigo automtico.
package capitulo01;

/**
* Mostra uma mensagem simples na tela.
* @author Rafael Santos
*/
public class AloMundo
{
public static void main(String[] args)
{
System.out.println("Al, Mundo !");
}
}
Figura 18 - O cdigo completo da classe AloMundo
Editando a classe criada
Para continuar com o exemplo, vamos editar a classe. A classe AloMundo completa mostrada na Figura 18. O editor do Eclipse
automaticamente coloriza e modifica fontes de palavras-chave, comentrios, strings e outros elementos de classes em Java, facilitando a sua
leitura. O tipo de fonte e cor usado para os diferentes elementos do cdigo-fonte podem ser customizados com o dilogo mostrado na Figura 17,
no menu Java/Editor, orelha Syntax.
Compilando e executando a classe criada
Uma das capacidades mais teis do Eclipse a compilao automtica de cdigo. Assim que o cdigo modificado gravado, todas as classes que
so relacionadas com a modificada so recompiladas automaticamente.
Para executar um programa que tenha o mtodo main adequado, clique no cone Run ( ). A janela de dilogo mostrada na Figura 19
aparecer.

Figura 19 - Configurao de execuo de classes

Figura 20 - Configurao para execuo da classe AloMundo

Clique duas vezes no menu Java Application (ou no boto New) e o dilogo da Figura 19 mudar para o da Figura 20. O dilogo est
praticamente preenchido, e no necessrio adicionar mais nada para executar a classe. Ao clicarmos no boto Run, uma janela nova no Eclipse
chamada Console abrir e mostrar o resultado do programa (Figura 21).

Figura 21 - Resultado da execuo da classe AloMundo

Figura 22 - Dilogo para seleo de superclasse
Criando, compilando e executando uma segunda classe
Como segundo exemplo, vamos criar uma classe AloMundoGrafico que mostrar a mensagem Al, Mundo ! usando uma interface grfica.
Esta classe ser criada da mesma forma que a AloMundo, exceto que ela herdar da classe JFrame. A seleo da superclasse feita quando
criamos a nova classe (Figura 14 e Figura 15), clicando no boto Browse... prximo ao campo de texto da superclasse. Este boto abre um
dilogo, mostrado na Figura 22, que permite que entremos os caracteres iniciais da classe sendo procurada em um campo de texto, e com uma
rea de seleo que mostra quais classes disponveis iniciam com os caracteres iniciais.
Para esta segunda classe, escolhemos a superclasse como JFrame e completamos os mtodos necessrios (o construtor para definir a interface
grfica da frame e o mtodo main para construir uma instncia da prpria classe).
Ao editar esta classe, criamos instncias ou usamos algumas classes que no so importadas por default, como Container, JLabel e Color:
sempre que o Eclipse encontrar, no cdigo-fonte, uma classe que no esteja explicitamente importada pela classe editada, ele marcar a linha com
referncias a classes desconhecidas com uma marca que pode ser um cone de lmpada amarela ou um sinal de pare vermelho (ou,
frequentemente, um em cima do outro). Estas marcaes so mostradas na Figura 23. Clique no cone da lmpada amarela ou sinal de pare para ter
uma lista de sugestes de correo (mostrada na Figura 24). Para as classes existentes o Eclipse mostrar a opo de importar a classe com nome
completo, o que faremos. Aps aceitar as sugestes, grave o arquivo para que ele seja recompilado, novas sugestes podem aparecer. Quando o
sinal de pare prximo do nome do arquivo na janela do editor desaparecer, o cdigo estar sem erros.

Figura 23 - Marcaes de problemas em classes editadas

Figura 24 - Sugestes do Eclipse para completar o cdigo gerado

O cdigo completo desta classe mostrado na Figura 25Erro! A origem da referncia no foi encontrada.. Para executar esta classe
necessrio executar um procedimento ligeiramente diferente do mostrado para a primeira aplicao: se clicarmos no cone Run ( ) a ltima
aplicao executara ser lanada novamente. Precisamos registrar a classe sendo editada como uma aplicao executvel. Para isto, clique no
pequeno tringulo preto do cone Run, o que trar um menu, mostrado na Figura 26. Neste menu, selecione a opo Run... que trar o dilogo
de configurao de lanamento de aplicaes. Este dilogo deve ser similar ao mostrado na Figura 27.


Figura 25 - Cdigo completo da segunda aplicao




Figura 26 - Menu Run

No dilogo mostrado na Figura 27, selecione a entrada Java Application no menu no painel esquerda e clique em New. O Eclipse
automaticamente preencher os campos do dilogo usando os dados da classe sendo editada. O dilogo preenchido mostrado na Figura 28.
package capitulo01;

import java.awt.Color;
import java.awt.Container;
import java.awt.Font;

import javax.swing.JFrame;
import javax.swing.JLabel;

/**
* Mostra a mensagem "Al, Mundo !" usando uma
* interface grfica.
* @author Rafael Santos
*/
public class AloMundoGrafico extends JFrame
{

public AloMundoGrafico()
{
super();
Container cp = getContentPane();
JLabel label = new JLabel("Al, Mundo !");
label.setFont(new Font("Serif",Font.BOLD,48));
label.setForeground(new Color(0,0,180));
cp.add(label);
pack();
show();
}

public static void main(String[] args)
{
new AloMundoGrafico();
}
}

Figura 27 - Dilogo para criao de mecanismo de lanamento de aplicao

Figura 28 - Dilogo para criao de mecanismo de lanamento (preenchido)
Ao clicar nos botes Apply ou Run, a aplicao ser executada. Para execut-la novamente basta clicar no cone Run ( ) a aplicao
executada por ltimo ser lanada. O resultado da segunda aplicao mostrado na Figura 29.

Figura 29 - Janela da segunda aplicao


Criando, compilando e executando Applets
Como terceiro exemplo vamos criar, compilar e executar uma Applet. O mecanismo de execuo de applets ser diferente, pois estas sero
executadas por um navegador.
O primeiro passo criar uma nova classe em um pacote existente (ou, se for o caso, criar um novo pacote). Para isso, vamos selecionar o pacote
onde queremos inserir a applet e, clicando com o boto direito do mouse, selecionar o menu New/Class. Crie uma classe que herde de
JApplet. O formulrio desta classe, preenchido, mostrado na Figura 30. Podemos selecionar a superclasse (JApplet) clicando no boto
Browse, e digitando as primeiras letras da superclasse (Figura 31). Clique em OK para selecionar a superclasse e em Finish para criar a applet.

Figura 30 - Criando uma applet (formulrio preenchido)

Figura 31 - Selecionando a superclasse para a applet
O cdigo criado estar tambm vazio, isto , sem mtodos ou campos. Uma applet deve ter ao menos o mtodo init, que inicializa a interface
grfica e prepara a applet para responder a eventos dos usurios. Nesta seo vamos apresentar o cdigo completo de uma calculadora de horas
simples, sem entrar em detalhes da implementao.
O cdigo-fonte completo da applet mostrado na Figura 32.
package capitulo01;
// Todos estes imports foram incluidos automaticamente pelo Eclipse

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.GridLayout;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.SimpleDateFormat;
import java.util.StringTokenizer;

import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JFormattedTextField;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
/**
* Esta classe implementa uma calculadora simples de horas trabalhadas. Ateno foi dada interface e funcio-
* namento, mas a classe no faz nada alm de clculos simples.
*/
public class Calculadora extends JApplet implements ActionListener
{
// Este boto far o envio dos dados (mas nesta applet ele est s de decorao)
private JButton enviar;
// Esta a matriz das horas trabalhadas por projeto.
private JFormattedTextField[][] horasNoDia;
private JFormattedTextField[] somaDasHoras;
// Para simplificar, teremos somente trs dias de trabalho
private final int diasDeTrabalho = 3;
// Para simplificar, teremos projetos constantes (deveriam ser obtidos de um banco de dados)
private final String[] projetos =
{
"Projeto IMBROGLIO",
"Projeto BROUHAHA",
"Projeto SHENANIGAN",
"Projeto PANDEMONIUM",
"Suporte a outros departamentos",
"Outros"
};

/**
* O mtodo init o mais crtico de uma applet: ele cria a interface com o usurio e registra eventos para os
* componentes desta interface.
*/
public void init()
{
// Vamos manipular o container da applet (interface grfica)
Container ct = getContentPane();
// Escolhemos o layout de borda
ct.setLayout(new BorderLayout());
// Vamos criar os campos de texto.
horasNoDia = new JFormattedTextField[diasDeTrabalho][projetos.length];
somaDasHoras = new JFormattedTextField[diasDeTrabalho];
// Vamos adicionar uma linda matriz de campos de texto !
// Para isto vamos usar dois JPanels para organizao.
JPanel painelDosProjetos = new JPanel(new GridLayout(projetos.length+2,1));
JPanel painelDasHoras = new JPanel(new GridLayout(projetos.length+2,diasDeTrabalho));
// Adicionamos os labels ao painel de projetos. Notem que temos duas linhas a mais no layout: uma para
// as horas (1, 2, 3) e uma para a soma das horas trabalhadas.
painelDosProjetos.add(new JLabel(""));
for(int projeto=0;projeto<projetos.length;projeto++)
{
JLabel umProjeto = new JLabel(" "+projetos[projeto]+" ",JLabel.RIGHT);
painelDosProjetos.add(umProjeto);
}
painelDosProjetos.add(new JLabel("<html><font color=\"#800000\">TOTAL:</font></html>",JLabel.LEFT));
// Adicionamos os campos ao painel de horas trabalhadas.
// Primeiro, os ttulos das colunas.
for(int dia=0;dia<diasDeTrabalho;dia++)
{
JLabel ttulo = new JLabel("<html><font size=+2>"+(dia+1)+"</center></html>",JLabel.CENTER);
ttulo.setBackground(new Color(200,220,255));
painelDasHoras.add(ttulo);
}
// Agora, a matriz das horas trabalhadas.
for(int projeto=0;projeto<projetos.length;projeto++)
{
for(int dia=0;dia<diasDeTrabalho;dia++)
{
horasNoDia[dia][projeto] = new JFormattedTextField(new SimpleDateFormat("K:mm"));
horasNoDia[dia][projeto].setText("00:00");
horasNoDia[dia][projeto].setHorizontalAlignment(JTextField.RIGHT);
horasNoDia[dia][projeto].addActionListener(this);
painelDasHoras.add(horasNoDia[dia][projeto]);
}
}
// Finalmente adicionamos os campos com horas somadas
for(int dia=0;dia<diasDeTrabalho;dia++)
{
somaDasHoras[dia] = new JFormattedTextField(new SimpleDateFormat("K:mm"));
somaDasHoras[dia].setText("000:00");
somaDasHoras[dia].setHorizontalAlignment(JTextField.RIGHT);
somaDasHoras[dia].setEditable(false);
painelDasHoras.add(somaDasHoras[dia]);
}
// Criamos o boto para enviar as horas trabalhadas.
enviar = new JButton("Enviar");
enviar.addActionListener(this);
// Este boto ser vermelho claro.
enviar.setBackground(new Color(255,200,200));
// Adicionamos os painis ao contedo da applet.
ct.add(painelDosProjetos,BorderLayout.WEST);
ct.add(painelDasHoras,BorderLayout.CENTER);
// Adicionamos o boto ao contedo da applet.
ct.add(enviar,BorderLayout.SOUTH);
// Finalmente, modificamos o contedo do painel
setContentPane(ct);
}

/**
* Este mtodo ser chamado cada vez que um evento de ao for executado. No caso, cada vez que um campo de texto
* for modificado (a tecla ENTER deve ser pressionada) o mtodo ser executado. Este mtodo recalcula as horas
* trabalhadas em um dia.
*/
public void actionPerformed(ActionEvent e)
{
// Para cada dia de trabalho...
for(int dia=0;dia<diasDeTrabalho;dia++)
{
// A soma dos minutos do dia zerada
int somaDoDia = 0;
// Para cada projeto em um dia
for(int projeto=0;projeto<projetos.length;projeto++)
{
// Recuperamos horas e minutos trabalhados como
// uma String.
String quantasHoras = horasNoDia[dia][projeto].getText();
// Vamos recuperar as horas e minutos processando
// a String que os contm.
StringTokenizer st = new StringTokenizer(quantasHoras,":");
int horas = Integer.parseInt(st.nextToken());
int minutos = Integer.parseInt(st.nextToken());
// Adicionamos a soma do dia (em minutos).
somaDoDia += (60*horas)+minutos;
}
// Ao final do dia, recalculamos e reformatamos as horas trabalhadas
int horas = somaDoDia / 60;
int minutos = somaDoDia % 60;
// Deve haver outra maneira de fazer isto, mas esta
// funciona e foi mais rpido assim.
somaDasHoras[dia].setText(formata(horas,3)+":"+formata(minutos,2));
// S pra mostrar como, mudamos o fundo da clula da soma
// das horas trabalhadas de acordo com o nmero de minutos.
if (somaDoDia == 0)
somaDasHoras[dia].setBackground(Color.LIGHT_GRAY);
else if (somaDoDia <= 4*60)
somaDasHoras[dia].setBackground(new Color(200,255,200));
else if (somaDoDia <= 8*60)
somaDasHoras[dia].setBackground(new Color(200,200,255));
else
somaDasHoras[dia].setBackground(new Color(255,200,200));
}
}

/**
* Este mtodo auxiliar formata strings contendo valores.
*/
private String formata(int valor,int dgitos)
{
String formatada = ""+valor;
while(formatada.length() < dgitos) formatada = "0"+formatada;
return formatada;
}

}
Figura 32 - Cdigo-fonte da applet
Ao salvar a applet, ela deve ter sido compilada sem erros. Agora vamos criar um arquivo .jar da mesma (o que pode no ser necessrio para applets
que so compostas de somente uma classe).
Para criar o .jar, selecione o menu File/Export. A janela mostrada na Figura 33 aparecer. Selecione a opo JAR file e clique em Next. A janela de
detalhes da exportao (mostrada na Figura 34) aparecer. Nesta janela, selecione as classes que deseja incluir no .jar isto pode ser feito classe a
classe ou por pacotes. aconselhvel marcar para exportao somente os arquivos necessrios, para evitar que o arquivo .jar fique
desnecessariamente grande. Selecione tambm um nome de arquivo (sem a extenso .jar) como destino da exportao (no exemplo, usei
minhaapplet). Anote o diretrio onde este .jar ser criado.

Figura 33 - Janela de exportao de arquivos

Figura 34 - Detalhes da exportao de arquivos .jar
Clique Next para ir para a prxima janela, mostrada na Figura 35. Nesta janela, desmarque as opes de exportar classes com erros ou advertncias
de compilao e clique Next. A janela da Figura 36 aparecer. No necessrio modificar nada nesta janela, podemos ento clicar em Finish para
criar o arquivo .jar.

Figura 35 - Outras opes para exportao de arquivos .jar

Figura 36 - Opes de manifesto para arquivos .jar

Podemos ver o contedo do arquivo .jar usando o comando jar, parte do JDK. Executando o comando jar tvf minhaapplet.jar temos como resultado

C:\Documents and Settings\rafael\Desktop\AppTest>jar tvf minhaapplet.jar
25 Tue Apr 01 09:57:22 BRT 2003 META-INF/MANIFEST.MF
920 Tue Apr 01 09:51:08 BRT 2003 capitulo01/Calculadora.class

Devemos agora criar um arquivo HTML simples no mesmo diretrio onde o arquivo .jar foi criado. Este arquivo deve conter o trecho

<APPLET CODE = "capitulo01.Calculadora"
ARCHIVE = "minhaapplet.jar"
WIDTH=340 HEIGHT=200>
Oops, nada de applets para voc !
</APPLET>
Segue uma descrio bsica do contedo deste arquivo:
A descrio da applet est entre <APPLET> e </APPLET>.
Os argumentos para a tag <APPLET> so:
o CODE: diz qual a classe da applet que ser executada, sem a extenso .class. No caso, como a classe faz parte de um pacote,
usamos o nome do pacote como prefixo: capitulo01.Calculadora.
o ARCHIVE: diz qual o nome do arquivo .jar, que dever obrigatoriamente estar no mesmo diretrio do arquivo HTML.
o WIDTH e HEIGHT: indicam qual o tamanho da janela da applet, e geralmente so determinados atravs de tentativa e erro.
O texto entre <APPLET> e </APPLET> ser exibido em navegadores que no tenham suporte a applets.
O arquivo HTML pode ser formatado vontade e conter outros elementos grficos. O importante que o cdigo que inclui a applet esteja
correto.
Para testar a applet, basta abrir o arquivo HTML em um navegador. Para disponibilizar a applet na Internet/Intranet, basta colocar o arquivo .jar e
o HTML em um diretrio visvel na Internet/Intranet. A Figura 37 mostra a applet sendo executada em um navegador.

Figura 37 - A applet, sendo executada no Mozilla