Desenvolvendo aplicações

22

Desenvolvendo aplicac

¸ ˜

oes

para a Web

Uma aplica¸c˜ao Java pode ser executada sem modifica¸c˜ao em qualquer plataforma que tenha a m´aquina virtual Java instalada. Esta caracter´ıstica faz com que as aplica¸c˜oes Java possam ser transferidas atrav´es da Internet para serem executadas nas diferentes m´aquinas que comp˜oem a rede mundial de computadores.

Este cap´ıtulo mostra como criar applets, que s˜ao programas Java que podem ser exe-cutados a partir de navegadores web.

22.1

Applets

Os applets s˜ao pain´eis que podem ser embutidos em p´aginas web e cujo c´odigo ´e executado sob o controle dos navegadores web usados para exib´ı-las.

22.1.1 O modo de execu¸c˜ao de um applet

A execu¸c˜ao de um applet ´e controlada a partir dos m´etodos init, start, stop e destroy, que s˜ao chamados pelo navegador web em resposta a eventos espec´ıficos.

public void init(). Este m´etodo ´e chamado um ´unica vez para inicializar o applet. Isto ocorre, por exemplo quando a p´agina ´e carregada pelo navegador pela primeira vez.

public void start(). Este m´etodo ´e chamado logo ap´os a execu¸c˜ao do m´etodo init e, ap´os isso, sempre que a p´agina contendo o applet ´e visitada (isto ocorre, por exemplo, quando o usu´ario retorna `a p´agina do applet ap´os ter visitado outras p´aginas). public void stop(). Este m´etodo ´e chamado sempre que o usu´ario deixa a p´agina que

Figura 22.1. O ciclo de vida de um applet

M

ozilla página do applet O usuário deixa a página do applet O usuário visita a execução do navegador O usuário termina a execução do navegador O usuário termina a página do applet O usuário visita a

M

ozilla

M

ozilla pela primeira vez

init() start() stop() start() destroy() destroy()

public void destroy(). Este m´etodo ´e chamado quando o navegador termina sua execu¸c˜ao.

Os m´etodos acima s˜ao p´ublicos. A pr´opria classe que especifica o applet deve ser definida como p´ublica. A Figura 22.1 mostra a seq¨uˆencia das chamadas aos m´etodos init, start, stop e destroy. Esta seq¨uˆencia ´e conhecida como ciclo de vida de um applet.

Embora concebido para ser executado apenas uma vez, quando o applet ´e iniciado, a chamada ao m´etodo init (bem como as chamadas aos demais m´etodos do seu ciclo de vida) depende do ambiente de execu¸c˜ao. Assim, ´e poss´ıvel que certos navegadores em certas situa¸c˜oes executem o m´etodo init mais de uma vez.

22.1.2 Construindo applets

Todo applet deve ser especificado como uma subclasse de Applet que, por sua vez, ´e uma subclasse de Panel. Se o applet cont´em componentes swing, ent˜ao deve ser especificado como subclasse de JApplet, que ´e uma subclasse de Applet. A figura 22.2 mostra a hierarquia dessas classes.

Ao conceber um applet devemos codificar no m´etodo init todas as a¸c˜oes que quere-mos executar ao iniciar a aplica¸c˜ao. O m´etodo start deve conter as a¸c˜oes que queremos executar sempre que o usu´ario visitar a p´agina do applet, enquanto o m´etodo stop deve conter as a¸c˜oes que ser˜ao executadas sempre que o usu´ario deixar a p´agina do applet. O m´etodo destroy deve conter as a¸c˜oes que finalizam a aplica¸c˜ao.

22.2 Executando applets 3

Figura 22.2. Hierarquia das classes relacionadas a applets Object Component Container Panel Applet JApplet

Exemplo 22.1. O programa abaixo cria um applet que consiste de um campo de texto edit´avel. A classe que implementa o applet deve ser p´ublica e declarada como subclasse de Applet (linha 3); a declara¸c˜ao import na linha 1 torna poss´ıvel esta referˆencia.

1 import java.applet.Applet; 2 import java.awt.*;

3 public class C22Exemplo1 extends Applet { 4 public void init() {

5 TextField texto = new TextField("Exemplo de Applet"); 6 this.add(texto);

7 }

8 }

Neste applet temos apenas o m´etodo init no qual um objeto da classe TextField ´e criado (linha 5) e adicionado ao applet (linha 6).

Observe que na linha 6 poder´ıamos ter usado apenas a chamada add(texto), sem o referente this. Isto porque o m´etodo init ´e sempre executado pelo objeto que implementa o applet que, sendo da classe Container, pode fazer referˆencia direta a add. 

O gerente de leiaute padr˜ao de um applet da classe Applet ´e o FlowLayout. Se ne-cess´ario devemos definir um outro tipo de gerente de leiaute.

22.2

Executando applets

O applet do Exemplo 22.1 deve ser executado atrav´es de um navegador, como parte de uma p´agina web. Uma alternativa cˆomoda para testar um applet sem nos preocuparmos com a p´agina na qual ele ser´a inserido ´e usar o aplicativo appletviewer.

Figura 22.3. appletviewer exibindo o applet do Exemplo 21.1

22.2.1 Usando o appletviewer

O aplicativo appletviewer faz parte do ambiente padr˜ao Java. Para us´a-lo basta digitar o comando:

appletviewer hArquivoTag i

onde hArquivoTagi ´e um arquivo texto contendo um par de tags html identificando o c´odigo que implementa o applet. A forma mais simples destas tags ´e a seguinte:

<applet code="hIdentCodApplet i"

width="hLarguraApplet i" height="hAlturaApplet i"> </applet>

As aspas s˜ao obrigat´orias, hIdentCodApplet i identifica o arquivo contendo o c´odigo do applet, e hLarguraApplet i e hAlturaApplet i definem, em quantidade de pixels, a largura e altura da ´area que o applet deve ocupar na p´agina web.

Qualquer arquivo texto fornecido como parˆametro para o aplicativo appletviewer ser´a processado e sempre que uma tag identificando um applet for encontrada, o applet correspondente ser´a exibido, como se estivesse sendo carregado a partir de uma p´agina web.

Geralmente, quando queremos testar um applet que estamos construindo, colocamos em seu pr´oprio c´odigo fonte um coment´ario contendo as tags que permitem a execu¸c˜ao do applet atrav´es do appletviewer.

Exemplo 22.2. Se colocarmos a seguinte linha de coment´ario no c´odigo fonte do programa do Exemplo 22.1:

//<applet code="C22Exemplo1.class" width="200" height="50"></applet> ao digitarmos o comando

appletviewer C22Exemplo1.java

o applet implementado pelo c´odigo C22Exemplo1.class ser´a carregado e ter´a seus m´etodos init e start executados pelo visualizador. A janela de exibi¸c˜ao ter´a 200 pixels de largura e 50 de altura, como a mostrada na Figura 22.3. 

22.2 Executando applets 5

O bot˜ao Applet na janela do appletviewer exibe um menu que permite carregar e reiniciar a execu¸c˜ao do applet, bem como executar seus m´etodos start e stop. Isso permite simular o comportamento que o applet ter´a quando executado atrav´es de um navegador web.

22.2.2 Usando um navegador web

Os applets quando inseridos em uma p´agina web s˜ao executados pelo navegador usado para exib´ı-la. As p´aginas web s˜ao codificadas atrav´es da linguagem de marca¸c˜ao de texto html, que permite tanto a especifica¸c˜ao do texto quanto a especifica¸c˜ao dos demais elementos que comp˜oem uma p´agina web como, por exemplo, arquivos de imagens, sons, conex˜ao com outras p´aginas web, etc.

Este cap´ıtulo n˜ao apresenta detalhes da linguagem html. Para testar nossas aplica¸c˜oes basta saber que grande parte dos comandos html s˜ao definidos atrav´es de pares de tags que iniciam com um r´otulo da forma:

<rotulo hdemais elementos da tag i>

e terminam com um r´otulo da forma </rotulo>. Observe que o par que identifica um applet possui esse formato. Por sua vez, a tag <html> define o in´ıcio de uma p´agina cujo fim ´e especificado por </html>. Para inserir um applet em uma p´agina web basta colocar as tags que o identificam no corpo de uma p´agina.

Exemplo 22.3. O texto a seguir define a p´agina web mais simples que podemos especificar contendo as tags que identificam o applet do Exemplo 22.1.

<html>

<applet code="C22Exemplo1.class" width="200" height="50"></applet> </html>

Se salvarmos esse texto em um arquivo texto de nome PagTeste.html, por exemplo, e o carregarmos usando um navegador web, teremos o in´ıcio da execu¸c˜ao do applet conforme explicado na Se¸c˜ao 22.1.1. 

A p´agina do exemplo acima, embora funcional, n˜ao possui a estrutura esperada para uma p´agina web, que deve ter seu cabe¸calho especificado pelas tags <head> e </head>, e seu corpo especificado pelas tags <body> e </body>. Normalmente as p´aginas web s˜ao constru´ıdas usando-se editores html que facilitam a especifica¸c˜ao dos seus v´arios elementos, incluindo as tags que identificam os applets.

Figura 22.4. appletviewer exibindo o applet do Exemplo 22.4

22.3

Outros modos de construir applets

Applets tanto podem ser constru´ıdos para usar componentes do pacote awt quanto compo-nentes do pacote swing. Podemos tamb´em desenhar nossos pr´oprios componentes atrav´es das primitivas do contexto gr´afico usado pelo m´etodo paint.

22.3.1 Usando o m´etodo paint

Um applet pode n˜ao conter explicitamente o c´odigo dos m´etodo init, start, stop e destroy. Neste caso, o ambiente executar´a as a¸c˜oes padr˜oes para carregar, interromper e reiniciar o applet.

Exemplo 22.4. O programa a seguir implementa o applet mostrado na Figura 22.4. 1 // <applet code="C22Exemplo4.class" width="150" height="60"> </applet> 2 import java.applet.*;

3 import java.awt.*;

4 public class C22Exemplo4 extends Applet { 5 public void paint(Graphics g) {

6 g.drawRect(0, 0, getSize().width - 1, getSize().height - 1); 7 g.setColor(Color.RED);

8 g.drawString("Josefa branca e rosa", 15, 30);

9 }

10 }

Este applet possui apenas o m´etodo paint, que ´e chamado pelo ambiente sempre que o applet deve ser mostrado. Isto ocorre, por exemplo, quando o applet ´e carregado (ao iniciar sua execu¸c˜ao e sempre que o usu´ario retornar `a p´agina que o cont´em) e tamb´em ao ser tornado vis´ıvel ap´os deixar de ser encoberto por alguma outra janela. Na chamada ao m´etodo paint o ambiente de execu¸c˜ao fornece como argumento o contexto gr´afico usado para determinar as caracter´ısticas gr´aficas do componente. Neste caso a ´area de desenho ter´a a dimens˜ao especificada para o applet (150 pixels de largura e 60 de altura).

O coment´ario da linha 1 permite a execu¸c˜ao deste applet pelo appletviewer. O m´etodo getSize ´e executado pelo objeto que implementa o applet. Logo, a referˆencia

22.3 Outros modos de construir applets 7

Figura 22.5. appletviewer exibindo o applet do Exemplo 22.5

getSize().width produz o valor 150 e a referˆencia getSize().height, o valor 60. Assim, o m´etodo drawRect da linha 6 desenha um retˆangulo cujo v´ertice superior esquerdo est´a posicionado na coordenada (0,0), tendo uma largura de 149 e uma altura de 59 pixels. Na linha 8 a cadeia de caracteres ”Josefa branca e rosa” ´e desenhada a partir da coordenada (15,30). Esta cadeia ´e desenhada com a cor vermelha, que ´e a cor corrente ap´os a execu¸c˜ao do m´etodo setColor da linha 7. 

22.3.2 Usando a classe JApplet

Se quisermos usar componentes swing para construir applets devemos especific´a-los como uma subclasse de JApplet que, por sua vez, ´e uma subclasse de JFrame. Assim, da mesma forma que ocorre com aplica¸c˜oes swing convencionais, em um applet que estende JApplet o gerente de leiaute e os componentes devem ser adicionados atrav´es do componente de conte´udo do applet (e n˜ao ao applet diretamente). O gerente de leiaute padr˜ao de um applet swing ´e o BorderLayout.

Exemplo 22.5. O programa a seguir implementa o applet mostrado na Figura 22.5, que exibe uma lista de n´umeros idˆentica `a lista da Tabela 21.2.

1 //<applet code="C22Exemplo5.class" width="160" height="100"> </applet> 2 import javax.swing.*;

3 import java.awt.*;

4 public class C22Exemplo5 extends JApplet { 5 String[] numeros = {"10","13","22","9","102"}; 6 public void init() {

7 Container conteudo = this.getContentPane(); 8 conteudo.add(new JList(numeros));

9 }

10 }

O vetor com a lista de n´umeros ´e especificado, na linha 5, como um atributo do objeto que implementa o applet. O componente de conte´udo ´e obtido na linha 7 e, atrav´es dele, na linha 8, ´e adicionado o componente da classe JList. 

Figura 22.6. appletviewer exibindo o applet do Exemplo 22.6

22.4

Tratando eventos

Os eventos s˜ao tratados da mesma forma que nas aplica¸c˜oes Java convencionais. Devemos especificar as classes capazes de monitor´a-los, criar os monitores e associ´a-los aos compo-nentes da interface que ser˜ao as fontes dos eventos que queremos tratar.

Exemplo 22.6. O programa abaixo especifica um applet que calcula a presta¸c˜ao inicial de um financiamento segundo a tabela price1. Este applet, mostrado na Figura 22.6, possui trˆes campos de texto para o usu´ario informar o valor do financiamento, os juros anuais e a quantidade de meses, al´em de um bot˜ao de c´alculo usado para calcular o valor da presta¸c˜ao inicial.

Dois tipos de eventos s˜ao tratados. Primeiro, o clique do mouse. Sempre que o usu´ario clicar o mouse sobre o bot˜ao de c´alculo o valor da primeira presta¸c˜ao ser´a atualizado segundo a f´ormula:

presta¸c˜ao = financiamento × juros × (1 + juros)

per´ıodo

(1 + juros)per´ıodo_{− 1}

Este tipo de evento ´e tratado implementando-se a classe abstrata MouseAdapter (linhas 33 a 43). O segundo tipo de evento ´e a obten¸c˜ao do foco do teclado. Sempre que o usu´ario clicar ou iniciar a digita¸c˜ao em um dos campos que definem o valor do financiamento, os juros ou a quantidade de meses, o valor da presta¸c˜ao ´e apagado. Este evento ´e tratado usando-se o pr´oprio applet para implementar a interface FocusListener.

1 //<applet code="C22Exemplo6.class" width="250" height="80"> </applet> 2 import java.awt.*;

3 import javax.swing.*; 4 import java.awt.event.*;

5 public class C22Exemplo6 extends JApplet implements FocusListener { 6 JTextField c_valor = new JTextField("");

1

Tamb´em chamado de Sistema Francˆes de Amortiza¸c˜ao, foi concebido pelo matem´atico Richard Price e tem como caracter´ıstica uma amortiza¸c˜ao dos juros maior que a do principal durante boa parte do per´ıodo de financiamento.

22.4 Tratando eventos 9

7 JTextField c_juros = new JTextField("");

8 JTextField c_meses = new JTextField(""); 9 JLabel c_prest = new JLabel("");

10 JButton b_calcula = new JButton("Prestacao 1:"); 11 public void init() {

12 Container conteudo = getContentPane(); 13 conteudo.setLayout(new GridLayout(4,2)); 14 conteudo.add(new JLabel("Valor:")); 15 conteudo.add(c_valor);

16 conteudo.add(new JLabel("Juros (aa):")); 17 conteudo.add(c_juros);

18 conteudo.add(new JLabel("Meses:")); 19 conteudo.add(c_meses);

20 conteudo.add(b_calcula); 21 conteudo.add(c_prest);

22 MonitoraMouse monitoraClique = new MonitoraMouse();

23 b_calcula.addMouseListener(monitoraClique); 24 c_valor.addFocusListener(this);

25 c_juros.addFocusListener(this); 26 c_meses.addFocusListener(this);

27 }

28 public void focusGained(FocusEvent e) { 29 c_prest.setText("");

30 }

31 public void focusLost(FocusEvent e) {

32 }

33 class MonitoraMouse extends MouseAdapter { 34 public void mouseClicked(MouseEvent e) {

35 double v = Double.parseDouble(c_valor.getText()); 36 int n = Integer.parseInt(c_meses.getText());

37 double i = Float.parseFloat(c_juros.getText())/100; 38 i = Math.pow(1 + i,1./12) - 1;

39 double fator = Math.pow(1 + i,n);

40 double prest = (v * i * fator)/(fator - 1); 41 c_prest.setText(Double.toString(prest));

42 }

43 }

44 }

Nas linhas 6 a 10 os componentes da interface s˜ao especificados como atributos do applet. O m´etodo init define o gerente de leiaute na linha 13, adiciona ao applet os objetos que comp˜oem sua interface (linhas 14 a 21) e define os tratadores de eventos nas linhas 22 a 26.

O objeto capaz de tratar os cliques do mouse ´e criado na linha 22 e associado ao bot˜ao de c´alculo na linha 23. O objeto capaz de tratar os eventos da classe FocusEvent ´e o pr´oprio applet, que ´e adicionado atrav´es do referente this aos trˆes campos de texto nas

linhas 24 a 26.

Este applet deve implementar todos os m´etodos definidos na interface FocusListener, mesmo que o corpo de alguns seja vazio (como ´e o caso do m´etodo focusLost nas linhas 31 e 32). A express˜ao da linha 38 transforma os juros anuais em juros mensais. 

22.5

Convertendo aplica¸

c˜

oes em applets

Para converter uma aplica¸c˜ao Java em um applet devemos remover seu m´etodo main e inserir os m´etodos pr´oprios de um applet, al´em de mudar a forma como as janelas e o seu conte´udo s˜ao constru´ıdos. Como regra geral temos que:

• A janela principal da aplica¸c˜ao em vez de estender a classe JFrame passa a estender a classe JApplet.

• A constru¸c˜ao da janela principal e as a¸c˜oes do m´etodo main passam a ser executadas pelo m´etodo init.

• N˜ao ´e necess´ario criar uma instˆancia da janela principal j´a que a cria¸c˜ao do applet fica a cargo do navegador web.

Exemplo 22.7. O programa abaixo especifica um applet constru´ıdo a partir do programa do Exemplo 21.11.

1 //<applet code="C22Exemplo7.class" width="150" height="100"> </applet> 2 import java.awt.*;

3 import javax.swing.*; 4 class Velocimetro {

5 protected int valor = 100; 6 void incrVel() { 7 valor++; 8 } 9 void decrVel() { 10 valor--; 11 } 12 int obtemVel() { 13 return valor; 14 } 15 }

16 public class C22Exemplo7 extends JApplet { 17 Velocimetro v = new Velocimetro(); 18 JButton btIncr = new JButton("+"); 19 JButton btDecr = new JButton("-"); 20 JLabel rotValor = new JLabel("100"); 21 public void init() {

22.6 Limita¸c˜oes dos applets 11

23 Container conteudo = getContentPane();

24 conteudo.setLayout(new GridLayout(3,2)); 25 conteudo.add(new JLabel("controle")); 26 conteudo.add(new JLabel(" ")); 27 conteudo.add(btIncr); 28 conteudo.add(new JLabel("velocidade")); 29 conteudo.add(btDecr); 30 conteudo.add(rotValor); 31 rotValor.setHorizontalAlignment(SwingConstants.RIGHT); 32 } 33 }

No exemplo 21.11 o m´etodo main apenas criava um objeto Velocimetro e constru´ıa uma instˆancia da classe JanelaPrincipal. Aqui, transformamos a classe JanelaPrincipal na classe C22Exemplo7 que implementa o applet, estendendo JApplet (linhas 16 a 32). O m´etodo construtor da classe JanelaPrincipal foi transformado no m´etodo init do applet. Este applet apenas mostra os componentes da interface; o tratamento de eventos pode ser feito de modo semelhante ao mostrado no Exemplo 21.13. _

22.6

Limita¸

c˜

oes dos applets

A execu¸c˜ao de applets possui restri¸c˜oes desenvolvidas para permitir que um navegador web possa executar um applet carregado a partir de outras m´aquinas e ambientes sem comprometer a seguran¸ca do sistema no qual est´a sendo executado.

• Os applets n˜ao podem usar bibliotecas ou invocar m´etodos que estejam em classes residentes fora dos pacotes padr˜oes da linguagem. O acesso a bibliotecas e pacotes ´e determinado pela pol´ıtica de seguran¸ca de cada visualizador, que geralmente permite acesso apenas aos pacotes java.*.

• Os applets n˜ao podem ler ou gravar arquivos na m´aquina em que est˜ao sendo execu-tados. Novamente, esta restri¸c˜ao depende da pol´ıtica adotada pelo visualizador. O appletviewer do ambiente Java permite algumas exce¸c˜oes a essa regra.

• Os applets n˜ao podem fazer conex˜oes atrav´es da rede, exceto para a m´aquina na qual eles residem.

• Os applets n˜ao podem executar nenhum programa na m´aquina em que est˜ao sendo executados.

• Os applets n˜ao podem ler certas propriedades do sistema (especificadas atrav´es de objetos da classe Properties). N˜ao podem, por exemplo, identificar o diret´orio cor-rente nem os dados que comp˜oem o caminho padr˜ao (CLASSPATH). Podem, entretanto, obter o caractere usado para separar os itens na identifica¸c˜ao de arquivos.

Existem modos de contornar algumas limita¸c˜oes. Por exemplo, quanto `a grava¸c˜ao de arquivos, um applet pode enviar informa¸c˜oes para programas na m´aquina onde ele reside. Estes programas ent˜ao gravariam os arquivos necess´arios.

Os applets podem ler arquivos identificados atrav´es de URLs, em vez de nomes de arquivos. As janelas que cont´em applets s˜ao identificadas de modo diferenciado, geralmente cont´em na base o texto ”Java Applet Window”.

22.7

Especificando e usando parˆ

ametros

Os applets podem ser parametrizados, com a declara¸c˜ao dos parˆametros e a defini¸c˜ao do valor inicial feita atrav´es de tags da forma:

<param name="hNomeParami" value="hValorParami">

onde hNomeParami e hValorParami s˜ao o nome e o valor atribu´ıdo ao parˆametro. Essas tags s˜ao inseridas entre a tags que identificam o applet.

Exemplo 22.8. A declara¸c˜ao abaixo define trˆes parˆametros para o applet identificado por C22Exemplo6.class:

<applet code="C22Exemplo6.class" width="250" height="80"> <param name="p_fin" value="130000">

<param name="p_juros" value="9"> <param name="p_meses" value="180"> </applet>

Sempre que este applet for carregado os valores 130000, 9 e 180 ser˜ao atribu´ıdos aos parˆametros p fin, p juros e p meses, respectivamente. 

Um applet pode a qualquer tempo obter o valor atribu´ıdo a um parˆametro atrav´es do m´etodo:

public String getParameter(String nomeParam). Este m´etodo retorna o valor atri-bu´ıdo ao parˆametro de nome nomeParam. O valor ´e fornecido como uma cadeia de caracteres e deve ser convertido em um tipo apropriado, se necess´ario. O m´etodo retorna o valor null se n˜ao existir um parˆametro com o nome nomeParam.

Exemplo 22.9. O m´etodo abaixo inicializa as vari´aveis c valor, c juros e c meses com os valores atribu´ıdos aos parˆametros p fin, p juros e p meses ou com os valores 100000, 12 e 240, caso estes parˆametros n˜ao tenham sido declarados.

22.7 Especificando e usando parˆametros 13

public void inicializaCampos() { String val = getParameter("p_fin"); if (val == null)

c_valor = new JTextField("100000"); else

c_valor = new JTextField(val); val = getParameter("p_juros"); if (val == null)

c_juros = new JTextField("12"); else

c_juros = new JTextField(val); val = getParameter("p_meses"); if (val == null)

c_meses = new JTextField("240"); else

c_meses = new JTextField(val); }

Este m´etodo pode fazer parte do applet do Exemplo 22.6. Deste modo, cada p´agina que o referencie pode adotar os valores nele definidos ou especificar, atrav´es dos parˆametros p fin, p juros e p meses, seus pr´oprios valores iniciais. 

22.7.1 Especificando diret´orios

Os visualizadores procuram pelo c´odigo de um applet no mesmo diret´orio em que est´a a p´agina sendo visualizada (a p´agina que possui a tag do applet). Para carregar um applet armazenado em um outro diret´orio devemos especificar sua localiza¸c˜ao atrav´es do parˆametro codebase="hLocalApplet i".

A identifica¸c˜ao do applet ser´a aposta `a localiza¸c˜ao hLocalApplet i, podendo ser um endere¸co absoluto, um subdiret´orio do diret´orio onde est´a a p´agina ou um endere¸co da Internet (especificado atrav´es de uma URL). N˜ao pode entretanto conter caracteres de en-dere¸camento relativo (. ou ..)

Exemplo 22.10. Considere uma p´agina web armazenada no diret´orio \user\pessoa. Nesta situa¸c˜ao a tag

<applet code="aplt.class" width="100" height="20"> <\applet> faz com que o applet seja procurado no diret´orio \user\pessoa. A tag

<applet code="aplt.class" codebase="exem" width="100" height="20"> <\applet>

<applet code="aplt.class" codebase="\progs\teste"

width="100" height="20"> <\applet> faz com que o applet seja procurado no diret´orio \progs\teste. A tag

<applet code="aplt.class" codebase="http://wwww.cic.unb.br/progs" width="100" height="20"> <\applet>

faz com que o applet seja procurado no diret´orio \progs do servidor identificado pelo endere¸co www.cic.unb.br. J´a a tag

<applet code="aplt.class" codebase="../exem"

width="100" height="20"> <\applet> ´