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

• Baixar a Apostila Java Progressivo

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.