Soluzione 5.6

Ecco una classe Tris. Notare in particolare la realizzazione del metodo isWinning. Piu` sotto e` disponibile una classe di collaudo TrisTester
public class Tris
{  
      /* costruttore che crea (ma non visualizza!)
          la scacchiera con i puntini
      */
      public Tris()
      {  
        board = new char[ROWS][COLUMNS];
        for (int i = 0; i < ROWS; i++)
          for (int j = 0; j < COLUMNS; j++)
            board[i][j] = '.';
      }

      /* restituisce una stringa da usare per visualizzare la scacchiera
         (deve contenere anche i caratteri per andare a capo al termine
         di ognuna delle tre righe)
      */
    public String toString()
    {  
        String s = "";
        for (int i = 0; i < ROWS; i++)
        {  
            s += '|';
            for (int j = 0; j < COLUMNS; j++)
                s += board[i][j];
            s += "|\n";
        }
        return s;
    }

      /* imposta la posizione [row][column] al valore c;
         lancia IllegalArgumentException se le coordinate sono errate;
         restituisce false se e solo se la posizione era gia' occupata
      */
    public boolean set(int row, int column, char c)
    {
        if (row < 0 || column < 0 || row > ROWS-1 || column > COLUMNS-1)
	        throw new IllegalArgumentException();
        if (board[row][column] != '.')
	        return false;
        board[row][column] = c;
        return true;
    }

      /* restituisce il carattere presente nella posizione [row][column];
         lancia IllegalArgumentException se le coordinate sono errate
      */
    public char get(int row, int column)
    {
        if (row < 0 || column < 0 || row > ROWS-1 || column > COLUMNS-1)
	        throw new IllegalArgumentException();
        return board[row][column];
    }

      /* restituisce il numero di posizioni occupate nella scacchiera
      */
    public int getCount()
    {
        int count = 0;
        for (int i = 0; i < ROWS; i++)
            for (int j = 0; j < COLUMNS; j++)
                if (board[i][j] != '.')
                    count++;
        return count;
    }

      /* restituisce true se e solo se esiste nella scacchiera una
         configurazione vincente per il carattere c
      */
    public boolean isWinning(char c)
    {
        if (board[0][0] == c)
        {
    	    if (board[0][1] == c && board[0][2] == c)
	            return true;
            if (board[1][1] == c && board[2][2] == c)
	            return true;
            if (board[1][0] == c && board[2][0] == c)
	            return true;
        }
        if (board[0][1] == c)
        {
            if (board[1][1] == c && board[2][1] == c)
                return true;
        }
        if (board[0][2] == c)
        {
            if (board[1][2] == c && board[2][2] == c)
                return true;
            if (board[1][1] == c && board[2][0] == c)
                return true;
        }
        if (board[1][0] == c)
        {
            if (board[1][1] == c && board[1][2] == c)
                return true;
        }
        if (board[2][0] == c)
        {  
            if (board[2][1] == c && board[2][2] == c)
                return true;
        }
        return false; 
    }

    private char[][] board;
    private static final int ROWS = 3;
    private static final int COLUMNS = 3;  
}

La classe Tris puo` essere collaudata tramite questa classe. Prestare attenzione ai commenti/domande inseriti nel testo.
import java.util.Scanner;

public class TrisTester
{  
    public static void main(String[] args)
    {
        System.out.println("Gioco del tris");
        System.out.println("Per inserire una mossa: fornire due numeri interi");
        System.out.println("(valore 0,1,2) su due righe di input consecutive");
        System.out.println("Rappresentano rispettivamente riga e colonna");

        Scanner in = new Scanner(System.in);
        boolean playAgain = true;
        while(playAgain)
        {   Tris b = new Tris();
            char player1 = 'X';
            char player2 = '0';
            char currPlayer = player1;
         
            while (!b.isWinning(player1) && !b.isWinning(player2) 
                                         && b.getCount() != 9)
            {  
                System.out.println("Situazione attuale");
                System.out.print(b); //Possiamo "stampare" l'oggetto b sullo 
                                     //standard output. Come mai?
                System.out.println("Inserire mossa del giocatore " +currPlayer);
                int row;
                int column;
                try
                {
                    row = Integer.parseInt(in.nextLine());
                    column = Integer.parseInt(in.nextLine());
                    if (b.set(row, column, currPlayer)) 
                    //Attenzione all'effetto di questa condizione...
                    {
                        if (currPlayer == player1) currPlayer = player2; 
                        else currPlayer = player1;
                    } 
                    else
                        System.out.println("Posizione gia' occupata");
                }
                catch (NumberFormatException e)
                {  System.out.println("Mossa errata: non hai inserito int"); }
                catch (IllegalArgumentException e)
                {  System.out.println("Mossa errata: non sono int tra 0 e 2"); }
            }

            System.out.println("Situazione finale");
            System.out.print(b);
            if (b.isWinning(player1))
                System.out.println("Vittoria del giocatore " + player1);
            else if (b.isWinning(player2))
                System.out.println("Vittoria del giocatore " + player2);
            else
                System.out.println("Pareggio");

            String s = "";
            while (!s.equalsIgnoreCase("SI") && !s.equalsIgnoreCase("NO"))
            {  
                System.out.println("Un'altra partita? (SI o NO)");
                s = in.nextLine();
            } 
            if (s.equalsIgnoreCase("SI"))
                playAgain = true;
            else
                playAgain = false;
        }
    }
}