Tutorial – Introdução ao ambiente Eclipse

Tutorial – Introdução ao ambiente Eclipse
Rafael Santos
(revisto em 26/10/2003)
Introdução ....................................................................................................................................................................................................................... 1
Instalando o Java Development Kit ................................................................................................................................................................................ 2
Instalando o Eclipse ........................................................................................................................................................................................................ 4
Desinstalando o Eclipse .............................................................................................................................................................................................. 4
Passos para criação e execução de uma classe ............................................................................................................................................................... 4
Primeira execução 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 código 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
Introdução
O Eclipse é um ambiente integrado de desenvolvimento gratuito que pode ser usado para desenvolvimento de aplicações em Java, sendo um dos
mais recomendados para isto. O Eclipse não contém módulos para criação de interfaces gráficas, o que considero vantajoso para iniciantes na
linguagem Java, pois o foco deve ser a linguagem e não o aspecto visual de uma aplicação. Versões do Eclipse existem para diversos sistemas
operacionais, o que é outra vantagem. Mais informações 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. Versões específicas do JDK e do Eclipse
serão usadas, mas como estes softwares são constantemente atualizados, é possível que existam pequenas diferenças na numeração das versões
mostradas no documento e as existentes nos sites.
Instalando o Java Development Kit
Para instalar o Java 2 Development Kit (J2SDK, também referenciado como JDK neste documento), faça o download do arquivo j2sdk1_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 executável.
Após umas janelas com informações sobre o instalador (que desaparecerão sem necessidade de interação), a janela mostrada na Figura 1
aparecerá. Clique no botão “I accept the terms in the license agreement” e depois no botão Next (que será ativado). A janela da Figura 2
aparecerá, e nela você poderá selecionar quais componentes deseja instalar. Por default, todas as opções estarão selecionadas, é aconselhável
deixar assim a não ser que existam restrições no espaço em disco – se houverem, os demonstrativos (Demos) e código-fonte (Source Code) podem
ser desmarcados para instalação. Também é aconselhável manter o caminho de instalação para c:\j2sdk1.4.2_01.
Figura 1 - Licença do JDK
Figura 2 - Customização da instalação
Após a seleção dos componentes para instalação, clique em Next. A Figura 3 aparecerá. Esta janela lista os navegadores instalados e
reconhecidos, e o instalador registrará o Java Plug-In (para execução de applets) para estes navegadores. Clique em Install para prosseguir.
Dependendo da versão 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 instalação várias janelas com diálogos como o da Figura 5 aparecerão. Não é necessário tomar nenhuma
providência neste passo. Ao final da instalação a janela mostrada na Figura 6 será mostrada. É aconselhável reinicializar o computador após a
instalação (uma janela aparece pedindo confirmação para reinicialização).
Figura 3 - Registro dos navegadores
Figura 4 - Aviso sobre versão do sistema operacional
Figura 5 - Processo de instalação
Figura 6 - Término da instalação do JDK
Você pode testar a instalação do JDK de duas formas: uma é através do Java Web Start, cujo ícone deve ter sido instalado no desktop do
computador. Clique duas vezes neste ícone para executar o programa, sua execução é sinal de que a instalação foi concluída com sucesso.
Alternativamente, abra um terminal (com o menu Iniciar/Programas/Acessórios/Prompt de comando) e digite nele java. No
terminal deverão aparecer mensagens impressas pelo comando java.
Instalando o Eclipse
Primeiro, é necessário 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). Aparecerão várias 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 também o arquivo eclipse-JDT, que é comum para todas as plataformas – o nome do link para download será dependente da versão do
Eclipse, mas somente um arquivo deve aparecer na lista JDT Runtime Binary. Por exemplo, para o Windows 2000 e versão 2.1.1 do Eclipse, os
arquivos que devem ser copiados são eclipse-platform-2.1.1-win32.zip e eclipse-JDT-2.1.1.zip.
Para instalar o Eclipse, basta descompactar os arquivos em uma localização qualquer. É sugerido descompactar os dois arquivos em
C:\Arquivos de Programas. O diretório eclipse (em minúsculas) será criado automaticamente. Como alguns arquivos existem em
ambos os arquivos .zip a ser descompactados, o descompactador pode mostrar algumas advertências ou pedir para sobreescrever arquivos, o que
pode ser feito sem problemas.
Desinstalando o Eclipse
Se por alguma razão você quiser desinstalar o Eclipse, basta apagar o diretório onde este foi instalado – não existe um mecanismo específico de
desinstalação.
Passos para criação e execução de uma classe
Primeira execução do Eclipse
Execute pela primeira vez o Eclipse, clicando no aplicativo C:\Arquivos de programas\eclipse\eclipse (assumindo que o Eclipse foi instalado no
diretório 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 vários pacotes e classes relacionados com um tema. Para criar
um novo projeto, clique no botão New Wizard ( ), está localizado logo abaixo do menu File. A janela mostrada na Figura 8 aparecerá.
Figura 7 - Janela inicial do Eclipse
Figura 8 - Janela do New Wizard
No diálogo mostrado na Figura 8, selecione Java no painel esquerdo e Java Project no painel direito e clique no botão 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 diretório, evite usar caracteres
inadequados para nomes de diretórios. Entre o nome de projeto e clique no botão Next. No exemplo, usei o nome de projeto Exercicios1.
Note que é possível especificar um diretório diferente do default, desmarcando a caixa Use Default e escolhendo o diretório manualmente.
1
É desaconselhável o uso de acentos em nomes de projetos, pacotes e classes – a interpretação de acentos em nomes de arquivos depende da implementação do sistema
operacional e pode causar problemas.
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
perspectiva2 Java aparecerá – clique Yes. Após isto, a janela da Figura 10 aparecerá.
Figura 9 - Seleção do nome de projeto
Figura 10 - Configurações do projeto
Na janela mostrada na Figura 10 não precisamos entrar nenhuma informação, mas ela poderia ser usada para indicar pacotes adicionais para o
projeto sendo criado. Para terminar a criação do projeto, clique no botão Finish.
Após a criação 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 são usados em Java para agrupar classes que tenham algo em comum (por exemplo,
que façam parte de uma aplicação). No caso de aplicações que devem ser distribuídas, o Eclipse facilita ainda mais a criação do arquivo para
distribuição se colocarmos todas as classes pertencentes a aplicação em um pacote.
2
Conjunto de janelas que tem determinada aparência 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 botão
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 próximo passo, cuja janela é mostrada na Figura 12.
Na Figura 12 devemos entrar o nome de um pacote antes de prosseguir. Nomes de pacotes são mais restritos que nomes de projetos: não podem
conter espaços nem caracteres especiais e é sugerido que iniciem com letras minúsculas. Para este exemplo, escolhemos o nome de pacote
capitulo01 (veja a nota de rodapé 1 na página nº 5). Após 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 também usa as bibliotecas padrão de Java
(JRE_LIB).
Figura 11 - Janela principal do Eclipse (depois de adicionar um projeto)
Figura 12 - Criação 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 botão 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 próximo passo, cuja janela é mostrada na Figura 14.
Figura 13 - Janela principal do Eclipse (depois da criação de um pacote no projeto)
Figura 14 - Diálogo para criação de uma nova classe
O preenchimento do diálogo que aparece na Figura 14 depende da finalidade da classe a ser criada:
•
Em qualquer caso, o nome da classe deve ser fornecido – é aconselhável usar os padrões de nome sugeridos para classes (primeira letra
maiúscula, alternando entre palavras, evitando acentos).
•
Para criar uma classe simples, que representará um conceito qualquer, não precisaremos selecionar mais nenhuma opção (por default, a
superclasse aparecerá como java.lang.Object no diálogo mas esta não aparecerá explicitamente no código). Para criar uma classe
que herda de outra, devemos selecionar uma Superclasse (usando o botão Browse ou entrando o nome completo da casa no campo
correspondente) e, se for necessário, selecionar a caixa Constructors from superclass. Para classes que implementam
interfaces, devemos usar o botão Add para adicionar as interfaces no campo correspondente. As declarações de extends e
implements podem também ser escritas manualmente depois que o código for gerado.
•
Para criar uma classe que contenha o método main, podemos clicar na caixa próxima ao texto public static void
main(String[] args). Novamente, este trecho de código pode ser escrito manualmente posteriormente.
Para continuar com o exemplo, vamos criar uma classe AloMundo com um método main simples. O diálogo preenchido adequadamente aparece
na Figura 15. Após o preenchimento devemos clicar no botão Finish.
Figura 16 - A classe AloMundo criada no pacote capitulo01
Figura 15 - Diálogo para criação de uma nova classe (preenchido)
A Figura 16 mostra a classe recém-criada – o Eclipse automaticamente abre uma janela do editor que mostra o código criado para a classe.
Os componentes básicos da interface do Eclipse são mostrados na Figura 16. À esquerda temos a janela Package Explorer, que mostra o
conteúdo do projeto e, hierarquicamente, pacotes no projeto, classes nos pacotes e métodos 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, métodos, etc.) da classe. Na parte
inferior temos a janela de Tasks que mostra quais são as tarefas associadas ao projeto – uma maneira de marcar tarefas a executar pelo
programador.
Notas sobre o código criado
O código criado pelo Eclipse, mostrado de forma parcial na janela central na Figura 16, pode não estar formatado de acordo com as preferências
do programador (o que é o meu caso). Diversas opções de configuração do código gerado podem ser alteradas, selecionando o menu
Window/Preferences e clicando, na árvore de opções do lado esquerdo, em Java/Code Formatter. As opções usadas por mim são
mostradas na Figura 17 – elas se aproximam mais do estilo de código ao qual estou acostumado, mas isto é questão de preferência pessoal.
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 código completo da classe AloMundo
Figura 17 - Preferências do Eclipse para formatação de código
Existem diversas opções no diálogo mostrado na Figura 17, é sugerido que somente sejam modificadas as opções que sejam compreendidas para
evitar surpresas. Algumas opções que podem ser exploradas seguramente são as de geração de código, no menu Java/Templates do diálogo
mostrado na Figura 17. Estas opções permitem o ajuste fino da criação de código automático.
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, comentários, strings e outros elementos de classes em Java, facilitando a sua
leitura. O tipo de fonte e cor usado para os diferentes elementos do código-fonte podem ser customizados com o diálogo mostrado na Figura 17,
no menu Java/Editor, orelha Syntax.
Compilando e executando a classe criada
Uma das capacidades mais úteis do Eclipse é a compilação automática de código. Assim que o código modificado é gravado, todas as classes que
são relacionadas com a modificada são recompiladas automaticamente.
Para executar um programa que tenha o método main adequado, clique no ícone Run (
aparecerá.
Figura 19 - Configuração de execução de classes
). A janela de diálogo mostrada na Figura 19
Figura 20 - Configuração para execução da classe AloMundo
Clique duas vezes no menu Java Application (ou no botão New) e o diálogo da Figura 19 mudará para o da Figura 20. O diálogo está
praticamente preenchido, e não é necessário adicionar mais nada para executar a classe. Ao clicarmos no botão Run, uma janela nova no Eclipse
chamada Console abrirá e mostrará o resultado do programa (Figura 21).
Figura 22 - Diálogo para seleção de superclasse
Figura 21 - Resultado da execução da classe AloMundo
Criando, compilando e executando uma segunda classe
Como segundo exemplo, vamos criar uma classe AloMundoGrafico que mostrará a mensagem “Alô, Mundo !” usando uma interface gráfica.
Esta classe será criada da mesma forma que a AloMundo, exceto que ela herdará da classe JFrame. A seleção da superclasse é feita quando
criamos a nova classe (Figura 14 e Figura 15), clicando no botão Browse... próximo ao campo de texto da superclasse. Este botão abre um
diálogo, 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 seleção que mostra quais classes disponíveis iniciam com os caracteres iniciais.
Para esta segunda classe, escolhemos a superclasse como JFrame e completamos os métodos necessários (o construtor para definir a interface
gráfica da frame e o método main para construir uma instância da própria classe).
Ao editar esta classe, criamos instâncias ou usamos algumas classes que não são importadas por default, como Container, JLabel e Color:
sempre que o Eclipse encontrar, no código-fonte, uma classe que não esteja explicitamente importada pela classe editada, ele marcará a linha com
referências a classes “desconhecidas” com uma marca que pode ser um ícone de lâmpada amarela ou um sinal de pare vermelho (ou,
frequentemente, um em cima do outro). Estas marcações são mostradas na Figura 23. Clique no ícone da lâmpada amarela ou sinal de pare para ter
uma lista de sugestões de correção (mostrada na Figura 24). Para as classes existentes o Eclipse mostrará a opção de importar a classe com nome
completo, é o que faremos. Após aceitar as sugestões, grave o arquivo para que ele seja recompilado, novas sugestões podem aparecer. Quando o
sinal de pare próximo do nome do arquivo na janela do editor desaparecer, o código estará sem erros.
Figura 24 - Sugestões do Eclipse para completar o código gerado
Figura 23 - Marcações de problemas em classes editadas
O código completo desta classe é mostrado na
Figura 25Erro! A origem da referência não foi encontrada.. Para executar esta classe é
) a última
necessário executar um procedimento ligeiramente diferente do mostrado para a primeira aplicação: se clicarmos no ícone Run (
aplicação executara será lançada novamente. Precisamos registrar a classe sendo editada como uma aplicação executável. Para isto, clique no
pequeno triângulo preto do ícone Run, o que trará um menu, mostrado na Figura 26. Neste menu, selecione a opção Run... que trará o diálogo
de configuração de lançamento de aplicações. Este diálogo deve ser similar ao mostrado na Figura 27.
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 gráfica.
* @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();
}
Figura 26 - Menu Run
public static void main(String[] args)
{
new AloMundoGrafico();
}
}
Figura 25 - Código completo da segunda aplicação
No diálogo 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 diálogo usando os dados da classe sendo editada. O diálogo preenchido é mostrado na Figura 28.
Figura 27 - Diálogo para criação de mecanismo de lançamento de aplicação
Figura 28 - Diálogo para criação de mecanismo de lançamento (preenchido)
Ao clicar nos botões Apply ou Run, a aplicação será executada. Para executá-la novamente basta clicar no ícone Run (
executada por último será lançada. O resultado da segunda aplicação é mostrado na Figura 29.
) – a aplicação
Figura 29 - Janela da segunda aplicação
Criando, compilando e executando Applets
Como terceiro exemplo vamos criar, compilar e executar uma Applet. O mecanismo de execução de applets será diferente, pois estas serão
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 botão direito do mouse, selecionar o menu New/Class. Crie uma classe que herde de
JApplet. O formulário desta classe, preenchido, é mostrado na Figura 30. Podemos selecionar a superclasse (JApplet) clicando no botão
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 31 - Selecionando a superclasse para a applet
Figura 30 - Criando uma applet (formulário preenchido)
O código criado estará também vazio, isto é, sem métodos ou campos. Uma applet deve ter ao menos o método init, que inicializa a interface
gráfica e prepara a applet para responder a eventos dos usuários. Nesta seção vamos apresentar o código completo de uma calculadora de horas
simples, sem entrar em detalhes da implementação.
O código-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
import
import
import
import
import
java.awt.GridLayout;
java.awt.Toolkit;
java.awt.event.ActionEvent;
java.awt.event.ActionListener;
java.text.SimpleDateFormat;
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. Atenção foi dada à interface e funcio* namento, mas a classe não faz nada além de cálculos simples.
*/
public class Calculadora extends JApplet implements ActionListener
{
// Este botão fará o envio dos dados (mas nesta applet ele está só de decoração)
private JButton enviar;
// Esta é a matriz das horas trabalhadas por projeto.
private JFormattedTextField[][] horasNoDia;
private JFormattedTextField[] somaDasHoras;
// Para simplificar, teremos somente três 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 método init é o mais crítico de uma applet: ele cria a interface com o usuário e registra eventos para os
* componentes desta interface.
*/
public void init()
{
// Vamos manipular o container da applet (interface gráfica)
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 organização.
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 títulos das colunas.
for(int dia=0;dia<diasDeTrabalho;dia++)
{
JLabel título = new JLabel("<html><font size=+2>"+(dia+1)+"</center></html>",JLabel.CENTER);
título.setBackground(new Color(200,220,255));
painelDasHoras.add(título);
}
// 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 botão para enviar as horas trabalhadas.
enviar = new JButton("Enviar");
enviar.addActionListener(this);
// Este botão será vermelho claro.
enviar.setBackground(new Color(255,200,200));
// Adicionamos os painéis ao conteúdo da applet.
ct.add(painelDosProjetos,BorderLayout.WEST);
ct.add(painelDasHoras,BorderLayout.CENTER);
// Adicionamos o botão ao conteúdo da applet.
ct.add(enviar,BorderLayout.SOUTH);
// Finalmente, modificamos o conteúdo do painel
setContentPane(ct);
}
/**
* Este método será chamado cada vez que um evento de ação for executado. No caso, cada vez que um campo de texto
* for modificado (a tecla ENTER deve ser pressionada) o método será executado. Este método 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 contém.
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 rápido assim.
somaDasHoras[dia].setText(formata(horas,3)+":"+formata(minutos,2));
// Só pra mostrar como, mudamos o fundo da célula da soma
// das horas trabalhadas de acordo com o número 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 método auxiliar formata strings contendo valores.
*/
private String formata(int valor,int dígitos)
{
String formatada = ""+valor;
while(formatada.length() < dígitos) formatada = "0"+formatada;
return formatada;
}
}
Figura 32 - Código-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 não ser necessário para applets
que são compostas de somente uma classe).
Para criar o .jar, selecione o menu File/Export. A janela mostrada na Figura 33 aparecerá. Selecione a opção JAR file e clique em Next. A janela de
detalhes da exportação (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. É aconselhável marcar para exportação somente os arquivos necessários, para evitar que o arquivo .jar fique
desnecessariamente grande. Selecione também um nome de arquivo (sem a extensão .jar) como destino da exportação (no exemplo, usei
minhaapplet). Anote o diretório onde este .jar será criado.
Figura 33 - Janela de exportação de arquivos
Figura 34 - Detalhes da exportação de arquivos .jar
Clique Next para ir para a próxima janela, mostrada na Figura 35. Nesta janela, desmarque as opções de exportar classes com erros ou advertências
de compilação e clique Next. A janela da Figura 36 aparecerá. Não é necessário modificar nada nesta janela, podemos então clicar em Finish para
criar o arquivo .jar.
Figura 35 - Outras opções para exportação de arquivos .jar
Figura 36 - Opções de manifesto para arquivos .jar
Podemos ver o conteúdo 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 diretório 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 descrição básica do conteúdo deste arquivo:
•
•
A descrição da applet está entre <APPLET> e </APPLET>.
Os argumentos para a tag <APPLET> são:
o CODE: diz qual é a classe da applet que será executada, sem a extensão .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 diretório do arquivo HTML.
o WIDTH e HEIGHT: indicam qual é o tamanho da janela da applet, e geralmente são determinados através de tentativa e erro.
• O texto entre <APPLET> e </APPLET> será exibido em navegadores que não tenham suporte a applets.
• O arquivo HTML pode ser formatado à vontade e conter outros elementos gráficos. O importante é que o código 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 diretório visível na Internet/Intranet. A Figura 37 mostra a applet sendo executada em um navegador.
Figura 37 - A applet, sendo executada no Mozilla