public class BoardTest {
    public static void main(String[] args) {

        while(true){
            showMenu();  // 顯示棋盤(pán)
            boolean isPlay = Utility.readMenuSelection();   // 讀取玩家輸入
            if(isPlay){  // isPlay == true 進(jìn)入游戲
                System.out.println("歡迎來(lái)到三子棋小游戲！");
                Board board = new Board();      // 創(chuàng)建棋盤(pán)對(duì)象
                Player player = new Player();   // 創(chuàng)建玩家對(duì)象
                Computer computer = new Computer(); // 創(chuàng)建電腦對(duì)象
                board.initBoard();  // 初始化棋盤(pán)
                char flag = ' ';    // 接收棋局判斷的返回值
                // 博弈過(guò)程
                while(true){
                    board.showBoard();  // 顯示棋盤(pán)
                    System.out.print("請(qǐng)輸入落棋點(diǎn)(x,y):>");
                    player.moveChess(board);   // 玩家走
                    flag = board.isWin();
                    if(flag != 'c'){  // 將玩家和電腦的棋子傳入，判斷當(dāng)前棋局的形式
                        break;   // != 'c' 則跳出循環(huán)
                    }
                    computer.moveChess(board); // 電腦走
                    flag = board.isWin();
                    if(flag != 'c'){  // 將玩家和電腦的棋子傳入，判斷當(dāng)前棋局的形式
                        break;   // != 'c' 則跳出循環(huán)
                    }
                }
                if(flag == player.getChess()){
                    System.out.println("玩家贏！");
                } else if (flag == computer.getChess()){
                    System.out.println("電腦贏！");
                } else {
                    System.out.println("平局！");
                }
            } else {    // 否則 再次確認(rèn)玩家是否要離開(kāi)
                System.out.println("真的要離開(kāi)嘛？(Y/N):");
                boolean isExit = Utility.readConfirmSelection();  // 讀取玩家輸入
                if(isExit){  // isExit == true 退出游戲
                    System.out.println("退出成功！");
                    break;
                }
            }
        }

    }

    // 游戲菜單
    public static void showMenu(){
        System.out.println("============================================");
        System.out.println("==========        1. play        ===========");
        System.out.println("==========        2. exit        ===========");
        System.out.println("============================================");
        System.out.print("請(qǐng)輸入選擇:>");
    }
}

// 屬性：
private int row; // 行
private int col; // 列
private char[][] board; // 棋盤(pán)數(shù)組

// 方法：
public void initBoard() {...} // 用來(lái)初始化棋盤(pán)，講棋盤(pán)二維數(shù)組中的每個(gè)元素賦值為' '
public void showBoard() {...} // 用來(lái)顯示棋盤(pán)
public char isWin() {...}     // 判斷當(dāng)前棋局的形勢(shì)
private boolean isFull(){...} // 判斷棋盤(pán)是否已滿
// getter方法，因?yàn)椴辉试S設(shè)置棋盤(pán)屬性，沒(méi)有setter方法
public int getRow() {...}    // 返回行
public int getCol() {...}    // 返回列
public char[][] getBoard() {...}  // 返回棋盤(pán)數(shù)組
// 構(gòu)造器
public Board() {...} // 空參構(gòu)造器，在其中默認(rèn)設(shè)置了行列，并new了棋盤(pán)數(shù)組對(duì)象

public class Board {
    private int row; // 行
    private int col; // 列
    private char[][] board; // 棋盤(pán)數(shù)組

    /**
     * @description： 構(gòu)造器，用來(lái)設(shè)置棋盤(pán)大小
     * @parameter row, 表示行數(shù)；  col, 表示列數(shù)
     */
    public Board() {
        row = 3;
        col = 3;
        board = new char[row][col];
    }

    /**
     * @description: 用來(lái)初始化棋盤(pán)，講棋盤(pán)二維數(shù)組中的每個(gè)元素賦值為' '
     */
    public void initBoard() {
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                board[i][j] = ' ';
            }
        }
    }

    /**
     * @description: 用來(lái)顯示棋盤(pán)
     */
    public void showBoard() {
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (j < col - 1) {
                    System.out.print(" " + board[i][j] + " |");
                } else {
                    System.out.print(" " + board[i][j] + " ");
                }
            }
            System.out.println();
            if (i < row - 1) {
                for (int k = 0; k < col; k++) {
                    if (k < col - 1) {
                        System.out.print("---|");
                    } else {
                        System.out.print("---");
                    }
                }
                System.out.println();
            }
        }
    }

    /**
     * @description 判斷當(dāng)前棋局的形勢(shì)
     * @return 返回  玩家的棋子 玩家贏， 返回 電腦的棋子 電腦贏
     * 返回 'q' 平局           ， 返回 'c' 繼續(xù)
     */
    public char isWin() {
        // 判斷同一行是否相同
        for (int i = 0; i < row; i++) {
            if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ') {
                return board[i][0];  // 返回該行的一個(gè)棋子
            }
        }
        // 判斷同一列是否相同
        for(int i = 0; i < col; i++){
            if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != ' ') {
                return board[i][0];  // 返回該列的一個(gè)棋子
            }
        }
        // 判斷對(duì)角線是否相同
        if(board[0][0] == board[1][1] && board[1][1]  == board[2][2] && board[0][0] != ' ' || board[0][2] == board[1][1] && board[1][1] ==  board[2][0] && board[0][2] != ' '){
            return board[1][1];        // 返回對(duì)角線中間的棋子
        }

        // 判斷棋盤(pán)是否已滿
        if(isFull()){
            return 'q';  // 已滿返回'q'
        } else {
            return 'c';  // 未滿返回'c'
        }
    }

    /**
     * @description 判斷棋盤(pán)是否已滿
     * @return true 表示已滿  false 表示未滿
     */
    private boolean isFull(){
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if(board[i][j] == ' '){
                    return false;  // 未滿返回false
                }
            }
        }
        return true; // 已滿返回true
    }

    public int getRow() {
        return row;
    }

    public int getCol() {
        return col;
    }

    public char[][] getBoard() {
        return board;
    }
}

// 屬性：
private char chess;  // 玩家的棋子
// 方法：
public void moveChess(Board board){...} // 玩家下棋，講棋子放到指定位置
// getter方法
public char getChess() {...} // 用來(lái)返回玩家的棋子
// 構(gòu)造器:
public Player() {...} // 空參構(gòu)造器，默認(rèn)設(shè)置了代表玩家棋子的字符

public class Player {
    private char chess;  // 棋子

    /**
     * @description 空參構(gòu)造器，用來(lái)設(shè)置用戶的棋子
     */
    public Player() {
        chess = '*';
    }

    /**
     * @description 玩家下棋，講棋子放到指定位置
     * @param board 接收使用的棋盤(pán)數(shù)組
     */
    public void moveChess(Board board){
        Scanner sc = new Scanner(System.in);
        while(true){
            int x = sc.nextInt(); // 接收x坐標(biāo)
            int y = sc.nextInt(); // 接收y坐標(biāo)
            boolean isFlag = Utility.readPosition(x,y,board); // 判斷位置是否合適
            if(isFlag){ // 合適則將玩家棋子存入棋盤(pán)的對(duì)應(yīng)位置中
                board.getBoard()[x-1][y-1] = chess; 
                return;
            }
            System.out.print("輸入有誤，請(qǐng)重新輸入:>");
        }
    }

    /**
     * @return 返回玩家的棋子
     */
    public char getChess() {
        return chess;
    }
}

// 屬性：
private char chess;  // 電腦的棋子
// 方法：
public void moveChess(Board board){...} // 電腦下棋，在棋盤(pán)中隨機(jī)位置放入一個(gè)棋子
// getter方法：
public char getChess() {...}  // 返回電腦的棋子
// 構(gòu)造器：
public Computer() {...}   // 空參構(gòu)造，默認(rèn)設(shè)置了代表電腦棋子的字符

import java.util.Scanner;

public class Computer {
    private char chess;  // 電腦的棋子

    /**
     * @description 用來(lái)設(shè)置電腦的棋子
     */
    public Computer() {
        chess = '#';
    }

    /**
     * @description   在棋盤(pán)中隨機(jī)位置放入一個(gè)棋子
     * @param board   接收使用的棋盤(pán)數(shù)組
     */
    public void moveChess(Board board){
        Scanner sc = new Scanner(System.in);
        while(true){
            int x = (int)(Math.random() * 3);
            int y = (int)(Math.random() * 3);
            boolean isFlag = Utility.readPosition(x+1,y+1,board);
            if(isFlag){
                board.getBoard()[x][y] = chess;
                return;
            }
        }

    }

    /**
     *
     * @return 返回電腦的棋子
     */
    public char getChess() {
        return chess;
    }
}

// 方法 
public static boolean readMenuSelection() {...} // 讀取玩家進(jìn)入菜單界面的輸入選項(xiàng)，并進(jìn)行判斷。
public static boolean readConfirmSelection() {...} // 讀取玩家確認(rèn)選項(xiàng)的輸入，'Y'表示確認(rèn) 'N'表示否認(rèn)
public static boolean readPosition(int x, int y, Board board){...} // 判斷玩家輸入的x y 坐標(biāo)是否合理，合理位置返回true, 不合理位置返回false

import java.util.Scanner;

public class Utility {
    /**
     * @description： 讀取用戶輸入的數(shù)字，并進(jìn)行判斷
     * @return 輸入1則返回true， 輸入2 則返回false
     */
    public static boolean readMenuSelection() {
        int num = new Scanner(System.in).nextInt();
        while (true) {
            if (num == 1) {
                return true;
            } else if (num == 2) {
                return false;
            } else {
                System.out.print("輸入有誤，請(qǐng)重新輸入:>");
            }
        }
    }

    /**
     * @description： 讀取用戶輸入的字符，并做出判斷
     * @return 輸入'Y' 返回true, 輸入'N' 返回false
     */
    public static boolean readConfirmSelection() {
        String str = new Scanner(System.in).next();
        while(true){
            if(str.length() == 1){
                char ch = str.toUpperCase().charAt(0);  // 獲取該字符
                System.out.println(ch);
                if(ch == 'Y'){
                    return true;
                } else if( ch == 'N'){
                    return false;
                }
            }
            System.out.print("輸入有誤，請(qǐng)重新輸入:>");
        }
    }

    /**
     * @description 判斷用戶輸入的落棋點(diǎn)是否在合理位置
     * @param x x坐標(biāo)
     * @param y y坐標(biāo)
     * @param board 使用的棋盤(pán)對(duì)象
     * @return 合理位置返回true, 不合理位置返回false
     */
    public static boolean readPosition(int x, int y, Board board){
        if(1 <= x && x <= board.getRow() && 1 <= y && y <= board.getCol() && board.getBoard()[x - 1][y - 1] == ' '){
            return true;
        }
        return false;
    }
}