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

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.

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 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 15 - Diálogo para criação de uma nova classe (preenchido)

Figura 16 - A classe AloMundo criada no pacote capitulo01

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.

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.

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

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 ( ). A janela de diálogo mostrada na Figura 19 aparecerá.

Figura 19 - Configuração de execução de classes

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 21 - Resultado da execução da classe AloMundo

Figura 22 - Diálogo para seleção 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 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 23 - Marcações de problemas em classes editadas

Figura 24 - Sugestões do Eclipse para completar o código gerado

O código completo desta classe é mostrado na Figura 25Erro! A origem da referência não foi encontrada.. Para executar esta classe é necessário executar um procedimento ligeiramente diferente do mostrado para a primeira aplicação: se clicarmos no ícone Run ( ) a última 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.

Figura 25 - Código completo da segunda aplicação

Figura 26 - Menu Run

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.

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(); } public static void main(String[] args) { new AloMundoGrafico(); } }

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 ( ) – a aplicação executada por último será lançada. O resultado da segunda aplicação é mostrado na Figura 29.

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 30 - Criando uma applet (formulário preenchido)

Figura 31 - Selecionando a superclasse para a applet

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