JAVA – APLICAÇÕES GRÁFICAS Propriedades Utilizadas

JAVA – APLICAÇÕES GRÁFICAS
Propriedades Utilizadas:
ANIMATION
FACULDADE DE TECNOLOGIA SENAC PELOTAS
Nome do aluno: Davi Beskow Venzke
Identificação da Turma: ADS III semestre Noite
Data:13/05/2010
1 Bouncing Circle
1.1 Introdução e Funcionamento
A propriedade Bouncing Circle é uma animação de um círculo que percorre uma area
cujo valor e representado por getbounds() método que retorna o tamanho da janela, a
classe tem propriedades grafícas que podem ser definidas pelo programador como
tamanho do círculo, trajetória e cor, o seu funcionamento se dá através de cálculos
matemáticos de incremento e decremento das variaveis para que ocorra o movimento
dentro da area da janela.
1.2 Código da aplicação
/*
* Copyright (c) 2000 David Flanagan. All rights reserved.
* This code is from the book Java Examples in a Nutshell, 2nd Edition.
* It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
* You may study, use, and modify it for any non-commercial purpose.
* You may distribute it non-commercially as long as you retain this notice.
* For a commercial use license, or to purchase the book (recommended),
* visit http://www.davidflanagan.com/javaexamples2.
*/
import java.applet.Applet;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;
/** An applet that displays a simple animation */
public class BouncingCircle extends Applet implements Runnable {
int x = 150, y = 100, r = 100; // Position and radius of the circle
int dx = 11, dy = 7; // Trajectory of circle
Thread animator; // The thread that performs the animation
volatile boolean pleaseStop; // A flag to ask the thread to stop
/** This method simply draws the circle at its current position */
public void paint(Graphics g) {
g.setColor(Color.red);
g.fillOval(x - r, y - r, r * 2, r * 2);
}
/**
* This method moves (and bounces) the circle and then requests a redraw.
* The animator thread calls this method periodically.
*/
public void animate() {
// Bounce if we've hit an edge.
Rectangle bounds = getBounds();
if ((x - r + dx < 0) || (x + r + dx > bounds.width))
dx = -dx;
if ((y - r + dy < 0) || (y + r + dy > bounds.height))
dy = -dy;
// Move the circle.
x += dx;
y += dy;
// Ask the browser to call our paint() method to draw the circle
// at its new position.
repaint();
}
/**
* This method is from the Runnable interface. It is the body of the thread
* that performs the animation. The thread itself is created and started in
* the start() method.
*/
public void run() {
while (!pleaseStop) { // Loop until we're asked to stop
animate(); // Update and request redraw
try {
Thread.sleep(100);
} // Wait 100 milliseconds
catch (InterruptedException e) {
} // Ignore interruptions
}
}
/** Start animating when the browser starts the applet */
public void start() {
animator = new Thread(this); // Create a thread
pleaseStop = false; // Don't ask it to stop now
animator.start(); // Start the thread.
// The thread that called start now returns to its caller.
// Meanwhile, the new animator thread has called the run() method
}
/** Stop animating when the browser stops the applet */
public void stop() {
// Set the flag that causes the run() method to end
pleaseStop = true;
}
}
1.3 Propriedades utilizadas
classes importadas Applet, Color, Graphics, Rectangle.
A classe BouncingCircle é uma classe extendida da Classe Applet.
int x = 60, y = 60, r = 60; // / Posição e raio do círculo
int dx = 10, dy = 10; // Trajetória do círculo
Thread animator; // thread que executa a animação é usado para melhorar a execução
da applet e mante-lo funcionando até o fechamento do programa.
volatile boolean pleaseStop; // Um sinalizador de pedir para parar a thread
O volatile serve para manter o pleseStop visivel a todas as threads
//Este método simplesmente chama o círculo em sua posição atual
public void paint(Graphics g) {
//seta a cor vermelha
g.setColor(Color.red);
g.fillOval(x - r, y - r, r * 2, r * 2);
}
/*
* Este método move (em saltos) o círculo e então pede um redesenho.
* animate() é chamado periodicamente.
*/
public void animate() {
// verifica quando o círculo bate no borda.
Rectangle bounds = getBounds();// recebe volores do metodo getbounds da classe
component
if ((x - r + dx < 0) || (x + r + dx > bounds.width))
dx = -dx; //decrementa a variável
if ((y - r + dy < 0) || (y + r + dy > bounds.height))
dy = -dy; //decrementa a variável
// Move o circulo
x += dx; //incrimento
y += dy; //incrimento
// método repaint () para desenhar o círculo
// Na sua nova posição.
repaint();
}
/**
* Este método é a partir da interface Runnable.
* Que realiza a animação
*/
public void run() {
while (!pleaseStop) { // Loop até fecharmos a janela
animate(); // solicita redesenho
try {
Thread.sleep(100);
} // espera 100 milliseconds
catch (InterruptedException e) {
}
}
}
// começa a animação
public void start() {
animator = new Thread(this); // Cria a thread
pleaseStop = false; // Seta pleaseStop para false
animator.start(); // Inicia a thread.
}
// Para a animação quando é fechada a janela
public void stop() {
// Seta a variavel pleaseStop para que pare o metodo run()
pleaseStop = true;
}
}
1.4 Visualização da Ferramenta em Funcionamento
1.5 Conclusão
Durante o estudo da aplicação Bouncing Circle notei a simplicidade do código com o
uso do extends que além de otimizar, melhora a visualização do código e facilita o seu
entendimento, o uso da instrução Thread, que melhora o desenpenho da aplicação bem
como o uso de seu metodo sleep(), que permite gerar uma pausas.