如何用Java實現(xiàn)五子棋游戲

這篇文章主要介紹“如何用Java實現(xiàn)五子棋游戲”，在日常操作中，相信很多人在如何用Java實現(xiàn)五子棋游戲問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”如何用Java實現(xiàn)五子棋游戲”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

該項目為Java編程語言編寫的五子棋游戲(控制臺版），用到二維數(shù)組、for循環(huán)、if語句、while()語句、Scanner Until包，此項目主要是對數(shù)組的使用。該項目的功能有落子、輸出棋盤、判斷輸贏。

代碼條：

package edu.qizi.gam;
 
import java.util.Scanner;
 
public class GobangTest {
 public static void main(String[] args) {
  int BoardSize = 20;
  // 棋盤的實現(xiàn)
  String[][] board = new String[BoardSize][BoardSize];
  
  for (int i = 0; i < board.length; i++) {
   for (int j = 0; j < board[i].length; j++) {
    board[i][j] = "+";
   }
  }
  //輸出棋盤
  PrintBoard(board);
  while(true) {
  //黑棋落子
  System.out.println("黑棋落子");
  BlackMoveLater(board);
//  每下一步黑棋要輸出一下棋盤
  PrintBoard(board);
  
//  行判斷黑棋
  BlackRow(BoardSize, board);
//  列判斷黑棋
  BlackLine(BoardSize, board);
//  自左上--->右下判斷黑棋，每次第二個for循環(huán)最開始列不變，階梯逼近左下的方法
  BlackTopLeftToBottomRight_Line(BoardSize, board);
//  自左上--->右下判斷黑棋，每次第二個for循環(huán)最開始行不變，階梯逼近右上的方法
  BlackTopLeftToBottomRight_Row(BoardSize, board);
//  自右上--->左下判斷黑棋，每次第二個for循環(huán)最開始列不變，階梯逼近右下的方法
  BlackTopRightToBottomLeft_Line(BoardSize, board);
//  自右上--->左下判斷黑棋，每次第二個for循環(huán)最開始行不變，階梯逼近左上的方法
  BlackTopRightToBottomLeft_Row(BoardSize, board);
  
  
//  白棋落子
  System.out.println("白棋落子");
  WhiteMoveLater(board);
//  每下一步白棋要輸出一下棋盤
  PrintBoard(board);
  
//  行判斷白棋
  WhiteRow(BoardSize, board);
//  列判斷白棋
  WhiteLine(BoardSize, board);
//  自左上--->右下判斷白棋，每次第二個for循環(huán)最開始列不變，階梯逼近左下的方法
  WhiteTopLeftToBottomRight_Line(BoardSize, board);
//  自左上--->右下判斷白棋，每次第二個for循環(huán)最開始行不變，階梯逼近右上的方法
  WhiteTopLeftToBottomRight_Row(BoardSize, board);
//  自右上--->左下判斷白棋，每次第二個for循環(huán)最開始列不變，階梯逼近右下的方法
  WhiteTopRightToBottomLeft_Line(BoardSize, board);
//  自右上--->左下判斷白棋，每次第二個for循環(huán)最開始行不變，階梯逼近左上的方法
  WhiteTopRightToBottomLeft_Row(BoardSize, board);
  } 
 }

下面是實現(xiàn)的方法

//實現(xiàn)棋盤輸出的方法
 public static void PrintBoard(String[][] board) {
   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();
   }
  }

實現(xiàn)黑棋落子

// 實現(xiàn)黑棋落子的方法
 public static void BlackMoveLater(String[][] board) {
  while(true) {
  Scanner sc1=new Scanner(System.in);
  System.out.println("請輸入黑棋落子的橫坐標[1---20]:");
  int BlackBoard_x=sc1.nextInt();
  //判斷橫坐標是否數(shù)組越界
  if(BlackBoard_x<1 || BlackBoard_x>20) {
   System.out.println("你輸入的坐標范圍有誤 ,橫坐標取1到20,請正確輸入:\n");
   continue;
  }
  Scanner sc2=new Scanner(System.in);
  System.out.println("請輸入黑棋落子的縱坐標[1---20]:");
  int BlackBoard_y=sc2.nextInt();
  //判斷縱坐標是否數(shù)組越界
  if(BlackBoard_y<1 || BlackBoard_y>20) {
   System.out.println("你輸入的坐標范圍有誤,縱坐標取1到20,請正確輸入:\n");
   continue;
  }
  //判斷此位置是否可以落入棋子
  if(board[BlackBoard_x-1][BlackBoard_y-1]=="○") {
   System.out.println("此位置已經(jīng)有棋子了，請你將棋子下到空位置");
   continue;
  }else {
    board[BlackBoard_x-1][BlackBoard_y-1]="●";
    break;
  }
  }
 }

實現(xiàn)白棋落子

// 實現(xiàn)白棋落子的方法
 public static void WhiteMoveLater(String[][] board) {
  while(true) {
  Scanner sc1=new Scanner(System.in);
  System.out.println("請輸入白棋落子的橫坐標[1---20]:");
  int WhiteBoard_x=sc1.nextInt();
  //判斷橫坐標是否數(shù)組越界
  if(WhiteBoard_x<1 || WhiteBoard_x>20) {
   System.out.println("你輸入的坐標范圍有誤 ,橫坐標取1到20,請正確輸入:\n");
   continue;
   }
  Scanner sc2=new Scanner(System.in);
  System.out.println("請輸入白棋落子的縱坐標[1---20]:");
  int WhiteBoard_y=sc2.nextInt();
  //判斷縱坐標是否數(shù)組越界
  if(WhiteBoard_y<1 || WhiteBoard_y>20) {
   System.out.println("你輸入的坐標范圍有誤,縱坐標取1到20,請正確輸入:\n");
   continue;
   }
  //判斷此位置是否可以落入棋子
  if(board[WhiteBoard_x-1][WhiteBoard_y-1]=="●") {
   System.out.println("此位置已經(jīng)有棋子了，請你將棋子下到空位置\n");
   continue;
  }else {
   board[WhiteBoard_x-1][WhiteBoard_y-1]="○";
   break;
  }
  }
 }

判定輸贏以黑棋為例（有六個方法）,下面一一列舉

// 實現(xiàn)行判斷黑棋子
 public static void BlackRow(int BoardSize, String[][] board) {
//  先定義一個數(shù)number,以此來計數(shù)
  int number=0;
//  一行一行的讀取數(shù)組中的元素
  for(int row=0;row<BoardSize;row++) {
   for(int line=0;line<BoardSize;line++) {
//    如果此行中有元素為黑棋則number+1
    if(board[row][line]=="●") {
     number++;
    }
//    當number為5的時候則黑棋一方的勝
    while(number==5) {
     System.out.println("黑棋方勝！");
        //勝出后輸出棋盤
        for ( row = 0; row < board.length; row++) {
         for ( line = 0; line < board[row].length; line++) {
          System.out.print( board[row][line]+" ");
         }
         System.out.println();
        }
        //勝后退出系統(tǒng)
        System.exit(0);
    }
//    如果此行中雖有五個黑棋但是并不相連，不能說是黑棋方勝，需將number置為0
    if(board[row][line]=="○"|| board[row][line]=="+") {
     number=0;
    }
   }
//   每一行讀取數(shù)組元素后未能分出勝負需要將number置為0
   number=0;
  }
 }

展現(xiàn)第一個方法的結(jié)果

第二個方法代碼

// 實現(xiàn)列判斷黑棋子
 public static void BlackLine(int BoardSize, String[][] board) {
//  先定義一個數(shù)number,以此來計數(shù)
  int number=0;
//  一列一列的讀取數(shù)組中的元素
  for(int Line=0;Line<BoardSize;Line++) {
   for(int row=0;row<BoardSize;row++) {
//    如果此列中有元素為黑棋則number+1
    if(board[row][Line]=="●") {
     number++;
    }
//    當number為5的時候則黑棋一方的勝
    while(number==5) {
     System.out.println("黑棋方勝！");
        //勝出后輸出棋盤
        for ( row = 0; row < board.length; row++) {
         for ( Line = 0; Line < board[row].length; Line++) {
          System.out.print( board[row][Line]+" ");
         }
         System.out.println();
        }
        //勝后退出系統(tǒng)
        System.exit(0);
    }
//    如果此列中雖有五個黑棋但是并不相連，不能說是黑棋方勝，需將number置為0
    if(board[row][Line]=="○"|| board[row][Line]=="+") {
     number=0;
    }
   }
//   每一列讀取數(shù)組元素后未能分出勝負需要將number置為0
   number=0;
  }
 }

展現(xiàn)第二個方法的結(jié)果

第三個方法代碼

// 實現(xiàn)自左上--->右下判斷黑棋，每次第二個for循環(huán)最開始列不變，階梯逼近左下的方法
 public static void BlackTopLeftToBottomRight_Line(int BoardSize, String[][] board) {
//  先定義一個數(shù)number,以此來計數(shù)
  int number=0;
//  每當執(zhí)行第二個for循環(huán)的時候列l(wèi)ine總是從0開始
  for(int row=0;row<BoardSize;row++) {
//   執(zhí)行這個for循環(huán)的時候每一次行+1，列+1，數(shù)據(jù)元素呈現(xiàn)階梯分布，階梯逼近左下
   for(int line=0,i=row;line<BoardSize-row;line++,i++) {
//    如果此階梯中有元素為黑棋則number+1
    if(board[i][line]=="●") {
     number++;
    }
//    當number為5的時候則黑棋一方的勝
    while(number==5) {
     System.out.println("黑棋方勝！");
        //勝出后輸出棋盤
        for ( row = 0; row < board.length; row++) {
         for ( line = 0; line < board[i].length; line++) {
          System.out.print( board[row][line]+" ");
         }
         System.out.println();
        }
        //勝后退出系統(tǒng)
        System.exit(0);
    }
//    如果此階梯中雖有五個黑棋但是并不相連，不能說是黑方勝，需將number置為0
    if(board[i][line]=="○"|| board[i][line]=="+") {
     number=0;
    }
   }
//   每當?shù)诙€for循環(huán)完畢后需要將number置為0
   number=0;
  }
 }

展現(xiàn)第三種方法的結(jié)果

第四個方法代碼

// 實現(xiàn)自左上--->右下判斷黑棋，每次第二個for循環(huán)最開始行不變，階梯逼近右上的方法
 public static void BlackTopLeftToBottomRight_Row(int BoardSize, String[][] board) {
//  先定義一個數(shù)number,以此來計數(shù)
  int number=0;
//  每當執(zhí)行第二個for循環(huán)的時候行row總是從0開始
  for(int line=0;line<BoardSize;line++) {
//   執(zhí)行這個for循環(huán)的時候每一次列+1，行+1，數(shù)據(jù)元素呈現(xiàn)階梯分布，階梯逼近右上
   for(int row=0,i=line;row<BoardSize-line;row++,i++) {
//    如果此階梯中有元素為黑棋則number+1
    if(board[row][i]=="●") {
     number++;
    }
//    當number為5的時候則黑棋一方的勝
    while(number==5) {
     System.out.println("黑棋方勝！");
        //勝出后輸出棋盤
        for ( row = 0; row < board.length; row++) {
         for ( line = 0; line < board[row].length; line++) {
          System.out.print( board[row][line]+" ");
         }
         System.out.println();
        }
        //勝后退出系統(tǒng)
        System.exit(0);
    }
//    如果此階梯中雖有五個黑棋但是并不相連，不能說是黑方勝，需將number置為0
    if(board[row][i]=="○"|| board[row][i]=="+") {
     number=0;
    }
   }
//   每當?shù)诙€for循環(huán)完畢后需要將number置為0
   number=0;
  }
 }

第四個方法結(jié)果展示

第五個方法的代碼

// 實現(xiàn)自右上--->左下判斷黑棋，每次第二個for循環(huán)最開始列不變，階梯逼近右下的方法
 public static void BlackTopRightToBottomLeft_Line(int BoardSize, String[][] board) {
//  先定義一個數(shù)number,以此來計數(shù)
  int number=0;
//  每當執(zhí)行第二個for循環(huán)的時候列l(wèi)ine總是從最后一列開始
  for(int row=0;row<BoardSize;row++) {
//   執(zhí)行這個for循環(huán)的時候每一次列+1，行+1，數(shù)據(jù)元素呈現(xiàn)階梯分布，階梯逼近右下
   for(int line=BoardSize-1,i=row;line>=0+row;line--,i++) {
//    如果此階梯中有元素為黑棋則number+1
    if(board[i][line]=="●") {
     number++;
    }
//    當number為5的時候則黑棋一方的勝
    while(number==5) {
     System.out.println("黑棋方勝！");
        //勝出后輸出棋盤
        for ( row = 0; row < board.length; row++) {
         for ( line = 0; line < board[row].length; line++) {
          System.out.print( board[row][line]+" ");
         }
         System.out.println();
        }
        //勝后退出系統(tǒng)
        System.exit(0);
    }
//    如果此階梯中雖有五個黑棋但是并不相連，不能說是黑方勝，需將number置為0
    if(board[i][line]=="○"|| board[i][line]=="+") {
     number=0;
    }
   }
//   每當?shù)诙€for循環(huán)完畢后需要將number置為0
   number=0;
  }
 }

第五個方法結(jié)果展示

第六個方法的代碼

// 實現(xiàn)自右上--->左下判斷黑棋，每次第二個for循環(huán)最開始行不變，階梯逼近左上的方法
 public static void BlackTopRightToBottomLeft_Row(int BoardSize, String[][] board) {
//  先定義一個數(shù)number,以此來計數(shù)
  int number=0;
//  每當執(zhí)行第二個for循環(huán)的時候行row總是從最后一列開始
  for(int line=BoardSize-1;line>=0;line--) {
//   執(zhí)行這個for循環(huán)的時候每一次列+1，行+1，數(shù)據(jù)元素呈現(xiàn)階梯分布，階梯逼近左上
   for(int row=0,j=line;row<line;j--,row++) {
//    如果此階梯中有元素為黑棋則number+1
    if(board[row][j]=="●") {
     number++;
    }
//    當number為5的時候則黑棋一方的勝
    while(number==5) {
     System.out.println("黑棋方勝！");
        //勝出后輸出棋盤
        for ( row = 0; row < board.length; row++) {
         for ( line = 0; line < board[row].length; line++) {
          System.out.print( board[row][line]+" ");
         }
         System.out.println();
        }
        //勝后退出系統(tǒng)
        System.exit(0);
    }
//    如果此階梯中雖有五個黑棋但是并不相連，不能說是黑方勝，需將number置為0
    if(board[row][j]=="○"|| board[row][j]=="+") {
     number=0;
    }
   }
//   每當?shù)诙€for循環(huán)完畢后需要將number置為0
   number=0;
  }
 }

第六個方法結(jié)果展示

后面是白棋的判斷方法的代碼，與黑棋一樣

// 實現(xiàn)行判斷白棋
 public static void WhiteRow(int BoardSize, String[][] board) {
//  先定義一個數(shù)number,以此來計數(shù)
  int number=0;
//  一行一行的讀取數(shù)組中的元素
  for(int row=0;row<BoardSize;row++) {
   for(int line=0;line<BoardSize;line++) {
//    如果此行中有元素為白棋則number+1
    if(board[row][line]=="○") {
     number++;
    }
//    當number為5的時候則白棋一方的勝
    while(number==5) {
     System.out.println("白棋方勝！");
        //勝出后輸出棋盤
        for ( row = 0; row < board.length; row++) {
         for ( line = 0; line < board[row].length; line++) {
          System.out.print( board[row][line]+" ");
         }
         System.out.println();
        }
        //勝后退出系統(tǒng)
        System.exit(0);
    }
//    如果此行中雖有五個白棋但是并不相連，不能說是白棋方勝，需將number置為0
    if(board[row][line]=="●"|| board[row][line]=="+") {
     number=0;
    }
   }
//   每一行讀取數(shù)組元素后未能分出勝負需要將number置為0
   number=0;
  }
 }
// 實現(xiàn)列判斷白棋
 public static void WhiteLine(int BoardSize, String[][] board) {
//  先定義一個數(shù)number,以此來計數(shù)
  int number=0;
//  一列一列的讀取數(shù)組中的元素
  for(int line=0;line<BoardSize;line++) {
   for(int row=0;row<BoardSize;row++) {
//    如果此列中有元素為白棋則number+1
    if(board[row][line]=="○") {
     number++;
    }
//    當number為5的時候則白棋一方的勝
    while(number==5) {
     System.out.println("白棋方勝！");
        //勝出后輸出棋盤
        for ( row = 0; row < board.length; row++) {
         for ( line = 0; line < board[row].length; line++) {
          System.out.print( board[row][line]+" ");
         }
         System.out.println();
        }
        //勝后退出系統(tǒng)
        System.exit(0);
    }
//    如果此列中雖有五個白棋但是并不相連，不能說是白棋方勝，需將number置為0
    if(board[row][line]=="●"|| board[row][line]=="+") {
     number=0;
    }
   }
//   每一列讀取數(shù)組元素后未能分出勝負需要將number置為0
   number=0;
  }
 }
// 實現(xiàn)自左上--->右下判斷白棋，每次第二個for循環(huán)最開始列不變，階梯逼近左下的方法
 public static void WhiteTopLeftToBottomRight_Line(int BoardSize, String[][] board) {
//  先定義一個數(shù)number,以此來計數(shù)
  int number=0;
//  每當執(zhí)行第二個for循環(huán)的時候列l(wèi)ine總是從0開始
  for(int row=0;row<BoardSize;row++) {
//   執(zhí)行這個for循環(huán)的時候每一次行+1，列+1，數(shù)據(jù)元素呈現(xiàn)階梯分布，階梯逼近左下
   for(int line=0,i=row;line<BoardSize-row;line++,i++) {
//    如果此階梯中有元素為白棋則number+1
    if(board[i][line]=="○") {
     number++;
    }
//    當number為5的時候則白棋一方的勝
    while(number==5) {
     System.out.println("白棋方勝！");
        //勝出后輸出棋盤
        for ( row = 0; row < board.length; row++) {
         for ( line = 0; line < board[i].length; line++) {
          System.out.print( board[row][line]+" ");
         }
         System.out.println();
        }
        //勝后退出系統(tǒng)
        System.exit(0);
    }
//    如果此階梯中雖有五個白棋但是并不相連，不能說是黑白方勝，需將number置為0
    if(board[i][line]=="●"|| board[i][line]=="+") {
     number=0;
    }
   }
//   每當?shù)诙€for循環(huán)完畢后需要將number置為0
   number=0;
  }
 }
// 實現(xiàn)自左上--->右下判斷白棋，每次第二個for循環(huán)最開始行不變，階梯逼近右上的方法
 public static void WhiteTopLeftToBottomRight_Row(int BoardSize, String[][] board) {
//  先定義一個數(shù)number,以此來計數(shù)
  int number=0;
//  每當執(zhí)行第二個for循環(huán)的時候行row總是從0開始
  for(int line=0;line<BoardSize;line++) {
//   執(zhí)行這個for循環(huán)的時候每一次列+1，行+1，數(shù)據(jù)元素呈現(xiàn)階梯分布，階梯逼近右上
   for( int row=0,i=line;row<BoardSize-line;row++,i++) {
//    如果此階梯中有元素為白棋則number+1
    if(board[row][i]=="○") {
     number++;
    }
//    當number為5的時候則白棋一方的勝
    while(number==5) {
     System.out.println("白棋方勝！");
        //勝出后輸出棋盤
        for ( row = 0; row < board.length; row++) {
         for ( line = 0; line < board[row].length; line++) {
          System.out.print( board[row][line]+" ");
         }
         System.out.println();
        }
        //勝后退出系統(tǒng)
        System.exit(0);
    }
//    如果此階梯中雖有五個白棋但是并不相連，不能說是白方勝，需將number置為0
    if(board[row][i]=="●"|| board[row][i]=="+") {
     number=0;
    }
   }
//   每當?shù)诙€for循環(huán)完畢后需要將number置為0
   number=0;
  }
 }
// 實現(xiàn)自右上--->左下判斷白棋，每次第二個for循環(huán)最開始列不變，階梯逼近右下的方法
 public static void WhiteTopRightToBottomLeft_Line(int BoardSize, String[][] board) {
//  先定義一個數(shù)number,以此來計數(shù)
  int number=0;
//  每當執(zhí)行第二個for循環(huán)的時候列l(wèi)ine總是從最后一列開始
  for(int row=0;row<BoardSize;row++) {
//   執(zhí)行這個for循環(huán)的時候每一次列+1，行+1，數(shù)據(jù)元素呈現(xiàn)階梯分布，階梯逼近右下
   for(int line=BoardSize-1,i=row;line>=0+row;line--,i++) {
    if(board[i][line]=="○") {
//     如果此階梯中有元素為白棋則number+1
     number++;
    }
//    當number為5的時候則白棋一方的勝
    while(number==5) {
     System.out.println("白棋方勝！");
        //勝出后輸出棋盤
        for ( row = 0; row < board.length; row++) {
         for ( line = 0; line < board[row].length; line++) {
          System.out.print( board[row][line]+" ");
         }
         System.out.println();
        }
        //勝后退出系統(tǒng)
        System.exit(0);
    }
//    如果此階梯中雖有五個白棋但是并不相連，不能說是白方勝，需將number置為0
    if(board[i][line]=="●"|| board[i][line]=="+") {
     number=0;
    }
   }
//   每當?shù)诙€for循環(huán)完畢后需要將number置為0
   number=0;
  }
 }
// 實現(xiàn)自右上--->左下判斷白棋，每次第二個for循環(huán)最開始行不變，階梯逼近左上的方法
 public static void WhiteTopRightToBottomLeft_Row(int BoardSize, String[][] board) {
//  先定義一個數(shù)number,以此來計數(shù)
  int number=0;
//  每當執(zhí)行第二個for循環(huán)的時候行row總是從最后一列開始
  for(int line=BoardSize-1;line>=0;line--) {
//   執(zhí)行這個for循環(huán)的時候每一次列+1，行+1，數(shù)據(jù)元素呈現(xiàn)階梯分布，階梯逼近左上
   for(int row=0,j=line;row<line;j--,row++) {
//    如果此階梯中有元素為白棋則number+1
    if(board[row][j]=="○") {
     number++;
    }
//    當number為5的時候則白棋一方的勝
    while(number==5) {
     System.out.println("白棋方勝！");
        //勝出后輸出棋盤
        for ( row = 0;row < board.length; row++) {
         for ( line = 0;line < board[row].length; line++) {
          System.out.print( board[row][line]+" ");
         }
         System.out.println();
        }
        //勝后退出系統(tǒng)
        System.exit(0);
    }
//    如果此階梯中雖有五個白棋但是并不相連，不能說是白方勝，需將number置為0
    if(board[row][j]=="●"|| board[row][j]=="+") {
     number=0;
    }
   }
//   每當?shù)诙€for循環(huán)完畢后需要將number置為0
   number=0;
  }
 }
}

到此，關(guān)于“如何用Java實現(xiàn)五子棋游戲”的學習就結(jié)束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續(xù)學習更多相關(guān)知識，請繼續(xù)關(guān)注億速云網(wǎng)站，小編會繼續(xù)努力為大家?guī)砀鄬嵱玫奈恼拢?/p>