Jogo da velha com POO

public boolean verificaVitoria(String sinal) {
if ((posicoes[0][0] == sinal && posicoes[0][1] == sinal && posicoes[0][2] == sinal) || //linha 1
(posicoes[1][0] == sinal && posicoes[1][1] == sinal && posicoes[1][2] == sinal) || //linha 2
(posicoes[2][0] == sinal && posicoes[2][1] == sinal && posicoes[2][2] == sinal) || //linha 3
(posicoes[0][0] == sinal && posicoes[1][0] == sinal && posicoes[2][0] == sinal) || //coluna 1
(posicoes[0][1] == sinal && posicoes[1][1] == sinal && posicoes[2][1] == sinal) || //coluna 2
(posicoes[0][2] == sinal && posicoes[1][2] == sinal && posicoes[2][2] == sinal) || //coluna 3
(posicoes[0][0] == sinal && posicoes[1][1] == sinal && posicoes[2][2] == sinal) || //diagonal
(posicoes[0][2] == sinal && posicoes[1][1] == sinal && posicoes[2][0] == sinal)) { //diagonal inversa
return true;
}
return false;
}

@Staroski, pronto fiz com todas possibilidades.

JogoDaVelha.java:19: error: ‘void’ type not allowed here
jogador1.jogada(tabuleiro,menu.lerLinha(), menu.lerColun
a());
^
JogoDaVelha.java:19: error: ‘void’ type not allowed here
jogador1.jogada(tabuleiro,menu.lerLinha(), menu.lerColun
a());

^
JogoDaVelha.java:30: error: method jogada in class Jogador cannot be applied to
given types;
jogador2.jogada(tabuleiro);
^
required: Tabuleiro,int,int
found: Tabuleiro
reason: actual and formal argument lists differ in length
.\Jogador.java:15: error: cannot find symbol
if (posições[linha][coluna] == sinal || posições[linha][coluna]
== ‘O’) {
^
symbol: variable posições
location: class Jogador
.\Jogador.java:15: error: cannot find symbol
if (posições[linha][coluna] == sinal || posições[linha][coluna]
== ‘O’) {
^
symbol: variable sinal
location: class Jogador
.\Jogador.java:15: error: cannot find symbol
if (posições[linha][coluna] == sinal || posições[linha][coluna]
== ‘O’) {
^
symbol: variable posições
location: class Jogador
.\Jogador.java:16: error: incompatible types: unexpected return value
return false;
^
.\Jogador.java:19: error: cannot find symbol
posições[linha][coluna] = sinal;
^
symbol: variable posições
location: class Jogador
.\Jogador.java:19: error: cannot find symbol
posições[linha][coluna] = sinal;
^
symbol: variable sinal
location: class Jogador
.\Jogador.java:20: error: cannot find symbol
jogada++;
^
symbol: variable jogada
location: class Jogador
.\Jogador.java:21: error: incompatible types: unexpected return value
return true;
^
11 errors

O que eu preciso arrumar no Jogador.java?

public class Jogador{
private int qtd, id, id_jogador;
public int linha=0, coluna=0;

//Construtor
public Jogador(int id_jogador){
	this.id_jogador = id_jogador; 
}
public int getid(){
	return this.id;
}
public void jogada(Tabuleiro tabuleiro, int linha, int coluna){
	this.linha = linha;
	this.coluna = coluna;		
	 if (posicoes[linha][coluna] == sinal || posicoes[linha][coluna] == 'O') {
        return false;

   	 } 	else { //jogada válida
       	 posicoes[linha][coluna] = sinal;
        	jogada++;
       	 return true;
    	}
  	}
}

Fiz alterações!

Tabuleiro

public class Tabuleiro {
public String[][] matriz;
public String[][] posicoes;

    public Tabuleiro() {
        posicoes = new String[3][3];
        for (int i = 0; i < posicoes.length; i++) {
            for (int j = 0; j < posicoes[i].length; j++) {
                posicoes[i][j] = "";
            }
        }
    }

    public String getPosicao(int linha, int coluna) {
        return posicoes[linha][coluna];
    }

    public String getPosicoes(int a, int b){
        return matriz[a][b];
    }

    public void setPosicao(int linha, int coluna, String valor) {
        posicoes[linha][coluna] = valor;
    }
    public boolean verificaVitoria(String sinal) {
        if ((posicoes[0][0] == sinal && posicoes[0][1] == sinal && posicoes[0][2] == sinal) || //linha 1
                (posicoes[1][0] == sinal && posicoes[1][1] == sinal && posicoes[1][2] == sinal) || //linha 2
                (posicoes[2][0] == sinal && posicoes[2][1] == sinal && posicoes[2][2] == sinal) || //linha 3
                (posicoes[0][0] == sinal && posicoes[1][0] == sinal && posicoes[2][0] == sinal) || //coluna 1
                (posicoes[0][1] == sinal && posicoes[1][1] == sinal && posicoes[2][1] == sinal) || //coluna 2
                (posicoes[0][2] == sinal && posicoes[1][2] == sinal && posicoes[2][2] == sinal) || //coluna 3
                (posicoes[0][0] == sinal && posicoes[1][1] == sinal && posicoes[2][2] == sinal) || //diagonal
                (posicoes[0][2] == sinal && posicoes[1][1] == sinal && posicoes[2][0] == sinal)) {  //diagonal inversa
            return true;
        }
        return false;
	}
}

Jogador
public class Jogador{
private int qtd, id, id_jogador;
public int linha=0, coluna=0;

	//Construtor
	public Jogador(int id_jogador){
		this.id_jogador = id_jogador; 
	}
	public int getid(){
		return this.id;
	}
	public void jogada(Tabuleiro tabuleiro, int linha, int coluna){
		this.linha = linha;
		this.coluna = coluna;		
		 if (posicoes[linha][coluna] == sinal || posicoes[linha][coluna] == 'O') {
            return false;

       	 } 	else { //jogada válida
           	 posicoes[linha][coluna] = sinal;
            	jogada++;
           	 return true;
        	}
	  	}
	  	public void jogada(Tabuleiro tabuleiro){
	  		System.out.println(tabuleiro);
	  		menu.lerLinha();
	  		menu.lerColuna();
	  	}
	  		public void jogada(Tabuleiro tabuleiro){	
		 if (id ==1)
		 	tabuleiro.setPosicao(linha, coluna, "X");
		 else
            tabuleiro.setPosicao(linha, coluna, "O");

      		  	}
	}

Menu

import java.util.Scanner;
public class Menu{
	private Scanner sc = new Scanner (System.in);
	private int linha=0, coluna=0;
	public Menu(){
	}
	public void imprimeTabuleiro(int oi, int ola, Tabuleiro tabuleiro){
		 String[][] matriz = tabuleiro.getPosicoes();

		 for (int a = 0; a < matriz.length; a++) {
            for (int b = 0; b < matriz[0].length; b++) {
                System.out.print(matriz[a][b] + " | ");
            }
            System.out.println();
        }
    }
	public int lerLinha(){
		System.out.println("Digite a linha: ");
		this.linha = sc.nextInt();
		return linha;
	
	}
	public int lerColuna(){
		
		System.out.println("Digite a coluna: ");
		this.coluna = sc.nextInt();
			return coluna;
		}
	}

Main

public class JogoDaVelha {
	public static void main(String[] args) {
		Menu menu = new Menu();
		Tabuleiro tabuleiro = new Tabuleiro();
		int linha, coluna, contador=0;
		Jogador jogador1;
		Jogador jogador2;
		boolean vitoriaX=false, vitoriaO=false;

    	//Identifica o jogador 1 como humano ( usando id 1 )
		jogador1 = new Jogador(1);
		jogador2 = new Jogador(2);

		//Impressão inicial para começar o jogo
		menu.imprimeTabuleiro(tabuleiro);

		do{
			//Faz a jogada do primeiro jogador, considerando o método para usuário humano
			jogador1.jogada(tabuleiro,menu.lerLinha(), menu.lerColuna());
			//contabiliza a jogada com sucesso, visto que os métodos já garantem que a jogada sempre acontecerá com sucesso
			contador++;
			//Imprime o tabuleiro para o usuário ver a situação atual
			menu.imprimeTabuleiro(tabuleiro);
			//Verifica se alguém venceu
			vitoriaX = tabuleiro.verificaVitoria("X");
			vitoriaO = tabuleiro.verificaVitoria("O");
			//Caso ngm tenha vencido ainda e não tenha acabado as jogadas, o segundo jogador joga.
			if(vitoriaX == false && vitoriaO == false && contador < 9){
				//Faz a jogada do primeiro jogador, considerando o método para usuário computador
				jogador2.jogada(tabuleiro);
				//contabiliza a jogada com sucesso, visto que os métodos já garantem que a jogada sempre acontecerá com sucesso
				contador++;
				//Imprime o tabuleiro para o usuário ver a situação atual
				menu.imprimeTabuleiro(tabuleiro);	
				//Verifica se alguém venceu		
				vitoriaX = tabuleiro.verificaVitoria("X");
				vitoriaO = tabuleiro.verificaVitoria("O");
			}
			//Repete a estrutura enquanto ngm vencer e houver jogadas disponíveis.
		}while(vitoriaX == false && vitoriaO == false && contador < 9);

		//Verifica se o jogador 1 ganhou
		if (vitoriaX) {
			System.out.println("Vitória do jogador X");
		}else{
			//Verifica se o jogador 2 ganhou
			if (vitoriaO) {
				System.out.println("Vitória do jogador O");
			}else{
				//Verifica se deu velha
				System.out.println("Deu velha!");
			}
		}
	}
}

Agora, dá os seguintes erros:

.\Jogador.java:29: error: method jogada(Tabuleiro) is already defined in class J
ogador
                        public void jogada(Tabuleiro tabuleiro){
                                    ^
JogoDaVelha.java:15: error: method imprimeTabuleiro in class Menu cannot be appl
ied to given types;
                menu.imprimeTabuleiro(tabuleiro);
                    ^
  required: int,int,Tabuleiro
  found: Tabuleiro
  reason: actual and formal argument lists differ in length
JogoDaVelha.java:23: error: method imprimeTabuleiro in class Menu cannot be appl
ied to given types;
                        menu.imprimeTabuleiro(tabuleiro);
                            ^
  required: int,int,Tabuleiro
  found: Tabuleiro
  reason: actual and formal argument lists differ in length
JogoDaVelha.java:34: error: method imprimeTabuleiro in class Menu cannot be appl
ied to given types;
                                menu.imprimeTabuleiro(tabuleiro);
                                    ^
  required: int,int,Tabuleiro
  found: Tabuleiro
  reason: actual and formal argument lists differ in length
.\Menu.java:8: error: method getPosicoes in class Tabuleiro cannot be applied to
 given types;
                 String[][] matriz = tabuleiro.getPosicoes();
                                              ^
  required: int,int
  found: no arguments
  reason: actual and formal argument lists differ in length
.\Jogador.java:15: error: cannot find symbol
                 if (posicoes[linha][coluna] == sinal || posicoes[linha][coluna]
 == 'O') {
                     ^
  symbol:   variable posicoes
  location: class Jogador
.\Jogador.java:15: error: cannot find symbol
                 if (posicoes[linha][coluna] == sinal || posicoes[linha][coluna]
 == 'O') {
                                                ^
  symbol:   variable sinal
  location: class Jogador
.\Jogador.java:15: error: cannot find symbol
                 if (posicoes[linha][coluna] == sinal || posicoes[linha][coluna]
 == 'O') {
                                                         ^
  symbol:   variable posicoes
  location: class Jogador
.\Jogador.java:16: error: incompatible types: unexpected return value
            return false;
                   ^
.\Jogador.java:19: error: cannot find symbol
                 posicoes[linha][coluna] = sinal;
                 ^
  symbol:   variable posicoes
  location: class Jogador
.\Jogador.java:19: error: cannot find symbol
                 posicoes[linha][coluna] = sinal;
                                           ^
  symbol:   variable sinal
  location: class Jogador
.\Jogador.java:20: error: cannot find symbol
                jogada++;
                ^
  symbol:   variable jogada
  location: class Jogador
.\Jogador.java:21: error: incompatible types: unexpected return value
                 return true;
                        ^
.\Jogador.java:26: error: cannot find symbol
                        menu.lerLinha();
                        ^
  symbol:   variable menu
  location: class Jogador
.\Jogador.java:27: error: cannot find symbol
                        menu.lerColuna();
                        ^
  symbol:   variable menu
  location: class Jogador
15 errors

Por favor, use o botão de texto pré-formatado quando postar código aqui no fórum, ele é identificado pelo seguinte símbolo: </>

Sobre os erros, tenho certeza que se você traduzir as mensagens de erro, vai te dar uma luz.para identificar o problemas.
Pelo menos tente. :wink:

Eu formatei o tópico todinho. Por exemplo no erro: cannot find symbol:
variable menu
não existe uma variavel, mas eu n preciso criar pq é um método (menu.java);

incompatible types: unexpected return value, se eu apagar vai funcionar, mas não é isso que eu desejo, tem que me retornar se é vdd ou no.

jogada++, já tem um método jogada mas ta pedindo variável?

Então na declaração do método você tem que trocar o void pelo tipo de dado que o método vai retornar.

Então, os métodos lerLinha e lerColuna estão declarados na classe Menu.
Você está criando um objeto do tipo Menu no seu método main, mas a classe Jogador não tem nenhuma variável menu que aponte pra esse objeto:

public void jogada(Tabuleiro tabuleiro){
    System.out.println(tabuleiro);
    menu.lerLinha();  // não há nenhum objeto menu nesta classe
    menu.lerColuna(); // não há nenhum objeto menu nesta classe
}

Não, você declarou dois métodos jogada na classe Jogador, provavelmente não percebeu pois não está indentado corretamente:

// aqui tem um método chamado jogada
public void jogada(Tabuleiro tabuleiro){
          System.out.println(tabuleiro);
          menu.lerLinha();
          menu.lerColuna();
      }   // aqui tem outro método chamado jogada
          public void jogada(Tabuleiro tabuleiro){    
     if (id ==1)
         tabuleiro.setPosicao(linha, coluna, "X");
     else
        tabuleiro.setPosicao(linha, coluna, "O");

                }

Se indentar direitinho, fica fácil de ver, olha só:

// aqui tem um método chamado jogada
public void jogada(Tabuleiro tabuleiro){
    System.out.println(tabuleiro);
    menu.lerLinha();
    menu.lerColuna();
}

// aqui tem outro método chamado jogada
public void jogada(Tabuleiro tabuleiro){    
    if (id == 1)
        tabuleiro.setPosicao(linha, coluna, "X");
    else
        tabuleiro.setPosicao(linha, coluna, "O");
}

Eu preciso dos dois métodos jogada, em um eu posso passar os parametros int linha e int coluna que resolve?

Porque precisa de dois métodos jogada?
O que muda de um pro outro?

Não sei, se vc olhar o UML tem 2 jogada, um que passa 2int e tabuleiro, e outro só tabuleiro.

Criei a variável sinal, e agora tenho erros apenas na classe Jogador.

Jogador.java:17: error: cannot find symbol
                        tabuleiro.setPosicao(linha, coluna, "X");
                                             ^
  symbol:   variable linha
  location: class Jogador
Jogador.java:17: error: cannot find symbol
                        tabuleiro.setPosicao(linha, coluna, "X");
                                                    ^
  symbol:   variable coluna
  location: class Jogador
Jogador.java:19: error: cannot find symbol
            tabuleiro.setPosicao(linha, coluna, "O");
                                 ^
  symbol:   variable linha
  location: class Jogador
Jogador.java:19: error: cannot find symbol
            tabuleiro.setPosicao(linha, coluna, "O");
                                        ^
  symbol:   variable coluna
  location: class Jogador
Jogador.java:24: error: cannot find symbol
                 if (posicoes[linha][coluna] == sinal || posicoes[linha][coluna]
 == 'O') {
                     ^
  symbol:   variable posicoes
  location: class Jogador
Jogador.java:24: error: cannot find symbol
                 if (posicoes[linha][coluna] == sinal || posicoes[linha][coluna]
 == 'O') {
                                                         ^
  symbol:   variable posicoes
  location: class Jogador
Jogador.java:27: error: cannot find symbol
                 posicoes[linha][coluna] = sinal;
                 ^
  symbol:   variable posicoes
  location: class Jogador
Jogador.java:28: error: cannot find symbol
                jogada++;
                ^
  symbol:   variable jogada
  location: class Jogador
8 errors

Não consigo entender pq ele não acha o posicoes, sendo que tá declarado em tabuleiro…

Por quê tu não programas utilizando uma IDE como o NetBeans? Acho que é bom compilar por linha de comando quando o código é básico mas, como esse código já parece ser um pouco mais complexo, me parece já ser recomendável utilizar-se uma IDE.

Então você tem que perguntar para quem fez essa modelagem ou ler a documentação que explica o que cada método deve fazer.

Essa mensagem de erro pode ser traduzida como:

Erro na linha número 17 do arquivo Jogador.java
Símbolo não encontrado: variável linha

1 curtida

Eu não uso para não ficar mal acostumado, aprender lidar com erros… e na hora da prova se faz tudo no sublime!

Staroski, consegui finalizar o código, mas to com um problema: quando roda só aparece o X, por exemplo: digite linha e coluna, ai tá digita, aí proximo: linha e coluna, e aparece sempre o X!

public class Jogador {

    private int qtd, id; // o atributo qtd ainda não está em uso

    public Jogador(int id_jogador) {
        this.id = id_jogador;
    }

    public int getid() {
        return this.id;
    }
    // Em um desses métodos aqui teria que validar se a posição da jogada está vazia
    public void jogada(Tabuleiro tabuleiro, int linha, int coluna) {

        if (id == 1) {
            tabuleiro.setPosicao(linha, coluna, "X");
        } else {
            tabuleiro.setPosicao(linha, coluna, "O");
        }
    }

    public void jogada(Tabuleiro tabuleiro) {
        // esse método ainda não está ajustado
    }
}

O que eu preciso melhorar aqui para funcionar perfeitamente?

Segue resultado do cmd:

Digite a linha:
1
Digite a coluna:

0

X
X

Digite a linha:
2
Digite a coluna:
1

X
X
X
X

Digite a linha:
1
Digite a coluna:
0

X
X
X
X

Não sei como está seu código mas, considerando que num jogo da velha há 2 jogadores, provavelmente está esquecendo de alternar entre eles.

public class Jogador {

    private int qtd, id; // o atributo qtd ainda não está em uso

    public Jogador(int id_jogador) {
        this.id = id_jogador;
    }

    public int getid() {
        return this.id;
    }
    // Em um desses métodos aqui teria que validar se a posição da jogada está vazia
    public void jogada(Tabuleiro tabuleiro, int linha, int coluna) {

        if (id == 1) {
            tabuleiro.setPosicao(linha, coluna, "X");
        } else {
            tabuleiro.setPosicao(linha, coluna, "O");
        }
    }

    public void jogada(Tabuleiro tabuleiro) {
        // esse método ainda não está ajustado
    }
}

Só alterei o jogador.

Alguma luz?

Sua lógica na classe JogoDaVelha estava furada, você só chamava o método jogada do jogador humano.

public class JogoDaVelha {

    public static void main(String[] args) {
        Menu menu = new Menu();
        Tabuleiro tabuleiro = new Tabuleiro();

        // Identifica o jogador 1 como humano ( usando id 1 )
        Jogador jogador1 = new Jogador(1);
        Jogador jogador2 = new Jogador(2);

        // Impressão inicial para começar o jogo
        menu.imprimeTabuleiro(tabuleiro);

        // começa com o jogador humano
        Jogador jogador = jogador1;

        boolean acabou = false;
        do {
            if (jogador.getId() == 1) {
                // Faz a jogada do considerando o método para usuário humano
                jogador.jogada(tabuleiro, menu.lerLinha(), menu.lerColuna());
            } else {
                // Faz a jogada do considerando o método para computador
                jogador.jogada(tabuleiro);
            }

            // troca de jogador
            if (jogador == jogador1) {
                jogador = jogador2;
            } else {
                jogador = jogador1;
            }

            // Imprime o tabuleiro para o usuário ver a situação atual
            menu.imprimeTabuleiro(tabuleiro);

            // Verifica se alguém venceu
            if (tabuleiro.verificaVitoria("X")) {
                System.out.println("Vitória do jogador X");
                acabou = true;
            } else if (tabuleiro.verificaVitoria("O")) {
                System.out.println("Vitória do jogador O");
                acabou = true;
            } else if ((jogador1.getQtd() + jogador2.getQtd()) == 9) {
                System.out.println("Deu velha!");
                acabou = true;
            }
        } while (!acabou);
    }
}

Classe Menu:

import java.util.Scanner;

public class Menu {

    private Scanner teclado = new Scanner(System.in);

    public Menu() {}

    public void imprimeTabuleiro(Tabuleiro tabuleiro) {
        for (int linha = 0; linha < 3; linha++) {
            for (int coluna = 0; coluna < 3; coluna++) {
                System.out.print(tabuleiro.getPosicao(linha, coluna) + " | ");
            }
            System.out.println();
        }
    }

    public int lerColuna() {
        System.out.println("Digite a coluna: ");
        int coluna = Integer.parseInt(teclado.nextLine());
        return coluna;
    }

    public int lerLinha() {
        System.out.println("Digite a linha: ");
        int linha = Integer.parseInt(teclado.nextLine());
        return linha;
    }
}

Na classe Tabuleiro você estava comparando as posições com == ao invés de equals:

public class Tabuleiro {

    public String[][] posicoes;

    public Tabuleiro() {
        posicoes = new String[3][3];
        for (int i = 0; i < posicoes.length; i++) {
            for (int j = 0; j < posicoes[i].length; j++) {
                posicoes[i][j] = "";
            }
        }
    }

    public String getPosicao(int linha, int coluna) {
        return posicoes[linha][coluna];
    }

    public void setPosicao(int linha, int coluna, String valor) {
        posicoes[linha][coluna] = valor;
    }

    public boolean verificaVitoria(String sinal) {
        if ((posicoes[0][0].equals(sinal) && posicoes[0][1].equals(sinal) && posicoes[0][2].equals(sinal)) || // linha 1
            (posicoes[1][0].equals(sinal) && posicoes[1][1].equals(sinal) && posicoes[1][2].equals(sinal)) || // linha 2
            (posicoes[2][0].equals(sinal) && posicoes[2][1].equals(sinal) && posicoes[2][2].equals(sinal)) || // linha 3
            (posicoes[0][0].equals(sinal) && posicoes[1][0].equals(sinal) && posicoes[2][0].equals(sinal)) || // coluna 1
            (posicoes[0][1].equals(sinal) && posicoes[1][1].equals(sinal) && posicoes[2][1].equals(sinal)) || // coluna 2
            (posicoes[0][2].equals(sinal) && posicoes[1][2].equals(sinal) && posicoes[2][2].equals(sinal)) || // coluna 3
            (posicoes[0][0].equals(sinal) && posicoes[1][1].equals(sinal) && posicoes[2][2].equals(sinal)) || // diagonal
            (posicoes[0][2].equals(sinal) && posicoes[1][1].equals(sinal) && posicoes[2][0].equals(sinal))) { // diagonal inversa
            return true;
        }
        return false;
    }
}

Falta implementar a inteligência do Jogador quando for um computador:

public class Jogador {

    private int id;
    private int qtd;

    public Jogador(int id_jogador) {
        this.id = id_jogador;
    }

    public int getId() {
        return this.id;
    }

    public int getQtd() {
        return qtd;
    }

    public void jogada(Tabuleiro tabuleiro) {
        // aqui o computador deve escolher uma posição vazia do tabuleiro para jogar
        int linha = 0; // trocar o zero pela linha escolhida pelo computador;
        int coluna = 0; // trocar o zero pela coluna escolhida pelo computador;
        tabuleiro.setPosicao(linha, coluna, "O");
        qtd++;
    }

    public void jogada(Tabuleiro tabuleiro, int linha, int coluna) {
        tabuleiro.setPosicao(linha, coluna, "X");
    }
}

Staroski, obrigado. Antes mesmo de vc responder, fiz assim:

public class Jogador {

private int qtd, id;
private int linha, coluna;
private Menu menu = new Menu();

public Jogador(int id_jogador) {
    this.id = id_jogador;
    this.qtd = 0;
}

public int getid() {
    return this.id;
}

public void jogada(Tabuleiro tabuleiro, int linha, int coluna) {

    if (id == 1) {
        tabuleiro.setPosicao(linha, coluna, "X");
    } else {
        tabuleiro.setPosicao(linha, coluna, "O");
    }

    qtd++;
}

public void jogada(Tabuleiro tabuleiro) {

    do {

        System.out.println("É a vez do jogador com id " + getid());

        do {
            linha = menu.lerLinha();
        } while (linha < 0 || linha > 2);

        do {
            coluna = menu.lerColuna();
        } while (coluna < 0 || coluna > 2);

        if (tabuleiro.getPosicao(linha, coluna) != " ") {
            System.out.println("Erro: Essa jogada já foi efetuada!");
            menu.imprimeTabuleiro(tabuleiro);
            continue;
        }

    } while (tabuleiro.getPosicao(linha, coluna) != " ");

    jogada(tabuleiro, linha, coluna);

    qtd++;

    if (qtd > 9) {
        System.out.println("Deu empate!");
        System.exit(0);
    }
}

}

import java.util.ArrayList;

import java.util.List;

public class JogoDaVelha {

public static void main(String[] args) {

    List<Jogador> jogadores = new ArrayList<>();
    int indexAtual;
    boolean finalizado;


    jogadores.add(new Jogador(1));
    jogadores.add(new Jogador(2));

    Menu menu = new Menu();

    Tabuleiro tabuleiro = new Tabuleiro();

    menu.imprimeTabuleiro(tabuleiro);

    finalizado = false;

    Jogador vencedor = null;

    indexAtual = 0;

    while (!finalizado) {

        Jogador jogador = jogadores.get(indexAtual);

        jogador.jogada(tabuleiro);

        if (tabuleiro.verificaVitoria("X") || tabuleiro.verificaVitoria("O")) {
            finalizado = true;
            vencedor = jogador;
        }

        menu.imprimeTabuleiro(tabuleiro);

        indexAtual = (indexAtual + 1) % jogadores.size();
    }

    System.out.println("A vitória foi do jogador com id " + vencedor.getid());

}

}
}