java控制台五子棋游戏

    首先我们要知道做一个五子棋游戏的流程。①、用户输入坐标，根据坐标下棋。②判断用户是否赢棋。③如果没有，电脑随机产生坐标，下棋。④、判断电脑是否赢棋。然后就根据这个流程一直循环。

 

    下面看代码，主要有三个类，游戏类，棋盘类，棋子类。我们从最简单的棋子类说起。棋子我们只需要黑棋和白棋，在这里我们使用枚举的方式。构造器传入当前棋子。getChessman（）获取当前棋子。

/**
 * 棋子枚举类
 */
public enum  Chessman {
    WHITE("○"),BLACK("●");
    private String chessman;

    /**
     * 构造器
     * @param chessman 棋子
     */
    private Chessman(String chessman){
        this.chessman = chessman;
    }

    /**
     * 获取棋子
     * @return 返回棋子
     */
    public String getChessman(){
        return this.chessman;
    }
}

    接下来是棋盘类，直接看代码，代码中都有详细的注释。

/**
 * 棋盘
 */
public class Chessboard {

    //使用二维数组作为棋盘
    private String[][] board;
    //棋盘大小
    public static final int BOARD_SIZE = 15;

    /**
     * 初始化棋盘
     */
    public void initChessboard(){
        board = new String[BOARD_SIZE][BOARD_SIZE];
        for (int i = 0; i < board.length; i++){
            for (int j = 0; j < board[i].length; j++){
                board[i][j] = "十";
            }
        }
    }

    /**
     * 输出棋盘
     */
    public void printBoard(){
        for (int i = 0; i < board.length; i++){
            for (int j = 0; j < board[i].length; j++){
                System.out.print(board[i][j]);
            }
            System.out.println();
        }
    }

    /**
     * 给棋盘位置赋值
     * @param posX  x坐标
     * @param posY  y坐标
     * @param chessman  棋子
     */
    public void setBoard(int posX,int posY,String chessman){
        this.board[posX][posY] = chessman;
    }

    /**
     * 获取棋盘
     * @return  返回当前棋盘
     */
    public String[][] getBoard(){
        return this.board;
    }
}

    最后一个是游戏类。代码如下：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 五子棋游戏
 */
public class GobangGame {

    private Chessboard chessboard;          //棋盘
    private int posX;                       //用户输入的X坐标
    private int posY;                       //用户输入的Y坐标
    private final int WIN_COUNT = 5;        //判断赢棋的棋子数

    /**
     * 空构造器
     */
    public GobangGame(){

    }

    /**
     * 含参构造器，初始化棋盘和棋子属性
     * @param chessboard 棋盘
     */
    public GobangGame(Chessboard chessboard){
        this.chessboard = chessboard;
    }

    /**
     * 判断用户输入是否合法
     * @param inputStr  用户输入的字符串
     * @return
     */
    public boolean isValid(String inputStr){
        //将用户输入的字符串使用英文逗号，分隔成一个字符串数组，分别储存X和Y坐标
        String[] inputStrArr = inputStr.split(",");
        //将字符串类型的坐标转换成Int型的坐标
        try {
            posX = Integer.parseInt(inputStrArr[0]) - 1;
            posY = Integer.parseInt(inputStrArr[1]) - 1;
        }catch (NumberFormatException e){       //异常处理，当数字的格式不正确的时候
            chessboard.printBoard();        //输出棋盘
            System.out.println("请按照（数字，数字）格式输入：");
            return false;       //返回不合法
        }
        //判断用户输入的坐标是否在规定范围内，大于0，小于BOARD_SIZE
        if (posX < 0 || posX >= Chessboard.BOARD_SIZE || posY < 0 || posY >= Chessboard.BOARD_SIZE){
            chessboard.printBoard();
            System.out.println("坐标只能大于0小于等于" + Chessboard.BOARD_SIZE + "，请重新输入：");
            return false;
        }
        //获取当前棋盘
        String[][] board = chessboard.getBoard();
        //判断输入位置是否有棋子，如果不等于“十”，说明已经有棋子了
        if (board[posX][posY] != "十"){
            chessboard.printBoard();
            System.out.println("当前位置已有棋子，请重新输入：");
            return false;
        }
        return true;
    }

    /**
     * 再来一次
     * @param chessman 最后赢棋的是电脑玩家还是用户
     * @return
     * @throws IOException
     */
    public boolean isReplay(String chessman) throws IOException {
        chessboard.printBoard();        //输出棋盘
        //判断最后一步，是电脑玩家还是用户，如果是用户（用户使用黑棋）提示赢棋。
        String message = chessman.equals(Chessman.BLACK.getChessman()) ? "恭喜你赢了！" : "很遗憾你输了！";
        System.out.println(message + "再来一次？（y/n）");
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        //是否再来一次
        if (bufferedReader.readLine().equals("y")){
            return true;
        }
        return false;
    }

    /**
     * 随机获取电脑玩家，下棋的坐标
     * @return  返回电脑玩家下棋的坐标数组
     */
    public int[] computerDo(){
        //在棋盘大小范围内，进行随机
        int posX = (int) (Math.random() * (Chessboard.BOARD_SIZE - 1));
        int posY = (int) (Math.random() * (Chessboard.BOARD_SIZE - 1));
        String[][] board = chessboard.getBoard();
        //如果当前随机的坐标位置已有棋子，则重新随机坐标
        while (board[posX][posY] != "十"){
            posX = (int) (Math.random() * (Chessboard.BOARD_SIZE - 1));
            posY = (int) (Math.random() * (Chessboard.BOARD_SIZE - 1));
        }
        //返回坐标数组
        int[] result = {posX,posY};
        return result;
    }

    /**
     * 判断是否赢棋
     * @param posX  X坐标
     * @param posY  Y坐标
     * @param icon  棋子类型，黑棋还是白棋
     * @return
     */
    public boolean isWin(int posX,int posY, String icon){
        //满足赢棋条件最开始的X坐标
        int startX = 0;
        //满足赢棋条件最开始的Y坐标
        int startY = 0;
        //满足赢棋条件结束的X坐标
        int endX = Chessboard.BOARD_SIZE - 1;
        //满足赢棋条件结束的Y坐标
        int endY = Chessboard.BOARD_SIZE - 1;
        //当前棋子，落棋后的，周围相同棋子数
        int sameCount = 0;
        int temp = 0;
        //判断最开始的X坐标和Y坐标是否超过棋盘大小
        temp = posX - WIN_COUNT + 1;
        startX = temp < 0 ? 0 : temp;
        temp = posY - WIN_COUNT + 1;
        startY = temp < 0 ? 0 : temp;
        temp = posX + WIN_COUNT - 1;
        //判断满足赢棋条件结束棋子的X坐标和Y坐标是否超过棋盘的大小
        endX = temp > Chessboard.BOARD_SIZE - 1 ? Chessboard.BOARD_SIZE : temp;
        temp = posY + WIN_COUNT - 1;
        endY = temp > Chessboard.BOARD_SIZE - 1 ? Chessboard.BOARD_SIZE : temp;
        String[][] board = chessboard.getBoard();
        //计算从左到右，相同棋子的个数
        for (int i = startY; i < endY ;i++){
            if (board[posX][i] == icon && board[posX][i + 1] == icon){
                sameCount++;
            }else if (sameCount != WIN_COUNT - 1){
                sameCount = 0;
            }
        }
        //计算从上到下，相同棋子的个数
        if (sameCount == 0){
            for (int i = startX; i < endX; i++){
                if (board[i][posY] == icon && board[i + 1][posY] == icon) {
                    sameCount++;
                } else if (sameCount != WIN_COUNT - 1) {
                    sameCount = 0;
                }
            }
        }
        if (sameCount == 0) {
            // 从左上到右下计算相同相邻棋子的数目
            int j = startY;
            for (int i = startX; i < endX; i++) {
                if (j < endY) {
                    if (board[i][j] == icon && board[i + 1][j + 1] == icon) {
                        sameCount++;
                    } else if (sameCount != WIN_COUNT - 1) {
                        sameCount = 0;
                    }
                    j++;
                }
            }
        }
        //返回是否赢棋
        return sameCount == WIN_COUNT - 1 ? true : false;
    }

    /**
     * 开始游戏
     * @throws IOException 接收输入
     */
    public void start() throws IOException {
        boolean isOver = false;         //游戏是否结束
        chessboard.initChessboard();    //初始化棋盘
        chessboard.printBoard();        //输出棋盘
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        //获取用户输入的坐标
        String inputStr = null;
        //如果输入不为空
        while ((inputStr = bufferedReader.readLine()) != null){
            isOver = false;
            //判断输入坐标是否合法，不合法退出本次循环，等待下一次输入
            if (!isValid(inputStr)){
                continue;
            }
            //用户使用黑棋
            String chessman = Chessman.BLACK.getChessman();
            //设置棋子
            chessboard.setBoard(posX,posY,chessman);
            //判断是否赢棋
            if (isWin(posX,posY,chessman)){
                isOver = true;
            }else {
                //如果没有，则电脑玩家进行操作，获取电脑玩家随机的下棋坐标
                int[] computerPosArr = computerDo();
                //电脑玩家使用白棋
                chessman = Chessman.WHITE.getChessman();
                //设置棋子
                chessboard.setBoard(computerPosArr[0],computerPosArr[1],chessman);
                //判断电脑玩家是否赢棋
                if (isWin(computerPosArr[1],computerPosArr[1],chessman)){
                    isOver = true;
                }
            }
            //判断是否结束游戏
            if (isOver){
                //当本次游戏结束是，询问是否再来一次
                if (isReplay(chessman)){
                    //如果再来一次，则初始化棋盘，输出棋盘
                    chessboard.initChessboard();
                    chessboard.printBoard();
                    continue;
                }
                //如果不继续游戏，则退出
                break;
            }
            chessboard.printBoard();
            System.out.println("请输入坐标:");
        }
    }
    public static void main(String[] args) throws Exception {
	// write your code here
        GobangGame game = new GobangGame(new Chessboard());
        game.start();
    }
}

    效果如图：

    以上就是全部内容，如果发现错误，请指出，谢谢。

有问题欢迎私聊或者发送邮箱（964427082@qq.com）一起讨论