方法与简单的控制台五子棋程序

方法就是一段可以被重复调用的方法块。在Java中要想进行方法的定义，则可以使用如下的语法完成。

public static 返回类型 方法名称([参数类型 变量, ......]) {
    方法体代码;
    [return [返回值];]
}

1.其返回类型为void 时：么有返回值

2.返回值为数据类型：基本类型和引用类型

定义一个无返回值无实参的方法：

public class TestDemo {
    public static void main(String[] args) {
        print();    //主方法里面直接调用方法
    }
    public static void print() {
        System.out.println("Hello    World!"); //定义方法
    }
}

定义一个无返回值有参数的方法：

public class TestDemo {
    public static void main(String[] args) {
        print("Hello");    //主方法里面直接调用方法
        print("    world");
    }
    public static void print(String msg) {    //定义方法
        System.out.print(msg); 
    }

}

定义有参数有返回值有参数的方法：

public class TestDemo {
    public static void main(String[] args) {
        int result = add(10, 20);
        System.out.println(result);
        //将返回值输出
        System.out.println(add(100, 200));
    }
    public static int add(int x, int y) {    //定义方法
        return x + y;
    }
}

方法的重载：

      就好比一个班里有多个名字叫“张三”的同学，老师也无法通过姓名来区分他们，为了达到区分不同同学的目的，老师还需要用到这些同学别的信息（如面部信息，身高，声音等），同样，编译器为了区分这些函数，除了用方法名这个特征外，还会用到这个方法的参数列表来区分不同的方法。即方法的名称及其参数列表（参数类型+参数个数）一起构成方法的签名。

重载方法println的使用：

public class ShowPrintlnOverload {
    public static void main(String[] args) {
        System.out.println(123);//输出整形int
        System.out.println(12.3);//输出双精度double
        System.out.println('a');//输出字符char类型
        System.out.println("A");//输出字符串类型String
        System.out.println(false);//输出布尔类型boolean
    }
}

System是在java.lang包中定义了一个内置类，在该类中定义了一个静态对象out，由于静态成员属于类成员的，所以他的访问方式是“类名.成员名”-----System.out。在本质上，out是PrintStream类的实例对象，println()则是PrintStream类中定义的方法。

上述代码可以输出不同的数据类型，相同的方法名+不同的参数列表是典型的方法重载的特征。

构成重载：

a.方法名称相同

b.方法的参数列表不同（包括参数个数，参数类型，参数顺序，至少有一项不同）

c.方法的返回值和修饰符可以相同，也可以不同。

注意！！！！方法的签名仅包括方法名称和方法参数，因此方法重载不能够根据方法的不同返回值来区分不同的方法，因为返回值不属于方法签名的一部分。例如，int add(int ,int )和void add(int ,int )的方法签名是相同的，编译器会认为这两个方法完全相同而无法区分，因此达不到重载的目的。

控制台五子棋：

由用户手动输入一个数字，来控制棋盘的大小，黑方和白方分别用1，2表示，当五子连线则胜利，打印出胜利方。

生成棋盘：

Scanner in = new Scanner(System.in);
        System.out.print("请输入棋盘大小");
        int row = in.nextInt();
        int col = in.nextInt();
        //        生成棋盘
        int[][] arr = new int[row + 1][col + 1];//方便输入行列的坐标
        for (int i = 0; i < arr[0].length; i++) {
            arr[0][i] = i;
        }
        for (int i = 0; i < arr.length; i++) {
            arr[i][0] = i;
        }

开始下棋的逻辑：

int m, n;
        boolean flag = true;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
        for (; ; ) {
            if (flag) {
                System.out.print("黑方下棋");
                m = in.nextInt();
                n = in.nextInt();
                arr[m][n] = 1;
            } else {
                System.out.print("白方下棋");
                m = in.nextInt();
                n = in.nextInt();
                arr[m][n] = 2;
            }

            for (int i = 0; i < arr.length; i++) {
                for (int j = 0; j < arr[i].length; j++) {
                    System.out.print(arr[i][j] + " ");
                }
                System.out.println();
            }
//五子棋下棋以后的逻辑判断
            if (flag) {
                //表示黑方（1）下的棋
                //黑方是否胜利的逻辑判断
                //judge返回true，就表示赢了;返回false就表示没赢
                if (judge(arr, m, n, 1)) {
                    System.out.println("黑方胜利！");
                    return;
                }
                flag = false;
            } else {

                if (judge(arr, m, n, 2)) {
                    System.out.println("白方胜利！");
                    return;
                }
                flag = true;
            }
        }
    }

下棋的逻辑判断：

/**
     * 判断下棋的逻辑
     * @param chess 存储所有棋子的二维数组
     * @param m 下棋的行
     * @param n 下棋的列
     * @param data 黑棋1或者白棋2
     * @return 返回true，表示data胜利了，返回false，表示没有胜利
     */
    private static boolean judge(int[][] chess, int m, int n, int data) {
        int count = 1;
        int j = 0;

        // 先判断横向的左边
        //   ...   [m,n-1] [m,n] [m,n+1]
        for(j=n-1; j>0; --j){
            if(chess[m][j] == data){
                count++;
            } else {
                break;
            }
        }
        // 再判断横向的右边
        for(j=n+1; j<chess[0].length; ++j){
            if(chess[m][j] == data){
                count++;
            } else {
                break;
            }
        }

        // 判断count
        if(count == 5){
            return true;
        }

        // 给count要重置一下
        count = 1;
        // 判断竖方向
        int i=0;
        // 判断当前棋子的上方向
        for(i=m-1; i>0; --i){
            if(chess[i][n] == data){
                count++;
            } else {
                break;
            }
        }
        // 判断当前棋子的下方向
        for(i=m+1; i<chess.length; ++i){
            if(chess[i][n] == data){
                count++;
            } else {
                break;
            }
        }

        // 判断count
        if(count == 5){
            return true;
        }

        // count需要重置一下
        count = 1;
        // 判断左斜上方向
        for(i=m-1, j=n+1; i>0 && j<chess[0].length; --i, ++j){
            if(chess[i][j] == data){
                count++;
            } else {
                break;
            }
        }
        // 判断左斜下方向
        for(i=m+1, j=n-1; i<chess.length && j>0; ++i, --j){
            if(chess[i][j] == data){
                count++;
            } else {
                break;
            }
        }
        // 判断count
        if(count == 5){
            return true;
        }

        // count需要重置一下
        count = 1;
        // 判断右斜上方向
        for(i=m-1, j=n-1; i>0 && j>0; --i, --j){
            if(chess[i][j] == data){
                count++;
            } else {
                break;
            }
        }
        // 判断右斜下方向
        for(i=m+1, j=n+1; i<chess.length && j<chess[0].length; ++i, ++j){
            if(chess[i][j] == data){
                count++;
            } else {
                break;
            }
        }
        // 判断count
        if(count == 5){
            return true;
        }

        // 上面检查了各个方向，都没有胜利，直接返回false，表示还又有赢棋
        return false;
    }


}

运行结果：