Curso de Java - Métodos

[anterior, índice, seguinte]

Applets

As aplets são pequenos programas Java que podem ser inseridos dentro de páginas HTML. Com este recurso, uma página torna-se dinâmica, podendo interagir com o usuário que a consulte. Um applet pode ainda executar tarefas complexas, como realizar cálculos e apresentar gráficos, sons e imagens em movimento. O quadro abaixo apresenta uma applet com o clássico Jogo da Velha. Experimente clicar com o mouse em alguma de suas casas:

Inserindo applets na página HTML

Para inserir uma applet numa página HTML, usamos a diretiva <applet>, a qual deve apresentar pelo menos três parametros: code, width e height. Assim, a especificação mais simples tem a forma: 

<applet
    code=[java applet]
    width=[largura]
    height=[altura]>

onde [java applet] é o nome da classe principal (que identifica o programa) Java, e [largura] e [altura] indicam a largura e a altura em pixels da área dentro da página reservada para a apresentação da applet. Por exemplo, a applet do Jogo da Velha foi inserida nesta página através das diretivas: 

<applet
    code=TicTacToe.class
    width=120
    height=120>
</applet>

Existem ainda, outros parâmetros adicionais que podem ser acrescentados opcionalmente:

Lembre-se que para atribuir a cada parâmetro um dado que não seja uma única palavra, é preciso encerrá-lo entre aspas.

Passagem de parâmetros para a applet

Freqüentemente desejamos utilizar uma mesma applet em páginas diferentes, esperando, porém, que ela se comporte diferentemente em cada uma delas. Isto é possível através da passagem de parâmetros. Um parâmetro é especificado pela diretiva <param>, a qual deve aparecer dentro do escopo delimitado pelas diretivas <applet> e </applet>. A sintaxe dessa diretiva é a seguinte: 

<param name=[nome] value=[valor]>

onde [nome] indica o nome do parâmetro, tal como é esperado pela applet, e [valor] representa a informação a ser passada. Como exemplo, vamos inserir abaixo uma applet chamado StringApplet que escreve um texto passado como parâmetro na área da applet: 

<applet code=StringApplet.class width=360 height=40 
 name="Applet de mansagem">
<param name=frase value="Alô, Pessoal!">
</applet>

isto nos dará a saída

Navegador que não suporta Applets

No momento, nem todos os programas navegadores existentes dão suporte a applets Java. Muitos usuários ainda encontram-se utilizando versões antigas do Netscape em ambiente Windows 3.1, além de outros navegadores como o Mosaic, por exemplo, os quais foram concebidos antes do advento da linguagem Java. Tais navegadores simplesmente ignoram as diretivas <applet>, <param> e </applet>.

Como não temos meios para saber quando um usuário possui ou não um navegador adequado, necessitamos de uma maneira de polidamente advertí-lo sobre o uso de applets. Para isso, basta introduzir código HTML ordinário no escopo da diretiva <applet>. Os navegadores sem suporte para Java vão exibir esse conteúdo como se as diretivas de applets não estivessem lá. Já os navegadores com suporte a Java ignoram qualquer coisa que esteja nesse escopo, exceto, é claro, quando forem diretivas <param>.

Por exemplo: 

<applet
    code=StringApplet.class
    width=360
    height=40
    align=middle>
<param name=frase value="Alô Pessoal!">
<p> Obs: esta página não poderá ser visualizada corretamente pelo
    seu navegador pois ele não é capaz de executar applets Java.
</applet>

Escrevendo a primeira applet

Como qualquer programa Java, uma applet deve conter ao menos uma classe pública, e essa classe pública deve estender a classe Applet. A classe Applet faz parte do package applet que integra o Java Developers Kit (JDK) e define o comportamento básico que uma applet deve ter. Esta permite a codificação de uma applet mínimal em pouquíssimas linhas, como segue: 

import java.applet.*;
public class AloPessoal extends Applet {
}

A primeira linha deste código informa ao compilador Java que esta applet utilizará algumas ou todas as classes presentes no package applet.

A segunda linha declara a nova classe AloPessoal como derivada da classe Applet. Essa classe deve ser pública para que possamos acessá-la ao rodar a applet. Se não fosse pública, ainda assim poderia ser compilada, porém a applet não poderia ser executada. Na declaração de AloPessoal fazemos uso do conceito de herança da OOP por meio de derivação de classes. Esta derivação funciona da mesma maneira que vimos anteriormente no capítulo sobre classes. Agora, porém, a diferença é que a classe Applet foi escrita pelo pessoal da Sun e não por nós mesmos.

Podemos compilar e em seguida rodar essa applet. Para isso, basta criarmos uma página HTML com o seguinte código: 

<html><head>
<title>Primeira Applet</title>
</head><body>
<applet code=AloPessoal.class width=320 height=80>

</applet>
</html>

Contudo, não seremos capazes de visualizar nada além de um retângulo cinza.

Durante a fase de testes não é conveniente utilizarmos um programa navegador para executar uma applet. Isto por causa do mecanismo de cache presente na maioria dos navegadores que lhes permite uma melhor performance durante a carga das páginas. Esse mecanismo freqüêntemente se atrapalha ao lidar com versões diferentes de uma mesma applet. Existe, porém, um programa no JDK chamado appletviewer. O appletviewer é uma maneira muito conveniente de se testar e validar uma única applet antes que ela seja introduzida em uma página HTML. Para executar uma applet com o appletviewer, basta chamar o programa passando-lhe o nome de uma página HTML contendo apenas as diretivas necessárias à applet.

Vamos acrescentar a essa applet código necessário para que ela escreva o texto "Alô Pessoal!" em sua janela: 

import java.applet.*;
import java.awt.*;
public class AloPessoal extends Applet {
   public void paint(Graphics g) {
      g.drawString("Alô Pessoal!", 100, 20);
   }
}

O código acrescentado neste exemplo ficará mais claro com a discussão que faremos no tópico seguinte.

Applet que recebem parâmetros

Agora vamos desenvolvelr um applet que reconhece os parâmetros passados no HTML. Para isso, vamos implementar o applet Vamos implementar o StringApplet discutido na seçào de passagem de parâmetros para applet.
Todo parâmetro passado de página Web para applet possui um nome e valor literal. Para obter o valor do parâmetro, usa-se o método getParam. O StringApplet recebe o parâmetro com nome frase e desenha na janela. 

import java.applet.*;
import java.awt.*;
public class StringApplet extends Applet {
   String msg;
   public void paint(Graphics g) {
      msg = getParam("frase");
      g.drawString(msg, 100, 20);
   }
}

Agora, se quiser aperfeiçoar mais um pouco e escrever a mensagem, iniciando na coordenada indicada? É simples. Basta definir dois variáveis para designar a coordenada x e y. Porém, os parâmetros passados da página para applet sempre é um string. Para converter string para inteiros, usa-se o método parseInt(). 

import java.applet.*;
import java.awt.*;
public class Stringapplet2 extends Applet {
   String msg, int x,y;
   public void paint(Graphics g) {
      msg = getParam("frase");
      x = Integer.parseInt(getParam("xcoord");
      Y = Integer.parseInt(getParam("ycoord");
      g.drawString(msg, x, y);
   }
}

As coordenadas x e y do ponto inicial da frase foi considerado de "xcoord" e "ycoord" respectivamente. Para escrever "Alo, pessoal!" começando de (10,20), basta inserir o código

<applet code=StringApplet.class width=360 height=40
 name="Applet de mansagem">
<param name=frase value="Alô, Pessoal!">
<param name="xcoord" value = 10>
<param name=ycoord value=20>
</applet>

na página HTML.

Desenhando na Janela

Embora a maioria das applets que escrevemos sejam razoavelmente simples, há certas coisas de que precisamos saber para podermos escrever nossas próprias applets. O espaço de uma página HTML reservado à uma applet, isto é, sua janela, é uma área gráfica. Isto significa que precisamos saber como desenhar nessa janela. Para isso, devemos usar a classe Java chamada Graphics. Apenas isso, porém, não é o suficiente. Precisamos aprender como utilizar os diversos tipos de controles existentes, como botões, caixas de texto, listas de rolagem, etc, e como dispor esses controles na janela segundo uma ordem lógica.

Uma outra coisa muito importante a saber é como tratar eventos. A movimentação e o clicar do mouse, o pressionar de uma tecla, etc, são eventos que ocorrem durante a execução de um programa. Tais eventos produzem mensagens que são enviadas à applet. Como resultado da recepção dessas mensagens, ocorre dentro da applet a chamada de métodos. A applet deve prover métodos para tratar de todos os eventos que sejam necessários à realização de sua tarefa.

Responder aos movimentos do mouse não é coisa que se tenha que fazer com freqüência. Entretanto é interessante saber como fazê-lo. Tal tratamento seria indispensável se estivéssemos escrevendo um jogo, por exemplo, ou um programa gráfico que permitisse desenhar na janela através do mouse. Nosso próximo exemplo será justamente um programa que permite fazer isso. Ao executar essa a Applet Davinci no appletviewer vemos uma janela em branco. Clicando com o mouse e em seguida arrastando para alguma direção, veremos um traço preto acompanhando o apontador onde quer que o arrastemos. Apesar de ser um programa muito simples, nos dá uma idéia clara sobre como utilizar o mouse e o dispositivo gráfico para realizar tarefas similares. 

import java.awt.*;
import java.applet.*;

public class Davinci extends Applet
{
    Point pontoInicial;         
    Point pontos[];
    int numpontos;
    boolean desenhando;

    public void init()
    {
        pontoInicial = new Point(0, 0);
        pontos = new Point[1000];
        numpontos = 0;

        desenhando = false;
    }

    public void paint(Graphics g)
    {
        int antX = pontoInicial.x;
        int antY = pontoInicial.y;

        for (int i=0; i<numpontos; i++)
        {
            g.drawLine(antX, antY, pontos[i].x, pontos[i].y);
            antX = pontos[i].x;
            antY = pontos[i].y;
        }
    }

    public boolean mouseDown(Event evt, int x, int y)
    {
        if (!desenhando)
        {
            desenhando = true;
            pontoInicial.x = x;
            pontoInicial.y = y;
        }
        else
            desenhando = false;

        return true;
    }

    public boolean mouseMove(Event evt, int x, int y)
    {
        if ((desenhando) && (numpontos < 1000))
        {
            pontos[numpontos] = new Point(x, y);
            ++numpontos;
            repaint();
        }

        return true;
    }
}

Veja como essa applet responde aos cliques do mouse:

Compreendendo a applet Davinci

Vamos agora estudar detalhadamente a applet Davinci. As duas primeiras linhas informam ao compilador que estaremos usando classes dos packages awt e applet: 

import java.awt.*;
import java.applet.*;

O package awt (Abstract Window Toolkit) contém dezenas de classes para desenhar em janelas. Estas classes dão-nos acesso a métodos para desenhar na tela, responder a eventos, manipular controles como botões e menus, etc. O package applet contém classes necessárias para se construir um applet báciso.

A próxima linha do programa declara a classe Davinci como subclasse da classe Applet. 

public class Davinci extends Applet

Em seguida temos a declaração dos dados de que a applet necessitará. 

    Point pontoInicial;         
    Point pontos[];
    int numpontos;
    boolean desenhando;

A classe Point está definida no package awt e representa uma estrutura de dados contendo um par de números x e y, isto é, as coordenadas de um ponto. O inteiro numpontos dá o número de pontos armazenados no vetor pontos e o booleano desenhando indica que estamos no modo de desenho.

O método init()

O método init está definido na classe Applet. Estamos, portanto, fazendo uma sobreposição desse método para prover informações iniciais adicionais para a applet. Como veremos adiante, o método init é um dos métodos que compões o ciclo normal de vida de uma applet. Esse método é chamado pelo programa navegador imediatamente após a applet ter sido carregada. No caso de nossa applet, a primeira coisa a fazer é criar um novo objeto Point para conter as coordenadas do ponto inicial do desenho: 

pontoInicial = new Point(0, 0);

Aqui o operador new cria um novo objeto da classe Point e chama seu construtor com os valores (0, 0), os quais serão atribuídos aos campos x e y respectivamente. Depois, precisamos criar um vetor de objetos da classe Point para conter as coordenadas dos pontos que serão traçados: 

pontos = new Point[1000];

Nas próximas duas linhas, inicializamos as duas variáveis restantes: 

numpontos = 0;
desenhando = false;

A primeira delas indica a quantidade total de pontos presentes no vetor pontos, que no início é zero. A segunda indica que não estamos no modo de desenho, isto é, passear com o mouse por cima da janela da applet não provocará o traçado do desenho.

O método mouseDown()

Como qualquer outro programa que trabalhe com janelas, as applets devem responder a eventos do mouse, como os de movimento e de clicagem, por exemplo. O método mouseDown é chamado sempre que o usuário fizer um clique com o mouse sobre a área da janela. Os argumentos desse método são um objeto da classe Event, a qual veremos mais adiante, e as coordenadas x e y do ponto da janela em que ocorreu o clique. Em nossa applet, na ocorrência desse evento, devemos verificar em que modo estamos trabalhando, se de desenho ou não, pois isso afetará a maneira de tratar os eventos subseqüêntes: 

if (!desenhando)

Se não estivermos desenhando, então o clicar do mouse indica que o usuário deseja iniciar um novo traçado. Devemos então alternar para o modo de desenho, guardando as coordenadas x e y do ponto de clicagem como as coordenadas iniciais do novo traçado: 

desenhando = true;
pontoInicial.x = x;
pontoInicial.y = y;

Se já estivermos no modo de desenho, tudo o que precisamos fazer é alternar para o modo normal: 

else
   desenhando = false;

método mouseMove()

Este método é chamado sempre que ocorrer mudança de posição do mouse dentro da área do applet. o seu argumento é objeto Event e coordenadas x, y do mouse . Este método foi redefinido para acrescentar um ponto com coordenada do mouse a mais no vetor de pontos. Note que testa se o vetor já está cheio.
Após acrescentar pontos no vetor, chama o método repaint().

Os quatro estágios de execução de uma applet

Além do estágio inicial, caracterizado pela chamada o método init, uma applet tem mais três outros: partida, parada e destruição.

O estágio de partida ocorre quando se inicia a execução da applet, imediatamente após o estágio inicial, ou quando a applet for reiniciada. Isso geralmente acontece quando o usuário pressiona o botão "voltar" do navegador após ter visualizado uma outra página. Diferente do estágio inicial, o estágio de partida pode ocorrer múltiplas vezes durante uma sessão. Para interceptar esse estado, sobrepomos o método start.

O estágio de parada ocorre quando uma applet se torna invisível na tela. Isso ocorre quando o usuário abandona a página em que se encontra a applet para consultar uma outra. Isso não significa que a applet deve parar de executar; ela poderá continuar realizando alguma tarefa não aparente. Se este for o caso, podemos então sobrepor o método stop.

Finalmente o estágio de destruição é aquele em que a applet está sendo removida da memória e todos os recursos por ela alocados são devolvidos ao sistema operacional. Assim como estágio de inicial, o estágio de destruição ocorre apenas uma vez, mediante a chamada do método destroy.

Programação Orientada a Eventos

O desenvolvimento de applets baseia-se no modelo de execução de programa conhecido como execução orientada a eventos. Este paradigma de programação difere significativamente do tradicional na forma como se dá o controle de fluxo da execução.

Na programação tradicional, quando o programa precisa ler um dado do teclado, por exemplo, há a chamada para uma função do sistema que realiza a leitura do teclado. Essa função fica continuamente monitorando o teclado para poder capturar o valor da tecla pressionada. Assim, a execução do programa fica suspensa até o momento em que o usuário resolve prosseguir, pressionando uma tecla.

Por outro lado, na programação orientada a eventos, quando o programa necessita de um dado ele simplesmente avisa ao usuário sobre essa necessidade, geralmente imprimindo alguma mensagem na tela, e em seguida continua o processamento realizando alguma outra tarefa, se for o caso. Quando o usuário pressiona uma tecla, o sistema operacional se encarrega de avisar ao programa sobre a ocorrência desse "evento" e dar a ele a chance de realizar o que for preciso com a informação fornecida pelo usuário. Há, contudo, outros tipos de eventos. Um evento pode ser o clicar ou mover do mouse, entrada de texto, necessidade de atualizar uma janela, disparo de um temporizador, etc. Processar eventos provenientes do mouse, por exemplo, é uma grande dificuldade para a programação tradicional, pois geralmente o programa não tem como prever sobre qual "botão virtual" o usuário vai clicar. No caso da applet de desenho, simplesmente indicamos o que fazer para cada alteração do mouse.

Os eventos principais das applets são:

A seguir, vamos tratar de eventos provenientes do teclado e do mouse.

Teclado

Existem apenas dois eventos que podem provir do teclado: keyDown e keyUp. 

public boolean keyDown(Event evento, int keyCode)

Este método é chamado quando alguma tecla for pressionada. keyCode é um número que dá um código correspondente à tecla precionada. Como existem teclados sem padronização, existem determinados códigos especiais para algumas designar certas teclas:

A informação de que a tecla shift, control e alt (ou meta) foi pressionada é obtida do parâmetro event recebido, usando método correspondente. Todos eles retornam um dado booleano indicando a situação da respectiva tecla. Suponha que o nome do parâmetro de evento (do tipo Event) é evento. Então temos 

public boolean keyUp(Event event, int keyCode)

Este método é chamado quando a tecla pressionada é liberada pelo usuário. Os parâmetros recebidos são os mesmo do método keyDown.

Não se esqueça de que ocorrem dois eventos ao pressionar uma tecla: keyDown e keyUp. Não é, porém, obrigatório tratar ambos os eventos. Esses métodos já estão codificados na classe Applet provendo um tratamento padrão para os respectivos eventos.

Mouse

Os métodos associados eventos provenientes do mouse recebem dois parâmetros: evento do tipo Event e coordenadas x e y da posição do ponteiro mouse (do tipo inteiro) relativos às coordenadas d janela atual. Estes já foram bem explicados acima.

Bem, além do método mouseDown e mouseMove, existe ainda alguns métodos, recebendo mesmo parâmetro que estes:

public boolean mouseUp(Event event, int x, int y)

Este método é chamado quando botão do mouse que estava precionado for solto.

public boolean mouseDrag(Event event, int x, int y)

Este método é chamado, quando o usuário arrastar o mouse (precionar o botão, mudar de posição sem soltar o botão e em seguida, soltar o botão).

public boolean mouseEnter(Event event, int x, int y)
public boolean mouseExit(Event event, int x, int y)

São chamadas respectivamente quando mouse entra e sai do objeto em que o método pertence. Podemos usar este método por exemplo, para acender o botão em que o mouse está, antes msmo do clique de mouse.

No evento do mouse, não há como detectar o botão (se é direito ou esquerdo) do mouse precionado. Isto deve ao fato do mouse dos computadores da Apple possuir apenas um botão, e Java, por poder ser executado em qualquer plataforma, assume que o mouse possui apenas um botão.

[anterior, índice, seguinte]

Copyright © 1997-2008, Waldeck Schützer e Sadao Massago - Departamento de Matemática - UFSCar