Java - Noções básicas de miniaplicativo

A appleté um programa Java executado em um navegador da web. Um miniaplicativo pode ser um aplicativo Java totalmente funcional porque possui toda a API Java à sua disposição.

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

• Um miniaplicativo é uma classe Java que estende a classe java.applet.Applet.

• Um método main () não é chamado em um miniaplicativo e uma classe de miniaplicativo não definirá main ().

• Os miniaplicativos são projetados para serem incorporados a 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.

• É necessário um JVM para visualizar um miniaplicativo. 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 chama vários métodos durante a vida útil do miniaplicativo.

• Os miniaplicativos têm regras de segurança rígidas que são aplicadas pelo navegador da web. A segurança de um miniaplicativo é freqüentemente referida como segurança de sandbox, comparando o miniaplicativo a uma criança brincando em uma sandbox com várias regras que devem ser seguidas.

• Outras classes de que o miniaplicativo precisa podem ser baixadas em um único arquivo Java Archive (JAR).

Ciclo de Vida de um Applet

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

• init- Este método se destina a qualquer inicialização necessária para o seu miniaplicativo. Ele é chamado depois que as tags param dentro da tag do miniaplicativo foram processadas.

• start- Este método é chamado automaticamente depois que o navegador chama o método init. Também é chamado sempre que o usuário retorna à página que contém o miniaplicativo após ter ido para outras páginas.

• stop- Este método é chamado automaticamente quando o usuário sai da página em que o miniaplicativo está. Ele pode, portanto, ser chamado repetidamente no mesmo miniaplicativo.

• destroy- Este método só é chamado quando o navegador é encerrado normalmente. Como os miniaplicativos devem residir em uma página HTML, normalmente você não deve deixar recursos para trás depois que um usuário deixa a página que contém o miniaplicativo.

• paint- Chamado imediatamente após o método start (), e também sempre que o miniaplicativo precisar se redesenhar no navegador. O método paint () é, na verdade, herdado de java.awt.

Um miniaplicativo "Hello, World"

A seguir está um miniaplicativo 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 Applet

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

Isso inclui métodos que fazem o seguinte -

• Obter parâmetros de miniaplicativo
• Obtenha a localização de rede do arquivo HTML que contém o miniaplicativo
• Obtenha a localização de rede do diretório de classe do miniaplicativo
• Imprima uma mensagem de status no navegador
• Buscar uma imagem
• Buscar um clipe de áudio
• Tocar 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 miniaplicativo e controla sua execução. O visualizador pode -

• Solicite informações sobre o autor, versão e direitos autorais do miniaplicativo
• Solicite uma descrição dos parâmetros que o miniaplicativo reconhece
• Inicialize o miniaplicativo
• Destrua o miniaplicativo
• Inicie a execução do miniaplicativo
• Pare 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 miniaplicativo "Hello, World" está completo como está. O único método substituído é o método de pintura.

Invocando um miniaplicativo

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

A tag <applet> é a base para embutir um miniaplicativo em um arquivo HTML. A seguir está um exemplo que invoca o miniaplicativo "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>

Note- Você pode consultar Tag do miniaplicativo HTML para entender mais sobre como chamar miniaplicativos a partir de HTML.

O atributo code da tag <applet> é 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 miniaplicativo é executado. A diretiva do miniaplicativo deve ser fechada com uma tag </applet>.

Se um miniaplicativo aceita parâmetros, os valores podem ser passados ​​para os parâmetros adicionando tags <param> entre <applet> e </applet>. O navegador ignora o texto e outras marcas entre as marcas do miniaplicativo.

Navegadores não habilitados para Java não processam <applet> e </applet>. Portanto, qualquer coisa que apareça entre as tags, não relacionada ao miniaplicativo, é 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 <applet> como mostrado -

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

Se um miniaplicativo 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 do pacote / classe. Por exemplo -

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

Obtendo os Parâmetros do Applet

O exemplo a seguir demonstra como fazer um miniaplicativo responder aos parâmetros de configuração especificados no documento. Este miniaplicativo 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 miniaplicativo 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 miniaplicativo, em vez de a cada atualização, é conveniente e eficiente.

O visualizador ou navegador do miniaplicativo chama o método init () de cada miniaplicativo que executa. O visualizador chama init () uma vez, imediatamente após carregar o miniaplicativo. (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 outro dado sem caractere, a string deve 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 private parseSquareSize () de 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 miniaplicativo 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 miniaplicativo falhe com entrada incorreta.

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

Especificando Parâmetros de Applet

A seguir está um exemplo de um arquivo HTML com um CheckerApplet incorporado nele. O arquivo HTML especifica ambos os parâmetros para o miniaplicativo por meio da 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>

Note - Os nomes dos parâmetros não diferenciam maiúsculas de minúsculas.

Conversão de aplicativo para miniaplicativos

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

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

• 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 aula pública. Caso contrário, o miniaplicativo não pode ser carregado.

• Elimine o método principal do 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 miniaplicativo. Você não precisa construir explicitamente o objeto do miniaplicativo. O navegador cria uma instância para você e chama o método init.

• Remova a chamada para setSize; para miniaplicativos, o dimensionamento é feito com os parâmetros de largura e altura no arquivo HTML.

• Remova a chamada para setDefaultCloseOperation. Um miniaplicativo não pode ser fechado; ele termina quando o navegador é encerrado.

• Se o aplicativo chamar setTitle, elimine a chamada para o método. Os miniaplicativos 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 miniaplicativo é exibido automaticamente.

Manipulação de eventos

Os miniaplicativos herdam um grupo de métodos de tratamento 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 pega-tudo chamado processEvent.

Para reagir a um evento, um miniaplicativo 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 esse miniaplicativo da seguinte maneira -

<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." Depois de clicar dentro do retângulo, "clique do mouse" também será exibido.

Exibindo Imagens

Um miniaplicativo pode exibir imagens no formato GIF, JPEG, BMP e outros. Para exibir uma imagem dentro do miniaplicativo, 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 esse miniaplicativo da seguinte maneira -

<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 miniaplicativo pode reproduzir um arquivo de áudio representado pela interface AudioClip no pacote java.applet. A interface AudioClip possui três métodos, incluindo -

• public void play() - Reproduz o clipe de áudio uma vez, desde o início.

• public void loop() - Faz com que o clipe de áudio seja reproduzido continuamente.

• public void stop() - Pára de reproduzir o clipe de áudio.

Para obter um objeto AudioClip, você deve invocar o método getAudioClip () da classe Applet. O método getAudioClip () retorna imediatamente, independentemente de o URL ser resolvido 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 esse miniaplicativo da seguinte maneira -

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