11.2. Registar jogadores no jogo

Agora precisamos de um método que permita registar um jogador no jogo. Adicionamos o seguinte método à classe Jogo:

   /**
    * Juntar um jogador com um dado nome a este jogo.
    * @param nomeJog O nome do jogador.
    * @requires O jogador com o nome nomeJog ainda não estah  
    *           registado neste jogo && 
    *           este jogo ainda comporta mais jogadores
   */
    public void juntarJogador (String nomeJog) {
        this.jogadores[??] = new Jogador (nomeJog);
    }

O método cria um novo jogador, com o nome dado pelo parâmetro, e adiciona-o ao conjunto de jogadores do jogo.

Que índice devemos usar para indicar o elemento do array jogadores ao qual deve ser atribuído o novo jogador? A primeira vez que o método é chamado deve ser zero, a segunda vez deve ser um e assim sucessivamente.

Repare que o índice a usar tem o mesmo valor que o número de jogadores registados no jogo no momento em que se vai registar um novo jogador (quando há zero jogadores em jogo, o próximo jogador deve ser atribuído ao elemento de índice zero do array, quando há um jogador em jogo, o próximo jogador deve ser atribuído ao elemento de índice um do array e assim sucessivamente).

Então, para que se possa guardar, para um jogo, quantos jogadores estão inscritos a cada momento, vamos adicionar um novo atributo de instância.

Adicionamos o atributo quantosEmJogo, o qual é inicializado a zero, e acrescentamos também um método que revela o seu valor. Mudamos também parte da pré-condição do método juntarJogador de forma a que as classes cliente saibam como podem verificar se o jogo não comporta mais jogadores (definimos um máximo de 5 jogadores).

​x
/**
 * Classe cujos objetos representam jogos
 * @author Isabel Nunes
 */
public class Jogo {
    
      // A coleccao dos jogadores
      private Jogador [] jogadores;
      // Pontuacao objetivo
      private int objetivo;
      // Numero de jogadores em jogo
      private int quantosEmJogo;
    
    /**
     * Construir um jogo.
     * @param objetivo A pontuacao com que se ganha este jogo
     * @requires objetivo > 0
     */
    public Jogo (int objetivo) {
        this.objetivo = objetivo;
        this.jogadores = new Jogador [5];
        this.quantosEmJogo = 0;
    }
​
    /**
     * A pontuacao objetivo deste jogo.
     */
    public int pontuacaoObjetivo () {
        return this.objetivo;
    }
​
    /**
     * O numero de jogadores que estao em jogo.
     */
    public int quantosEmJogo () {
        return this.quantosEmJogo;
    }
​
   /**
    * Juntar um jogador com um dado nome a este jogo.
    * @param nomeJog O nome do jogador.
    * @requires O jogador com o nome nomeJog ainda não estah  
    *           registado neste jogo && 
    *           this.quantosEmJogo() < 5
    */
    public void juntarJogador (String nomeJog) {
        this.jogadores[this.quantosEmJogo] = new Jogador (nomeJog);
        this.quantosEmJogo++;
    }
   ...
​
}

Repare que usámos este novo atributo como o índice que faltava no método juntarJogador. Quando um jogador é acrescentado ao jogo, o valor desse atributo quantosEmJogo tem que ser incrementado, pois passa a existir mais um jogador registado no jogo.

Vamos agora adicionar a instrução seguinte

xxxxxxxxxx
    meuJogo.juntarJogador("Maria"); 

ao método main da classe ClienteDeJogo. As figuras seguintes ilustram o estado da memória em várias fases da execução desta instrução:

• quando o método juntarJogador é invocado (repare o valor de this no contexto deste método – é o mesmo conteúdo da variável meuJogo, que é precisamente o alvo da invocação):
• o método juntarJogador , na sua instrução this.jogadores[this.quantosEmJogo] = new Jogador (nomeJog);, começa por invocar o construtor da classe Jogador de modo a criar o jogador de nome "Maria"; a figura seguinte mostra o estado da memória quando esse construtor foi executado; repare no valor de this no contexto do construtor – é o novo objeto do tipo Jogador, acabado de criar e já inicializado:

• de seguida, ainda através da instrução this.jogadores[this.quantosEmJogo] = new Jogador (nomeJog);, o método juntarJogador atribui a referência para o novo jogador à primeira posição do array jogadores, pois o valor que o atributo quantosEmJogo tem no momento é zero:

• finalmente, quando o método juntarJogador termina, o controle de execução volta ao main e o estado da memória é:

Vamos então relembrar o conteúdo da classe ClienteDeJogo e acrescentar ainda uma instrução que registe um segundo jogador no jogo:

xxxxxxxxxx
public class ClienteDeJogo {
​
    public static void main (String [] args) {
​
        Jogo meuJogo = new Jogo(30); 
        System.out.println("O objetivo eh " + meuJogo.pontuacaoObjetivo()); 
​
        meuJogo.juntarJogador("Maria"); 
        meuJogo.juntarJogador("Pedro");         
    }
}

Após a execução da última instrução do main, o estado da memória ficará:

Anterior: 11.1. A classe Jogo

Seguinte: 11.3. Registar pontuação de um dado jogador do jogo – 1ª versão