Java基础实训项目——————五子棋

package com.bzu.test;

import java.util.Scanner;
/*
文件名：FiveChessGame.java
项目名称：五子棋游戏(控制台)
项目功能：在控制台实现五子棋游戏
创建日期：2018.11.11
修改日期：2018.11.19
修改内容：添加文档注释
*/
//五子棋游戏
public class FiveChessGame
{
     

	//使用静态初始化二维数组的方式创建棋盘
	static char[][] chess={
       
					          {
     ' ','0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'},  //第0行
					          {
     '0','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},  //第1行
					          {
     '1','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},
					          {
     '2','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},
					          {
     '3','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},  //第4行
					          {
     '4','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},
					          {
     '5','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},
					          {
     '6','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},
					          {
     '7','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},
					          {
     '8','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},
					          {
     '9','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},
					          {
     'a','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'}, //第11行
					          {
     'b','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},
					          {
     'c','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},
					          {
     'd','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},
					          {
     'e','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},
					          {
     'f','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'}   //第16行
			          };
	
	//主函数main
	public static void main(String[] args)
	{
     
		//使用循环将棋盘的内容输出
//		for(int i=0;i
//			for(int j=0;j
//				System.out.print(chess[i][j]+" ");
//			}
//			System.out.println(); //换行
//		}
		//调用printChess方法，输出棋盘的内容
		printChess();
		//使用死循环实现黑白双方反复下棋
		boolean flag=true;//设定flag的值如果为true,用于控制黑方落子；如果flag的为false，用于控制白方落子
		//创建Scanner扫描器
		Scanner sc=new Scanner(System.in); 
		while(true){
     
			//控制黑方落子
			if(flag){
       
				//黑方落子
				System.out.println("请黑方落子：");
				String blackStr=sc.next();  //黑方从控制台输入的内容
//				System.out.println("黑方输入的内容是:"+blackStr);
				//charAt(下标)  将字符串根据下标拆分为一个一个的字符      "34" "af" "be"
				char cB1=blackStr.charAt(0);
				char cB2=blackStr.charAt(1);
//				System.out.println("行是:"+cB1);
//				System.out.println("列是:"+cB2);
				//根据黑方从控制台输入的行和列，判断该位置上是否已经有棋子了
				//调用isHaveChess方法,该方法返回结果:1或者0
				int numB=isHaveChess(cB1,cB2);
				if(numB==1){
       //如果if条件是成立,说明该位置上已经有棋子了，需要让黑方重新落子
					System.out.println("该位置上已经有棋子了，请重新输入");
					flag=true; //需要将flag的值赋值为true,保证控制黑方落子
				}else{
       //如果else成立，说明该位置上没有棋子，可以正常下棋落子，然后正常打印棋盘
					//假设黑方输入的是a行，f列，在二维数组棋盘中对应的行下标和列下标是11和16
					//chess[11][16]='@';
					//调用updateBlackChess方法，该方法能够根据黑方在控制台输入的行和列，在对应的位置将*修改为@
					updateBlackChess(cB1,cB2);
					//当黑方输入完行列后，将对应位置的内容修改为@后，要重新将棋盘的内容输出
					//for(int i=0;i
						//for(int j=0;j
							//System.out.print(chess[i][j]+" ");
						//}
						//System.out.println();//换行
					//}
					//调用printChess方法，将棋盘的内容输出
					printChess();
					//判断黑方是否会胜利，如果黑方胜利，游戏结束；如果黑方未胜利，让白方继续落子
					//调用isBlackWin方法，目的是判断黑方是否会胜利
					boolean bWin=isBlackWin();
					if(bWin){
        //黑方胜利的情况，游戏结束
						System.out.println("黑方胜利，游戏结束");
						break; //直接结束循环，while死循环结束，游戏也就结束了
					}else{
       //黑方还未胜利的情况
						flag=false; //当黑方输入落子后，flag的值要修改为false，黑方完了让白方落子
					}
				}
				
			}
			
			//控制白方落子
			if(!flag){
     
				//白方落子
				System.out.println("请白方落子:");
				String whiteStr=sc.next();  //白方输入的内容
//				System.out.println("白方输入的内容是:"+whiteStr);
				//将白方输入的内容拆分，得到对应的行和列
                char cW1=whiteStr.charAt(0);
				char cW2=whiteStr.charAt(1);
//				System.out.println("行是:"+cW1);
//				System.out.println("列是:"+cW2);
				//调用isHaveChess方法，判断白方是否重复落子
				int numW=isHaveChess(cW1,cW2);
				if(numW==1){
      //该位置上已经有棋子的情况
					System.out.println("该位置上已经有棋子了，请重新输入");
					flag=false;  //控制是让白方落子
				}else{
      //该位置上没有棋子的情况
					//假设白方输入的是3行6列，在二维数组棋盘中对应的行下标和列下标是4和7
					//chess[4][7]='0';
					//调用updateWhilteChess方法
					updateWhiteChess(cW1,cW2);
					//当白方输入完后，将对应的位置修改为0，需要重新将棋盘的内容输出
					//for(int i=0;i
						//for(int j=0;j
							//System.out.print(chess[i][j]+" ");
						//}
						//System.out.println();//换行
					//}
					//调用printChess方法，输出棋盘的内容
					printChess();
					boolean TWin=isWhiteWin();
					if(TWin){
        //白方胜利的情况，游戏结束
						System.out.println("白方胜利，游戏结束");
						break; //直接结束循环，while死循环结束，游戏也就结束了
					}else{
       //白方还未胜利的情况
						flag=true; //当黑方输入落子后，flag的值要修改为false，黑方完了让白方落子
					}
				}
			}
		}
		
		
	}  //main方法结束的括号
	
	//自定义方法  -- 将二维数组棋盘的内容输出
	public static void printChess(){
     
		for(int i=0;i<chess.length;i++){
      //变量i表示访问棋盘的行，取值是0-16
			for(int j=0;j<chess[i].length;j++){
      //变量j表示访问棋盘每一行的列，取值是0-16
				System.out.print(chess[i][j]+" ");
			}
			System.out.println();//换行
		}
	}
	
	//自定义方法  -- 根据黑方在控制台输入的行和列，在对应的位置将*修改为@
	//c1和c2参数表示黑方在控制台输入的行和列      a行f列       3行5列
	public static void updateBlackChess(char c1,char c2){
     
		//思路： a行f列    c1=a   c2=f       chess[11][16]='@'
		//     3行5列   c1=3   c2=5       chess[4][6]='@'
		//     1行2列    行下标和列下标2行和3列  chess[2][3]='@'
		//核心解决办法： 根据在控制台输入的行和列，要找出在二维数组棋盘中对应的行下标和列下标，最后根据行下标和列下标在棋盘中将*覆盖为@
		char[] cr={
     ' ','0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
		//   下标          0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16
		int x=0;
		int y=0;
		//c1和c2表示黑方从控制台输入的行和列    x和y表示根据输入的行列找到二维数组棋盘中的行下标和列下标
		//c1=a  c2=f     --->  x=11 y=16
		for(int i=0;i<cr.length;i++){
     //变量i表示访问一维数组cr的下标，取值是0-16
			if(cr[i]==c1){
      //当if判断成立的时候，此时i的值就是找到的行下标
				x=i;  
			}
			if(cr[i]==c2){
       //当if判断成立的时候，此时i的值就是找到的列下标
				y=i;
			}
		}
		//根据找到的行下标x和列下标y，找到对应的位置，将*修改为@
		chess[x][y]='@';
	}
	
	//自定义方法  -- 根据白方输入的行和列，在对应的位置将*改成0
	public static void updateWhiteChess(char c1,char c2){
     
		int x=0;
		int y=0;
		//c1和c2表示在控制台输入的行和列    x和y表示二维数组棋盘中的行下标和列下标
		char[] cr={
     ' ','0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
		//下标                0    1   2   3   4   5   6   7   8   9  10   11  12  13  14  15  16
		for(int i=0;i<cr.length;i++){
       //变量i表示访问数组cr的下标
			if(cr[i]==c1){
     
				x=i;
			}
			if(cr[i]==c2){
     
				y=i;
			}
		}
		//根据行下标和列下标将对应位置的*修改为0
		chess[x][y]='0';
	}
	
	//自定义方法 -- 根据从控制台输入的行和列，判断该位置上是否有棋子
	//c1和c2表示从控制台输入的行和列    该方法如果返回1表示该位置上有棋子    该方法如果返回0表示该位置上没有棋子
	public static int isHaveChess(char c1,char c2){
     
		//思路：根据从控制输入的行c1和列c2,找到二维数组棋盘中的行下标和列下标，根据行下标和列下标判断该位置上是否是0或者@
		int x=0;
		int y=0;  //x和y表示二维数组棋盘中的行下标和列下标
		char[] cr={
     ' ','0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
		//下标                 0    1   2   3  4    5  6    7   8  9   10  11  12  13  14  15  16
		for(int i=0;i<cr.length;i++){
       //变量i表示访问数组cr的下标，取值0-16
			if(cr[i]==c1){
       //判断找出行下标
				x=i;
			}
			if(cr[i]==c2){
      //判断找出列下标
				y=i;
			}
		}
		//根据找到的行下标和列下标x y，判断该位置上是否有棋子
		//如果该位置上有棋子，返回1；如果该位置上没有棋子，返回0
		if(chess[x][y]=='0' || chess[x][y]=='@'){
        //if条件成立，该位置上有棋子
			return 1;
		}else{
       //else条件成立，该位置上没有棋子
			return 0;
		}
	}
	
	//自定义方法 -- 判断黑方胜利
	//该方法如果返回true,表示黑方胜利；该方法如果返回false，表示黑方未胜利
	public static boolean isBlackWin(){
     
		//判断横向-是否有连续5个@
		for(int i=1;i<chess.length;i++){
      //变量i表示访问棋盘的行，取值是1-16
			//i=1  j=1 2 3 4 5 6 .... 12
			//i=2  j=1 2 3 4 5 6 .... 12
			//...
			//i=16 j=1 2 3 4 5 6 .... 12
			for(int j=1;j<chess[i].length-4;j++){
      //变量j表示访问棋盘每一行的列，取值是1-12
				if(chess[i][j]=='@'&&chess[i][j+1]=='@'&&chess[i][j+2]=='@'&&chess[i][j+3]=='@'&&chess[i][j+4]=='@'){
     
					//该判断只要成立，说明横向有连续5个@
					return true;
				}
			}
		}
		//判断纵向|是否有连续5个@
		for(int j=1;j<chess[0].length;j++){
       //变量j表示棋盘中的每一列  chess[0].length表示第0行的列为17列    j的取值是1-16
			//j=1   i=1 2 3 4 5 6 7 ...12
			//j=2   i=1 2 3 4 5 6 7 ...12
			//...
			//j=16  i=1 2 3 4 5 6 7... 12
			for(int i=1;i<chess.length-4;i++){
      //变量i表示棋盘的行，从1开始，取值到12
				if(chess[i][j]=='@'&&chess[i+1][j]=='@'&&chess[i+2][j]=='@'&&chess[i+3][j]=='@'&&chess[i+4][j]=='@'){
     
					//该判断成立，说明纵向有连续5个@
					return true;
				}
			}
		}
        
        //判断正斜是否有连续五个‘@’
        
        for(int i = 1; i< chess.length-4;i++){
     
            for(int j = 5;j<chess[i].length;j++){
     
                if(chess[i][j] == '@' && chess[i+1][j-1]=='@'&& chess[i+2][j-2]=='&' && chess[i+3][j-3]=='@'&&chess[i+4][j-4]=='@'){
     
                    return true;
                }

            }
        }
        //判断反斜是否有连续五个‘@’
        for(int i =1 ; i<chess.length-4;i++){
     	//变量i表示访问棋盘的行，取值从1开始，到12结束
        	for(int j = 1;j<chess[i].length-4; j++) {
       // 变量j表示访问棋盘的列，从1开始，到12结束
        		if (chess[i][j] == '@' && chess[i+1][j+1] == '@' && chess[i+2][j+2] == '@' && chess[i+3][j+3] == '@' && chess[i+4][j+4]=='@') {
     
				
        			//该判断成立，
        			return true;        		
        		}
        	}
        }
        return false;
    }

	
	//自定义方法 -- 判断白方胜利
	//该方法如果返回true，表示白方胜利，该方法如果返回false，表示白方未胜利
	public static boolean isWhiteWin() {
     
		//判断横向是否有连续5个0 
				for (int i = 1 ;i < chess.length;i++ )
				{
     
					for (int j = 1 ;j <chess[i].length-4;j++) {
     
						if (chess[i][j]=='0'&&chess[i][j+1]=='0'&& chess[i][j+2]=='0'&& chess[i][j+3]=='0'&&chess[i][j+4]=='0') {
     
							return true;
						}
					}
				}
				//判断纵向是否有连续5个0
				for(int j = 1 ; j <chess[0].length ;j++) {
     
					for(int i = 1 ;i < chess.length-4;i++) {
     
						if (chess[i][j]=='0'&&chess[i+1][j]=='0'&& chess[i+2][j]=='0'&& chess[i+3][j]=='0'&&chess[i+4][j]=='0') {
     
							return true;
					}
				}
			}
				//判断正斜/是否有连续5个0
				for(int i = 1 ;i <chess.length-4;i++)
				{
     
					for(int j =5 ;j<chess[i].length;j++) {
     
						if(chess[i][j]== '0'&&chess[i+1][j-1]== '0'&&chess[i+2][j-2]== '0'&&chess[i+3][j-3]== '0'&&chess[i+4][j-4]== '0'){
     
							return true;
							}
						}
					}
						
				//判断反斜\是否有连续5个0
				for(int i = 1 ;i <chess.length-4;i++){
     
		            for (int j = 1; j <chess[i].length-4;j++ ) {
     
						if(chess[i][j]== '0'&&chess[i+1][j+1]== '0'&&chess[i+2][j+2]== '0'&&chess[i+3][j+3]== '0'&&chess[i+4][j+4]== '0') {
     
							return true;
						}
					}
		        }
				return false;
		}	
	}