APS LPOO 3ºSemestre

Prévia do material em texto

Universidade Paulista UNIP 
Ciência da Computação 
 
 
 
 
Atividade Prática Supervisionada 
Programação Orientada Objeto 
 
 
 
 
 
 
Clécio de Almeida Junior – RA: N11914-4 – Turma: CC3P-68 
Denis Ramos de Souza – RA: D31749-0 – Turma: CC3P-68 
Lilian G S Trocolli – RA: D36FCH-9 – Turma: CC3Q-68 
William Dourado Cruz Silva – RA: C533FA-6 – Turma: CC3Q-68 
 
 
 
 
São Paulo – SP 
Junho – 2018 
SUMÁRIO 
1 OBJETIVO ........................................................................................................... 2 
2 INTRODUÇÃO ..................................................................................................... 2 
2.1 Gerações De Linguagem De Programação ............................................... 3 
2.2 Conceitos de programação orientada objeto ........................................... 4 
2.3 Objeto ........................................................................................................... 4 
2.4 Classe ........................................................................................................... 4 
2.5 Herança ........................................................................................................ 5 
2.6 Encapsulamento .......................................................................................... 5 
2.7 Polimorfismo ............................................................................................... 5 
3 DISSERTAÇÃO ................................................................................................... 6 
3.1 Ter foco no cliente ....................................................................................... 6 
3.2 Fazer a equipe trabalhar bem. .................................................................... 7 
3.3 Administrar os recursos ............................................................................. 7 
3.4 Conceitos ..................................................................................................... 7 
3.5 Herança e Objetos ....................................................................................... 7 
3.6 Envio e recebimento das informações ...................................................... 7 
3.7 Processamento das informações .............................................................. 8 
3.8 Interface Gráfica .......................................................................................... 8 
3.9 Entrada de Dados ........................................................................................ 8 
3.10 Cálculo do vencedor ................................................................................ 8 
3.11 Matemática por trás do Jogo da Velha ................................................... 9 
3.12 Considerações finais ............................................................................... 9 
4 PROJETO .......................................................................................................... 11 
4.1 Diagrama de Classes ................................................................................ 11 
4.2 Fluxo de funcionamento do sistema ....................................................... 12 
4.2.1 Tela inicial do Sistema ............................................................................................ 12 
4.2.2 Tela após início das jogadas ................................................................................. 12 
4.2.3 Quando existe algum vencedor ............................................................................ 13 
4.2.4 Quando não há algum vencedor .......................................................................... 13 
5 LINHAS DE CÓDIGO ........................................................................................ 15 
5.1 ControleDeEntrada .................................................................................... 15 
5.2 jogodavelha ............................................................................................... 15 
5.3 Display ........................................................................................................ 17 
6 BIBLIOGRAFIA ................................................................................................. 24 
7 FICHAS DE ATIVIDADES PRÁTICAS SUPERVISIONADAS .......................... 25 
 
 
 
 
 
 
LISTA DE FIGURAS 
Figura 1 - Diagrama de Classes ............................................................................... 11 
Figura 2 - Tela inicial do Sistema ............................................................................. 12 
Figura 3 - Tela após início das jogadas .................................................................... 12 
Figura 4 - Quando existe algum vencedor ................................................................ 13 
Figura 5 - Quando não há algum vencedor ............................................................. 13 
Figura 6 - Tela após o reinício das partidas.............................................................. 14 
 
 
 
 
 
 
 
 
2 
 
1 OBJETIVO 
 Esse trabalho tem por objetivo conceituar, mostrar e aplicar os conceitos de 
POO – Programação Orientada Objeto. 
 Neste apresentaremos a Programação Orientada Objeto através de parte de 
sua história e conceitos básicos da linguagem de programação JAVA, e este projeto 
foi fundamentado em pesquisas, aprendizados em sala de aula e laboratório de 
informática. 
 Esperamos que além dos conceitos e aplicação mostrada através deste projeto 
o leitor também entenda o básico para o funcionamento de linguagens orientadas a 
objeto e desperte ainda mais interesse em estudos nesta disciplina. 
 
2 INTRODUÇÃO 
 
 Hoje, com o advento de um mundo cada vez mais moderno temos cada vez 
mais perto o mundo digital devido as facilidades e agilidades que nos proporcionam. 
 Mas para que esse mundo digital nos proporcione cada vez mais recursos, 
operabilidade, facilidades entre outros, contamos com uma estrutura de hardware e 
software, que é desenvolvido através de uma linguagem de programação, muito a 
quem já imaginávamos um dia. 
 Graças ao desenvolvimento da ciência e tecnologia hoje temos um mundo 
digital bem abrangente e cada vez mais expansivos. Neste mundo digital além de 
máquinas poderosas com alto poder computacional em nossas mãos, assim como 
nossos smartphones por exemplo, temos também o software que é responsável por 
nossa comunicação com a máquina. 
 Através das linguagens de programação construímos os softwares e através 
deles conseguimos programar, estruturar e realizar determinadas funções para 
alcançar um objetivo através das máquinas. 
 Assim como a evolução das máquinas se dá pelo hardware, essa também se 
dá pela evolução de suas linguagens de programação, um complementa o outro, logo, 
evoluem praticamente juntos, mesmo assim, cada um deles tem sua própria história 
evolutiva. 
 
 
3 
 
 
2.1 Gerações De Linguagem De Programação 
 
→Na primeira geração temos a linguagem de máquina que é o tipo mais 
primitivo de programação a programação que está mais perto da máquina do que 
qualquer outra coisa palpável por nós humanos. 
A linguagem de máquina é uma linguagem crua, ou seja, não muda seu estado 
natural. Essa linguagem é formada de string de números, definindo a realização das 
operações em um computador, sendo realizado uma tarefa de cada vez em ordem 
cronológica. 
 →Na segunda geração temos a linguagem Assembly e como seu próprio nome 
diz, sim, é uma linguagem de montagem onde já podemos encontrar algum tipo de 
articulação. Essa linguagem consiste de abreviações de expressões em inglês que 
são operações elementares, onde se originou a base da linguagem Assembly. 
Os Assemblers são programas tradutores que convertem programas de 
linguagem Assembly em linguagem de máquina a velocidade do computador. 
A linguagem Assembly assim como a linguagem de máquina também segue 
uma ordem cronológica,porém, esta já nos abrange mais recursos como por exemplo 
a chamadas de subprogramas e/ou funções. 
Embora o código seja mais claro para seres humanos, ele é incompreensível 
para computadores até ser traduzido em linguagem de máquina através dos 
Assemblers. 
→Chegamos a terceira geração de linguagem a Linguagem de Alto Nível que 
é a Linguagem Orientada a Usuário. São chamadas linguagem orientada a usuário as 
linguagens que são perfeitamente compreensíveis para nós seres humanos, através 
delas, digitamos não mais abreviações como no Assemby mas sim palavras inteiras 
(comandos) de acordo com a sintaxe da linguagem que estamos desenvolvendo a 
programação. Esse tipo de linguagem permite aos programas escrever instruções que 
se pareçam com o inglês e contêm notações matemáticas comumente utilizadas. As 
linguagens C, C++, .NET e o JAVA são exemplos desse tipo de linguagem. 
Essas linguagens possuem grandes dicionários com entradas saídas e também 
muitas outras funções que podem ser utilizadas pelo programador. Essas linguagens 
trazem um enorme leque de possibilidades para o desenvolvimento de um programa 
mantendo as características básicas das gerações anteriores, como por exemplo 
4 
 
programação estruturada, que é aquela que há uma certa ordem cronológica a ser 
seguida e/ou repedida de acordo com que o programador quer desenvolver. 
→Vamos falar agora da quarta geração. As linguagens de quarta geração são 
as Linguagens Orientadas a Objetos. A orientação a objetos é um paradigma que 
representa uma filosofia para construção de sistemas. Em vez de construir um sistema 
por um conjunto de procedimentos e variáveis nem sempre agrupadas em grupo como 
nas linguagens estruturadas relatadas anteriormente, nas linguagens orientada a 
objeto procura-se chegar cada vez mais perto das relações de um mundo real, e essa 
é a principal base para o desenvolvimento nestas linguagens proximidade com o 
mundo real devido as suas relações em grupo. 
 
2.2 Conceitos de programação orientada objeto 
 Como introduzido acima, na orientação a objetos utilizamos uma ótica mais 
próxima do mundo real, lidamos com objetos que são estruturas que carregam dados 
e comportamentos próprios, além de trocarem mensagens entre si com o objetivo de 
formar algo maior, um sistema por exemplo. 
 Atualmente a programação orientada a objeto é o paradigma mais amplamente 
utilizado nos dias de hoje, e aqui vamos listar alguns conceitos deste paradigma: 
 
2.3 Objeto 
 Objeto é uma entidade independente que possui nome, atributos e métodos. É 
tudo que pode ter e/ou sofrer algum tipo de ação direta ou indiretamente. 
 O nome do objeto é a identidade dele. 
 Os atributos de um objeto são as características que aquele objeto tem, e por 
sua vez quem determina o valor do atributo é o estado. 
 Já os métodos são as ações do objeto, tipos decisões, repetições, contas e etc. 
 Por mais que um objeto seja parecido com o outro, eles nunca são e/ou serão 
iguais. 
 
2.4 Classe 
 Classe é um modelo abstrato de algo a ser seguido, através da classe podemos 
criar outras classes ou objetos. A classe é a abstração de uma entidade do mundo 
real. 
5 
 
 Na classe você define atributos e métodos de determinados objetos ou outras 
classes. 
 
 
2.5 Herança 
 Herança é um mecanismo que permite definir uma nova classe a partir de uma 
classe já existente, essa classe já existente é chamada de superclasse, já a classe 
criada a partir de uma superclasse é chamada de subclasse. 
 Uma subclasse herda todas as características de uma superclasse, mas, o 
mesmo não ocorre ao contrário. 
 
2.6 Encapsulamento 
 Encapsulamento é uma técnica usada para proteger determinado atributo, é 
uma técnica usada para o usuário ou algum programador não ter acesso direto ao 
atributo preservando assim sua integridade. 
 
2.7 Polimorfismo 
 Polimorfismo é a capacidade de um objeto poder ser referenciado de várias 
formas. 
 
 
6 
 
3 DISSERTAÇÃO 
Nosso projeto inicialmente foi construído no intuído de cumprir a demanda de 
aplicações de todos os conceitos de orientação a objeto, atendendo os prazos 
estipulados, como também dialogar com outras disciplinas, tais interdisciplinaridades 
que serão relatadas nos próximos tópicos do trabalho. 
Mas como entrada é importante relatar os desafios enfrentados no 
cumprimento das metas estipuladas do nosso projeto, algo que se relaciona aos 
desafios enfrentados em qualquer em empresa que se proponha desenvolver 
“soluções de software” e ao mesmo tempo cumprir prazos de entrega e ao mesmo 
tempo não falhar na qualidade e na integridade do sistema. 
Como boa parte do que cursam Ciência da Computação tem como objetivo 
entrada no mercado relacionado ao desenvolvimento de programas, é necessário 
haver uma preparação para entender como funciona o planejamento de projetos. Uma 
quantidade significativa das atividades atuais é orientada a equipes e envolve 
múltiplas organizações, sendo estas características determinantes das atividades 
futuras de projetos. Lidar com equipes e com ambiente corporativo diverso, visando 
desenvolvimento de (novos) sistemas ou produtos de software, requer uma habilidade 
que combina arte e ciência e a isso se denomina gestão de projetos (de software). 
Como é observado, no decorrer do desenvolvimento do projeto, houve necessidade 
de alternar as prioridades do desenvolvimento do sistema. Entre elas estavam, a 
aparência do sistema, a aplicação das funcionalidades e conceito de orientação a 
objeto e a instabilidade do sistema. 
Como foi relatado na revista mensal, Espaço da Acadêmico, Nº 171 de agosto 
de 2015 três pilares formam a base da gestão de projetos: 
 
3.1 Ter foco no cliente 
Isso no ambiente de aprendizado se refere a atender a demanda que a 
atividade prática supervisionada. Foi necessário da parte de todos integrantes se 
adaptar aos novos paradigmas de desenvolvimento dos programas e restruturação do 
sistema para aplicação dos conceitos de orientação a objeto. 
7 
 
3.2 Fazer a equipe trabalhar bem. 
Como foi observado por todos participantes do trabalho, houve a necessidade 
de criação de um cronograma que permitisse uma forma eficiente de delegação de 
tarefas e que ao mesmo tempo fizesse jus as capacidades desenvolvidas por cada 
integrante no decorrer do curso. 
3.3 Administrar os recursos 
O grande desafio do nosso projeto foi encontrar o programa que melhor fizesse 
a aplicação dos conceitos de orientação a objeto e ao mesmo tempo fosse de encontro 
aos outros conceitos aplicados em outras disciplinas, ainda assim, tendo que lidar com 
o recurso escasso que é o tempo, sendo que a maioria dos participantes tem que lidar 
com a jornada de trabalho e ainda contribuir para a conclusão do trabalho. 
3.4 Conceitos 
Houve uma concordância entre todos participantes do grupo que haveria a 
necessidade de um sistema que fizesse o uso de conceitos matemáticos e que 
pudesse atender o prazo estipulado para entrega do projeto. Desta forma, foi 
consenso de todos que fosse desenvolvido um jogo da velha que a conseguisse 
aplicar conceitos de matrizes e ainda permitir grande parte dos conceitos de 
orientação a objetos, os quais já foram relatados anteriormente e foram 
exemplificados por meio do nosso sistema. 
3.5 Herança e Objetos 
Como qualquer programa orientado a objeto, o Jogo da Velha obedeceu alguns 
conceitos de herança. O programa foi imaginado a princípio fazendo uma 
comunicação bem delimitada de interface gráfica e lógica de programação. Sendo 
assim criada uma classe com o foco principal fazer envio e recebimento de informação 
e outro conjunto de classes focada no processamento das informações. 
3.6 Envio e recebimento das informações 
Foi criada uma classe que tem o intuito de gerar interface gráfica para o usuário, 
representar todas posições de um jogo da velha e representar valores que comumente 
são representadoscomo “X” ou “O” e informar ao o usuário de qual jogador é a vez. 
Todas essas informações sendo comunicadas pela classe responsável pela entrada 
de dados. 
8 
 
3.7 Processamento das informações 
Nosso programa tem uma classe filho que é responsável pela comunicação e 
recebimento de informações, o que pode variar o comportamento de acordo com a 
situação, se no caso específico, o botão já foi clicado, ou se já houve algum vencedor, 
tal posição não terá mais inserção de valor. Lembrando que o valor inserido nunca 
será igual ao valor anterior, ou seja, sempre irá variar entre “X” e “O”. A partir do 
momento que essa classe processar o valor inserido no sistema, será enviado para a 
classe pai que será responsável por definir se houver algum vencedor ou se no caso 
o jogo terminou sem vencedor. 
3.8 Interface Gráfica 
Como nesse semestre os conteúdos não foram focados no desenvolvimento 
de interfaces gráficas, o grupo desenvolveu uma interface rudimentar, focada apenas 
na coleta do valor de “X” ou “O” e exibir a vez do jogador que fará a próxima jogada 
para, nesse caso, como é a proposta deste trabalho semestral, haver maior empenho 
no desenvolvimento de uma lógica de programação que efetuar todas possibilidades 
encontradas num jogo da velha e garantir a utilização dos conceitos aprendidos 
referente a semestre. 
3.9 Entrada de Dados 
Foi criada uma classe no Sistema nomeada como “Display”, que tem o 
propósito de gerenciar a interface gráfica do sistema, mas no caso foi criada uma outra 
classe com o nome de “ControleDeEntrada” que, como o nome já diz, tem o foco em 
fazer o controle de quais valores são inseridos e ao mesmo tempo fazer a alternância 
entre valores inseridos e também impedir que qualquer campo que já tenha sido 
preenchido com “X” ou “O” não possa ser preenchido novamente até que o jogo seja 
reiniciado, desta forma, gerenciando o acesso ao campos e garantindo que todas as 
regras do jogo de velha sejam obedecidas. 
3.10 Cálculo do vencedor 
No sistema foi criado uma classe com o nome “JogoDaVelha” que tem como 
principal objetivo receber todos valores inseridos pelos jogadores. A classe referente 
aos cálculos possui o atributo que armazena todos valores inseridos pelo sistema, 
portanto, essa classe também é responsável de armazenar todas jogadas válidas, ou 
seja, todas que passaram pelo crivo do controle de dados. 
9 
 
A partir do momento que são inseridas a jogadas válidas, a classe se 
responsabiliza por identificar jogadas feita e efetuar cálculos para definir, no caso, se 
houve algum vencedor ou caso o contrário, o jogo foi encerrado sem que houvesse 
qualquer vencedor. 
3.11 Matemática por trás do Jogo da Velha 
Um conceito aplicado no projeto da APS foi o conceito de matriz. Algo 
totalmente necessário, pois um jogo da velha funciona com uma matriz bidimensional. 
Como um jogo da velha funciona com 9 posições, foi necessária a utilização de uma 
matriz de ordem 3 por 3, sendo assim, uma matriz quadrada. 
Dizemos que uma matriz A de ordem m x n é quadrada, quando m = n. Isso 
significa que o número de linhas será igual ao número de colunas. Podemos 
representar este tipo de matriz por An. 
Para compreendermos a conceituação de matriz, precisamos aderir à 
convenção dos matemáticos em que a ordenação das linhas de uma matriz seja dada 
de cima para baixo, e a ordenação das colunas, da esquerda para a direita. 
Em uma matriz quadrada, definimos a diagonal principal e a diagonal 
secundária. A principal é formada pelos elementos aij tais que i = j. Na secundária, 
temos i + j = n + 1. Como na regra do joga da velha é definido o vencedor por que 
preencher por valores iguais de um ponto da matriz até o ponto oposto, foi necessária 
uma verificação não só apenas da diagonal principal e segundaria, mas também de 
todas linhas e colunas da matriz. 
3.12 Considerações finais 
No decorrer do semestre, foram identificados vários desafios referentes ao 
desenvolvimento desse projeto. O desafio mais didático e mais claramente observado 
é o contraste de paradigmas de linguagem. Como proposto no semestre anterior, tinha 
que lidar com uma linguagem de programação estruturada, que em suma, possui 
estruturas básicas de controle: sequência, condição e repetição. O que contrasta com 
a linguagem de programação orientada a objeto, que além de lidar com essa estrutura, 
possui a proposta de representar conceitos que dialogam com objetos da vida real, 
conceitos tais como herança, sendo que em muitas situações, objetos possuem a 
características de compartilhar propriedades e comportamentos dinâmicos, ou seja, 
podem apresentar comportamentos diferentes de acordo com as situações. 
10 
 
Mas todas dificuldades enfrentadas no nosso projeto, nos coloca numa posição 
de reflexão de acerca da importância do nosso projeto. O mais importante foi exercício 
de aplicação dos conceitos aplicados, aperfeiçoando das capacidades de abstração e 
conceitualização, como já é a proposta de uma linguagem de programação orientada 
a objeto. E no final das contas, o mais importante é o impacto do legado que o 
aprendizado de uma linguagem traz para o futuro profissional, que o curso Ciência da 
Computação proporciona. Tudo que nos vai levar aprender a lidar com 
responsabilidades enfrentadas no dia a dia no mercado de trabalho e nos torna 
profissionais capacitados. 
 
 
 
 
 
 
 
 
 
 
11 
 
4 PROJETO 
4.1 Diagrama de Classes 
Como foi relatado nos tópicos anteriores o sistema possui uma separação clara entre 
a interface gráfica e cálculo das jogadas. A comunicação entre as classes é feita por 
meio de instância do objeto “ControleDeEntrada” na classe “Display” 
 
 
 
Figura 1 - Diagrama de Classes 
 
12 
 
4.2 Fluxo de funcionamento do sistema 
4.2.1 Tela inicial do Sistema 
O sistema possui uma aparência simples, apenas apresentando saudações e 
indicando a vez do Jogador, a vez do jogador é definida inicialmente com X, ou o 
último valor inserido antes do jogo reinciar. 
 
Figura 2 - Tela inicial do Sistema 
 
4.2.2 Tela após início das jogadas 
Ao iniciar as jogadas sistema, a mensagem de saudações é alterada para uma frase 
de efeito que incentive a continuada das jogadas e sempre abaixo existe a indicação 
de qual é a vez do jogador. 
 
Figura 3 - Tela após início das jogadas 
13 
 
4.2.3 Quando existe algum vencedor 
Quando o sistema identifica um vencedor, ele demonstra ao usuário quem venceu a 
partida e logo abaixo, exibe uma mensagem de provocação ao adversário e 
impossibilita qualquer jogada até o jogo seja reiniciado. 
 
Figura 4 - Quando existe algum vencedor 
 
4.2.4 Quando não há algum vencedor 
Quando o sistema identifica um vencedor, ele demonstra ao usuário que ninguém 
venceu a partida e logo abaixo, exibe a mensagem do próximo jogador, caso ele 
deseje efetuar nova jogada. 
 
Figura 5 - Quando não há algum vencedor 
14 
 
Tela após o reinício das partidas 
Após que há um clique no botão reiniciar, como já sugere o nome, o jogo é reiniciado 
e a interface do sistema volta à aparência inicial, indicando o próximo jogador. 
 
 
Figura 6 - Tela após o reinício das partidas 
 
15 
 
5 LINHAS DE CÓDIGO 
5.1 ControleDeEntrada 
package jogodavelha; 
public class ControleDeEntrada extends JogoDaVelha { 
 private int l=0, c=0; 
 private static int alternateValue=0; 
 private boolean jaClicado=false; 
 
 String getAlternateValue () { 
 return alternateValue==1 || alternateValue==0?"X":"O"; 
 } 
 String getIconAdress (int value) { 
 String vencedor = super.getVencedor(); 
 if (vencedor == "" && jaClicado==false) { 
 this.alternateValue=value; 
 } 
 return value==2?"/jogodavelha/x.png":value==1?"/jogodavelha/o.png":"/jogodavelha/blank.png"; 
 } 
 String getIconAdress (int value, boolean jaClicado) { 
 String iconAdress = "";this.jaClicado=jaClicado; 
 iconAdress = getIconAdress (value); 
 this.jaClicado=false; 
 return iconAdress; 
 } 
 private String troca (int matriz) { 
 String alternateValueIcon="", vencedor=super.getVencedor(); 
 if (matriz==0 && vencedor=="") { 
 if (alternateValue==0 || alternateValue==1) { 
 alternateValueIcon=getIconAdress(2); 
 } else { 
 alternateValueIcon=getIconAdress(1); 
 } 
 super.setLC(l,c,alternateValue); 
 } else { 
 alternateValueIcon=getIconAdress(matriz,true); 
 } 
 return alternateValueIcon; 
 } 
 public String botaoClicado (int l, int c) { 
 this.l=l; 
 this.c=c; 
 return troca (super.getMatrizJogoDaVelha()[l][c]); 
 } 
} 
 
 
 
5.2 jogodavelha 
package jogodavelha; 
 
public class JogoDaVelha { 
 private static int matrizJogoDaVelha[][] = new int[3][3]; 
 private String vencedor = "",labelVencedor = ""; 
 private int cliques=0; 
 /* Linha X Coluna */ 
 /* ColunaA ColunaB ColunaC 
 LinhaA AA AB AC 
 LinhaB BA BB BC 
 LinhaC CA CB CC 
16 
 
 */ 
 public void setVencedor (String vencedor) { 
 this.vencedor=vencedor; 
 if (this.vencedor!=""){ 
 this.labelVencedor="O \'"+this.vencedor+"\' ganhou!"; 
 } else { 
 cliques=0; 
 } 
 
 } 
 public int getCliques () { 
 return cliques; 
 } 
 public String getVencedor () { 
 return vencedor; 
 } 
 public String getLabelVencedor () {; 
 return labelVencedor; 
 } 
 private void aAToCC () { 
 int aAToCC=0,aAToCCiSX=0,aAToCCiSO=0; 
 for(int a = 0;a<3;a++) { 
 aAToCC=matrizJogoDaVelha[a][a]; 
 if (aAToCC==2) aAToCCiSX++; 
 if (aAToCC==1) aAToCCiSO++; 
 } 
 if (aAToCCiSX == 3) setVencedor ("X"); 
 if (aAToCCiSO == 3) setVencedor ("O"); 
 } 
 private void cAToAC () { 
 int cAToAC=0, cAToACiSX=0, cAToACiSO=0; 
 for(int a = 0;a<3;a++){ 
 cAToAC=matrizJogoDaVelha[2-a][a]; 
 if (cAToAC==2) cAToACiSX++; 
 if (cAToAC==1) cAToACiSO++; 
 } 
 if (cAToACiSX == 3) setVencedor ("X"); 
 if (cAToACiSO == 3) setVencedor ("O"); 
 } 
 private void verticais (int coluna) { 
 int verticais=0, verticaiSEX=0, verticaiSEO=0; 
 for(int a = 0;a<3;a++){ 
 verticais=matrizJogoDaVelha[a][coluna]; 
 if (verticais == 2) verticaiSEX++; 
 if (verticais == 1) verticaiSEO++; 
 } 
 if (verticaiSEX == 3) setVencedor ("X"); 
 if (verticaiSEO == 3) setVencedor ("O"); 
 } 
 private void horizontais (int linha) { 
 int horizontais=0, horizontaisEX=0, horizontaisEO=0; 
 for(int a = 0;a<3;a++){ 
 horizontais=matrizJogoDaVelha[linha][a]; 
 if (horizontais == 2) horizontaisEX++; 
 if (horizontais == 1) horizontaisEO++; 
 } 
 if (horizontaisEX == 3) setVencedor ("X"); 
 if (horizontaisEO == 3) setVencedor ("O"); 
 } 
 public void matrizJogoDaVelhaReset () { 
 this.matrizJogoDaVelha = new int[3][3]; 
 setVencedor(""); 
17 
 
 } 
 public void contarJogada () { 
 cliques++; 
 System.out.println("cliques : "+cliques); 
 if(vencedor=="" && cliques==9) { 
 this.labelVencedor="Deu velha!"; 
 cliques=0; 
 } else if (vencedor=="") { 
 this.labelVencedor="Que vença o melhor!"; 
 } 
 } 
 public void setLC (int l, int c, int lc) { 
 this.matrizJogoDaVelha[l][c]=lc; 
 horizontais(l); 
 verticais(c); 
 if(l==c)aAToCC(); 
 for (int a = 0;a<3;a++) { 
 if(l == 2-a && c == a) cAToAC(); 
 } 
 contarJogada (); 
 } 
 public int[][] getMatrizJogoDaVelha () { 
 return matrizJogoDaVelha; 
 } 
} 
 
 
5.3 Display 
package jogodavelha; 
 
import java.awt.Toolkit; 
import javax.swing.Icon; 
 
/** 
 * 
 * @author Usuário 
 */ 
public class Display extends javax.swing.JFrame { 
 
 /** 
 * Creates new form Display 
 */ 
 public Display() { 
 initComponents(); 
 setIcon(); 
 vezDoJogador(); 
 } 
 
 /** 
 * This method is called from within the constructor to initialize the form. 
 * WARNING: Do NOT modify this code. The content of this method is always 
 * regenerated by the Form Editor. 
 */ 
 @SuppressWarnings("unchecked") 
 // <editor-fold defaultstate="collapsed" desc="Generated Code"> 
 private void initComponents() { 
 
 reiniciar = new javax.swing.JButton(); 
18 
 
 botao1 = new javax.swing.JButton(); 
 botao5 = new javax.swing.JButton(); 
 botao4 = new javax.swing.JButton(); 
 botao2 = new javax.swing.JButton(); 
 botao9 = new javax.swing.JButton(); 
 botao3 = new javax.swing.JButton(); 
 botao7 = new javax.swing.JButton(); 
 botao8 = new javax.swing.JButton(); 
 botao6 = new javax.swing.JButton(); 
 vencedorLabel = new javax.swing.JLabel(); 
 vezDoJogador = new javax.swing.JLabel(); 
 
 setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); 
 setTitle("JogoDaVelhaBicho"); 
 setResizable(false); 
 
 reiniciar.setFont(new java.awt.Font("Segoe UI Light", 1, 24)); // NOI18N 
 reiniciar.setText("REINICIAR"); 
 reiniciar.addActionListener(new java.awt.event.ActionListener() { 
 public void actionPerformed(java.awt.event.ActionEvent evt) { 
 reiniciarActionPerformed(evt); 
 } 
 }); 
 
 botao1.setBackground(new java.awt.Color(255, 255, 255)); 
 botao1.setIcon(new javax.swing.ImageIcon(getClass().getResource("/jogodavelha/blank.png"))); 
// NOI18N 
 botao1.setFocusable(false); 
 botao1.addActionListener(new java.awt.event.ActionListener() { 
 public void actionPerformed(java.awt.event.ActionEvent evt) { 
 botao1ActionPerformed(evt); 
 } 
 }); 
 
 botao5.setBackground(new java.awt.Color(255, 255, 255)); 
 botao5.setIcon(new javax.swing.ImageIcon(getClass().getResource("/jogodavelha/blank.png"))); 
// NOI18N 
 botao5.setFocusable(false); 
 botao5.addActionListener(new java.awt.event.ActionListener() { 
 public void actionPerformed(java.awt.event.ActionEvent evt) { 
 botao5ActionPerformed(evt); 
 } 
 }); 
 
 botao4.setBackground(new java.awt.Color(255, 255, 255)); 
 botao4.setIcon(new javax.swing.ImageIcon(getClass().getResource("/jogodavelha/blank.png"))); 
// NOI18N 
 botao4.setFocusable(false); 
 botao4.addActionListener(new java.awt.event.ActionListener() { 
 public void actionPerformed(java.awt.event.ActionEvent evt) { 
 botao4ActionPerformed(evt); 
 } 
 }); 
 
 botao2.setBackground(new java.awt.Color(255, 255, 255)); 
 botao2.setIcon(new javax.swing.ImageIcon(getClass().getResource("/jogodavelha/blank.png"))); 
// NOI18N 
 botao2.setFocusable(false); 
 botao2.addActionListener(new java.awt.event.ActionListener() { 
 public void actionPerformed(java.awt.event.ActionEvent evt) { 
 botao2ActionPerformed(evt); 
 } 
19 
 
 }); 
 
 botao9.setBackground(new java.awt.Color(255, 255, 255)); 
 botao9.setIcon(new javax.swing.ImageIcon(getClass().getResource("/jogodavelha/blank.png"))); 
// NOI18N 
 botao9.setFocusable(false); 
 botao9.addActionListener(new java.awt.event.ActionListener() { 
 public void actionPerformed(java.awt.event.ActionEvent evt) { 
 botao9ActionPerformed(evt); 
 } 
 });botao3.setBackground(new java.awt.Color(255, 255, 255)); 
 botao3.setIcon(new javax.swing.ImageIcon(getClass().getResource("/jogodavelha/blank.png"))); 
// NOI18N 
 botao3.setFocusable(false); 
 botao3.addActionListener(new java.awt.event.ActionListener() { 
 public void actionPerformed(java.awt.event.ActionEvent evt) { 
 botao3ActionPerformed(evt); 
 } 
 }); 
 
 botao7.setBackground(new java.awt.Color(255, 255, 255)); 
 botao7.setIcon(new javax.swing.ImageIcon(getClass().getResource("/jogodavelha/blank.png"))); 
// NOI18N 
 botao7.setFocusable(false); 
 botao7.addActionListener(new java.awt.event.ActionListener() { 
 public void actionPerformed(java.awt.event.ActionEvent evt) { 
 botao7ActionPerformed(evt); 
 } 
 }); 
 
 botao8.setBackground(new java.awt.Color(255, 255, 255)); 
 botao8.setIcon(new javax.swing.ImageIcon(getClass().getResource("/jogodavelha/blank.png"))); 
// NOI18N 
 botao8.setFocusable(false); 
 botao8.addActionListener(new java.awt.event.ActionListener() { 
 public void actionPerformed(java.awt.event.ActionEvent evt) { 
 botao8ActionPerformed(evt); 
 } 
 }); 
 
 botao6.setBackground(new java.awt.Color(255, 255, 255)); 
 botao6.setIcon(new javax.swing.ImageIcon(getClass().getResource("/jogodavelha/blank.png"))); 
// NOI18N 
 botao6.setFocusable(false); 
 botao6.addActionListener(new java.awt.event.ActionListener() { 
 public void actionPerformed(java.awt.event.ActionEvent evt) { 
 botao6ActionPerformed(evt); 
 } 
 }); 
 
 vencedorLabel.setBackground(new java.awt.Color(255, 255, 255)); 
 vencedorLabel.setFont(new java.awt.Font("Arial", 2, 24)); // NOI18N 
 vencedorLabel.setForeground(new java.awt.Color(0, 83, 114)); 
 vencedorLabel.setText("Que comecem os jogos!"); 
 
 vezDoJogador.setFont(new java.awt.Font("Tahoma", 3, 18)); // NOI18N 
 vezDoJogador.setText(" Vez do jogador"); 
 
 javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); 
 getContentPane().setLayout(layout); 
20 
 
 layout.setHorizontalGroup( 
 layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 .addGroup(layout.createSequentialGroup() 
 .addComponent(botao1, javax.swing.GroupLayout.PREFERRED_SIZE, 0, 
Short.MAX_VALUE) 
 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addComponent(botao2, javax.swing.GroupLayout.PREFERRED_SIZE, 0, 
Short.MAX_VALUE) 
 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addComponent(botao3, javax.swing.GroupLayout.PREFERRED_SIZE, 0, 
Short.MAX_VALUE)) 
 .addComponent(vencedorLabel, javax.swing.GroupLayout.DEFAULT_SIZE, 
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) 
 .addGroup(layout.createSequentialGroup() 
 .addComponent(reiniciar, javax.swing.GroupLayout.PREFERRED_SIZE, 393, 
javax.swing.GroupLayout.PREFERRED_SIZE) 
 .addGap(0, 0, Short.MAX_VALUE)) 
 .addComponent(vezDoJogador, javax.swing.GroupLayout.DEFAULT_SIZE, 
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) 
 .addGroup(layout.createSequentialGroup() 
 .addComponent(botao7, javax.swing.GroupLayout.PREFERRED_SIZE, 0, 
Short.MAX_VALUE) 
 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addComponent(botao8, javax.swing.GroupLayout.PREFERRED_SIZE, 0, 
Short.MAX_VALUE) 
 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addComponent(botao9, javax.swing.GroupLayout.PREFERRED_SIZE, 0, 
Short.MAX_VALUE)) 
 .addGroup(layout.createSequentialGroup() 
 .addComponent(botao4, javax.swing.GroupLayout.PREFERRED_SIZE, 0, 
Short.MAX_VALUE) 
 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addComponent(botao5, javax.swing.GroupLayout.PREFERRED_SIZE, 0, 
Short.MAX_VALUE) 
 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addComponent(botao6, javax.swing.GroupLayout.PREFERRED_SIZE, 0, 
Short.MAX_VALUE)) 
 ); 
 layout.setVerticalGroup( 
 layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 .addGroup(layout.createSequentialGroup() 
 .addGap(0, 0, 0) 
 .addComponent(vencedorLabel, javax.swing.GroupLayout.PREFERRED_SIZE, 29, 
javax.swing.GroupLayout.PREFERRED_SIZE) 
 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addComponent(vezDoJogador, javax.swing.GroupLayout.PREFERRED_SIZE, 23, 
javax.swing.GroupLayout.PREFERRED_SIZE) 
 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 .addComponent(botao3, javax.swing.GroupLayout.DEFAULT_SIZE, 
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) 
 .addComponent(botao1, javax.swing.GroupLayout.Alignment.TRAILING, 
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, 
Short.MAX_VALUE) 
 .addComponent(botao2, javax.swing.GroupLayout.Alignment.TRAILING, 
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, 
Short.MAX_VALUE)) 
 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 .addComponent(botao5, javax.swing.GroupLayout.DEFAULT_SIZE, 
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) 
21 
 
 .addComponent(botao6, javax.swing.GroupLayout.DEFAULT_SIZE, 
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) 
 .addComponent(botao4, javax.swing.GroupLayout.DEFAULT_SIZE, 
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) 
 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 .addComponent(botao7, javax.swing.GroupLayout.Alignment.TRAILING, 
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, 
Short.MAX_VALUE) 
 .addComponent(botao8, javax.swing.GroupLayout.Alignment.TRAILING, 
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, 
Short.MAX_VALUE) 
 .addComponent(botao9, javax.swing.GroupLayout.Alignment.TRAILING, 
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, 
Short.MAX_VALUE)) 
 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addComponent(reiniciar, javax.swing.GroupLayout.DEFAULT_SIZE, 
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) 
 ); 
 
 pack(); 
 }// </editor-fold> 
 
 ControleDeEntrada inputJogoDaVelha = new ControleDeEntrada(); 
 
 private void recomecarJogo () { 
 Object reset = new javax.swing.ImageIcon(getClass().getResource("/jogodavelha/blank.png")); 
 botao1.setIcon((Icon) reset); 
 botao2.setIcon((Icon) reset); 
 botao3.setIcon((Icon) reset); 
 botao4.setIcon((Icon) reset); 
 botao5.setIcon((Icon) reset); 
 botao6.setIcon((Icon) reset); 
 botao7.setIcon((Icon) reset); 
 botao8.setIcon((Icon) reset); 
 botao9.setIcon((Icon) reset); 
 inputJogoDaVelha.matrizJogoDaVelhaReset(); 
 vencedorLabel.setText("Que os jogoscomeçem!"); 
 vezDoJogador(); 
 } 
 
 private void vezDoJogador () { 
 if(inputJogoDaVelha.getVencedor()!=""){ 
 vezDoJogador.setText("Vez do jogador \'"+inputJogoDaVelha.getAlternateValue()+"\' chorar!"); 
 } else { 
 vezDoJogador.setText("Vez do jogador \'"+inputJogoDaVelha.getAlternateValue()+"\'"); 
 } 
 } 
 
 private void reiniciarActionPerformed(java.awt.event.ActionEvent evt) { 
 // TODO add your handling code here: 
 recomecarJogo(); 
 } 
 
 private String clique (int l, int c) { 
 String icon = ""; 
 icon = inputJogoDaVelha.botaoClicado(l,c); 
 vencedorLabel.setText(inputJogoDaVelha.getLabelVencedor()); 
 vezDoJogador (); 
 return icon; 
 } 
 
22 
 
 private void botao9ActionPerformed(java.awt.event.ActionEvent evt) { 
 botao9.setIcon(new javax.swing.ImageIcon(getClass().getResource(clique(2,2)))); 
 } 
 
 private void botao1ActionPerformed(java.awt.event.ActionEvent evt) { 
 botao1.setIcon(new javax.swing.ImageIcon(getClass().getResource(clique(0,0)))); ; 
 } 
 
 private void botao2ActionPerformed(java.awt.event.ActionEvent evt) { 
 botao2.setIcon(new javax.swing.ImageIcon(getClass().getResource(clique(0,1)))); 
 } 
 
 private void botao3ActionPerformed(java.awt.event.ActionEvent evt) { 
 botao3.setIcon(new javax.swing.ImageIcon(getClass().getResource(clique(0,2)))); 
 } 
 
 private void botao4ActionPerformed(java.awt.event.ActionEvent evt) { 
 botao4.setIcon(new javax.swing.ImageIcon(getClass().getResource(clique(1,0)))); 
 } 
 
 private void botao5ActionPerformed(java.awt.event.ActionEvent evt) { 
 botao5.setIcon(new javax.swing.ImageIcon(getClass().getResource(clique(1,1)))); 
 } 
 
 private void botao6ActionPerformed(java.awt.event.ActionEvent evt) { 
 botao6.setIcon(new javax.swing.ImageIcon(getClass().getResource(clique(1,2)))); 
 } 
 
 private void botao7ActionPerformed(java.awt.event.ActionEvent evt) { 
 botao7.setIcon(new javax.swing.ImageIcon(getClass().getResource(clique(2,0)))); 
 } 
 
 private void botao8ActionPerformed(java.awt.event.ActionEvent evt) { 
 botao8.setIcon(new javax.swing.ImageIcon(getClass().getResource(clique(2,1)))); 
 } 
 
 private void setIcon () { 
 
this.setIconImage(Toolkit.getDefaultToolkit().getImage(getClass().getResource("/jogodavelha/icon.png
"))); 
 } 
 /** 
 * @param args the command line arguments 
 */ 
 public static void main(String args[]) { 
 /* Set the Nimbus look and feel */ 
 //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) "> 
 /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel. 
 * For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html 
 */ 
 try { 
 for (javax.swing.UIManager.LookAndFeelInfo info : 
javax.swing.UIManager.getInstalledLookAndFeels()) { 
 if ("Windows".equals(info.getName())) { 
 javax.swing.UIManager.setLookAndFeel(info.getClassName()); 
 break; 
 } 
 } 
 } catch (ClassNotFoundException ex) { 
 
java.util.logging.Logger.getLogger(Display.class.getName()).log(java.util.logging.Level.SEVERE, null, 
ex); 
23 
 
 } catch (InstantiationException ex) { 
 
java.util.logging.Logger.getLogger(Display.class.getName()).log(java.util.logging.Level.SEVERE, null, 
ex); 
 } catch (IllegalAccessException ex) { 
 
java.util.logging.Logger.getLogger(Display.class.getName()).log(java.util.logging.Level.SEVERE, null, 
ex); 
 } catch (javax.swing.UnsupportedLookAndFeelException ex) { 
 
java.util.logging.Logger.getLogger(Display.class.getName()).log(java.util.logging.Level.SEVERE, null, 
ex); 
 } 
 //</editor-fold> 
 
 /* Create and display the form */ 
 java.awt.EventQueue.invokeLater(new Runnable() { 
 public void run() { 
 new Display().setVisible(true); 
 
 } 
 }); 
 } 
 
 // Variables declaration - do not modify 
 private javax.swing.JButton botao1; 
 private javax.swing.JButton botao2; 
 private javax.swing.JButton botao3; 
 private javax.swing.JButton botao4; 
 private javax.swing.JButton botao5; 
 private javax.swing.JButton botao6; 
 private javax.swing.JButton botao7; 
 private javax.swing.JButton botao8; 
 private javax.swing.JButton botao9; 
 private javax.swing.JButton reiniciar; 
 private javax.swing.JLabel vencedorLabel; 
 private javax.swing.JLabel vezDoJogador; 
 // End of variables declaration 
} 
 
24 
 
 
6 BIBLIOGRAFIA 
 
Livros: 
Php Programação com Orientação a Objetos – 3ª Edição 
Revista mensal, Espaço da Acadêmico, Nº 171 de agosto de de 2015, acesso dia 05 
de junho de 2018 
Sites: 
http://renepegoraro.tripod.com/ADAII/Aula9.pdf 
https://www.infoescola.com/matematica/matrizes/ Matrizes, acesso dia 04 de junho 
de 2018 
Trabalhos: 
Programação Orientada a Objetos: Uma abordagem com Java 
https://s3.amazonaws.com/academia.edu.documents/34585921/poojava.pdf?AWSAc
cessKeyId=AKIAIWOWYYGZ2Y53UL3A&Expires=1527964983&Signature=jd6pVtC
AH%2BrPalM034a0IiE0jQA%3D&response-content-
disposition=inline%3B%20filename%3DPoojava.pdf Ivan Luiz Marques 
Conceitos básicos de programação orientada a objeto 
https://s3.amazonaws.com/academia.edu.documents/38693459/Apostila_Java_B.pdf
?AWSAccessKeyId=AKIAIWOWYYGZ2Y53UL3A&Expires=1527965304&Signature=
L61l7MGrEJV%2F4K%2B620MdS%2BPSLy8%3D&response-content-
disposition=inline%3B%20filename%3DSubClasse_Roedores_SubClasse_Caes_Su
bCla.pdf Fernanda Farinelli 
 
 
 
 
 
 
 
 
 
 
 
 
http://renepegoraro.tripod.com/ADAII/Aula9.pdf
https://www.infoescola.com/matematica/matrizes/
https://s3.amazonaws.com/academia.edu.documents/34585921/poojava.pdf?AWSAccessKeyId=AKIAIWOWYYGZ2Y53UL3A&Expires=1527964983&Signature=jd6pVtCAH%2BrPalM034a0IiE0jQA%3D&response-content-disposition=inline%3B%20filename%3DPoojava.pdf
https://s3.amazonaws.com/academia.edu.documents/34585921/poojava.pdf?AWSAccessKeyId=AKIAIWOWYYGZ2Y53UL3A&Expires=1527964983&Signature=jd6pVtCAH%2BrPalM034a0IiE0jQA%3D&response-content-disposition=inline%3B%20filename%3DPoojava.pdf
https://s3.amazonaws.com/academia.edu.documents/34585921/poojava.pdf?AWSAccessKeyId=AKIAIWOWYYGZ2Y53UL3A&Expires=1527964983&Signature=jd6pVtCAH%2BrPalM034a0IiE0jQA%3D&response-content-disposition=inline%3B%20filename%3DPoojava.pdf
https://s3.amazonaws.com/academia.edu.documents/34585921/poojava.pdf?AWSAccessKeyId=AKIAIWOWYYGZ2Y53UL3A&Expires=1527964983&Signature=jd6pVtCAH%2BrPalM034a0IiE0jQA%3D&response-content-disposition=inline%3B%20filename%3DPoojava.pdf
https://s3.amazonaws.com/academia.edu.documents/38693459/Apostila_Java_B.pdf?AWSAccessKeyId=AKIAIWOWYYGZ2Y53UL3A&Expires=1527965304&Signature=L61l7MGrEJV%2F4K%2B620MdS%2BPSLy8%3D&response-content-disposition=inline%3B%20filename%3DSubClasse_Roedores_SubClasse_Caes_SubCla.pdfhttps://s3.amazonaws.com/academia.edu.documents/38693459/Apostila_Java_B.pdf?AWSAccessKeyId=AKIAIWOWYYGZ2Y53UL3A&Expires=1527965304&Signature=L61l7MGrEJV%2F4K%2B620MdS%2BPSLy8%3D&response-content-disposition=inline%3B%20filename%3DSubClasse_Roedores_SubClasse_Caes_SubCla.pdf
https://s3.amazonaws.com/academia.edu.documents/38693459/Apostila_Java_B.pdf?AWSAccessKeyId=AKIAIWOWYYGZ2Y53UL3A&Expires=1527965304&Signature=L61l7MGrEJV%2F4K%2B620MdS%2BPSLy8%3D&response-content-disposition=inline%3B%20filename%3DSubClasse_Roedores_SubClasse_Caes_SubCla.pdf
https://s3.amazonaws.com/academia.edu.documents/38693459/Apostila_Java_B.pdf?AWSAccessKeyId=AKIAIWOWYYGZ2Y53UL3A&Expires=1527965304&Signature=L61l7MGrEJV%2F4K%2B620MdS%2BPSLy8%3D&response-content-disposition=inline%3B%20filename%3DSubClasse_Roedores_SubClasse_Caes_SubCla.pdf
https://s3.amazonaws.com/academia.edu.documents/38693459/Apostila_Java_B.pdf?AWSAccessKeyId=AKIAIWOWYYGZ2Y53UL3A&Expires=1527965304&Signature=L61l7MGrEJV%2F4K%2B620MdS%2BPSLy8%3D&response-content-disposition=inline%3B%20filename%3DSubClasse_Roedores_SubClasse_Caes_SubCla.pdf
25 
 
7 FICHAS DE ATIVIDADES PRÁTICAS SUPERVISIONADAS 
 
 
 
 
26