Threes字符版

慢慢优化，看看自己的重构能力。

第一版渣渣如下：

public class Threes {

    public static final int SIZE = 4;

    public static int[][] matrix = new int[SIZE][SIZE];

    public static int step = 0;

    public static void main(String[] args) throws Exception {
        init();
        printMatrix(matrix);
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String line = "";
        while ((line = reader.readLine()) != null) {
            boolean flag = false;
            if ("a".equals(line)) {
                flag = moveRowBackward();
            } else if ("d".equals(line)) {
                flag = moveRowForward();
            } else if ("w".equals(line)) {
                flag = moveColBackward();
            } else if ("s".equals(line)) {
                flag = moveColForward();
            } else {
                System.out.print("INVALID INPUT!!!input:");
                continue;
            }
            if (flag) {
                addNumber(line);
            } else {
                System.out.print("CANNOT MOVE!!!input:");
                continue;
            }
            step++;
            printMatrix(matrix);
        }
    }

    private static void init() {
        for (int i = 0; i < SIZE; i++) {
            for (int j = 0; j < SIZE; j++) {
                matrix[i][j] = (int) (Math.random() * 3);
            }
        }
    }

    private static void printMatrix(int[][] mat) {
        System.out.println("---------------------");
        for (int i = 0; i < SIZE; i++) {
            System.out.print("|");
            for (int j = 0; j < SIZE; j++) {
                System.out.print(formatNumber(mat[i][j]) + "|");
            }
            System.out.println();
        }
        System.out.println("--------------------- step:" + step);
        System.out.print("input:");
    }

    private static String formatNumber(int number) {
        String result = String.valueOf(number);
        if ("0".equals(result)) {
            result = " ";
        }
        for (int i = result.length(); i < 4; i++) {
            result = " " + result;
        }
        return result;
    }

    private static void addNumber(String move) {
        int number = 1 + (int) (Math.random() * 2);
        if ("a".equals(move)) {
            int pos = (int) (Math.random() * SIZE);
            while (matrix[pos][SIZE - 1] != 0) {
                pos = (int) (Math.random() * SIZE);
            }
            matrix[pos][SIZE - 1] = number;
        } else if ("d".equals(move)) {
            int pos = (int) (Math.random() * SIZE);
            while (matrix[pos][0] != 0) {
                pos = (int) (Math.random() * SIZE);
            }
            matrix[pos][0] = number;
        } else if ("w".equals(move)) {
            int pos = (int) (Math.random() * SIZE);
            while (matrix[SIZE - 1][pos] != 0) {
                pos = (int) (Math.random() * SIZE);
            }
            matrix[SIZE - 1][pos] = number;
        } else if ("s".equals(move)) {
            int pos = (int) (Math.random() * SIZE);
            while (matrix[0][pos] != 0) {
                pos = (int) (Math.random() * SIZE);
            }
            matrix[0][pos] = number;
        }
    }

    private static boolean moveRowBackward() {
        boolean flag = false;
        for (int row = 0; row < SIZE; row++) {
            for (int i = 0; i < SIZE - 1; i++) {
                if (canCombine(matrix[row][i], matrix[row][i + 1])) {
                    flag = true;
                    matrix[row][i] = matrix[row][i] + matrix[row][i + 1];
                    for (int j = i + 1; j < SIZE - 1; j++) {
                        matrix[row][j] = matrix[row][j + 1];
                    }
                    matrix[row][SIZE - 1] = 0;
                    break;
                }
            }
        }
        return flag;
    }

    private static boolean moveRowForward() {
        boolean flag = false;
        for (int row = 0; row < SIZE; row++) {
            for (int i = SIZE - 1; i > 0; i--) {
                if (canCombine(matrix[row][i], matrix[row][i - 1])) {
                    flag = true;
                    matrix[row][i] = matrix[row][i] + matrix[row][i - 1];
                    for (int j = i - 1; j > 0; j--) {
                        matrix[row][j] = matrix[row][j - 1];
                    }
                    matrix[row][0] = 0;
                    break;
                }
            }
        }
        return flag;
    }

    private static boolean moveColBackward() {
        boolean flag = false;
        for (int col = 0; col < SIZE; col++) {
            for (int i = 0; i < SIZE - 1; i++) {
                if (canCombine(matrix[i][col], matrix[i + 1][col])) {
                    flag = true;
                    matrix[i][col] = matrix[i][col] + matrix[i + 1][col];
                    for (int j = i + 1; j < SIZE - 1; j++) {
                        matrix[j][col] = matrix[j + 1][col];
                    }
                    matrix[SIZE - 1][col] = 0;
                    break;
                }
            }
        }
        return flag;
    }

    private static boolean moveColForward() {
        boolean flag = false;
        for (int col = 0; col < SIZE; col++) {
            for (int i = SIZE - 1; i > 0; i--) {
                if (canCombine(matrix[i][col], matrix[i - 1][col])) {
                    flag = true;
                    matrix[i][col] = matrix[i][col] + matrix[i - 1][col];
                    for (int j = i - 1; j > 0; j--) {
                        matrix[j][col] = matrix[j - 1][col];
                    }
                    matrix[0][col] = 0;
                    break;
                }
            }
        }
        return flag;
    }

    private static boolean canCombine(int a, int b) {
        if (a == 0 || b == 0) {
            return true;
        } else if (a + b == 3) {
            return true;
        } else if (a == b && a + b > 4) {
            return true;
        } else {
            return false;
        }
    }
}

第二版

package threes;

public class Matrix {

    private int[][] matrix;

    private int size;

    private int step;

    public Matrix(int size) {
        this.size = size;
        this.step = 0;
        init();
    }

    private void init() {
        matrix = new int[size][size];
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                matrix[i][j] = (int) (Math.random() * 3);
            }
        }
    }

    public void print() {
        System.out.println("---------------------");
        for (int i = 0; i < size; i++) {
            System.out.print("|");
            for (int j = 0; j < size; j++) {
                System.out.print(ThreeUtils.formatNumber(matrix[i][j]) + "|");
            }
            System.out.println();
        }
        System.out.println("--------------------- step:" + step);
    }

    public boolean moveRowBackward() {
        boolean flag = false;
        for (int row = 0; row < size; row++) {
            for (int i = 0; i < size - 1; i++) {
                if (ThreeUtils.canCombine(matrix[row][i], matrix[row][i + 1])) {
                    flag = true;
                    matrix[row][i] = matrix[row][i] + matrix[row][i + 1];
                    for (int j = i + 1; j < size - 1; j++) {
                        matrix[row][j] = matrix[row][j + 1];
                    }
                    matrix[row][size - 1] = 0;

                    int number = getRandomNumber();
                    int pos = (int) (Math.random() * size);
                    while (matrix[pos][size - 1] != 0) {
                        pos = (int) (Math.random() * size);
                    }
                    matrix[pos][size - 1] = number;

                    break;
                }
            }
        }
        return flag;
    }

    public boolean moveRowForward() {
        boolean flag = false;
        for (int row = 0; row < size; row++) {
            for (int i = size - 1; i > 0; i--) {
                if (ThreeUtils.canCombine(matrix[row][i], matrix[row][i - 1])) {
                    flag = true;
                    matrix[row][i] = matrix[row][i] + matrix[row][i - 1];
                    for (int j = i - 1; j > 0; j--) {
                        matrix[row][j] = matrix[row][j - 1];
                    }
                    matrix[row][0] = 0;

                    int number = getRandomNumber();
                    int pos = (int) (Math.random() * size);
                    while (matrix[pos][0] != 0) {
                        pos = (int) (Math.random() * size);
                    }
                    matrix[pos][0] = number;

                    break;
                }
            }
        }
        return flag;
    }

    public boolean moveColBackward() {
        boolean flag = false;
        for (int col = 0; col < size; col++) {
            for (int i = 0; i < size - 1; i++) {
                if (ThreeUtils.canCombine(matrix[i][col], matrix[i + 1][col])) {
                    flag = true;
                    matrix[i][col] = matrix[i][col] + matrix[i + 1][col];
                    for (int j = i + 1; j < size - 1; j++) {
                        matrix[j][col] = matrix[j + 1][col];
                    }
                    matrix[size - 1][col] = 0;

                    int number = getRandomNumber();
                    int pos = (int) (Math.random() * size);
                    while (matrix[size - 1][pos] != 0) {
                        pos = (int) (Math.random() * size);
                    }
                    matrix[size - 1][pos] = number;

                    break;
                }
            }
        }
        return flag;
    }

    public boolean moveColForward() {
        boolean flag = false;
        for (int col = 0; col < size; col++) {
            for (int i = size - 1; i > 0; i--) {
                if (ThreeUtils.canCombine(matrix[i][col], matrix[i - 1][col])) {
                    flag = true;
                    matrix[i][col] = matrix[i][col] + matrix[i - 1][col];
                    for (int j = i - 1; j > 0; j--) {
                        matrix[j][col] = matrix[j - 1][col];
                    }
                    matrix[0][col] = 0;

                    int number = getRandomNumber();
                    int pos = (int) (Math.random() * size);
                    while (matrix[0][pos] != 0) {
                        pos = (int) (Math.random() * size);
                    }
                    matrix[0][pos] = number;

                    break;
                }
            }
        }
        return flag;
    }

    protected boolean canMove() {
        return true;
    }

    protected int getRandomNumber() {
        int number = 1 + (int) (Math.random() * 3);
        return number;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public int getStep() {
        return step;
    }

    public void setStep(int step) {
        this.step = step;
    }
}

package threes;

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

public class Threes {

    public static final int SIZE = 4;

    public static void main(String[] args) throws Exception {
        Matrix matrix = new Matrix(SIZE);
        matrix.print();
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String line = "";
        System.out.print("input:");
        while ((line = reader.readLine()) != null) {
            boolean flag = false;
            if ("a".equals(line)) {
                flag = matrix.moveRowBackward();
            } else if ("d".equals(line)) {
                flag = matrix.moveRowForward();
            } else if ("w".equals(line)) {
                flag = matrix.moveColBackward();
            } else if ("s".equals(line)) {
                flag = matrix.moveColForward();
            } else {
                System.out.print("INVALID INPUT!!!input:");
                continue;
            }
            if (!flag) {
                System.out.print("CANNOT MOVE!!!input:");
                continue;
            }
            matrix.print();
            System.out.print("input:");
        }
    }
}

package threes;

public class ThreeUtils {

    public static String formatNumber(int number) {
        String result = String.valueOf(number);
        if ("0".equals(result)) {
            result = " ";
        }
        for (int i = result.length(); i < 4; i++) {
            result = " " + result;
        }
        return result;
    }

    public static boolean canCombine(int a, int b) {
        if (a == 0 || b == 0) {
            return true;
        } else if (a + b == 3) {
            return true;
        } else if (a == b && a + b > 4) {
            return true;
        } else {
            return false;
        }
    }
}