Fundamentos do Applet Java

Applet é um programa Java. Geralmente, ele é executado dentro de um navegador da Web que suporta Java. Devido ao suporte completo da API Java, o Applet é um aplicativo Java completo.

A seguir, são apresentadas as diferenças importantes entre um aplicativo Java independente e um applet:

• A classe Applet em Java herda a classe java.applet.Applet.

• A classe Applet não define main(), então um programa Applet não chama o método main().

• O Applet foi projetado para ser embutido em uma página HTML.

• Quando o usuário navega por uma página HTML que contém Applet, o código do Applet é baixado para o computador do usuário.

• Para visualizar um Applet, é necessário um JVM. O JVM pode ser um plug-in do navegador da Web ou um ambiente de tempo de execução independente.

• O JVM do usuário cria um exemplo da classe Applet e chama vários métodos do ciclo de vida do Applet.

• O Applet tem regras de segurança rigorosas impostas pelo navegador da Web, e o mecanismo de segurança do Applet é conhecido como segurança sandbox.

• As outras classes necessárias para o Applet podem ser baixadas em forma de arquivo Java Archive (JAR).

Ciclo de vida do Applet

Os quatro métodos na classe Applet nos fornecem um esqueleto para desenvolver mini-aplicativos:

• init: O objetivo deste método é fornecer qualquer inicialização necessária para o seu Applet. Este método é chamado após o processamento das tags param dentro da marcação do Applet.

• start: Este método é chamado automaticamente após o método init() ser chamado pelo navegador. Este método é chamado sempre que o usuário retornar à página que contém o Applet.

• stop: Quando o usuário remove o Applet da página, este método é chamado automaticamente. Portanto, você pode chamar este método repetidamente no mesmo Applet.

• destroy: Este método é chamado apenas quando o navegador é fechado corretamente. Como o Applet é válido apenas em páginas HTML, você não deve esquecer de liberar qualquer recurso após o usuário sair da página que contém o Applet.

• paint: Este método é chamado imediatamente após o método start() ou quando o Applet precisar ser redesenhado no navegador. O método paint() é realmente herdado de java.awt.

"Hello, World" Applet:

A seguir está um simples programa Applet HelloWorldApplet.java:

import java.applet.*;
import java.awt.*;
　
public class HelloWorldApplet extends Applet
{
　　　public void paint(Graphics g)
　　　{
　　　　　　g.drawString("Hello World",　25,　50);
　　　}
}

Estas instruções importarão os seguintes classes para a nossa classe Applet:

java.applet.Applet.
java.awt.Graphics.

Sem essas declarações import, o compilador Java não reconhecerá a classe Applet e Graphics.

Classe Applet

Cada Applet é uma subclasse da classe java.applet.Applet, e a classe Applet básica fornece métodos para as subclasses derivadas, para obter informações de contexto do navegador e serviços.

Esses métodos fazem o seguinte:

• Obter os parâmetros do Applet

• Obter a localização na rede do arquivo HTML que contém o Applet

• Obter a localização na rede do diretório da classe Applet

• Imprimir as informações de estado do navegador

• Obter uma imagem

• Obter um fragmento de áudio

• Reproduzir um fragmento de áudio

• Ajustar o tamanho deste Applet

Além disso, a classe Applet ainda oferece uma interface, que fornece ao visualizador ou navegador para obter informações do Applet e controlar a execução do Applet.

O visualizador pode ser:

• Solicitação de informações do autor, versão e direitos autorais do Applet

• Descrição da solicitação de parâmetros identificados pelo Applet

• Inicializar o Applet

• Destruir o Applet

• Iniciar a execução do Applet

• Finalizar a execução do Applet

A classe Applet fornece implementações padrão para esses métodos, que podem ser rewritten conforme necessário.

Os applets "Hello, World" são escritos de acordo com os padrões. A única método rewritten é o método paint.

Chamada do Applet

Applet é um programa Java. Geralmente, ele é executado dentro de navegadores que suportam Java. Devido ao suporte completo da API Java, o Applet é um aplicativo Java completo.

O tag <applet> é a base para embeder Applet em um arquivo HTML. Abaixo está um exemplo de como chamar o applet "Hello World";

<html>
<title>The Hello, World Applet</title>
<hr>
<applet code="HelloWorldApplet.class" width="320" height="120">
se seu navegador fosse Java-habilitado, um "Hello, World"
a mensagem apareceria aqui.
</applet>
<hr>
</html>

Atenção: Você pode referir-se ao tag Applet do HTML para obter mais informações sobre como chamar applet do HTML.

<applet> especifica os atributos da tag para executar a classe Applet. width e height são usados para especificar o tamanho inicial da área de exibição do Applet. O Applet deve usar </applet> para fechar.

Se o Applet aceitar parâmetros, os valores dos parâmetros precisam ser adicionados na tag <param>, que está entre <applet> e </applet> entre. O navegador ignora o texto entre as tags <applet> e outras tags.

Navegadores que não suportam Java não podem executar <applet> e </applet> portanto, qualquer coisa que esteja entre as tags e não esteja relacionada ao applet é visível em navegadores que não suportam Java.

O visualizador ou navegador busca o código Java compilado no local do documento. Para especificar o caminho do documento, use o atributo codebase da tag <applet>.

Como mostrado a seguir:

<applet codebase="http://amrood.com/applets
code="HelloWorldApplet.class" width="320" height="120">

Se o Applet estiver em um pacote diferente do pacote padrão, o pacote em que ele está deve ser especificado no atributo code, por exemplo:

<applet code="mypackage.subpackage.TestApplet.class"
　　　　　　　　　　　width="320" height="120">

Obter parâmetros do applet

O exemplo a seguir demonstra como usar uma resposta do Applet para definir os parâmetros especificados no arquivo. O Applet exibe um padrão de xadrez preto e a segunda cor.

A segunda cor e o tamanho de cada coluna são especificados pelos parâmetros do Applet no documento.

CheckerApplet obtém seus parâmetros dentro do método init(). Também pode obter seus parâmetros dentro do método paint(). No entanto, é mais conveniente e eficiente que o Applet obtenha e salve os valores de configuração antes de começar a obter valores, em vez de obter valores a cada atualização.

O visualizador do Applet ou o navegador chama o método init() a cada vez que o Applet é executado. Após carregar o Applet, o Visualizador chama imediatamente o método init() (Applet.init() não faz nada), sobrescrevendo a implementação padrão do método, adicionando alguns códigos de inicialização personalizados.

O método getParameter() do Applet obtém o valor do parâmetro fornecido. Se o valor obtido for um número ou outro tipo de dados não caractere, deve ser analisado como tipo de string.

O exemplo a seguir é a modificação do CheckerApplet.java:

import java.applet.*;
import java.awt.*;
public class CheckerApplet extends Applet
{
　　　int squareSize =　50;//　Inicializar tamanho padrão
　　　public void init() {}
　　　private void parseSquareSize(String param) {}
　　　private Color parseColor(String param) {}
　　　public void paint(Graphics g) {}
}

A seguir estão o método init() da classe CheckerApplet e o método privado parseSquareSize():

public void init()
{
　　　String squareSizeParam = getParameter("squareSize");
　　　parseSquareSize(squareSizeParam);
　　　String colorParam = getParameter("color");
　　　Color fg = parseColor(colorParam);
　　　setBackground(Color.black);
　　　setForeground(fg);
}
private void parseSquareSize(String param)
{
　　　if (param == null) return;
　　　try {
　　　　　　squareSize = Integer.parseInt(param);
　　　}
　　　catch (Exception e) {
　　　　　//　Manter valor padrão
　　　}
}

O Applet chama parseSquareSize() para analisar o parâmetro squareSize. O parseSquareSize() chama o método da biblioteca Integer.parseInt(), que converte uma string em um inteiro. Quando o parâmetro é inválido, Integer.parseInt() lança uma exceção.

Portanto, o método parseSquareSize() também captura exceções e não permite que o Applet aceite entradas inválidas.

O Applet chama o método parseColor() para解析颜色参数为一个 Color 值。O método parseColor() realiza uma série de comparações de strings para coincidir o valor do parâmetro com os nomes de cores pré-definidos. Você precisa implementar esses métodos para que o Applet funcione.

Especificar parâmetros do applet

O seguinte exemplo é um arquivo HTML que contém a classe CheckerApplet. O arquivo HTML especifica dois parâmetros para o applet usando a tag <param>.

<html>
<title>Checkerboard Applet</title>
<hr>
<applet code="CheckerApplet.class" width="480" height="320">
<param name="color" value="blue">
<param name="squaresize" value="30">
</applet>
<hr>
</html>

Atenção: Os nomes dos parâmetros são insensíveis a maiúsculas e minúsculas.

Conversão de aplicativo para Applet

Converter um aplicativo Java gráfico (isto é, aplicativos que usam AWT e são iniciados pelo Java Program Launcher) em um applet embutido em uma página web é muito simples.

A seguir estão alguns passos para converter um aplicativo em Applet:

• Escreva uma página HTML que contenha tags capazes de carregar o código do applet.

• Escreva uma subclasse da classe JApplet e defina-a como public. Caso contrário, o Applet não pode ser carregado.

• Elimine o método main() do aplicativo. Não construa uma janela de framework para o aplicativo, pois ele será exibido no navegador.

• Mova o código de inicialização do construtor da janela de framework do aplicativo para o método init() do Applet. Você não precisa explicitamente construir o objeto Applet; o navegador fará isso chamando o método init().

• Remova a chamada para o método setSize(). Para o Applet, o tamanho já está definido pelos parâmetros width e height do arquivo HTML.

• Remova a chamada para o método setDefaultCloseOperation(). O Applet não pode ser fechado; ele termina com a saída do navegador.

• Se o aplicativo chamou o método setTitle(), elimine a chamada para esse método. O applet não pode ter uma barra de título. (Claro, você pode nomear a página web própria usando a tag title do HTML)

• Não chame setVisible(true), o Applet é exibido automaticamente.

Tratamento de eventos

A classe Applet herda muitos métodos de tratamento de eventos da classe Container. A classe Container define vários métodos, como processKeyEvent() e processMouseEvent(), usados para lidar com tipos específicos de eventos, e ainda há um método que captura todos os eventos chamado processEvent.

Para responder a um evento, o Applet deve sobrescrever o método de tratamento de eventos apropriado.

import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
import java.applet.Applet;
import java.awt.Graphics;
　
public class ExampleEventHandling extends Applet
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　implements MouseListener {
　
　　　　StringBuffer strBuffer;
　
　　　　public void init() {
　　　　　　　　　addMouseListener(this);
　　　　　　　　　strBuffer = new StringBuffer();
　　　　　　　　addItem("inicializando o applet ");
　　　　}
　
　　　　public void start() {
　　　　　　　　addItem("iniciando o applet ");
　　　　}
　
　　　　public void stop() {
　　　　　　　　addItem("parando o applet ");
　　　　}
　
　　　　public void destroy() {
　　　　　　　　addItem("desmontando o applet");
　　　　}
　
　　　　void addItem(String word) {
　　　　　　　　System.out.println(word);
　　　　　　　　strBuffer.append(word);
　　　　　　　　repaint();
　　　　}
　
　　　　public void paint(Graphics g) {
　　　　　　　　　//Desenhar um retângulo ao redor da área de exibição do applet.
　　　　　　　　g.drawRect(0, 0,
　　　　　　　　　　　　　　　　　　　　　　getWidth()　-　1,
　　　　　　　　　　　　　　　　　　　　　　getHeight()}　-　1)
　
　　　　　　　　　//exibir a string dentro do retângulo.
　　　　　　　　g.drawString(strBuffer.toString(),　10,　20);
　　　　}
　
　　
　　　　public void mouseEntered(MouseEvent event) {
　　　　}
　　　　public void mouseExited(MouseEvent event) {
　　　　}
　　　　public void mousePressed(MouseEvent event) {
　　　　}
　　　　public void mouseReleased(MouseEvent event) {
　　　　}
　
　　　　public void mouseClicked(MouseEvent event) {
　　　　　　　　　addItem("mouse clicado! ");
　　　　}
}

Aqui está a chamada para o Applet:

<html>
<title>Manuseio de Eventos</title>
<hr>
<applet code="ExampleEventHandling.class"
width="300" height="300">
</applet>
<hr>
</html>

No início, o Applet exibe "inicializando o applet. Iniciando o applet." e, em seguida, ao clicar no retângulo, é exibido "mouse clicado".

Exibir imagem

O Applet pode exibir GIF, JPEG, BMP e outros formatos de imagens. Para exibir uma imagem no Applet, você precisa usar o método drawImage() da classe java.awt.Graphics.

O seguinte exemplo demonstra todos os passos para exibir uma imagem:

import java.applet.*;
import java.awt.*;
import java.net.*;
public class ImageDemo extends Applet
{
　　private Image image;
　　private AppletContext context;
　　public void init()
　　{
　　　　　　context = this.getAppletContext();
　　　　　　String imageURL = this.getParameter("image");
　　　　　　if(imageURL == null)
　　　　　　{
　　　　　　　　　imageURL = "java.jpg";
　　　　　　}
　　　　　　try
　　　　　　{
　　　　　　　　　URL url = new URL(this.getDocumentBase(), imageURL);
　　　　　　　　　image = context.getImage(url);
　　　　　　}catch(MalformedURLException e)
　　　　　　{
　　　　　　　　　e.printStackTrace();
　　　　　　　　　//　Exibir no status bar do navegador
　　　　　　　　　context.showStatus("Não foi possível carregar a imagem!");
　　　　　　}
　　　}
　　　public void paint(Graphics g)
　　　{
　　　　　　context.showStatus("Exibindo imagem");
　　　　　　　200,　84, null);
　　　　　　g.drawString("www.javalicense.com",　35,　100);
　　　}　
}

Aqui está a chamada para o applet:

<html>
<title>The ImageDemo applet</title>
<hr>
<applet code="ImageDemo.class" width="300" height="200">
<param name="image" value="java.jpg">
</applet>
<hr>
</html>

Reproduzir áudio

O Applet pode reproduzir áudio usando o interface AudioClip do pacote java.applet. O interface AudioClip define três métodos:

• public void play(): Reproduzir o fragmento de áudio a partir do início uma vez.

• public void loop(): Reproduzir o fragmento de áudio em loop

• public void stop(): Parar a reprodução do fragmento de áudio

Para obter o objeto AudioClip, você deve chamar o método getAudioClip() da classe Applet. independentemente de a URL apontar para um arquivo de áudio real ou não, o método retorna imediatamente o resultado.

Até que o arquivo de áudio a ser reproduzido seja baixado.

O seguinte exemplo demonstra todos os passos necessários para reproduzir áudio:

import java.applet.*;
import java.awt.*;
import java.net.*;
public class AudioDemo extends Applet
{
　　　private AudioClip clip;
　　　private AppletContext context;
　　　public void init()
　　　{
　　　　　　context = this.getAppletContext();
　　　　　　String audioURL = this.getParameter("audio");
　　　　　　if(audioURL == null)
　　　　　　{
　　　　　　　　　audioURL = "default.au";
　　　　　　}
　　　　　　try
　　　　　　{
　　　　　　　　　URL url = new URL(this.getDocumentBase(), audioURL);
　　　　　　　　　clip = context.getAudioClip(url);
　　　　　　}catch(MalformedURLException e)
　　　　　　{
　　　　　　　　　e.printStackTrace();
　　　　　　　　　context.showStatus("Não foi possível carregar o arquivo de áudio!");
　　　　　　}
　　　}
　　　public void start()
　　　{
　　　　　　if(clip != null)
　　　　　　{
　　　　　　　　　clip.loop();
　　　　　　}
　　　}
　　　public void stop()
　　　{
　　　　　　if(clip != null)
　　　　　　{
　　　　　　　　　clip.stop();
　　　　　　}
　　　}
}

Aqui está a chamada do applet:

<html>
<title>The ImageDemo applet</title>
<hr>
<applet code="ImageDemo.class" width="0" height="0">
<param name="audio" value="test.wav">
</applet>
<hr>

Você pode usar o arquivo test.wav no seu computador para testar o exemplo acima.