Um Applet é um pequeno software que é executado, geralmente na forma de um plug-in, dentro de um programa maior. No âmbito de Java, os Applets são programas que podem ser facilmente inseridos em páginas HTML (ou seja, o programa é executado no contexto de um web browser). Esse recurso pode tornar sua página web mais interativa e trazer funcionalidades que o HTML não possui. Os Applets, geralmente, utilizam a biblioteca gráfica AWT, o que os torna bastante poderosos para o desenvolvimento de pequenas aplicações (sejam elas simples ou complexas).
Para iniciar o desenvolvimento de applets, vamos ver um clássico "Hello World".
import java.applet.Applet;
import java.awt.Graphics;
public class HelloWorld extends Applet {
@Override
public void paint(Graphics g) {
g.drawString("Hello World!", 50, 50);
}
}
Note que, como todo programa Java, os applets devem possuir pelo menos uma classe pública para que possam ser executados. A classe principal dos applets deve estender a classe Applet do pacote java.applet. Agora, vamos entender esse primeiro exemplo passo a passo.
As duas primeiras linhas importam as classes necessárias para a compilação do programa: java.applet.Applet e java.awt.Graphics. A primeira contém os atributos e métodos necessários para um applet simples; a segunda (uma classe da biblioteca gráfica AWT) é usada para exibir objetos na tela, desde retas e polígonos a imagens.
Nesse exemplo, a classe HelloWorld possui apenas um método, chamado paint. Esse é responsável por exibir os componentes gráficos na tela. Aqui, usamos o método drawString, da classe java.awt.Graphics, que recebe uma String para ser exibida, e dois inteiros representando a posição.
O resultado desse exemplo é um retângulo branco com o texto "Hello World!", como na applet a seguir.
Agora que já tivemos um primeiro contato com a programação de applets, vamos partir para um exemplo um pouco mais sofisticado. Nesse exemplo, iremos construir um simples joguinho de "ping-pong", cujo objetivo é não deixar a bola cair. Observe o código abaixo.
import java.applet.Applet;
import java.awt.Color;
import java.awt.Event;
import java.awt.Graphics;
public class PingPong extends Applet implements Runnable {
// Applet
private int larguraTela;
private int alturaTela;
// Cores
private final Color preto = new Color(0,0,0);
private final Color azul = new Color(0,0,155);
private final Color cinza = new Color(200,200,200);
// Bola
private final int BOLA_RAIO = 30;
private int bolaX;
private int bolaY;
private int moveBolaY;
private int moveBolaX;
// Para o movimento da bola
Thread t;
boolean movendo;
// Barra
private int barraX;
private int barraY;
private final int BARRA_W = 80;
private final int BARRA_H = 15;
@Override
public void init() {
setBackground(cinza);
larguraTela = this.getWidth();
alturaTela = this.getHeight();
barraX = larguraTela/2 - BARRA_W/2;
barraY = alturaTela - BARRA_H;
bolaX = larguraTela/2 - BOLA_RAIO/2;
bolaY = BOLA_RAIO/2;
moveBolaX = 2;
moveBolaY = 2;
t = new Thread(this);
movendo = false;
}
@Override
public void paint(Graphics g) {
g.setColor(azul);
g.fillArc(bolaX, bolaY, BOLA_RAIO, BOLA_RAIO, 0, 360);
g.setColor(preto);
g.fillRect(barraX, barraY, BARRA_W, BARRA_H);
}
@Override
public boolean keyDown(Event e, int tecla) {
if (tecla == Event.RIGHT){
moveDireita();
}
if (tecla == Event.LEFT){
moveEsquerda();
}
if (!movendo){
movendo = true;
t.start();
}
return true;
}
private void moveDireita(){
if (barraX + BARRA_W < larguraTela)
barraX += 2;
}
private void moveEsquerda(){
if (barraX > 0)
barraX -= 2;
}
private void moveBola(){
if (bolaY + BOLA_RAIO >= barraY && barraX <= bolaX + BOLA_RAIO
&& bolaX <= barraX + BARRA_W)
moveBolaY *= -1;
if (bolaY <= 0)
moveBolaY *= -1;
if (bolaX + BOLA_RAIO >= larguraTela)
moveBolaX *= -1;
if (bolaX <= 0)
moveBolaX *= -1;
bolaY += moveBolaY;
bolaX += moveBolaX;
}
@Override
public void run() {
while (true) {
moveBola();
repaint();
try {
Thread.sleep(60);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
Nesse exemplo, além de importar aquelas duas classes do exemplo anterior, importamos, também, as classes java.awt.Color e java.awt.Event. O primeiro é usado para setar cores de objetos e do background (aqui, utilizamos o construtor que recebe três parâmetros inteiros, entre 0 e 255, representando a quantidade de cada componente do sistema de cores RGB); o segundo é usado na captura de eventos em geral (como teclas pressionadas e movimentação do mouse). Agora vamos ter uma visão geral de cada método implementado nesse exemplo.
No método init, da classe Applet, colocamos todo o código que deve ser rodado assim que o programa é inicializado. No exemplo, utilizamos esse método para mudar a cor de fundo, determinar as posições iniciais da bola e da barra, inicializar as variáveis de incremento de posição da bola e criar uma nova thread, que será utilizada para atualizar a posição da bola e redesenhar os objetos na tela com o método repaint (vide método run). O uso de thread se fez necessário pois precisamos atualizar a posição da bola independente dos eventos que ocorram. Por isso, a classe do exemplo implementa a interface Runnable.
O método paint tem exatamente a mesma função que no exemplo anterior, a única diferença é que usamos outros dois métodos da classe java.awt.Graphics. São estes, fillArc e fillRect que desenham um círculo e um retângulo, respectivamente, preenchendo-os com a cor atual (definimos essas cores com uma chamada ao método setColor antes de desenhar cada objeto).
Os movimentos da bola e da barra são feitos pelos métodos moveBola, para a bola, e moveEsquerda e moveDireita, para a barra. O método que movimenta a bola é chamado dentro de um laço no método run. A cada iteração do laço, os objetos na tela são redesenhados. Os métodos que movimentam a barra são chamados dependendo da tecla que foi pressionada. Para isso, implementamos o método keyDown. Note que, ao pressionar alguma das duas teclas, seta para a esquerda e seta para a direita, pela primeira vez, a thread é iniciada e o jogo começa.
Confira, abaixo, o resultado do nosso segundo exemplo.
Por fim, podemos incluir um applet numa página HTML de uma forma bastante simples. Basta que compilemos a classe principal do aplicativo e utilizemos uma tag especial como mostrado a seguir.
Como exercício, acrescente mais um jogador ao exemplo anterior (uma barra localizada no canto superior da tela e controlada pelas teclas 'a' e 'd') e exiba os pontos de cada um deles.