Java之面向物件編程

五子棋（控制臺版）是「面向物件編程」中經典的小專案，下面我將提供一種解決視角，僅供參考，

題目描述：

編程實作控制臺版并支持兩人對戰的五子棋游戲，

（1）繪制棋盤 - 寫一個成員方法實作

（2）提示黑方和白方分別下棋并重新繪制棋盤 - 寫一個成員方法實作，

（3）每當一方下棋后判斷是否獲勝 - 寫一個成員方法實作，

（4）提示： 采用二維陣列來模擬并描述棋盤，棋盤如下：

注意點：

• 五子棋棋盤有且只有一張：單例模式實作
• 繪制棋盤函式：按行列印二維陣列，雙層for回圈實作
• 判斷落子是否合理：落子是否超出界限，落子是否已存在
• 勝利與否的判斷：四個方向的判斷
• 每個方向的判斷方法：9個字符的陣列中是否存在5個連續的與當前棋子一樣的字符

Gobang類：

import java.util.Scanner;

public class Gobang {
    // 初始化成員變數，落子區域：16*16
    // 用單例模式實作有且只有一個棋盤
    private char[][] chessboard = new char[17][17];
    private static Gobang gb = new Gobang();

    // 私有化無參構造方法： 繪制棋盤且提示黑子先手
    private Gobang() {
        for(int i = 0; i < 17; i++) {
            for(int j = 0; j < 17; j++) {
                if (0 == i && 0 == j) {
                    chessboard[i][j] = (char)32;
                } else if (0 == i && j <= 10) { //控制第一行的情況
                    chessboard[i][j] = (char)(j - 1 + 48);
                } else if (0 == i && j <= 16) {
                    chessboard[i][j] = (char)(j - 11 + 97);
                } else if (0 == j && i <= 10) { // 控制第一列的情況
                    chessboard[i][j] = (char)(i - 1 + 48) ;
                } else if (0 == j && i <= 16) {
                    chessboard[i][j] = (char)(i - 11 + 97);
                } else {
                    chessboard[i][j] = (char)43;
                }
            }
        }
        drawChessboard(true);
    }

    // 單例模式：從類層級獲取棋盤
    public static Gobang getGobang() {
        return gb;
    }
    // 繪制棋盤的成員方法
    public void drawChessboard(boolean flag) {
        System.out.println("--------------------趣味五子棋游戲-------------------");
        System.out.println("-----------------作者：Vigoroushui------------------");
        for(int i = 0; i < 17; i++){
            for(int j = 0; j < 17; j++) {
                System.out.print(chessboard[i][j]);
                System.out.print("  ");
            }
            System.out.println();
        }
        if(true == flag) {
            System.out.println("--------------------輪到黑方下棋--------------------");
        } else {
            System.out.println("--------------------輪到白方下棋--------------------");
        }
    }
    // 判斷落子合理性的成員方法
    public String judgeRationality(String n) {
        int judge = 0;
        // 判斷當前落子是否超出界限 [0,9]&&[a,f]
        for(int i = 1; i < 17; i++) {
            if(String.valueOf(chessboard[0][i]).equals(n)) {
                judge = 1;
                break;
            }
        }
        // 如果落子越界,給定"outer"標示符
        if(1 != judge) {
            return "outer";
        }
        return n;
    }
    // 開始五子棋游戲的成員方法
    public void playChess() {
        boolean flag = true; //用于控制黑白兩方落子的標示符，true代表黑方落子，false代表白方落子
        Scanner sc = new Scanner(System.in);
        while(true) {
            //合理值的判斷
            System.out.println("請輸入您要落子的行位置和列位置（如: a 4）:");
            int cow, column;
            while(true) {
                String a = judgeRationality(sc.next());
                String b = judgeRationality(sc.next());
                // 判斷落子是否越界
                if ("outer".equals(a) || "outer".equals(b)) {
                    System.out.println("您落子落到棋盤外面去了,請重新落子：");
                }else {
                    // 將輸入的值轉為二維陣列對應的行列下標
                    cow = (int) a.charAt(0) + 1 - 48;
                    column = (int) b.charAt(0) + 1 - 48;
                    if (cow >= 11) {
                        cow = (int) a.charAt(0) + 11 - 97;
                    }
                    if (column >= 11) {
                        column = (int) b.charAt(0) + 11 - 97;
                    }
                    //判斷落子是否已存在
                    if ('&' == chessboard[cow][column] || '#' == chessboard[cow][column]) {
                        System.out.println("您落子的位置已有棋子，請重新落子：");
                    }else {
                        break;
                    }
                }
            }
            // 落子
            if(flag) {
                chessboard[cow][column] = (char) 38; // 用 & 代表黑方落子
            } else {
                chessboard[cow][column] = (char) 35; // 用 # 代表白方落子
            }
            // 判斷是否勝利，若勝利，則退出回圈
            boolean win = isWin(cow, column);
            if(win && flag){
                System.out.println("恭喜黑子獲勝！");
                drawChessboard(true);
                break;
            }else if(win && !flag) {
                System.out.println("恭喜白子獲勝！");
                drawChessboard(false);
                break;
            }
            // 交換對手并重新繪制棋盤
            flag = !flag;
            drawChessboard(flag);
        }
    }
    // 判斷是否勝利的成員方法
    public boolean isWin(int cow, int column) {
        int highBound = 16;
        int lowBound = 1;
        // 每次落子連成線只可能有4種情況： 橫、縱、左斜、右斜
        // 創建4個一維陣列分別保存四個方向上9個子
        char[] cowChess = {'*', '*', '*', '*', '*', '*', '*', '*', '*'};
        char[] columnChess = {'*', '*', '*', '*', '*', '*', '*', '*', '*'};
        char[] leftDiagonal = {'*', '*', '*', '*', '*', '*', '*', '*', '*'};
        char[] rightDiagonal = {'*', '*', '*', '*', '*', '*', '*', '*', '*'};
        rightDiagonal[4] = leftDiagonal[4] = columnChess[4] = cowChess[4] = chessboard[cow][column];
        // 生成4個方向的成線陣列， 例如：橫方向 + + + + & & + + +
        for (int i = 1; i <= 4; i++) {
            // 生成橫方向的成線情況
            if (column - i >= lowBound) {
                cowChess[4 - i] = chessboard[cow][column - i];
            }
            if (column + i <= highBound) {
                cowChess[4 + i] = chessboard[cow][column + i];
            }
            // 生成縱方向的成線情況
            if (cow - i >= lowBound) {
                columnChess[4 - i] = chessboard[cow - i][column];
            }
            if (cow + i <= highBound) {
                columnChess[4 + i] = chessboard[cow + i][column];
            }
            // 生成左斜方向上的成線情況
            if (cow - i >= lowBound && column - i >= lowBound) {
                leftDiagonal[4 + i] = chessboard[cow - i][column - i];
            }
            if (cow + i <= highBound && column + i <= highBound) {
                leftDiagonal[4 - i] = chessboard[cow + i][column + i];
            }
            // 生成右斜方向上的成線情況
            if (cow - i >= lowBound && column + i <= highBound) {
                rightDiagonal[4 + i] = chessboard[cow - i][column + i];
            }
            if (column - i >= lowBound && cow + i <= highBound) {
                rightDiagonal[4 - i] = chessboard[cow + i][column - i];
            }
        }
        // 判斷4個方向是否存在五子連珠的情況
        boolean resCowChess = fiveSons(cowChess, cow, column);
        boolean resColumnChess = fiveSons(columnChess, cow, column);
        boolean resLeftDiagonal = fiveSons(leftDiagonal, cow, column);
        boolean resRightDiagonal = fiveSons(rightDiagonal, cow, column);
        // 若有一個方向上的存在五子連珠的情況，則勝利
        if(resCowChess || resColumnChess || resLeftDiagonal || resRightDiagonal) {
            return true;
        }else {
            return false;
        }
    }
    // 判斷五子連珠的方法，形參為有9個字符的陣列(對應四個方向)， 當前落子的行和列
    // 該方法只用于isWin()成員方法中，本質是一維陣列中找連續相同的字串
    private boolean fiveSons(char[] sons, int cow, int column) {
        int count = 1; // 統計連續子的個數
        for(int i = 0; i < 5;) {
            if (sons[i] == chessboard[cow][column]) {
                for (int j = i + 1; j < 9; j++) {
                    if(sons[j] == sons[j - 1]) {
                        count += 1;
                        if(5 == count) return true; // 若找到五子連珠的情況，則回傳勝利標示符true
                    }else {
                        count = 1;
                        i = j;
                        break;
                    }
                }
            }
            i++;
        }
        return false;
    }
}

GobangTest類：

public class GobangTest {

    public static void main(String[] args) {
       
        Gobang g = Gobang.getGobang();
        g.playChess();
        Gobang g2 = Gobang.getGobang(); // g和g2指向同一個棋盤
    }
}

后記：

本文代碼所用的開發環境為IntelliJ IDEA，代碼塊中每一步均有詳細的注釋，整個專案涉及到的核心知識點為：單例模式的實作、二維陣列的使用、類的使用（構造方法、成員變數、成員方法）