DP APS JAVA

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Atividade Prática Supervisionada
Ciência da Computação
Prof.: Marcelo Castro
385X
	
DESENVOLVIMENTO DE UM JOGO DE RECICLAGEM
Preocupações com o meio ambiente
Lucas Crisóstomo – C53DDF-6
Santana de Parnaíba
	
2018
ÍNDICE
OBJETIVO	03
1. INTRODUÇÃO	04
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. 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. PLANO DE DESENVOLVIMENTO DO JOGO	13
3.1 Java	13
3.2 Swing	15
3.3 AWT	16
4. 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
7. BIBLIOGRAFIA	43
8. FICHAS APS	44
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.
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)
  	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
  	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)
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)
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.
	
 Mecanismos do jogo
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.
Fonte: print screen do jogo sendo rodado no sistema macOS Sierra.
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.
Fonte: print screen do jogo sendo rodado no sistema macOS Sierra.
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.
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.
Fonte: print screen do jogo sendo rodado no sistema macOS Sierra
Já a segunda opção, “sair”, apenas fecha a janela atual do jogo.
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.
Fonte: print screen do jogo sendo rodado no sistema macOS Sierra
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
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 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
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
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
	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 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 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, 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 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 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 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.
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;
 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;
 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;
 }
 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
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
 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());
 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) {
 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
 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{
 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){
 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:
 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) {
 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;
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);
 }
 });
 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);
 setLocationRelativeTo(null);
 setVisible(true);
 setTitle("Jogo APS");
 }
 
 
 public static void main(String[] args) {
 new Aplicativo();
 }
}
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
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
Fonte: print screen do jogo sendo rodado no sistema macOS Sierra.
Imagem 5 – Tela de Fim do Jogo
Fonte: print screen do jogo sendo rodado no sistema macOS Sierra.
7. BLIBLIOGRAFIA
	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. 2019.
ORACLE. Class Random. Disponível em: < https://docs.oracle.com/javase/8/docs/api/java/util/Random.html >. Acesso em 20 de out. 2019.
ORACLE. Class JMenu. Disponível em: < https://docs.oracle.com/javase/7/docs/api/javax/swing/JMenu.html >. Acesso em 20 de out. 2019.
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. 2019.
ORACLE. Class Image. Disponível em: < https://docs.oracle.com/javase/7/docs/api/java/awt/Image.html>. Acesso em 22 de out. 2019.
ORACLE. Interface ActionListener. Disponível em: < https://docs.oracle.com/javase/7/docs/api/java/awt/event/ActionListener.html>. Acesso em 22 de out. 2019.
ORACLE. Class Graphics. Disponível em: < https://docs.oracle.com/javase/7/docs/api/java/awt/Graphics.html>. Acesso em 22 de out. 2019.
ORACLE. Class MouseAdapter. Disponível em: < http://docs.oracle.com/javase/7/docs/api/java/awt/event/MouseAdapter.html>. Acesso em 22 de out. 2019.
ORACLE. Class KeyAdapter. Disponível em: < https://docs.oracle.com/javase/7/docs/api/java/awt/event/KeyAdapter.html>. Acesso em 22 de out. 2019.
ORACLE. Class Rectangle. Disponível em: < https://docs.oracle.com/javase/7/docs/api/java/awt/Rectangle.html>. Acesso em 22 de out. 2019.
ORACLE. Class ActionEvent. Disponível em: < https://docs.oracle.com/javase/7/docs/api/java/awt/event/ActionEvent.html>. Acesso em 22 de out. 2019.
ORACLE. Class KeyEvent. Disponível em: < http://docs.oracle.com/javase/7/docs/api/java/awt/event/KeyEvent.html>. Acesso em 22 de out. 2019.
ORACLE. Class MouseEvent. Disponível em: < https://docs.oracle.com/javase/7/docs/api/java/awt/event/MouseEvent.html>. Acesso em 22 de out. 2019.
ORACLE. Interface MouseMotionListener. Disponível em: < https://docs.oracle.com/javase/7/docs/api/java/awt/event/MouseMotionListener.html>. Acesso em 22 de out. 2019.
8. FICHAS APS