06 面向对象编程(基础)

约 6281 字大约 21 分钟

2024-09-01

面向对象是一种开发软件的方法，使分析、设计和实现一个系统的方法尽可能接近人们认识一个系统的方法。包括三个方面：面向对象分析、面向对象设计、面向对象程序设计。
Java 语言是纯面向对象的语言。其所有数据类型都有相应的类，程序可以完全基于对象编写

6.1 类与对象

从类到对象，可以称为创建一个对象，也可以说实例化一个对象，或者把对象实例化
类是抽象的、概念的，代表一类事物
对象是具体的、实际的，代表一个个具体事物
类是对象的模板，对象是类的一个个体，对应一个实例

6.1.1 属性/成员变量

从概念或叫法上看：成员变量 = 属性 = field（字段）

class Cat{
	String name;
	int age;
}

6.1.2 创建对象

注意事项：

声明对象的场合，只是在内存中建立了一个引用。此时，该地址引用不指向任何内存空间。
对象的引用，也被称为对象的句柄。
使用 new 运算符创建对象实例时，会为对象分配空间，就会调用类的构造方法。那之后，会将该段内存的首地址赋给刚才建立的引用

6.1.3 类与对象的内存访问机制

栈：一般存放基本数据类型（局部变量）
堆：存放对象（如Cat cat1 = new Cat()，是在这里开辟的空间），所有的 java 对象都存储在堆中。
方法区：常量池（常量，比如字符串），类加载信息

创建对象时，先加载类信息，然后在堆中分配空间，栈中的对象名被赋予指向那个空间的地址。
之后进行指定初始化。该对象的属性中，是基本数据类型的直接记录在堆中；是字符串的记录一个地址，该地址指向方法区，那里的常量池有该字符串。

6.2 成员方法

使用成员方法，能提高代码的复用性。而且能把实现的细节封装起来，供其他用户调用。

6.2.1 方法的调用机制

以前文代码为例：

...
		int r = cat1.speak2(15, 135);
...
public int speak2(int n1, int n2){
   int res = n1 + n2;
   return res;
}
...

当程序执行到方法时，在栈中开辟一个新的栈空间。该空间里储存 n1 = 15 n2 = 135，之后计算并储存结果 res = 150
当方法执行完毕，或执行到 return 语句时，就会返回
把新栈空间中的 res = 150 返回 main 栈中调用方法的地方
返回后，继续执行该方法的后续代码

6.2.2 使用细节

调用细节：
- 同一个类中的方法调用，可以直接调用。
- 跨类的方法调用，需要创建新对象，然后再调用方法。

6.2.3 成员方法传参机制

Java 语言对对象采用的是 值传递，方法得到的总是那个传入对象的副本。

方法参数共有两种类型：

基本数据类型（数字、布尔值)
对象引用。

方法不能修改基本数据类型的参数。基本数据类型传递的是一个值，形参不影响实参。
方法可以改变对象参数的状态。
引用类型传递的是一个地址，形参和实参指向一处，两者总会相关。
但改变那个形参地址指向的场合，实参的指向不会改变

java 核心技术卷一：
4.5 方法参数
按值调用表示方法接收的是调用者提供的值。而按引用调用表示方法接受的是调用者提供的变量地址，一个方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。
java 程序设计语言总是采用按值调用，方法得到的是所有参数值的一个拷贝，特别是，方法不能修改传递给它的任何参数变量的内容。

> double percent = 10;
> harry.raiseSalary(percent):
> 不必理睬这个方法的具体实现， 在方法调用之后， percent 的值还是10。

但作将对象应用作为参数就不一样了。拷贝的是对象的引用变量而不是整个对象，拷贝的和原来的引用指向同一个对象，可以理解为拷贝的对象引用是它的别名，实质指的是一个东西。可以通过这个别名引用来改变原对象。

总结一下 Java 中方法参数的使用情况：

一个方法不能修改一个基本数据类型的参数（即数值型或布尔型）。
一个方法可以改变一个对象参数的状态。
一个方法不能让对象参数引用一个新的对象。

6.3 方法递归调用

递归：即方法自己调用自己，每次调用时传入不同变量。递归有助于编程者解决复杂问题，同时可以让代码变得简洁。

下面，示范一个斐波那契数列方法

class T{
    public int fib(int n){
       if(n == 1 || n == 2){
          return 1;
        }else{
            return (fib(n - 1)) + (feb(n - 2));
       }
   }
}

6.3.1 使用细节

执行一个方法时，就创建一个新的受保护的独立栈空间。
方法的局部变量是独立的，不会相互影响。
如果方法中使用的是引用变量，就会共享数据。（因为06 面向对象编程(基础) > ==6.2.3 成员方法传参机制==
递归必须向退出递归的条件逼近，否则就是无限递归，会提示 StackOverflowError “死龟”
当一个方法执行完毕，或遇到 return 就会返回。遵守谁调用就返回给谁。同时当方法执行完毕或返回时，该方法也执行完毕

6.4 方法重载

方法重载（Overload）：Java 中允许同一类中，多个同名方法的存在，但要求形参列表不一致。

6.5 可变参数

Java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。

语法：访问修饰符返回类型方法名（数据类型... 形参名）{代码块;}

public void m(int... n){
	//此时，n 相当于一个 数组。
	int length = n.length;
	int num1 = n[0];
}

6.5.1 使用细节

可变参数的实参可以是 0 个，也可以是任意多个。
可变参数的实参可以是数组

可变参数本质就是数组

因此，出现：

public void met(int... n){				//这个方法与下面的方法不能构成重载
}

的场合，不能有方法：

public void met(int[] n){				//这个方法与上面的方法不能构成重载
}

可变参数和普通参数可以一起放在形参列表，但必须保证可变参数在最后
```
public void m(double dou, int... n) {}
```
一个形参列表最多出现一个可变参数。

6.6 作用域

在 Java 编程中，主要的变量就是 属性（成员变量）和 局部变量。
我们说的局部变量一般是指在成员方法中定义的变量。
作用域的分类
- 全局变量：也就是属性，作用域为整个类体
- 局部变量：除了属性外的其他变量。作用域为定义它的代码块中
全局变量（属性）可以不赋值直接使用，那个场合有默认值。局部变量必须赋值使用

6.6.1 使用细节

属性和局部变量可以重名，访问时遵循就近原则
在同一作用域中，两个局部变量不能重名
属性的生命周期较长。其伴随对象的创建而创建，伴随对象的销毁而销毁。
局部变量生命周期较短。其伴随代码块的执行而创建，伴随代码块的结束而销毁。
全局变量/属性可以被本类使用，也可以被其他类（通过对象）使用。
局部变量只能被本类的对应方法中调用
全局变量/属性 可以加 修饰符
局部变量 不能加 修饰符

6.7 构造方法、构造器

构造方法又叫构造器（constructor），是类的一种特殊的方法。它的主要作用是完成对新对象的初始化

构造器的修饰符可以是默认。也可以是别的
参数列表规则同成员方法

6.7.1 使用细节

构造器本质也是方法(并不会继承)。所以，可以构造器重载。
构造器名和类名相同
构造器无返回值
构造器是完成对象的初始化，而不是创建
创建对象时，系统自动调用构造器
如果提供了构造器，则不会提供默认构造器了。
一旦定义了自己的构造器，就不能用无参构造器了。除非显式的定义一个无参构造器

6.7.2 流程分析

Person p1 = new Person("Amy", 10);

...

class Person{
	String name;
	int age = 20;
	public Person(String pName, int pAge){
		name = pName;
		age = pAge;
	}
}

加载类信息（方法区）
在堆中开辟空间（地址）
完成对象初始化
- 首先默认初始化。age = 0; name = null
- 之后显式初始化。age = 20; name = null //定义时的赋值
  其中，显式初始化和代码块初始化按编写的先后顺序依次进行。
- 之后构造器的初始化。age = 10; name = "Amy"
把对象在堆中的地址，返回给 p1

6.8 this 关键字

JVM 会给每个对象分配 this 代表当前对象。
相当于在堆中，this 指向自己（对象）
在类定义的方法中，Java 会自动用 this 关键字把所有变量和方法引用结合在一起。
遇到有同名的局部变量的场合，需要程序员加入 this 关键字进行区分。不加入 this 关键字的场合，Java 遵循就近原则。

class Example{
    int n = 0;
	public void act(int n) {}
}

上面这个类的 act() 方法实际有 2 个参数。对其调用：

Example e = new Exmaple();
e.act(100);

可见，出现在方法名前的参数 e，以及出现在方法名后的括号中的参数 100

出现在方法名前的参数被称为 隐式参数（也称为方法调用的目标或接收者）

出现在方法名后的参数被称为 显式参数，就是所谓的实参

在每一个方法中，用 this 指代隐式参数。

public void act(int n) {
    this.n = n;
}

此时，再以相同方式调用方法：

e.act(100);					// <———— 相当于 e.n = 100;

`super 与 this 关键字`

super 关键字：我们可以通过 super 关键字来实现对父类成员的访问，用来引用当前对象的父类。

this 关键字：指向自己的引用。

《java 核心技术卷 1》：5.1.3 子类构造器
this 有两个用途：一是引用隐式参数(所构造的对象)，二是调用该类其他的构造器
super 也有两个用途：一是调用超类的方法，二是调用超类的构造器。
在调用构造器的时候，这两个关键字的使用方式很相似。调用构造器的语句只能作为另一个构造器的第一条语句出现。构造参数既可以传递给本类(this ) 的其他构造器，也可以传递给超类(super ) 的构造器。

6.8.1 使用方法

this 关键字可以用来访问本类的属性、方法、构造器
this 用于区分当前类的属性和局部变量
访问本类中成员方法的语法：this.方法名
访问构造器的语法：this(参数列表);
注意：只能在构造器中访问另一个构造器。而且，如果有这个语法，必须放置在第一条语句。
this 不能在类定义的外部使用，只能在类定义的方法中使用

附录

迷宫游戏代码

/**
*@author Melody
*@version v1.2.6
**/

//迷宫
import java.util.Scanner;
public class MazeOut{

    public static void main(String[] args){
        //tools 方便后面调用方法。 inP 可以接收用户输入
        T tools = new T();
        Scanner inP = new Scanner(System.in);

        //提示并接收用户输入信息
        System.out.println("\n输入迷宫宽度（至少为6）：");
        int x = inP.nextInt();
        System.out.println("\n输入迷宫长度（至少为6）：");
        int y = inP.nextInt();
        //若用户输入的长或宽超出范围，则将其重置为正常值
        if(x < 6){
            x = 6;
        } else if(x > 110){
        	x = 110;
        }
        if(y < 6){
            y = 6;
        } else if(y > 60){
        	y = 60;
        }
        System.out.println("\n输入迷宫的困难度（请输入1 - 6的数字，数字越高越不容易获胜）：");
        int hard = inP.nextInt();
        if(hard == 7){
        	System.out.println("\n\n您选择了找点麻烦");
        } else if (hard == 8 || hard == 9){
        	System.out.println("\n\n您选择了给自己添堵");
        }
        System.out.println("\n\t迷宫生产完毕\n");

        //设置一个 count 值，记录步数。设为数组，以便数据通用。第一位记录当前值，第二位为最大值。
        int[] count = {0, 0};
        //调用方法，生成迷宫
        char[][] maze =new char[y][x];
        tools.newMaze(maze.length, maze[0].length, maze, hard);
        //调用方法，展示迷宫
        tools.showMaze(maze);

        //提示用户开始游戏
        System.out.println("\n召唤一个探索者，来探索迷宫吧（随便输点什么吧）");
        //输入 r 或 c 则采用递归方法，其余采用爬墙方法
        char inC = inP.next().charAt(0);
        if(inC == 'c'){
            System.out.println("\n您触发了迷宫之神的眷顾。");
            if(hard > 5){
            	System.out.println("\n迷宫之神眉头一皱，发现事情并不简单。");
            }
            if(x > 12 || y > 12){
                System.out.println("看到地图这么大，迷宫之神悻悻而归。他只喜欢12格以下的地图。");
                return;
            }
        } else if(inC == 'r'){
            System.out.println("\n您引来了一群无畏小黄鸡。他们视死如归，一心想着寻找出口");
        } else {
            System.out.println("\n我们找来了一只小蜘蛛。试试看吧。");
        }
        System.out.println("\n");
        //调用方法，解密
        if(inC == 'r' || inC == 'c'){
            tools.outMazeRec(maze, inC, count);
        } else {
            tools.outMaze(maze, count);
        }

    }
}





class T{
    //=======================================================================================

    //方法 newMaze：让 n3 生成随机的 长 * 宽 = n1 * n2 的迷宫，其困难度为 n4
    public void newMaze(int n1, int n2, char[][] n3, int n4){
        //构建迷宫墙壁，以'#'表示。并随机向其中填充石块，以'O'表示
        ////墙壁是迷宫的 开头和结尾行 以及 每行的开头和结尾
        for(int i = 0; i < n1; i++){
            for(int j = 0; j < n2; j++){
                if(i == 0 || i == n1 - 1 ||j == 0 || j == n2 - 1){
                    n3[i][j] = '#';
                }else{
                    //ran 是一个随机值，此处是概率生成挡路的石块'O'。其概率与 n4 值的大小正相关
                    //此外，若 n4（即用户输入的难度值 hard）超过范围，则按照 难度6 计算
                    int ran;
                    if(n4 <= 9 && n4 >= 0){
                        ran = (int)(Math.random() * (9 - n4) + 1);
                    }else{
                        ran = (int)(Math.random() * 3 + 1);
                    }
                    n3[i][j] = (ran == 1) ? 'O' : ' ';
                }
            }
        }
        //生成起点、终点，优化地形
        n3[1][1] = 'B';
        n3[2][1] = ' ';
        n3[1][2] = ' ';
        n3[n1 - 2][n2 - 2] = 'F';
        n3[n1 - 3][n2 - 2] = ' ';
        n3[n1 - 2][n2 - 3] = ' ';
    }





    //方法 showMaze：展示一个迷宫
    public void showMaze(char[][] n1){
        for(int i = 0; i < n1.length; i++){
            for(int j = 0; j < n1[i].length; j++){
                System.out.print(" " + n1[i][j]);
            }
            System.out.println();
        }
    }
    //=======================================================================================






    //=======================================================================================
    //方法 outMazeRec：递归方法迷宫游戏入口。可以接入普通递归方法，或最短路径方法。
    public void outMazeRec(char[][] n1, char n2, int[] count){
        //out：是否走出迷宫
        boolean out = false;
        //将迷宫的起止位置记为通路
        n1[1][1] = ' ';
        n1[n1.length - 2][n1[0].length -2] = ' ';
        //如果输入的是'c'，则采用最短路径法。反之采用普通递归方法
        if(n2 == 'c'){
            out = outCountMaze(1, 1, n1, count);
        }else{
            out = outMazeRecursion(1, 1, n1, count);
        }
        //把迷宫起始位置重新标注出来
        n1[1][1] = 'B';
        //判断是否解谜成功。如果成功，迷宫终点显示'V'，并展示步数，否则显示'F'
        if(out){
            n1[n1.length - 2][n1[0].length -2] = 'V';
            showMaze(n1);
            System.out.println("\t YOU WIN！！！");
            System.out.println("通过路径为 " + count[1] + " 格");
        } else {
            n1[n1.length - 2][n1[0].length -2] = 'F';
            showMaze(n1);
            System.out.println("\t YOU LOSE");
        }

    }
    //=======================================================================================




    //=======================================================================================
    //方法 outMazeRecursion：迷宫游戏，普通递归方法
    public boolean outMazeRecursion(int y, int x, char[][] n3, int[] count){
        count[1]++;
        if(n3[n3.length - 2][n3[0].length - 2] == '.'){
            return true;
        } else if(n3[y][x] == ' '){
            n3[y][x] = '.';
            if(outMazeRecursion(y, x + 1, n3, count)){
                return true;
            } else if(outMazeRecursion(y + 1, x, n3, count)){
                return true;
            } else if(outMazeRecursion(y, x - 1, n3, count)){
                return true;
            } else if(outMazeRecursion(y - 1, x, n3, count)){
                return true;
            } else{
                count[1]--;
                n3[y][x] = '+';
            }
        } else {
            count[1]--;
            return false;
        }
        count[1]--;
        return false;
    }
    //=======================================================================================






    //=======================================================================================
    //方法 outCountMaze：迷宫游戏，最短路径法的入口。这个入口由普通递归法接入。
    public boolean outCountMaze(int y, int x, char[][] n, int[] count){

        //首先，创建一个里数组。该数组用于 part1，原数组用于 part2。
        //似乎没必要作此设计。但我还是予以保留。
        char[][] inMaze = new char[n.length][n[0].length];
        for(int i = 0; i < n.length; i++){
            for(int j = 0; j < n[0].length; j++){
                inMaze[i][j] = n[i][j];
            }
        }

        //首先进行 part1，然后必定进行 part2。因为 part1 总会返回一个 false
        if(countMazeRec(y, x, inMaze, count) || true){
            count[0] = 0;
            return outMazeRecC(y, x, n, count);
        }
        return false;
    }


    //方法 countMazeRec：迷宫游戏，最短路径法，part1
    //该方法是先统计最短路径。最终总会返回 false
    public boolean countMazeRec(int y, int x, char[][] n3, int[] count){
        count[0]++;
        if(y == n3.length - 2 && x == n3[0].length - 2){
            if(count[0] < count[1] || count[1] == 0){
                count[1] = count[0];
            }
        } else if(n3[y][x] == ' '){
            n3[y][x] = '.';
            if(countMazeRec(y, x + 1, n3, count)){
                return true;
            } else if(countMazeRec(y + 1, x, n3, count)){
                return true;
            } else if(countMazeRec(y, x - 1, n3, count)){
                return true;
            } else if(countMazeRec(y - 1, x, n3, count)){
                return true;
            } else{
                n3[y][x] = ' ';
                count[0]--;
                return false;
            }
        } else {
            count[0]--;
            return false;
        }
        count[0]--;
        return false;
    }






    //方法 outMazeRecC：迷宫游戏，最短路径法，part2
    //该方法是在 part1 统计完最短路径后，按最短路径走出迷宫，并绘制路径
    public boolean outMazeRecC(int y, int x, char[][] n3, int[] count){
        count[0]++;
        if(y == n3.length - 2 && x == n3[0].length - 2){
            if(count[0] <= count[1]){
                return true;
            } else {
                n3[n3.length - 2][n3[0].length - 2] = ' ';
                count[0]--;
                return false;
            }
        } else if(n3[y][x] == ' '){
            n3[y][x] = '.';
            if(outMazeRecC(y, x + 1, n3, count)){
                return true;
            } else if(outMazeRecC(y + 1, x, n3, count)){
                return true;
            } else if(outMazeRecC(y, x - 1, n3, count)){
                return true;
            } else if(outMazeRecC(y - 1, x, n3, count)){
                return true;
            } else{
                n3[y][x] = ' ';
                count[0]--;
                return false;
            }
        } else {
            count[0]--;
            return false;
        }

    }
    //=======================================================================================






    //=======================================================================================
    //方法 outMaze：爬墙方法迷宫游戏入口
    public void outMaze(char[][] n1, int[] count){
        //boolean out：记录是否走出迷宫
        boolean out = false;
        //角色光标 m
        n1[1][1] = 'm';

        //创建一系列变量，后面解释用法
        //创建 角色坐标
        int x = 1;
        int y = 1;
        //创建 辅助坐标 及 方向字符。初始方向为右。
        int xi = 1;
        int yi = 0;
        char dir = 'r';
        //创建 里迷宫，标记起止点。
        char[][] inMaze = new char[n1.length][n1[0].length];
        inMaze[1][1] = 'B';
        inMaze[n1.length - 2][n1[0].length - 2] = 'F';

        //开始走迷宫。
        //如果一个迷宫有出路，则沿着一侧的墙壁走就一定能走到出路。以下方法就是基于这个原理。
        //角色坐标 y,x 是角色所在的位置坐标。辅助坐标 yi，xi 是角色靠近的墙壁坐标。
        //dir 代表角色此时的朝向。只要角色按照墙壁延申的方向向前，就一定不会迷路。
        //里迷宫的大小和真迷宫相同，坐标也一一对应。目的是为了记录数据，这些数据不会被用户看到。
        //里迷宫记载了 起始点 和 终点 的位置。如角色回到起点，则必定失败。到达终点则成功。
        for(;;){

            //判断 是否走出迷宫。如若是，则展示迷宫，记录脱出为真，并退出寻路
            if(inMaze[y][x] == 'F'){
                n1[y][x] = 'V';
                n1[1][1] = 'B';
                showMaze(n1);
                out = true;
                break;
            }

            //通过爬墙方式试图走出迷宫
            //这是方向朝右时的情况
            if(dir == 'r'){
                //如果角色面对墙壁，意味着走到了墙角，则角色坐标不变，调整墙壁坐标，并转向
                if(n1[y][x + 1] == '#' || n1[y][x + 1] == 'O'){
                    dir = yi > y ? 'u' : 'd';
                    yi = y;
                    xi = x + 1;
                //如果面前有路，且墙壁延伸，则前进
                } else if (n1[yi][xi + 1] == '#' || n1[yi][xi + 1] == 'O'){
                    n1[y][x] = '.';
                    x++;
                    xi++;
                    n1[y][x] = 'm';
                    count[1]++;
                //如果面前有路，但墙壁不延伸，则是遇到了转角。角色移动，转向，但墙壁坐标不变
                } else {
                    dir = yi > y ? 'd' : 'u';
                    n1[y][x] = '.';
                    n1[y][x + 1] = '.';
                    y = yi;
                    x = xi + 1;
                    n1[y][x] = 'm';
                    count[1] += 2;
                }
            //这是方向朝左的情况
            } else if(dir == 'l'){
                if(n1[y][x - 1] == '#' || n1[y][x - 1] == 'O'){
                    dir = yi > y ? 'u' : 'd';
                    yi = y;
                    xi = x - 1;
                } else if(n1[yi][xi - 1] == '#' || n1[yi][xi - 1] == 'O'){
                    n1[y][x] = '.';
                    x--;
                    xi--;
                    n1[y][x] = 'm';
                    count[1]++;
                } else {
                    dir = yi > y ? 'd' : 'u';
                    n1[y][x] = '.';
                    n1[y][x - 1] = '.';
                    y = yi;
                    x = xi - 1;
                    n1[y][x] = 'm';
                    count[1] += 2;
                }
            //这是方向朝下的情况
            } else if(dir == 'd'){
                if(n1[y + 1][x] == '#' || n1[y + 1][x] == 'O'){
                    dir = xi < x ? 'r' : 'l';
                    yi = y + 1;
                    xi = x;
                } else if(n1[yi + 1][xi] == '#' || n1[yi + 1][xi] == 'O'){
                    n1[y][x] = '.';
                    y++;
                    yi++;
                    n1[y][x] = 'm';
                    count[1]++;
                } else {
                    dir = xi < x ? 'l' : 'r';
                    n1[y][x] = '.';
                    n1[y + 1][x] = '.';
                    y = yi + 1;
                    x = xi;
                    n1[y][x] = 'm';
                    count[1] += 2;
                }
            //这是方向朝上的情况
            } else if(dir == 'u'){
                if(n1[y - 1][x] == '#' || n1[y - 1][x] == 'O'){
                    dir = xi < x ? 'r' : 'l';
                    yi = y - 1;
                    xi = x;
                } else if(n1[yi - 1][xi] == '#' || n1[yi - 1][xi] == 'O'){
                    n1[y][x] = '.';
                    y--;
                    yi--;
                    n1[y][x] = 'm';
                    count[1]++;
                } else {
                    dir = xi < x ? 'l' : 'r';
                    n1[y][x] = '.';
                    n1[y - 1][x] = '.';
                    y = yi - 1;
                    x = xi;
                    n1[y][x] = 'm';
                    count[1] += 2;
                }
            }

            //判断 是否回到起点。如若是，则一定是迷宫无解。展示迷宫并退出寻路
            if(inMaze[y][x] == 'B'){
                showMaze(n1);
                break;
            }
        }
        //输出结果
        if(out){
            System.out.println("\t YOU WIN！！！\n\t您的步数为：" + count[1]);
        } else {
            System.out.println("\t YOU LOSE");
        }
    }
}

八皇后代码

import java.util.Scanner;
public class EightQueen{

    public static void main(String[] args){
        T tools = new T();
        char[][] chess = new char[8][8];
        //调用方法，建立棋盘
        tools.buildChess(chess);
        //调用方法，开始游戏
        tools.eightQueen(chess);

    }
}



class T{
    //buildChess：建立一个新棋盘。该棋盘白色格子用' '表示，黑色格子用'#'表示
    public void buildChess(char[][] chess){
        for(int i = 0; i < chess.length; i++){
            for(int j = 0; j < chess[0].length; j++){
                chess[i][j] = ((i + j) % 2 == 0) ? ' ' : '#';
            }
        }
    }




    //eightQueen：八皇后游戏的接入口
    public void eightQueen(char[][] chess){
    	//建立 里棋盘 inward 及 计数数组 count。里棋盘用于计算问题，原棋盘输出给用户看。
    	//计数 count 使用数组，这样其数据在所有方法都能通用
        char[][] inward = new char[chess.length][chess[0].length];
        int[] count = {0} ;
        //进行游戏。因为穷举所有方法，最后返回的一定是 false。反正我们不在意。
        boolean isFinished = gameEQS(0, 0, chess, inward, count);
    }



    //gameEQS：八皇后游戏的基本方法
    //八皇后游戏方法。y 代表当前位置的纵坐标，x 是横坐标。chess 是棋盘，inward 是里棋盘，count 是计数数组
    public boolean gameEQS(int y, int x, char[][] chess, char[][] inward, int[] count){
        //当 y 超出棋盘 时，显然已经完成八皇后。
        //由于要进行穷举，此时我们计数并输出棋盘，然后返回 false 使其继续计算
        if(y == inward.length){
            count[0]++;
            System.out.println();
            gameEQS2(chess, inward, count);
            return false;
        //当 x 超出棋盘 时，显然棋盘该列已经无合法放置位置。我们返回 false
        } else if(x == inward[0].length){
            return false;
        //gameEQS1，这个方法是查看该格子是否是合法放置位置。如若是，返回 true，而且在该位置放置棋子'Q'
        //当这个位置合法，我们进入下一行，从头开始判断。
        //如果后面的判断为 false，我们就拿掉这枚棋子。如果后面判断为 true 说明我们找到了一个方法。
        //特别地，由于代码目前是穷举模式，我想我们永远不会在此输出 true
        } else if(gameEQS1(y, x, inward)){
            if(gameEQS(y + 1, 0, chess, inward, count)){
                return true;
            } else {
                inward[y][x] = ' ';
            }
        }
        //如果代码进行到这个位置，证明我们所在的格子不适合放置棋子。我们只好去看看下一格如何。
        return gameEQS(y, x + 1, chess, inward, count);
    }



    //gameEQS1：该方法是输入一个坐标，并输入里棋盘地址，在里棋盘上查看该位置是否合法
    //什么是合法的位置：就是该坐标的 同列、同行、同斜线 没有别的棋子
    //如果是合法位置，我们放置一个棋子，并返回 true
    public boolean gameEQS1(int y, int x, char[][] inward){
        for(int i = 0; i < inward.length; i++){
            for(int j = 0; j < inward[0].length; j++){
                if(j == x || i == y || i - j == y - x || i + j == y + x){
                    if(inward[i][j] == 'Q'){
                        return false;
                    }
                }
            }
        }
        inward[y][x] = 'Q';
        return true;
    }



    //gameEQS2：这个方法是把当前 里棋盘 的棋子放置到棋盘上，输出棋盘 并 输出计数。
    //在输出完成后，会清空棋盘。
    public void gameEQS2(char[][] chess, char[][] inward,int[] count){
        for(int i = 0; i < chess.length; i++){
            for(int j = 0; j < chess[0].length; j++){
                if(inward[i][j] == 'Q'){
                    chess[i][j] = 'Q';
                }
                System.out.print(" " + chess[i][j]);
            }
            System.out.println();
        }
        System.out.print("\n" + count[0] + "\n");
        buildChess(chess);
    }



    //gameEQSDebug
    //输出里棋盘。测试用。
    public void gameEQSDebug(char[][] inward){
        for(int i = 0; i < inward.length; i++){
            for(int j = 0; j < inward[0].length; j++){
                System.out.print(" " + inward[i][j]);
            }
            System.out.println();
        }
        System.out.println();
    }
}