UNIVERSIDADE PAULISTA

CIÊNCIAS DA COMPUTAÇÃO

JOGO SOBRE RECICLAGEM:

Como podemos ajudar o meio ambiente?

SÃO PAULO
2017

1
2
 ÍNDICE

OBJETIVO .....................................................................................................................04
1.0 INTRODUÇÃO .........................................................................................................0
5
1.1 Definição .................................................................................................................05
1.2
Importância .............................................................................................................05
1.3 Materiais
recicláveis ...............................................................................................06
1.3.1
Plástico .................................................................................................................06
1.3.2
Papel .....................................................................................................................06
1.3.3 Vidro .....................................................................................................................07
1.3.4 Metal .....................................................................................................................07
1.4 Reciclagem no Mundo ...........................................................................................07
2.0 REGRAS DO JOGO ................................................................................................08
2.1 Mecanismos do
jogo ..............................................................................................09
2.1.1 Tela
inicial ............................................................................................................09
2.1.2 Tela do jogo .........................................................................................................09
2.1.3 Menu superior .....................................................................................................10
2.1.4 Tela final ..............................................................................................................12
3.0 PLANO DE DESENVOLVIMENTO DO
JOGO .........................................................13
3.1 Java .........................................................................................................................13
3.2
Swing .......................................................................................................................15
3.3 AWT .........................................................................................................................16

2
4.0 PROJETO DO
PROGRAMA ....................................................................................18
4.1 Classe
Objeto ..........................................................................................................18
4.2 Classe
Fase .............................................................................................................19
4.3 Classe
Aplicativo ....................................................................................................23
5.0 LINHAS DE
CÓDIGO ...............................................................................................25
5.1 Classe
Objeto ..........................................................................................................25
5.2 Classe
Fase .............................................................................................................28
5.3 Classe
Aplicativo ....................................................................................................37
6.0 PROGRAMA EM
FUNCIONAMENTO .....................................................................40

3
BIBLIOGRAFIA .............................................................................................................43
FICHAS
APS ..................................................................................................................45

3
 OBJETIVO

Este trabalho tem como o objetivo conscientizar a pessoa que estiver jogando da
importância de se realizar a reciclagem, orientando o jogador a realizá-la de forma
consciente, colocando cada tipo de material em seu devido recipiente. Um jogo simples
e  educativo, mas sem perder a diversão e a jogabilidade.

4
5
 1.0 INTRODUÇÃO

1.1 Definição

  Reciclagem é o ato de pegar algum produto que já não é mais utilizado, e

transformá-lo em um produto novo, ao invés de jogá-lo fora. Pode ser qualquer
coisa, desde transformar um papel velho e usado em um novo.(Paulo,
Fridman.2007)

  1.2 Importância
 
A reciclagem não só é importante para preservar o meio ambiente,
contribuindo para a diminuição significativa da poluição do solo, da água e do ar,
como também pode proporcionar lucro para muitas empresas que podem utilizar o
material em novos produtos como acessórios e móveis, e assim, reduzir o custo de
produção, além de criar uma imagem boa de si mesma por ser amigável ao meio
ambiente. A reciclagem consiste na transformação de materiais usados em produtos
novos, que poderão ser inseridos na cadeia de consumo sem ter a necessidade de
extrair recursos naturais. Essa ação contribui para a redução de lixo gerado pelo ser
humano. Além disso, se compararmos o uso de recursos para fazer determinado
produto, com o processo de reciclagem e com o processo normal de conversão da
matéria prima vemos ganhos de até 97% em economia de uso de energia e água, e
diminuição da poluição do solo, água e ar com o processo de reciclagem.(Paulo,
Fridman.2007)
   Outro benefício da reciclagem é a quantidade de empregos que ela gera em
todo o país. Existem muitos desempregados, que não conseguindo trabalho em
outros setores, estão buscando trabalho neste setor, e conseguindo salários bons o
suficiente  para manterem suas famílias. Com isso, cooperativas de catadores de
papel e alumínio e outros materiais recicláveis já são uma boa realidade nos centros
urbanos de todo o Brasil.(Paulo, Fridman.2007)

6
   Outro ponto importante na reciclagem, é que ela também pode ser usada para
a produção de energia elétrica, barateando assim o custo de produção de energia e,
assim, fazendo com que a conta de luz fique mais barata.(Paulo, Fridman.2007)
1.3 Materiais recicláveis

1.3.1 Plástico

   Materiais como copos, garrafas, sacos, tampas, tigelas, entre outros são
recicláveis, e o processo pode ser feito de 3 maneiras diferentes.
   A primeira se chama "Reciclagem Mecânica" e é a mais comum entre as três,
e consiste basicamente em transformar os produtos de plástico recolhidos,
separados e lavados, em pequenos grânulos, e, a partir desses grânulos, formar um
produto completamente diferente do anterior. Os produtos mais comuns produzidos
a partir dessa técnica são sacos de lixo, pisos, mangueiras, embalagens não
alimentícias e peças de automóveis.( FRAGA, Simone Carvalho Levorato. 2014)
   A segunda se chama “Reciclagem Química” e é a mais elaborada das três, e
consiste em reprocessar os plásticos recolhidos, formando assim matéria prima, e
depois formar produtos de elevada qualidade á partir dessa matéria prima. Essa é a
forma mais cara de reciclagem de plástico, e requer uma quantidade enorme do
material para ser economicamente viável.( FRAGA, Simone Carvalho Levorato.
2014)
   A terceira opção se chama “Reciclagem Energética” e é aquela que não
transforma o plástico em outro produto, mas sim em energia elétrica e até mesmo
combustível, e consiste na incineração do material, aproveitando o poder calorífico
armazenado neles. Essa opção já é utilizada em 35 países diferentes, e esses
geram cerca de 10.000MW de energia por mês só com plástico.( FRAGA, Simone
Carvalho Levorato. 2014)

1.3.2 Papel

7
   Materiais como jornais, revistas, papéis, caixas de pizza, entre outros são
recicláveis, e são os materiais mais fáceis de se reciclar, podendo ser feito até
mesmo em casa facilmente, nas indústrias a reciclagem é feita rasgando o papel em
tiras uniformes, depois molhando-o com água para que vire apenas celulose, após
isso é drenada toda a água junto com a impureza e é prensado por cilindros a vapor,
e então está pronto para virar um novo papel. ( FRAGA, Simone Carvalho Levorato.
2014)

1.3.3 Vidro

   Materiais como copos, garrafas, potes de conserva, entre outros são

recicláveis, e para isso, o processo começa com a separação por cor de todos os
produtos de vidro recolhidos, após isso eles são triturados e fundidos em uma
temperatura de aproximadamente 1300 graus, se tornando vidro líquido, assim
podendo ser moldado da forma que for desejada. Hoje em dia, estima-se que
aproximadamente 40% de todas as embalagens de vidro no Brasil são feitas de
vidro reciclado, e esse número só tendi a subir cada dia mais.( FRAGA, Simone
Carvalho Levorato. 2014)

1.3.4 Metal

   Materiais como tampas de garrafa, latas, panelas, pregos, entre outros são
recicláveis, e para isso o material enviado para as empresas de reciclagem são
separados por tipo, como cobre, alumínio, ferro, entre outros e não vão para o setor
de prensagem, onde são compactados em cubos para facilitar a próxima etapa que
é a fundição, onde o metal é derretido, após isso ele é transformado em produtos
novos como latinhas. O alumínio é o produto reciclável mais aproveitável, tendo uma
porcentagem de quase 100% de aproveitamento, e o Brasil é o líder em reciclagem
do mesmo, com aproximadamente 100% das latinhas produzidas em território
nacional sendo feito de reciclagem.( FRAGA, Simone Carvalho Levorato. 2014)

8
1.4 Reciclagem no mundo
  
   Em muitos países no mundo os governos já estão cientes do potencial da
reciclagem, e de como ela é importante para a desaceleração da degradação do
meio ambiente. A Europa lidera a lista de países com melhor taxa de lixo reciclado,
onde aproximadamente 35% de todo o lixo produzido já é reciclado, e essa
reciclagem já é responsável por gerar 1% de todo o PIB do continente, porém, a
meta é que todas as cidades reciclem ao menos 50% de todo o seu lixo até 2020,
porém mesmo faltando muito tempo, 4 países já conseguiram bater essa meta, são
eles Áustria, Alemanha, Bélgica e Holanda.(Paulo, Fridman.2007)
   Sendo um exemplo de continente para reciclagem a Europa também
aproveita todo o lado econômico desta prática, sendo que já gerou mais de 2 milhão
de empregos por ano só nesse setor e fez 145 bilhões de euro só de rendimento
desse mercado.(Paulo, Fridman.2007)
   A Áustria é o país mais á frente em termos de reciclagem, situada na Europa
Central o país tem uma taxa de lixo produzida por pessoa por ano de cerca de
591Kg, porém cerca de 62,8% de todo o seu lixo já é tratado e reciclado.(Paulo,
Fridman.2007)
   Em contrastes com esses números, o Brasil em 2008 produziu 7,1 milhões de
toneladas de lixo, e apenas 13% desse total foi reciclado.(Paulo, Fridman.2007)
   Em termos econômicos, a reciclagem já gerou 12 bilhões de reais para o
Brasil, porém as áreas sem reciclagem representam um mercado em potencial
perdido de cerca de 8 bilhões de reais por ano para o governo, o que representa
cerca de 0,02% do PIB nacional.(Paulo, Fridman.2007)

9
 
2.0 REGRAS DO JOGO

Como o nosso objetivo com esse jogo é incentivar as pessoas a reciclar, nós
criamos um jogo onde a pessoa deve aprender qual tipo de lixo deve ser jogado em
qual cor de lixeira.
Para isso, nós fizemos um jogo em que vários tipos diferentes de lixo vão caindo
na tela, pegamos um ícone para metal, um para papel, um para vidro e um para
plástico, para o jogador aprender quais tipos de matérias são recicláveis ou não.
Já que a nossa intenção é fazer com que o jogador aprenda qual é a cor da lata
que se deve jogar cada tipo de lixo, nós pegamos ícones de latas sem nenhuma
indicação, fazendo com que as chances de o jogador lembrar dessa informação
aumentem muito, já que, caso ele erre a relação o jogo irá acabar.

2.1 Mecanismos do jogo

2.1.1 Tela Inicial

Para começarmos o jogo, devemos executar o nosso projeto dentro do

NetBeans, e então uma tela aparecerá com as instruções para que o jogador possa
iniciar o nosso jogo.
Para iniciar o jogo, o jogador deverá clicar em qualquer espaço da janela atual.
Na imagem á seguir, podemos ver a primeira tela sendo executada em um
computador.

10
 Fonte: print screen do jogo sendo rodado no sistema macOS Sierra.

2.1.2 Tela do jogo

Nós fizemos o jogo para ser bem simples e divertido, para isso criamos uma
mecânica de jogo bem simples.
Conforme os lixos vão caindo da parte de cima da tela, o jogador deve clicar
com o mouse e arrasta-las até a lixeira correspondente a cada tipo de lixo, realizando
assim a reciclagem do objeto, e fazendo com que o contador localizado no canto
superior esquerdo da tela encremente 1.
Caso o lixo ultrapasse o limite de tela antes do jogador conseguir efetuar a
reciclagem, ou o jogador tente jogar o lixo emu ma lixeira que não deve, o jogo se
encerrará.
Á seguir podemos ver a tela principal do jogo sendo executada.

11
 Fonte: print screen do jogo sendo rodado no sistema macOS Sierra.

2.1.3 Menu superior

No canto superior da tela de nosso jogo decidimos colocar um menu bem

simples, com uma aba chamada “opções”.
Podemos ver á seguir a tela do jogo com o menu sendo pressionado.

12
 Fonte: print screen do jogo sendo rodado no sistema macOS Sierra

Como podemos ver na imagem acima, esse menu nos dá duas opções, a
primeira “sobre”, nos dá um pouco mais de informação sobre o nosso jogo em uma
nova janela, como podemos ver á seguir.

13
 Fonte: print screen do jogo sendo rodado no sistema macOS Sierra

Já a segunda opção, “sair”, apenas fecha a janela atual do jogo.

2.1.4 Tela final

Caso o jogador não consiga realizar os objetivos do jogo, ele será redirecionado
para a tela de fim de jogo.
E, caso ele queira recomeçar o jogo, ele deve apertar enter, e o jogo começará
de novo, como podemos ver na imagem á seguir.

14
Fonte: print screen do jogo sendo rodado no sistema macOS Sierra

15
 3.0 PLANO DE DESENVOLVIMENTO DO JOGO

3.1 Java

Nós escolhemos usar o Java para a realização de nosso projeto pois, apesar de
os jogos de auto orçamento normalmente usarem ferramentas escritas em C++, como
Call of Duty, GTA, entre outros, o Java é uma linguagem simples e fácil de usar e, para
o nosso objetivo com esse projeto, supre todas as nossas necessidades. (Dawson,
2014)
Java é uma linguagem de programação orientada a objetos e baseada em
classes, que nasceu em 1995 criada por uma empresa chamada “Sun Microsystems”,
que, posteriormente, foi comprada pela Oracle. A linguagem tem muita influencia vinda
de linguagens de programação como C, hoje me dia ela é uma das linguagens de
programação mais utilizadas no mundo, e é principalmente utilizada para
desenvolvimento web. (SCHILDT, 2014)
Abaixo podemos observar um vetor o qual contém uma visão simples de como
uma linguagem de programação orientada á objetos funciona e como uma linguagem
de programação estruturada funciona.
Imagem 1 – LPOO vs LE

16
 Fonte: Apresentação feita pelo Instiuto Federal de Educação, Ciência e
Técnologia.
Como podemos ver no vetor acima, em uma linguagem estruturada todos os
seus procedimentos são realizados diretamente em seus dados globais. Já na
linguagem de programação orientada a objetos, nós dividimos todos os comandos de
nosso programa em métodos, e não utilizamos dados globais, mas sim objetos, esses
objetos servem como uma representação de objetos da vida real em nosso programa.
O Java possui uma biblioteca chamada “Util”, na qual encontramos diversas
classes que auxiliam no desenvolvimento de qualquer programa.
Entre essas classes estão a classe “ArrayList”, a qual permite você criar uma
lista com vários vetores que podem conter qualquer informação que você desejar, a
classe “List”, a qual te permite criar listas com diversos tipos de objetos diferentes, e as
classes “ThreadLocalRandom” e “Random“, as quais permitem que você gere um
número aleatório que esteja dentro de um determinado intervalo. (ORACLE)

3.2 Swing

Também escolhemos trabalhar com a interface gráfica Java Swing, já que é uma
interface bem simples de ser utilizada e contém muitas classes uteis para se fazer um
jogo.
Swing é uma interface de usuário gráfica sucessora á interface gráfica AWT, e
pode trabalhar junto com a mesma em um programa, porém, suas estruturas são muito
diferentes, enquanto a interface AWT passa muitas tarefas para o sistema operacional
realizar, a Swing tem um nível mais alto, fazendo com que o programa acabe utilizando
mais memória do computador, mas também faz com que o seu programa sofra poucas
mudanças se rodado em sistemas operacionais diferentes. (SCHILDT, 2014)
Para as imagens que queríamos usar para o jogo, nós usamos a classe
“ImagenIcon“, a qual serve para o tratamento de imagens externas.
Já para construir a janela na qual o nosso jogo iria ficar usamos a classe
“JPanel“, a qual serve como um painel que ira conter todos os elementos como botões,
textos, imagens, entre outros, a classe Timer, a qual permite usarmos um certo

17
intervalo de tempo para que uma nova ação seja feita, a classe “JFrame“, a qual serve
como a janela onde todo o jogo ira ocorrer, a classe “JMenuBar“, a qual serve para
criar um menu em cima da tela, o qual pode conter vários itens do tipo “JMenu“, o qual
é outra classe dentro do Swing, que também pode conter vários itens do tipo
“JMenuItem“, o qual também pertence a interface gráfica Swing. (ORACLE)
Além da Swing, também usamos a interface gráfica “AWT“(Abstract Window
Toolkit), decidimos utiliza-la pois ela contém diversas classes que auxiliam no
desenvolvimento de jogos.

3.3 AWT

A interface gráfica AWT procedeu a Swing, e foi a primeira interface a ser

integrada ao Java, logo em seu lançamento, e até hoje ela é a biblioteca padrão para
desenvolvimento em Java, ela é muito usada no desenvolvimento para sistemas
móveis, principalmente para o Androide. (SCHILDT, 2014)
Abaixo, podemos ver um vetor que melhor detalha como essas duas interfaces
trabalham juntas.
Imagem 2 – AWT e Swing

18
 Fonte: Página sobre “Swing” da Wikipédia.
Pelo vetor, podemos ver que ambas as interfaces gráficas têm sua origem no
mesmo pacote de classes “Java Lang”, também vemos que os componentes
pertencentes ao Swing fazem um papel parecido com o de um complemento, vemos
que os seus componentes sempre têm alguma relação com o AWT.
Para que o nosso jogo ficasse sempre em uma janela de tamanho ideal,
precisávamos de uma classe que nos desse as dimensões da tela do computador do
usuário, para isso usamos a classe Toolkit e a Dimension, as quais servem retornam o
tamanho da tela na qual o seu programa está sendo rodado. (ORACLE)
Além disso, essa interface contém várias classes úteis, como a classe “Image“, a
qual permite que você utilize imagens externas em seu programa, a classe “Rectangle“,
a qual trata suas imagens como um retângulo, podendo assim usar vários métodos
como a “colide”, a qual verifica se duas imagens se sobrepõem em algum momento, a
classe “ActionEvent“, a qual serve para que, sempre que determinado evento ocorra
durante o tempo em que o seu programa está rodando, ele irá realizar determinada
ação, e a classe “ActionListener”, a qual serve para perceber quando a ação criada
pela classe “ActionEvent” ocorre no programa. (ORACLE)
Para a parte gráfica usamos duas classes contidas na Interface AWT, sendo
elas e a classe “Graphics”, a qual permite que que você crie elementos gráficos para o
seu programa, a classe Graphics2d, a qual te dá mais controle sobre objetos
geométricos. (ORACLE)
No vetor abaixo podemos ver melhor como essas classes funcionam dentro de
um programa.
Imagem 3 – Graphics em Java

19
 Fonte: Imagem na sessão sobre graficos no site Apache Harmony.
Pelo vetor acima, podemos ver que ambas as classes utilizadas são classes
abstratas derivadas da classe Object, e que a classe “BufferedImageGraphics2D”,
também utilizada em nosso programa, é uma classe que vem da de
“CommomGraphic2D”.
Além disso, para usarmos o teclado em nosso jogo nós utilizamos as seguintes
classes contidas na interface gráfica AWT, a classe “KeyAdapter”, a qual permite que o
nosso programa possa receber comandos vindo diretamente do teclado, a classe
“KeyEvent”, a qual serve para você construir um evento com as teclas, por exemplo,
caso o usuário entre com a tecla enter, o programa ira realizar uma certa ação.
(ORACLE)
Já para o mouse, usamos a classe “MouseAdapter”, a qual nos permite trabalhar
com o mouse em nosso programa, a classe “MouseEvent”, a qual nos permite detectar
certas ações do mouse, como cliques, cliques duplos, entre outros, e usamos a classe
“MouseMotionListener”, a qual nos permite detectar movimentos do mouse, como
quando o usuário arrasta o mouse pela tela, ou o faz com o mouse pressionado, entre
outros. (ORACLE)

4.0 PROJETO DO PROGRAMA

Nós escolhemos dividir o nosso jogo em três classes diferentes, sendo elas uma
chamada “Objetos”, na qual será desenvolvido toda a parte que envolve os objetos, no
caso lixos, que irão ficar caindo na tela, outra chamada “Fase”, na qual controlamos
toda a lógica do jogo, como programar como o programa ira saber se o jogador perdeu
ou não, entre outras coisas, e, por fim, temos a classe “Aplicativo”, nela está contido o
nosso método “main”, e usamos ela para inicializar o nosso jogo, chamando os
diversos métodos contidos em nossas outras classes.

4.1 Classe Objeto

20
 Nós queríamos criar uma classe na qual tudo sobre os objetos usados em nosso
jogo fosse programado, para isso criamos variáveis.
Para sabermos o tamanho da tela do computador em que o nosso jogo está
rodando, nós criamos as variáveis “screenSize” do tipo “Dimension”, a qual recebe as
exatas dimensões da tela, e a variável “height” do tipo “Double“, a qual contém
somente a altura da tela que está sendo usada. Nós não criamos uma variável para a
largura pois não houve a necessidade de utilizar essa informação dentro dessa classe.
Nós também criamos algumas variáveis para trabalhar com as imagens dos
objetos sendo elas a variável “id” do tipo “int”, a qual serve para identificarmos os
diferentes tipos de objetos, a variável “largura” do tipo “int”,, a qual representará a
largura das imagens, a variável “altura”, a qual representará a altura da imagem, as
variáveis “x” e “y” do tipo “int”, as quais representam em que posição da tela os nossos
objetos estarão, a variável “Imagem” do tipo “Image”, a qual servirá para carregar as
imagens de nossos objetos, e a variável “visible” do tipo “Boolean”, a qual servirá para
saber se as imagens devem ser visíveis ou não.
Além disso, também criamos a variável “velocidade” do tipo “int”, a qual é usada
para escolhermos a velocidade com a qual os nossos objetos cairão na tela, e a
variável “contador”, a qual servirá de auxilio para o nosso método “Switch”.
Nós encapsulamos fortemente todas as variáveis para uma maior segurança em
nosso programa e criamos métodos “get” e “set” para todos eles.
Nós construímos um construtor nessa classe, o qual tem o propósito de, sempre
que for chamado, criar um novo objeto, para isso ele deve receber duas variáveis “x” e
“y” do tipo “int”, as quais serão usadas para o programa guardar em qual local da tela
esse objeto deverá estar.
Logo após, o programa irá gerar um número aleatório dentro do intervalo de 0 e
3, e, dependendo do resultado, escolherá uma imagem diferente. Caso seja 0 o objeto
criado terá a imagem de i, papel e terá um id igual a 1, caso seja 1 o objeto criado terá
a imagem de um vidro e terá um id igual a 2, e assim por diante.
Depois disso, nós fazemos a nossa variável “imagem” receber a imagem do
objeto selecionado, as variáveis “largura” e “altura” receber a largura e a altura da

21
imagem respectivamente, e fazemos com que essa imagem fique visível em nosso
programa.
Além disso também criamos o método “mexer”, nós criamos esse método com a
intenção de programar qual será o movimento dos nossos objetos. Para isso, nós
criamos uma condição “if” que checa se essa imagem está dentro da tela, caso esteja,
o seu componente “y” aumentará de acordo com a velocidade desejada, caso o
contrário, essa imagem não aparecerá mais na tela.

4.2 Classe Fase

Nessa classe, a qual estende a classe “JPanel”, já que vamos criar nossa tela
aqui, e implementa a interface “ActionListener”, para colocarmos ouvidores em nosso
programa, nós quisemos colocar tudo o que é pertinente ao funcionamento da nossa
fase, ou seja, colocar as imagens das latas de lixo que serão utilizadas no jogo, a
lógica de quando o jogo será terminado ou não, entre outras coisas.
Assim como na classe “Objeto”, também utilizamos as constantes “screenSize”
do tipo “Dimension”, para sabermos as dimensões da tela, e a constante “height” do
tipo “Double“, a qual contém somente a altura da tela, porém também criamos a
constante “width”, a qual contém somente a largura da tela utilizada.
Além disso, para organizarmos o local exato onde cada imagem das latas
deveria ficar nós criamos a constante “espacamentoLatas” do tipo “int”, a qual calcula a
que distância uma lata deve ficar da outra dividindo a largura da tela por 3, a variável
“alturaLatas” do tipo “int”, na qual colocamos em que altura todas as latas devem estar,
e as latas “x_Lata_Azul”, “x_Lata_Verde”,” x_Lata_Vermelha” e ” x_Lata_Amarela” do
tipo “int”, as quais contém os valores do eixo da largura em que as latas devem estar
em nosso programa.
Também criamos as variáveis “fundo”, “paper”, “glass”, “metal” e “plastic” do tipo
“Image”, as quais irão, no futuro, receber as imagens das latas de lixo de nosso jogo, e
a variável “inicio”, do tipo boolean, a qual indicará se o jogo está na tela inicial ou não.
Além disso também criamos a variável “contador” do tipo “int”, a qual servirá
para contarmos quantos objetos o usuário conseguiu fazer cair no cesto correto, a

22
variável “timer” do tipo “Timer”, a qual servirá para controlarmos o tempo de alguns
métodos, a variável “Inimigos’ do tipo “List”, a qual servirá para criarmos uma lista com
vários objetos que estarão caindo na tela, e a variável “emJogo” do tipo “boolean”, a
qual irá nos auxiliar para saber se o usuário perdeu ou não.
Logo no inicio, nós criamos um método chamada “coordinate”, a qual não recebe
nenhuma informação, mas devolve uma variável do tipo “int”, nesse método nós
criamos uma variável do tipo “int” chamada “coo”, e usamos um método contido na
classe “ThreadLocalRandom” para gerar um número aleatório entre 100 e o tamanho
da largura da tela menos 100. Nós criamos esse método para que, sempre que um
objeto apareça na tela, ele esteja em algum lugar aleatório da tela, fazendo com que o
jogo fique mais interessante e dinâmico.
Logo depois, nós criamos um construtor para essa classe chamado “Fase”, o
qual não recebe nenhum valor e também não devolve nada. O qual tem como objetivo
controlar todo o jogo, ou seja, para que o nosso programa nós temos que chamar esse
construtor. Nele nós fazemos com que a nossa tela tenha foco, isso faz com que,
quando você aperte algum botão enquanto nessa tela o programa registrará esse
movimento, também habilitamos um Buffer, para que a tela seja recarregada a cada
determinado tempo.
Também colocamos um ouvidor para o teclado, para que o programa sempre
saiba quando o usuário apertar alguma tecla do teclado, e adicionamos dois ouvidores
para o mouse, um para rastrear quando o usuário clica com o mouse, e um ouvidor
para rastrear se o usuário arrastou o mouse em algum momento.
Depois disso, também importamos todas as imagens de nossas latas e as
atribuímos para as nossas variáveis “fundo”, “paper”, “glass”, “metal” e “plastic” do tipo
“Image” já citadas anteriormente.
Além disso, também fazemos a variável “emJogo” receber o valor de verdadeiro
para que o jogo começo, chamamos o método “inicializarObjetos”, a qual será
responsável por lançar os objetos na tela, e criamos um timer que irá recarregar a tela
a cada 5 milésimos, para observarmos o movimento na tela.
Na mesma classe, também criamos o método “inicializarObjetos”, a qual não
recebe nem devolve nenhum valor. Nós criamos esse método com a intenção de,

23
sempre que precisarmos, chama-la para que os nossos objetos comecem a cair do
topo da tela.
Para isso, nós criamos a variável “inimigos” do tipo “ArrayList”, a qual servirá
para criarmos uma lista com todos os objetos que cairão na tela, e uma variável do tipo
“int” chama “coo”, a qual servirá para termos as coordenadas “x” dos objetos.
Após criarmos essas variáveis, nós criamos um objeto do tipo “Objeto” dando o
valor da variável “coo” e o número “0”, e já o adicionamos em nossa lista “inimigos”.
Nós fazemos isso pois queremos que o nosso objeto sempre inicie com as
coordenadas em “y” igual a 0, para que o objeto aparece no topo da tela, e a
coordenada em “x” igual um número aleatório, para que o objeto aparece em todos os
locais da tela.
Nós também criamos um novo Timer, o qual terminará sempre em 5 segundos,
e deverá adicionar um objeto á lista “inimigos”.
Para a parte gráfica, nós usamos a interface “Paint”, a qual deve receber um
objeto do tipo “Graphic”, porém não devolve nenhuma variável. Por isso a utilizamos
para cuidar de toda a parte de imagens.
Nós colocamos um “if” logo no inicio desse método para que, caso a variável
“inicio” seja falso ele deve rodar certos comando pois o usuário estará na tela inicial e,
caso seja verdadeira, rodará o jogo normalmente.
Para isso, nós criamos um objeto que irá cuidar dessas imagens chamado
“gráficos” do tipo “Graphics2D”, e mandamos ele desenhar todas as imagens de
nossas latas e de nosso fundo no fundo da tela.
Depois disso, criamos uma condição em que, caso o jogo ainda esteja rodando,
ou seja, a variável “emJogo” seja verdadeira, o programa desenhará todos os objetos
caindo em nossa tela e desenhará o contador de quantos objetos foram colocados na
cesta certa, e, caso não esteja, ele desenhará uma imagem com a mensagem de
“Game Over” na tela, nós também usamos os .
Logo após, nós sobrescrevemos o método “actionPerformed” contido na classe
“ActionListener”, o qual deve receber um objeto do tipo “ActionEvent”, porém não
devolve nenhuma variável. O Nosso objetivo com esse método foi programar as

24
mecânicas do jogo, sendo aqui aonde os objetos receberão o comando de se mover ou
não.
Para isso, nós criamos um laço de repetição, o qual verificará se todos os
objetos dentro da lista “inimigos”, e, caso eles estejam visíveis, ou seja, estejam dentro
da tela, ele fará com que esses objetos realizem o seu movimento devido, e, caso não
esteja visível, ele remove o objeto da lista.
Depois disso, nós chamamos o método “encontros”, para verificar se algum
objeto entrou em alguma cesta errada, e depois chamamos o método “repaint”, o qual
deve recarregar a tela, o qual só será chamado caso o jogo não esteja na tela inicial.
Para checarmos se um objeto caiu dentro do cesto correto ou não nós criamos a
classe “encontros”, a qual não recebe nem devolve nenhuma variável.
Nós criamos um laço de repetição que irá, o tempo inteiro, percorrer toda a lista
“inimigos”, e checará quais são as coordenadas “x” e “y”, de cada uma, caso as
coordenadas “y” de qualquer objeto passe de 900, o jogo acabará e a mensagem de
fim de jogo aparecerá, nós fizemos isso pois, casso a coordenada “y” passe desse
valor, significa que o objeto não está mais em tela.
Logo após, nós fizemos uma lógica para que, caso o objeto esteja dentro da
cesta de lixo correta, o objeto se tornará invisível e o contador irá ser acrescentado em
1, e, caso ele vá para qualquer outro cesto, a variável “emJogo” se torna falsa e a
imagem de fim de jogo aparece. Para isso, nós pegamos a coordenada x de cada lata
e acrescentamos 120 pixels para mais ou para menos para cobrir a área inteira da lata
de lixo.
Além disso, também criamos, dentro dessa mesma classe, uma classe chamada
“TecladoAdapter”, a qual estende a classe “KeyAdapter”, com o objetivo de podermos
usar o teclado para, sempre que o jogador perder, ele poder pressionar a tecla “Enter”,
poder voltar ao jogo.
Para isso, nós chamamos o método “keyPressed”, o qual nos dá qual tecla foi
pressionada pelo usuário, e, caso tenha sido “Enter” e não esteja em jogo, o programa
começará novamente um novo jogo para o usuário poder jogar.
Nós também criamos a classe “MouseAdapters”, a qual estende a classe
“MouseAdapter” e implementa a interface “MouseMotionListener”, nós criamos essa

25
classe para poder reconhecer os movimentos do mouse, mais especificamente
reconhecer quando o usuário arrasta o mouse pela tela e poder fazer com que o
usuário arraste os objetos que caem na tela.
Para isso, nós chamamos o método “mouseDragged”, o qual recebe um evento
de mouse, e, sempre que o usuário estiver arrastando o mouse em cima de um dos
objetos contidos na lista “inimigos”, ele pegará as coordenadas “x” e “y” do ponteiro do
mouse, e passará as coordenadas do “x” para a coordenada “x” do objeto.

4.3 Classe Aplicativo

Nessa classe, nosso objetivo é chamar todos os métodos já criados antes e

criarmos a janela de nosso jogo, para isso nós fizemos ela estender a classe “JFrame”,
a qual permite a criação da janela.
Logo no inicio da classe, já colocamos um construtor para ela, o qual não
precisa receber nenhum tipo de variável. Nele nós chamamos os métodos
“construirMenuBar”, o qual construirá o menu simples do nosso jogo, o método
“construirFase”, o qual iniciará toda a nossa fase em nosso programa, e o método
“configurarTela”, o qual definirá diversos aspectos de nossa janela, como as dimensões
da mesma.
Depois disso nós criamos o método “construirMenuBar”, no qual criamos um
menu simples com dois itens, o primeiro com o titulo “sobre”, o qual abre uma janela
com uma breve explicação do jogo, e outro item sair, o qual encerrará o jogo caso
chamado.
Nós também criamos o método “construirFase”, o qual não recebe nenhuma
variável, porém retorna um objeto do tipo JPanel, nele nós iniciamos um objeto do tipo
“Fase”, o que criará todo a parte gráfica de nosso programa, e depois a adicionamos
em nossa tela, e, por fim, nós retornamos a tela criada pelo método.
Além disso, também criamos o método “configurarTela”, o qual primeiro checará
qual é o tamanho da tela em que o programa está sendo rodado, depois, baseado
nesse dado definirá o tamanho da tela do programa, depois nós fazemos com que o
usuário não possa redimensionar o tamanho da janela, para que a parte gráfica não

26
fique errada, falamos para que, quando o usuário clique no botão de fechar a janela, o
programa feche por completo, fazemos com que a janela fique centrado na tela,
fazemos com que toda a parte gráfica fique visível, e adicionamos um tirulo para a
janela.
Por fim, dentro do nosso método “main”, nós apenas criamos um objeto do tipo
“Aplicativo”, o que chamará todos os construtores criados e criará o nosso jogo.

27
 5.0 LINHAS DE CÓDIGO

5.1 Classe Objeto

package aps.jogo;

import java.awt.Dimension;
import java.awt.Image;
import java.awt.Toolkit;
import java.util.Random;

import javax.swing.ImageIcon;

public class Objeto {

private static final int VELOCIDADE = 1;

private Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
private double height = screenSize.getHeight();

private static int contador = 0;

private int id;

private int x,y,largura,altura;

28
 private Image imagem;
private boolean visible;

public Objeto(int x, int y) {

this.x = x;
this.y = y;

ImageIcon referencia = new

ImageIcon(Aplicativo.class.getResource("/Imagens/Fundo.jpg"));
Random randomGenerator = new Random();
contador = randomGenerator.nextInt(4);
switch(contador){
case 0:
referencia = new
ImageIcon(Aplicativo.class.getResource("/Imagens/Papel_Icone.png"));
this.id = 0;
break;
case 1:
referencia = new
ImageIcon(Aplicativo.class.getResource("/Imagens/Vidro_Icone.png"));
this.id = 1;
break;
case 2:
referencia = new
ImageIcon(Aplicativo.class.getResource("/Imagens/Plastico_Icone.png"));
this.id = 2;
break;
case 3:
referencia = new
ImageIcon(Aplicativo.class.getResource("/Imagens/Metal_Icone.png"));
this.id = 3;

29
 break;
default:
}

imagem = referencia.getImage();

this.largura = imagem.getWidth(null);
this.altura = imagem.getHeight(null);

visible = true;
}

public void mexer() {

if (this.y > height) {
this.visible = false;
} else {
this.y += VELOCIDADE;
}
}

public boolean isVisible() {

return visible;
}

public void setVisible(boolean visible) {

this.visible = visible;
}

public Image getImagem() {

return imagem;
}

30
 public int getX() {
return x;
}

public void setX(int x) {

this.x = x;
}

public int getY() {

return y;
}

public void setY(int y) {

this.y = y;
}

public int getAltura() {

return altura;
}

public int getLargura() {

return largura;
}

public int getId(){

return this.id;
}
}

5.1 Classe Fase

31
package aps.jogo;

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

import javax.swing.ImageIcon;
import javax.swing.JPanel;
import javax.swing.Timer;

public class Fase extends JPanel implements ActionListener {

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

private final double width = screenSize.getWidth() - 600;
private final double height = screenSize.getHeight() - 150;
private final int espacamentoLatas = (int) (width - 250)/3;
private final int alturaLatas = (int) height - 250;
// Distribuindo as latas igualmente na tela

32
private final int x_Lata_Azul = 0;
private final int x_Lata_Verde = espacamentoLatas;
private final int x_Lata_Vermelha = 2 * espacamentoLatas;
private final int x_Lata_Amarela = 3 * espacamentoLatas;

private final Image fundo;

private final Image paper;
private final Image glass;
private final Image metal;
private final Image plastic;

private static int contador = 0;

private final Timer timer;
private List<Objeto> inimigos;
private boolean emJogo;

public int coordinate(){

int coo;
coo = ThreadLocalRandom.current().nextInt(100,(int) width - 100);

return coo;
}

public Fase() {
setFocusable(true);
setDoubleBuffered(true);
addKeyListener(new TecladoAdapter());
addMouseMotionListener(new MouseAdapters());
addMouseListener(new MouseAdapters());

33
 ImageIcon referencia = new
ImageIcon(Aplicativo.class.getResource("/Imagens/Fundo.jpg"));
fundo = referencia.getImage();
ImageIcon lataB = new
ImageIcon(Aplicativo.class.getResource("/Imagens/Lata_Azul.png"));
paper = lataB.getImage();
ImageIcon lataG = new
ImageIcon(Aplicativo.class.getResource("/Imagens/Lata_Verde.png"));
glass = lataG.getImage();
ImageIcon lataR = new
ImageIcon(Aplicativo.class.getResource("/Imagens/Lata_Vermelha.png"));
metal = lataR.getImage();
ImageIcon lataY = new
ImageIcon(Aplicativo.class.getResource("/Imagens/Lata_Amarela.png"));
plastic = lataY.getImage();

emJogo = true;

inicializarObjetos();

timer = new Timer(5, this);

timer.start();
}

public void inicializarObjetos() {

inimigos = new ArrayList<>();
int coo = coordinate();
inimigos.add(new Objeto(coo, 000));
Timer timer = new Timer(4000, new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {

34
 int coo = coordinate();
inimigos.add(new Objeto(coo, 000));
}
});
timer.start();
}

public void paint(Graphics g) {

Graphics2D graficos = (Graphics2D) g;
graficos.drawImage(fundo, 0, 0, null);
graficos.drawImage(paper,x_Lata_Azul,alturaLatas, null);
graficos.drawImage(glass, x_Lata_Verde,alturaLatas, null);
graficos.drawImage(metal, x_Lata_Vermelha,alturaLatas, null);
graficos.drawImage(plastic,x_Lata_Amarela,alturaLatas, null);

if (emJogo) {
for (int i = 0; i < inimigos.size(); i++) {
Objeto in = inimigos.get(i);
graficos.drawImage(in.getImagem(), in.getX(), in.getY(), this);
}
graficos.drawString("Objetos: " + contador, 5, 15);
} else {
ImageIcon fimJogo = new
ImageIcon(Aplicativo.class.getResource("/Imagens/GameOver.png"));
graficos.drawImage(fimJogo.getImage(), 0, 0, null);
timer.stop();
}
g.dispose();
}

@Override

35
 public void actionPerformed(ActionEvent e) {
for (int i = 0; i < inimigos.size(); i++) {
Objeto in = inimigos.get(i);
if (in.isVisible()) {
in.mexer();
} else {
inimigos.remove(i);
}
}
encontros();
repaint();
}

public void encontros() {

for (int i = 0; i < inimigos.size(); i++) {
Objeto tempObjeto = inimigos.get(i);
int ide = tempObjeto.getId();
if(tempObjeto.getY() > 900){
emJogo = false;
}

switch(ide){
case 0:
if(tempObjeto.getX() >= x_Lata_Azul - 26 && tempObjeto.getX() <=
x_Lata_Azul + 175
&& tempObjeto.getY() <= height - 200 && tempObjeto.getY() >= height -
270){
contador += 1;
tempObjeto.setVisible(false);
} else{

36
 if((tempObjeto.getX() >= x_Lata_Verde - 30 && tempObjeto.getX() <=
x_Lata_Verde+140||
tempObjeto.getX() >= x_Lata_Vermelha - 30 && tempObjeto.getX() <=
x_Lata_Vermelha + 140||
tempObjeto.getX() >= x_Lata_Amarela - 50 && tempObjeto.getX() <=
x_Lata_Amarela + 150)
&& tempObjeto.getY() <= height - 200 && tempObjeto.getY() >= height
- 270){

emJogo = false;
}
}
break;

case 1:
if(tempObjeto.getX() >= x_Lata_Verde - 30 && tempObjeto.getX() <=
x_Lata_Verde+140
&& tempObjeto.getY() <= height - 200 && tempObjeto.getY() >= height -
310){

contador += 1;
tempObjeto.setVisible(false);
} else {
if((tempObjeto.getX() >= x_Lata_Azul - 30 && tempObjeto.getX() <=
x_Lata_Azul + 140||
tempObjeto.getX() >= x_Lata_Vermelha -30 && tempObjeto.getX() <=
x_Lata_Vermelha + 140||
tempObjeto.getX() >= x_Lata_Amarela -30 && tempObjeto.getX() <=
x_Lata_Amarela + 150)
&& tempObjeto.getY() <= height - 200 && tempObjeto.getY() >=
height - 270){

37
 emJogo = false;
}
}
break;

case 2:
if(tempObjeto.getX() >= x_Lata_Vermelha - 30 && tempObjeto.getX() <=
x_Lata_Vermelha + 140
&& tempObjeto.getY() <= height - 200 && tempObjeto.getY() >= height -
310){

contador += 1;
tempObjeto.setVisible(false);
} else {
if((tempObjeto.getX() >= x_Lata_Azul - 30 && tempObjeto.getX() <=
x_Lata_Azul + 140||
tempObjeto.getX() >= x_Lata_Verde - 30 && tempObjeto.getX() <=
x_Lata_Verde+140||
tempObjeto.getX() >= x_Lata_Amarela - 30 && tempObjeto.getX() <=
x_Lata_Amarela + 150)
&& tempObjeto.getY() <= height - 200 && tempObjeto.getY() >= height
- 270){

emJogo = false;
}
}
break;

case 3:

38
 if(tempObjeto.getX() >= x_Lata_Amarela - 30 - 50 && tempObjeto.getX()
<= x_Lata_Amarela + 150
&& tempObjeto.getY() <= height - 200 && tempObjeto.getY() >= height -
300){

contador += 1;
tempObjeto.setVisible(false);
} else {
if((tempObjeto.getX() >= x_Lata_Azul - 30 && tempObjeto.getX() <=
x_Lata_Azul + 140|
tempObjeto.getX() >= x_Lata_Verde - 30 && tempObjeto.getX() <=
x_Lata_Verde+140||
tempObjeto.getX() >= x_Lata_Vermelha - 30 && tempObjeto.getX() <=
x_Lata_Vermelha + 140)
&& tempObjeto.getY() <= height - 200 && tempObjeto.getY() >= height
- 270){

emJogo = false;
}
}
break;
default:
}

}
}

private class TecladoAdapter extends KeyAdapter {

@Override
public void keyPressed(KeyEvent e) {

39
 if (e.getKeyCode() == KeyEvent.VK_ENTER && !emJogo) {
emJogo = true;
inicializarObjetos();
}
}
}

private class MouseAdapters extends MouseAdapter implements

MouseMotionListener{

@Override
public void mouseDragged(MouseEvent e){
for(int i = 0; i < inimigos.size(); i++){
if(e.getX() < inimigos.get(i).getX() + 80 && e.getX() > inimigos.get(i).getX() -
80
&& e.getY() < inimigos.get(i).getY() + 80 && e.getY() >
inimigos.get(i).getY() - 80){
inimigos.get(i).setX(e.getX() - 40);
inimigos.get(i).setY(e.getY() - 40);
}
}
}
}
}

5.3 Classe Aplicativo

package aps.jogo;

import java.awt.Dimension;

40
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JSeparator;

public class Aplicativo extends JFrame {

public Aplicativo() {
construirMenuBar();
construirFase();
configurarTela();
}

private JMenuBar construirMenuBar() {

JMenuBar menuBar = new JMenuBar();
JMenu menu = new JMenu("Opções");
JMenuItem sobre = new JMenuItem("Sobre");
sobre.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(null,
"Jogo sobre reciclgaem para APS", "Informações",
JOptionPane.INFORMATION_MESSAGE);
}

41
});

JMenuItem sair = new JMenuItem("Sair");

sair.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
});

menu.add(sobre);
menu.add(new JSeparator());
menu.add(sair);
menuBar.add(menu);
setJMenuBar(menuBar);
return menuBar;
}

private JPanel construirFase() {

Fase fase = new Fase();
add(fase);
return fase;
}

private void configurarTela() {

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
double width = screenSize.getWidth();
double height = screenSize.getHeight();
setSize((int) width - 600, (int) height - 150);
setResizable(false);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

42
 setLocationRelativeTo(null);
setVisible(true);
setTitle("Jogo APS");
}

public static void main(String[] args) {

new Aplicativo();
}
}

43
 6.0 PROGRAMA EM FUNCIONAMENTO

Imagem 1 – Tela inicial do jogo

Fonte: print screen do jogo sendo rodado no sistema macOS Sierra.

Imagem 2 – Jogo rodando normalmente

44
Fonte: print screen do jogo sendo rodado no sistema macOS Sierra.

Imagem 3 – Jogo rodando com o menu selecionado

Fonte: print screen do jogo sendo rodado no sistema macOS Sierra.

Imagem 4 – Menu do jogo

45
Fonte: print screen do jogo sendo rodado no sistema macOS Sierra.

Imagem 5 – Tela de Fim do Jogo

46
Fonte: print screen do jogo sendo rodado no sistema macOS Sierra.

BLIBLIOGRAFIA

47
 DAWSON, Michael. Beginning C++ Through Game Programming. 4. ed.
Boston: Cengage Learning PTR, 2014.
SCHILDT, Herbet. Java: A begginer’s Guide. 6. ed. Nova York: McGraw-Hill
Education, 2014.
SCHILDT, Herbet. Swing: A begginer’s Guide.1. ed. McGraw-Hill Education,
2006.
JACKSON, Wallace. Beginning Java 8 Games Development. 1. ed. Apress,
2014.
SÉRGIO, Adeodado; Paulo, Fridman. A arte da reciclagem. 1. ed. Horizonte
Geográfico, 2007.
FRAGA, Simone Carvalho Levorato. Reciclagem de materiais plásticos:
Aspectos técnicos, econômicos, ambientais e sociais. 1. ed. 2014.
ORACLE. Class ArrayList<E>. Disponível em: <
https://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html>. Acesso em 20 de
out. 2016.
ORACLE. Class Random. Disponível em: <
https://docs.oracle.com/javase/8/docs/api/java/util/Random.html >. Acesso em 20 de
out. 2016.
ORACLE. Class JMenu. Disponível em: <
https://docs.oracle.com/javase/7/docs/api/javax/swing/JMenu.html >. Acesso em 20 de
out. 2016.
ORACLE. Class Dimension. Disponível em: <
https://docs.oracle.com/javase/7/docs/api/java/awt/Dimension.html>. Acesso em 22 de
out. 2016.
ORACLE. Class Toolkit. Disponível em: <
https://docs.oracle.com/javase/7/docs/api/java/awt/Toolkit.html>. Acesso em 22 de out.
2016.
ORACLE. Class Image. Disponível em: <
https://docs.oracle.com/javase/7/docs/api/java/awt/Image.html>. Acesso em 22 de out.
2016.

48
 ORACLE. Interface ActionListener. Disponível em: <
https://docs.oracle.com/javase/7/docs/api/java/awt/event/ActionListener.html>. Acesso
em 22 de out. 2016.
ORACLE. Class Graphics. Disponível em: <
https://docs.oracle.com/javase/7/docs/api/java/awt/Graphics.html>. Acesso em 22 de
out. 2016.
ORACLE. Class MouseAdapter. Disponível em: <
http://docs.oracle.com/javase/7/docs/api/java/awt/event/MouseAdapter.html>. Acesso
em 22 de out. 2016.
ORACLE. Class KeyAdapter. Disponível em: <
https://docs.oracle.com/javase/7/docs/api/java/awt/event/KeyAdapter.html>. Acesso em
22 de out. 2016.
ORACLE. Class Rectangle. Disponível em: <
https://docs.oracle.com/javase/7/docs/api/java/awt/Rectangle.html>. Acesso em 22 de
out. 2016.
ORACLE. Class ActionEvent. Disponível em: <
https://docs.oracle.com/javase/7/docs/api/java/awt/event/ActionEvent.html>. Acesso em
22 de out. 2016.
ORACLE. Class KeyEvent. Disponível em: <
http://docs.oracle.com/javase/7/docs/api/java/awt/event/KeyEvent.html>. Acesso em 22
de out. 2016.
ORACLE. Class MouseEvent. Disponível em: <
https://docs.oracle.com/javase/7/docs/api/java/awt/event/MouseEvent.html>. Acesso
em 22 de out. 2016.
ORACLE. Interface MouseMotionListener. Disponível em: <
https://docs.oracle.com/javase/7/docs/api/java/awt/event/MouseMotionListener.html>.
Acesso em 22 de out. 2016.

49