一个控制台上永远都是你赢的五子棋游戏，囧

就是这样一个白痴游戏，我都花了那么久时间，真是有些泄气，不过啊
路漫漫其修远兮，不要急，不积跬步，无以至千里。
你还有一年的时间，这不弄出来了吗~
加油，不许泄气，加油~
发疯学习
想象一下三个月后的你，一年后的你该是一番什么模样啊？
期待！

package 五子棋小游戏;

public class Chessboard {

/*
 * 变量：
 * board 类型 String [][]
 * BOARD_SIZE 类型：int 初始值——22
 * 
 * 方法：
 * 构造方法：
 * 调用initalBoard()
 * intalBoard()
 * printBoard()
 * setBoard(int posX,int posY,String Chessman)
 * getBoard(),返回值为 String[][] 返回board二维数组
 * 
 */
    //棋盘二维数组以及棋盘的大小

    public static final int BOARD_SIZE = 15;
    private String[][] board= new String [BOARD_SIZE][BOARD_SIZE];

    //初始化棋盘二维数组。
    public Chessboard()
    {
        initalBoard();
    }

    //棋盘初始化赋值。共有方法，便于重新开始游戏初始化棋盘。无返回值
    public  void initalBoard()
    {
        for(int i=0;i<BOARD_SIZE;i++)
        {
            for(int j= 0;j<BOARD_SIZE;j++)
            {

                    board[i][j]="十";
            }
        }
    }

    // 打印棋盘，遍历一次board二维数组。共有 无返回值方法。
    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.print("\n");
        }
    }

    //第三个方法：将棋子放在相对应坐标上。
    public void setBoard(int posX,int posY,String Chessman)
    {
        board[posX][posY] = Chessman;
    }

    //第四个方法，getBoard() 作用在于：将封装的board数组返回到游戏中用于判断是否已有棋子 
    public String[][] getBoard()
    {
        return board;
    }

}

package 五子棋小游戏;

public enum Chessman 
{
    //java 5 之后才有枚举类的出现。 构造器私有，枚举类用于实例有限且固定的时候
    //实例都用public static final 修饰。提供获得实例的方法。
    //烦死了~
    BLACK("●"),WHITE("○");
    private String chessman;
    private Chessman(String chessman)
    {
        this.chessman= chessman;
    }
    public String getChessman()
    {
        return chessman;
    }
}

package 五子棋小游戏;

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

public class GobangGame {
/*
 * 变量：
 * 1,WIN_COUNT 
 * 2,posX,posY
 * 3,chessboard——引用Chessboard的二维数组。
 * 方法：
 * 1,isValid(String inputStr) throws Exception 方法内解决。

 * 3,isReplay(String chessman)
 * 4,int[] computerDo()
 * 5,isWon(int posX,int posY,String currentChessman)
 */


    public static final int WIN_COUNT = 5;
    public static int posX=0,posY=0;
    static Chessboard chessboard =new Chessboard();


    //第一个方法：无参构造器，以及初始化一个棋盘的构造器。后者还不知道其作用。
    public GobangGame()
    {

    }

    public GobangGame(Chessboard chessboard)
    {
        chessboard =new Chessboard();
    }

    //第二个方法；isValid(String inputStr) throws NumberFormatException (数字格式化异常)
    //经过三个步骤：a，判断是否为合法数字；b，判断是否在数组范围内的坐标；c，判断该坐标是否已有棋子。
    public static boolean isValid(String inputStr) throws NumberFormatException
    {
        //a,判断是否是合法数字。这里要try catch处理，会抛出异常。
        //将读到的输入以逗号隔开放在字符串数组中，并将其元素转换成数字赋值给xy坐标。
        try
        {
        String[]posStrArr =inputStr.split(",");
        posX = Integer.parseInt(posStrArr[0])-1;
        posY = Integer.parseInt(posStrArr[1])-1;
        }
        catch(NumberFormatException e)
        {
            chessboard.printBoard();
            System.out.println("你个傻叉~~~~(>_<)~~~~格式不正确啦，还能不能好好玩耍啦，格式是这样的啦——（数字，数字）：");
            return false;
        }

        //b,检验xy是否在棋盘的坐标范围内。
        if(posX<0||posX>Chessboard.BOARD_SIZE|| 
           posY<0||posY>Chessboard.BOARD_SIZE)
        {
            chessboard.printBoard();
            System.out.println("你看看，棋盘就那么大，想在棋盘外面自己玩呀，-_-! 老子再给你一次输入机会：");
            return false;
        }

        //c,检验这个坐标是否已经有棋子了。

        //我懂了，因为不能直接访问已经封装了的棋盘，所以通过方法获得这个二维数组的访问权。
        String [][]board = chessboard.getBoard();
        if(board[posX][posY]!="十")
        {
            chessboard.printBoard();
            System.out.println("你不长眼啊，这里都有棋子了，还往这里下-_-# ");
            return false;

        }
        return true;
    }
    public static 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[] computerPosXY ={posX,posY};
        return computerPosXY;
    }


    //isReplay()方法。不明白它为什么会抛出异常。
    public static boolean isReplay(String chessman) throws Exception
    {
        chessboard.printBoard();
        String message = chessman.equals(Chessman.BLACK.getChessman())
                ?"卧槽，你居然赢了我！%>_<%不服气，敢再来一盘吗？（y/n）"
                        :"切，小样你输了吧，有本事再来一盘，看我怎么虐你（y/n）";
        System.out.println(message);
        BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
        if(br.readLine().equals("y"))
        {
            return true;
        }
        return false;

    }


    //还有最后一个isWon()方法。
    public static boolean isWon(int posX,int posY,String ico)
    {
        //直线XY的起点和终点。
        int startX=0;
        int startY=0;
        int endX =Chessboard.BOARD_SIZE-1;
        int endY =Chessboard.BOARD_SIZE-1;
        //同一条直线上相邻棋子的累积数
        int SumOfCh = 0;
        int temp = 0;

        //计算起点的最小XY坐标
        temp = posX-WIN_COUNT + 1;
        //如果posX坐标小于4这个距离的话那么就由零坐标开始数，
        //否则就由距离posX坐标4的位置开始数起。
        startX = temp<0?0:temp;
        temp = posY - WIN_COUNT +1;
        startY = temp<0? 0 : temp;

        //计算终点的最大XY坐标。
        temp = posX+ WIN_COUNT-1;
        endX = temp>Chessboard.BOARD_SIZE-1? Chessboard.BOARD_SIZE-1:temp;
        temp = posY+WIN_COUNT-1;
        endY = temp>Chessboard.BOARD_SIZE-1? Chessboard.BOARD_SIZE-1:temp;


        //检验横方向 从左到右方向计算相邻棋子的数目
        String [][] board = chessboard.getBoard();
        for(int i = startY;i<endY;i++)
        {
            if(board[posX][i]==ico && board[posX][i+1]==ico)
            {
                SumOfCh ++ ;
            }
            else if (SumOfCh!= WIN_COUNT-1)
            {
                SumOfCh= 0;
            }
        }
        if(SumOfCh==WIN_COUNT-1)
        return true;    

        //同理检验竖方向的棋子数
        for(int i = startX;i<endX;i++)
        {
            if(board[i][posY]==ico && board[i+1][posY]==ico)
            {
                SumOfCh ++;
            }
            else if (SumOfCh!=WIN_COUNT-1)
            {
                SumOfCh = 0;
            }
        }
        if(SumOfCh==WIN_COUNT-1)
            return true;

        //检验对角线。要嵌套循环
        for(int i= startX;i<endX;i++)
        {
            for(int j=startY;j<endY;j++)
            {
                if(board[i][j]==ico && board[i+1][j+1]==ico)
                {
                    SumOfCh++;
                }
                else if(SumOfCh!= WIN_COUNT-1)
                {
                    SumOfCh = 0 ;
                }
            }
        }

        if(SumOfCh==WIN_COUNT-1)
            return true;

        // 检验反对角线。嵌套循环。
        for(int i =endX;i>startX;i--)
        {
            for (int j= startY;j>endY;j++)
            {
                if(board[i][j]==ico && board[i-1][j+1]==ico)
                {
                    SumOfCh ++ ;
                }
                else if(SumOfCh!= WIN_COUNT-1)
                {
                    SumOfCh =0;
                }
            }
        }
        if(SumOfCh==WIN_COUNT-1)
            return true;
        else return false;
        }
    public static void main(String[] args) throws NumberFormatException, IOException, Exception {
        BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
        String inputStr =null;
        boolean isOver;
        chessboard.printBoard();
        while((inputStr = br.readLine())!=null)
        {
            isOver =false;
            if(!isValid(inputStr))
            {
                continue;
            }
            String chessman = Chessman.BLACK.getChessman();

            chessboard.setBoard(posX, posY, chessman);

            if(isWon(posX,posY,chessman))
            {
                isOver = true;
            }
            else
            {
                int[]computerPosArr =computerDo();
                chessman = Chessman.WHITE.getChessman();
                chessboard.setBoard(computerPosArr[0],computerPosArr[1], chessman);
                if(isWon(computerPosArr[0],computerPosArr[1],chessman))
                {
                    isOver = true;
                }

            }
            if(isOver)
            {
                if(isReplay(chessman))
                {
                    chessboard.initalBoard();
                    chessboard.printBoard();
                    continue;

                }
                break;
            }
            chessboard.printBoard();
            System.out.println("快点下啦，要想那么久吗？囧");
        }

    }

}