tictactoe——前世今生

类的协作 职责 以及 可修改性

simple tictactoe

完成的是就是根据输入打印每次的棋盘，并且进行判断输赢

Board类

成员变量是一个二维棋盘（把行列设为final同时也应用于下面，可以增加可修改性，防止后续全部改变）
职责： 构建一个棋盘，并且记录每一次的情况，判定当前游戏的结果

这里比较巧妙的代码实现点是：虽然是X O 但在进行中我们可以让数字去代表这两个字符，并且判定结果
Gmae: turn=turn✖-1;
可谓是节省很多麻烦的关键因素

class Board {
    final static int row = 3;
    final static int col = 3;
    private int[][] board = new int[row][col];

    public void setBoard(int turn, String pos) {
        int x = pos.charAt(1) - '1';
        int y = pos.charAt(0) - 'A';
        if (this.board[x][y] != 0)
            System.out.println("Error. This place has been placed before");
        else
            board[x][y] = turn;
    }

    public void print() {
        System.out.print(this.toString());
    }

    public String toString() {
        String lineSeparator = System.getProperty("line.separator");
        String ret = "  A B C" + lineSeparator;
        for (int i = 0; i < row; i++) {
            ret += i + 1;
            for (int j = 0; j < col; j++) {
                if (board[i][j] == 1)
                    ret += " X";
                else if (board[i][j] == -1)
                    ret += " O";
                else
                    ret += " _";
            }
            ret += lineSeparator;
        }
        return ret;
    }

    /**
     * 根据题目要求进行判断
     * @return
     */
    public Result getStatement() {
        for (int i = 0; i < row; i++) {
            int temp = 0;
            for (int j = 0; j < col; j++)
                temp += board[i][j];

            if (temp == 3)         return Result.X_WIN;
            else if (temp == -3)   return Result.O_WIN;
        }

        for (int i = 0; i < row; i++) {
            int temp = 0;
            for (int j = 0; j < col; j++)
                temp += board[j][i];

            if (temp == 3)        return Result.X_WIN;
            else if (temp == -3)  return Result.O_WIN;
        }

        //检查对角线
        if (row == col) {
            int sum = 0, sum_two = 0;
            for (int i = 0; i < row; i++) {
                sum += board[i][i];
                sum_two += board[i][row - i-1];
            }
            if(sum==3||sum_two==3)          return Result.X_WIN;
            else if(sum==-3||sum_two==-3)   return Result.O_WIN;

        } else {
            System.out.println("行列不相等 嘻嘻");
        }
        return Result.DRAW;
    }
}

Game类

职责：进行游戏的进行，控制游戏的开始和终止。

public class Game {
    //棋盘与游戏是组合关系 有生命周期的联系
    private Board checkBoard = new Board();
    private int turn = 1;  //步数 来以此在棋盘判断是放入哪个

    //游戏主方法playGame
    //输入为对弈双方轮番落子的位置，以英文逗号为间隔，X先走
    public Result playGame(String s) {

        String[] position = s.split(",");
        for (String pos : position) {
            checkBoard.setBoard(turn, pos);
            checkBoard.print();
            if (checkBoard.getStatement() != Result.DRAW)
                break;
            turn*=-1;
        }
        return checkBoard.getStatement();
    }
}

交互&协作

Board与game的分离，各自实现各自的功能,并且很好的进行了协作

注意，有的同学实现了Player类，但会发现，这个类总是不断去调用board的内容，没有很好的实现单一原则，所以为何不都在board中实现呢？

这两个类之间是什么关系？
这两个类是 组合 关系，因为两者之间交互性较强，并且又生命周期的关系，游戏开始，棋盘肯定要建立，成员变量就要new Board()

Tictactoe

这是整体包的结构
六个主要类
两个枚举类
FIVE是继承上面类的，因为属于他的一种（其实那个类也可以实现为接口）

根据题意建立接口GameWinStrategy,里面的方法分别两种策略进行实现
并且HV与HVD为组合关系，因为就多了一个斜方判断，但仍然不能说是继承关系（仅仅为了代码复用）

Game 类

package cn.edu.nju.TicTacToe;
public class Game {
	private int size;

	/**
     * Game的接口方法，我们会通过该方法进行测试
     * @param gameMode 游戏模式,有四种可能，00,01,10,11
     * @param moveStr 落子序列
     * @param size 棋盘大小，size最小为3， 最大为9
     * @return 游戏结果
     * 
     * 根据需要改写方法，参数，返回结果类型不可修改
     */
    public Result playGame(String gameMode, String moveStr, int size){

    	Board board = new Board(size,gameMode);
    	String[] moves = moveStr.split(",");
    	Result res = Result.GAMING;

    	for(int counter=0;counter<moves.length;counter++)
		{
			res=board.nextMove(moves,counter);
			board.print();

    		// 游戏结束
    		if( !res.equals(Result.GAMING) )
    			break;
    	}
    	return res;
    }
}

Board类

package cn.edu.nju.TicTacToe;
public class Board {
	/**
	 * 成员变量的初始化代码请修改，请灵活选择初始化方式
	 * 必要时可添加成员变量
	 */
	protected char[][] cells;
	protected GameChessStrategy chessStrategy;  //五子方式
	protected GameWinStrategy winStrategy;  //输赢策略 横斜
	protected Player player = Player.X;

	/**
	 * 请修改构造方法，并添加合适的构造方法
	 */
	
	public Board(int boardSize, String gameMole){

		cells = new char[boardSize][boardSize];
		for(int i=0; i<boardSize; i++){
			for(int j=0; j<boardSize; j++){
				cells[i][j] = '_';
			}
		}

		//00 01 10 11 不同方式不同策略 多态
		char chess=gameMole.charAt(0);
		chessStrategy= (chess=='0')? (new GameChessStrategy()):(new GameChessStrategyFIVE());

		char win=gameMole.charAt(1);
		winStrategy= (win=='0') ? (new GameWinStrategyStrategy_HVD()):(new GameWinStrategyStrategy_HV());


	}

	/**
	 * @param moves 下棋的位置
	 * @return 落棋之后的结果
	 */
	public Result nextMove(String []moves,int counter) {
		chessStrategy.putChess(cells, nextPlay(), moves,counter);
		return winStrategy.check(cells,moves,counter);
	}
	
	/**
	 * @return 下一个落棋的玩家
	 */
	protected Player nextPlay(){
		Player res = player;
		player = player == Player.X ? Player.O : Player.X;   //进行player更替
		return res;
	}
	
	/**
	 * 棋盘的输出方法，根据需要进行修改
	 */
	public void print(){
		int length=cells.length;
		System.out.print(" ");
		for(int i=0;i<length;i++)
		{
			char temp=(char)('A'+i);
			System.out.print(" "+temp);
		}
		System.out.println();

		for(int i=0;i<length;i++)
		{
			System.out.print(i+1);
			for(int j=0;j<length;j++)
				System.out.print(" "+cells[i][j]);

			System.out.println();
		}
	}
}

体现了接口，抽象方法的思想，很nice的实现
主要传递的参数也很清晰： 游戏策略（体现了多态，动态时链接），下一步位置，当前步数。
各自类也有各自类的职责，清晰美丽