Ajude nosso projeto a se manter em funcionamento, faça um PIX de qualquer valor: 029 278 923 85

Código comentado sobre como criar um Jogo da Velha em Java

No tutorial passado mostramos um print do Jogo da Velha em Java, modo texto e Humano x Humano, bem como o código de 6 classes necessárias para rodar o programa:
Jogo da Velha em Java

Agora vamos comentar, em detalhes, cada classe, método e idéia que usamos para criar o jogo.

Classe JogoDaVelha.java

Bom, essa é a classe que possui o método main. Ou seja, a partir daí a aplicação se inicia.

Note como essa classe e o método está bem enxuto.
É uma boa prática fazer isso: só use a main() pra iniciar sua aplicação, tente ao máximo não encher ela de variáveis, métodos e outras coisas.

Bom, nessa classe apenas iniciamos o jogo, criando um objeto 'jogo' da Classe "Jogo".
Para saber mais, vá para a classe "Jogo" !


Classe Tabuleiro.java

Essa é uma classe bem simples e útil, que ficará encarregada de criar o tabuleiro, desenhá-lo na tela bem como fazer as checagens, para saber se uma linha, coluna ou diagonal foi preenchida por um dos jogadores.

A classe inicia criando uma Matriz 3x3 de inteiros, a matriz 'tabuleiro' que é nosso tabuleiro.
A seguir, o construtor padrão invoca o método "zeraTabuleiro()", que como o nome já diz, faz todos os inteiros da matriz 'tabuleiro' receberem o valor 0.

O código seguinte será invocado várias vezes durante o jogo, é o método que exibe a matriz na tela, o 'exibeTabuleiro()'.
Ele vai percorrer todos os elementos da tela, caso encontre -1, ele imprime um 'X', caso encontre 1 ele imprime o 'O', e caso encontre o número 0 ele não imprime nada (campo vazio no tabuleiro).

Caso nenhuma fila esteja completa, ou seja, caso ninguém tenha ganhado, o método ganhou() retorna 0 e podemos continuar no nosso método "Jogar()".

Os métodos seguintes, getPosicao() e setPosicao() são auto-explicativos. O getter retorna que número (-1, 0, 1) está em determinada posição, e o setter altera um local do tabuleiro para -1 ou 1, conforme o jogador seja X ou O. As posições são sempre representadas por um vetor chamado 'tentativa[2]', onde 'tentativa[0]' representa a linha e 'tentativa[1]' representa a coluna.

Os próximos métodos fazem a checagem de todas as linhas (checaLinhas()), colunas (checaColunas()) e das duas diagonais (checaDiagonais()).

Se alguma linha, coluna ou diagonal estiver cheia e marcadas com 'X', então a soma dos elementos dessa fila será -3 (-1 + -1 + -1 = -3), e o método retorna -1, sinalizando que o jogador 1 ganhou.
Se alguma linha, coluna ou diagonal estiver cheia e marcadas com 'O', então a soma dos elementos dessa fila será 3 (1 + 1 + 1 = 3), e o método retorna 1, sinalizando que o jogador 2 ganhou.

O último método, o 'tabuleiroCompleto()', checa todos os elementos da matriz, caso encontre um número 0, retorna false. Isso indica que a matriz não está totalmente preenchida.
Caso não encontre um número 0 sequer, é porque todos são 1 ou -1. Ou seja, o tabuleiro está completo, retornamos true e o jogo deu empatado.



Classe Jogo.java

Essa classe vai criar, através de variáveis:
um tabuleiro:
private Tabuleiro tabuleiro;

Números que irão controlar o número da rodada e de quem é a vez de jogar:
private int rodada=1, vez=1;

Dois jogadores:
private Jogador jogador1;
private Jogador jogador2;

E um objeto da classe Scanner para receber dados dos jogadores Humanos.


Sempre que criamos um objeto de uma classe, seu construtor padrão roda. No caso, é o "Jogo()".
Ele vai iniciar o tabuleiro:
tabuleiro = new Tabuleiro();
(Vá para a classe Tabuleiro e leia como ela funcione. Depois volte)

Em seguida, vai iniciar os jogadores, pra saber quem vai ser o primeiro, segundo e quem vai ser humano ou computador (escolha, por hora, humanos).

A seguir, vamos rodar o jogo a partir do comando:
while( Jogar() );

O método "Jogar()" é que vai controlar todo o jogo. Ele retorna um booleano.
Se o jogo ainda não tiver terminado, ele retorna 'true', então o laço while irá sempre rodar.

Quando o jogo terminar, alguém ganhando ou dando empate, o método "Jogar()" retornará 'false', o while não irá mais continuar e o construtor termina, terminando a criação do objeto e, conseqüentemente, o jogo.
Lembre-se: nossa main() apenas cria um objeto. Como o objeto foi criado, a aplicação terminou.





Classe Jogador.java

Nessa classe, colocamos em prática nossos conhecimentos de abstração e polimorfismo.

Há dois tipos de jogadores, o humano e o computador.
Portanto, seus métodos de jogar são diferentes. Por isso ela será abstrata, já que terá os métodos abstratos 'jogar()' e 'Tentativa()', já que a estratégia é diferente para cada tipo de jogador, e o computador não fará tentativas que não possa.

Nessa classe definimos o vetor de inteiros 'tentativa[2]', onde tentativa[0] armazenará a linha e tentativa[1] a posição da coluna de onde o jogador tentará marcar seu X ou O.

O método 'jogar()' recebe o atual tabuleiro, assim como o método 'Tentativa()' que também recebe as posições (linha, coluna) que o jogador vai tentar marcar seu X ou O.

O método 'checaTentativa()' vai se certificar que na posição que o Jogador irá marcar no tabuleiro está realmente vazio, ou seja, se aquela posição tem realmente o número 0.
Em breve, vamos criar o jogador Computador nível Easy, que vai jogar simplesmente marcando o tabuleiro aleatoriamente, por isso iremos usar o método 'checaTentativa()' para o computador também (por isso não é abstrato, vai servir tanto pra Humano como pra Computador).


Classe Humano.java

Ela herda a classe abstrata "Jogador".

Cada objeto criado recebe um número, 1 ou 2, que vai caracterizar como jogador 1 ou jogador 2, para as pessoas saberem de quem é a vez de jogar.

A seguir, vamos fazer o Override do método 'jogar()', personalizado para jogadores humanos.
Primeiro, chamamos o método 'Tentativa()', que vai pedir a linha e a coluna, vai checar se esses números são válidos (são 1, 2 ou 3) e vai fazer a alteração da matriz que vemos, pra matriz real do jogo.
Pois como jogador, vemos as linhas e colunas 1, 2 e 3. Porém, ao criamos a matriz tabuleiro[3][3], trabalhamos com linhas e colunas de números 0, 1 e 2.

Assim, se o jogador digitar linha 2 e coluna 3, subtraímos uma unidade de cada e mandamos 'linha 1 e coluna 2' pro Java.
Quando formos implementar o jogo do computador, isso não será necessário, usaremos direto as linhas e colunas 0, 1 e 2.
Essas alterações são apenas para lidas com os humanos.

Então, quando o jogador humano colocar uma dado correto, marcamos o 'X' ou o 'O' no tabuleiro através do método 'setPosicao()', do objeto 'tabuleiro' da classe "Tabuleiro".

Essas informações (tabuleiro e tentativas[2]) são necessárias pro método 'checaTentativa()' saber se na posição desejada já não existe algum X ou 0, além de se certificar que o usuário humano não vai colocar um número maior que 3 ou menor que 1.


Classe Computador.java

Ela herda a classe abstrata "Jogador", e nesse tutorial ela não faz nada.
Iremos implementar ela em um próximo tutorial, onde você irá aprender sobre inteligência artificial e poderá, finalmente, brincar com o computador através de uma aplicação que você mesmo fez.

5 comentários:

mano489 disse...

cara vc sõ muito bons

Anônimo disse...

Rapas isso foi um shou

Unknown disse...

hardddd

Professor Edson Barbosa disse...

OLá tudo bem! Parabéns pelo projeto, assim ajudam nós iniciantes! Seguinte estou com um erro no jog, tudo funcionou de boa, mas não marca na tela as jogadas do computador ou do Jogador 1... fica só marcando o que eu seleciono pra jogar...edson.jose.barbosa@gmail.com

Professor Edson Barbosa disse...

O jogo da Velha funcioneou bem, mas não mostra as jogadas do outro jogador...

Tutoriais de Java

Como Ganhar na Loteria