Java - Noções básicas de miniaplicativos

Um applet é um programa Java que é executado em um navegador da Web. Um applet pode ser um aplicativo Java totalmente funcional porque tem toda a API Java à sua disposição.

Existem algumas diferenças importantes entre um applet e um aplicativo Java autônomo, incluindo o seguinte −

Um applet é uma classe Java que estende a classe java.applet.Applet.
Um método main() não é invocado em um applet e uma classe de applet não definirá main().
Os miniaplicativos são projetados para serem incorporados em uma página HTML.
Quando um usuário visualiza uma página HTML que contém um miniaplicativo, o código do miniaplicativo é baixado para a máquina do usuário.
Uma JVM é necessária para visualizar um applet. A JVM pode ser um plug-in do navegador da Web ou um ambiente de tempo de execução separado.
A JVM na máquina do usuário cria uma instância da classe do miniaplicativo e invoca vários métodos durante a vida útil do miniaplicativo.
Os miniaplicativos têm regras de segurança rígidas que são impostas pelo navegador da Web. A segurança de um applet é muitas vezes referida como segurança de sandbox, comparando o applet a uma criança brincando em um sandbox com várias regras que devem ser seguidas.
Outras classes que o applet precisa podem ser baixadas em um único arquivo Java Archive (JAR).

Ciclo de vida de um miniaplicativo

Quatro métodos na classe Applet fornecem a estrutura na qual você constrói qualquer applet sério -

iniciar − Este método destina-se a qualquer inicialização necessária para seu applet. Ele é chamado depois que as tags de parâmetro dentro da tag do applet foram processadas.
iniciar − Este método é chamado automaticamente após o navegador chamar o método init. Também é chamado sempre que o usuário retorna à página que contém o applet depois de ter ido para outras páginas.
parar − Este método é chamado automaticamente quando o usuário sai da página em que o applet está. Ele pode, portanto, ser chamado repetidamente no mesmo applet.
destruir − Este método só é chamado quando o navegador é desligado normalmente. Como os applets devem viver em uma página HTML, você normalmente não deve deixar recursos para trás depois que um usuário sair da página que contém o applet.
pintar − Chamado imediatamente após o método start(), e também sempre que o applet precisar se repintar no navegador. O método paint() é, na verdade, herdado do java.awt.

Um miniaplicativo "Olá, Mundo"

A seguir está um applet simples chamado HelloWorldApplet.java −

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

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

Essas instruções de importação trazem as classes para o escopo de nossa classe de applet −

java.applet.Applet
java.awt.Graphics

Sem essas instruções de importação, o compilador Java não reconheceria as classes Applet e Graphics, às quais a classe applet se refere.

A classe de miniaplicativos

Cada applet é uma extensão da classe java.applet.Applet . A classe base Applet fornece métodos que uma classe derivada Applet pode chamar para obter informações e serviços do contexto do navegador.

Estes incluem métodos que fazem o seguinte -

Obter parâmetros do miniaplicativo
Obtenha o local de rede do arquivo HTML que contém o miniaplicativo
Obter o local de rede do diretório de classe do miniaplicativo
Imprimir uma mensagem de status no navegador
Buscar uma imagem
Buscar um clipe de áudio
Reproduzir um clipe de áudio
Redimensione o miniaplicativo

Além disso, a classe Applet fornece uma interface pela qual o visualizador ou navegador obtém informações sobre o applet e controla a execução do applet. O espectador pode -

Solicite informações sobre o autor, versão e direitos autorais do applet
Solicite uma descrição dos parâmetros que o applet reconhece
Inicializar o miniaplicativo
Destrua o miniaplicativo
Iniciar a execução do miniaplicativo
Parar a execução do miniaplicativo

A classe Applet fornece implementações padrão de cada um desses métodos. Essas implementações podem ser substituídas conforme necessário.

O applet "Hello, World" está completo como está. O único método substituído é o método de pintura.

Invocando um miniaplicativo

Um miniaplicativo pode ser invocado incorporando diretivas em um arquivo HTML e visualizando o arquivo por meio de um visualizador de miniaplicativos ou navegador habilitado para Java.

A tag é a base para incorporar um applet em um arquivo HTML. A seguir está um exemplo que invoca o applet "Hello, World" −

<html>
   <title>The Hello, World Applet</title>
   <hr>
   <applet code = "HelloWorldApplet.class" width = "320" height = "120">
      If your browser was Java-enabled, a "Hello, World"
      message would appear here.
   </applet>
   <hr>
</html>

Observação − Você pode consultar HTML Applet Tag para entender mais sobre como chamar applet a partir de HTML.

O atributo code da tag é obrigatório. Ele especifica a classe Applet a ser executada. A largura e a altura também são necessárias para especificar o tamanho inicial do painel no qual um applet é executado. A diretiva do applet deve ser fechada com uma tag .

Se um applet receber parâmetros, valores podem ser passados para os parâmetros adicionando tags entre e . O navegador ignora texto e outras tags entre as tags do applet.

Navegadores não habilitados para Java não processam e . Portanto, tudo o que aparece entre as tags, não relacionado ao applet, fica visível em navegadores não habilitados para Java.

O visualizador ou navegador procura o código Java compilado no local do documento. Para especificar o contrário, use o atributo codebase da tag como mostrado −

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

Se um applet residir em um pacote diferente do padrão, o pacote de retenção deve ser especificado no atributo code usando o caractere ponto (.) para separar os componentes de pacote/classe. Por exemplo -

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

Obtenção dos parâmetros do miniaplicativo

O exemplo a seguir demonstra como fazer um applet responder aos parâmetros de configuração especificados no documento. Este applet exibe um padrão quadriculado de preto e uma segunda cor.

A segunda cor e o tamanho de cada quadrado podem ser especificados como parâmetros para o applet dentro do documento.

CheckerApplet obtém seus parâmetros no método init(). Ele também pode obter seus parâmetros no método paint(). No entanto, obter os valores e salvar as configurações uma vez no início do applet, em vez de a cada atualização, é conveniente e eficiente.

O visualizador ou navegador de miniaplicativos chama o método init() de cada miniaplicativo que executa. O visualizador chama init() uma vez, imediatamente após carregar o applet. (Applet.init() é implementado para não fazer nada.) Substitua a implementação padrão para inserir o código de inicialização personalizado.

O método Applet.getParameter() busca um parâmetro dado o nome do parâmetro (o valor de um parâmetro é sempre uma string). Se o valor for numérico ou outros dados sem caracteres, a string deverá ser analisada.

O seguinte é um esqueleto de CheckerApplet.java −

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

public class CheckerApplet extends Applet {
   int squareSize = 50;   // initialized to default size
   public void init() {}
   private void parseSquareSize (String param) {}
   private Color parseColor (String param) {}
   public void paint (Graphics g) {}
}

Aqui estão os métodos init() e parseSquareSize() do CheckerApplet -

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) {
      // Let default value remain
   }
}

O applet chama parseSquareSize() para analisar o parâmetro squareSize. parseSquareSize() chama o método de biblioteca Integer.parseInt(), que analisa uma string e retorna um inteiro. Integer.parseInt() lança uma exceção sempre que seu argumento é inválido.

Portanto, parseSquareSize() captura exceções, em vez de permitir que o applet falhe na entrada incorreta.

O applet chama parseColor() para analisar o parâmetro color em um valor Color. parseColor() faz uma série de comparações de strings para corresponder o valor do parâmetro ao nome de uma cor predefinida. Você precisa implementar esses métodos para fazer este applet funcionar.

Especificando os parâmetros do miniaplicativo

O seguinte é um exemplo de um arquivo HTML com um CheckerApplet embutido nele. O arquivo HTML especifica ambos os parâmetros para o applet por meio da tag .

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

Observação − Os nomes dos parâmetros não diferenciam maiúsculas de minúsculas.

Conversão de aplicativos para miniaplicativos

É fácil converter um aplicativo Java gráfico (ou seja, um aplicativo que usa o AWT e que você pode iniciar com o iniciador do programa Java) em um applet que pode ser incorporado a uma página da Web.

A seguir estão as etapas específicas para converter um aplicativo em um applet.

Faça uma página HTML com a tag apropriada para carregar o código do miniaplicativo.
Forneça uma subclasse da classe JApplet. Torne esta classe pública. Caso contrário, o applet não poderá ser carregado.
Elimine o método main no aplicativo. Não construa uma janela de quadro para o aplicativo. Seu aplicativo será exibido dentro do navegador.
Mova qualquer código de inicialização do construtor da janela do quadro para o método init do applet. Você não precisa construir explicitamente o objeto applet. O navegador o instancia para você e chama o método init.
Remova a chamada para setSize; para applets, o dimensionamento é feito com os parâmetros de largura e altura no arquivo HTML.
Remova a chamada para setDefaultCloseOperation. Um applet não pode ser fechado; ele termina quando o navegador é encerrado.
Se o aplicativo chamar setTitle, elimine a chamada para o método. Applets não podem ter barras de título. (Você pode, é claro, intitular a própria página da web, usando a tag de título HTML.)
Não chame setVisible(true). O applet é exibido automaticamente.

Gerenciamento de eventos

Os applets herdam um grupo de métodos de manipulação de eventos da classe Container. A classe Container define vários métodos, como processKeyEvent e processMouseEvent, para lidar com tipos específicos de eventos e, em seguida, um método abrangente chamado processEvent.

Para reagir a um evento, um applet deve substituir o método específico do evento 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("initializing the apple ");
   }

   public void start() {
      addItem("starting the applet ");
   }

   public void stop() {
      addItem("stopping the applet ");
   }

   public void destroy() {
      addItem("unloading the applet");
   }

   void addItem(String word) {
      System.out.println(word);
      strBuffer.append(word);
      repaint();
   }

   public void paint(Graphics g) {
      // Draw a Rectangle around the applet's display area.
      g.drawRect(0, 0, 
      getWidth() - 1,
      getHeight() - 1);

      // display the string inside the rectangle.
      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 clicked! ");
   }
}

Agora, vamos chamar este applet da seguinte forma -

<html>
   <title>Event Handling</title>
   <hr>
   <applet code = "ExampleEventHandling.class" 
      width = "300" height = "300">
   </applet>
   <hr>
</html>

Inicialmente, o miniaplicativo exibirá "inicializando o miniaplicativo. Iniciando o miniaplicativo". Então, uma vez que você clique dentro do retângulo, "mouse clicked" também será exibido.

Exibindo imagens

Um applet pode exibir imagens no formato GIF, JPEG, BMP e outros. Para exibir uma imagem dentro do applet, você usa o método drawImage() encontrado na classe java.awt.Graphics.

A seguir está um exemplo que ilustra todas as etapas para mostrar imagens -

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();
         // Display in browser status bar
         context.showStatus("Could not load image!");
      }
   }
   
   public void paint(Graphics g) {
      context.showStatus("Displaying image");
      g.drawImage(image, 0, 0, 200, 84, null);
      g.drawString("www.javalicense.com", 35, 100);
   }  
}

Agora, vamos chamar este applet da seguinte forma -

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

Reproduzindo áudio

Um applet pode reproduzir um arquivo de áudio representado pela interface AudioClip no pacote java.applet. A interface AudioClip tem três métodos, incluindo -

reprodução nula pública() − Reproduz o clipe de áudio uma vez, desde o início.
loop void público() − Faz com que o clipe de áudio seja reproduzido continuamente.
parada nula pública() − Interrompe a reprodução do clipe de áudio.

Para obter um objeto AudioClip, você deve invocar o método getAudioClip() da classe Applet. O método getAudioClip() retorna imediatamente, quer a URL resolva ou não para um arquivo de áudio real. O arquivo de áudio não é baixado até que seja feita uma tentativa de reproduzir o clipe de áudio.

A seguir está um exemplo que ilustra todas as etapas para reproduzir um á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("Could not load audio file!");
      }
   }
   
   public void start() {
      if(clip != null) {
         clip.loop();
      }
   }
   
   public void stop() {
      if(clip != null) {
         clip.stop();
      }
   }
}

Agora, vamos chamar este applet da seguinte forma -

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

Você pode usar test.wav em seu PC para testar o exemplo acima.

Java - Multithreading Java - Comentários da Documentação

Java