07、Java学习-类与对象（面向对象初级）：-优快云博客

本文链接：https://blog.youkuaiyun.com/jiangxianfengge/article/details/143463636

Java学习第九天~第十天——类与对象（面向对象初级）：

24.10.31学到（218/910）。

24.11.01学到（262/910）。

我们先来看一段代码：


public class Object01{
	public static void main(String[] args){
		// 单独用变量解决问题： => 不利于数据的管理，因为我们把猫的信息拆解了。
		String cat1Name = "小白";
		int cat1age = 3;
		String cat1Color = "白色";

		String cat2Name = "小花";
		int cat2age = 100;
		String cat2Color = "花色";

		// 数组 => (1)数据类型体现不出来;(2)只能通过下标获取信息，造成变量名和内容不对应；
		// (3)不能体现猫的行为
		String[] cat1 = {"小白","3","白色"};
		String[] cat2 = {"小花","100","花色"};
	}
}

现有的技术存在很多的缺陷：

不利于数据的管理；
效率低。

所以才需要类与对象（OOP）。

类与对象概述：

一个程序可以看作是一个世界，其内部含有很多事物（对象——对象有属性和行为）。

类——把一类事物（如猫，狗）的特征（属性）和行为提取出来；是我们自定义的数据类型。
对象——就是一个实例（若类是猫，实例就是一个实际存在的猫，如上文的小白）。

再解释的清楚一点就是，人类就是一个类，而你就是一个对象。

从类到对象有几个说法：

创建一个对象；
实例化一个对象；
把类实例化。


public class Object01{
	public static void main(String[] args){
		// 单独用变量解决问题： => 不利于数据的管理，因为我们把猫的信息拆解了。
		String cat1Name = "小白";
		int cat1age = 3;
		String cat1Color = "白色";

		String cat2Name = "小花";
		int cat2age = 100;
		String cat2Color = "花色";

		// 数组 => (1)数据类型体现不出来;(2)只能通过下标获取信息，造成变量名和内容不对应；
		// (3)不能体现猫的行为
		String[] cat_1 = {"小白","3","白色"};
		String[] cat_2 = {"小花","100","花色"};

		// 使用oop面向对象的方法解决：
		// 实例化一只猫（创建一个猫的对象）：
		// 1、new Cat()表示创建一只猫；
		// 2、把创建的猫（对象）赋值给cat1；
		// 3、cat1就是一只猫啦。
		Cat cat1 = new Cat();
		cat1.name = "小白";
		cat1.age = 3;
		cat1.color = "白色";
		// 创建第二只猫：
		Cat cat2 = new Cat();
		cat2.name = "小花";
		cat2.age = 100;
		cat2.color = "花色";

		// 怎么访问对象的属性呢？
		System.out.println("第一只猫的信息：" + cat1.name + cat1.age + cat1.color);
	}
}

// 使用面向对象的方式来解决问题：
// 
// 定义一个猫类-》自定义的数据类型：
// 	
class Cat{
	// 属性：
	// 	名字、年龄、花色
	String name;
	int age;
	String color;

	// 行为：
}

类和对象的区别：

类是抽象的，概念的，代表一类事物；
对象是具体的，实际的，代表一个具体事物；
类是对象的模板，对象是类的一个个体，对应一个实例。

属性/成员变量：

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

属性是类的一个组成部分，一般是基本数据类型，也可以是引用类型（数组，字符串）

注意事项和细节：

属性的定义语法和变量一样。 访问修饰符数据类型属性名;
属性的定义类型可以为任意类型，包含基本数据类型和引用类型；
属性如果不赋值，有默认值，规则和数组一致。

访问修饰符的基本介绍（再中级OOP中详细讲解）：控制属性的访问范围

public；
protected；
private；
默认。

创建对象与访问属性：

如何创建对象：

先声明再创建：
- Cat cat;
- cat = new Cat();
- cat只是对象名，new Cat()才是真正的对象（数据空间）
直接创建：
- Cat cat = new Cat();

如何访问属性：

对象名.属性名;

对象分配机制：

Person p1 = new Person();
Person p2 = p1; // 将p2指向p1，指向的对象是一样的。

这是引用传递，不是值传递。（除了基本数据类型，都是引用传递）。

Java内存的结构分析：

栈：一般存放基本数据类型；（局部变量）
堆：存放对象；（Cat cat，数组等）
方法区：常量池（常量，字符串），类加载信息。

Java创建对象的流程简单分析：

先加载类信息（属性和方法信息，同一类只会加载一次）；
在堆中分配空间，进行默认初始化，把地址赋值给对象名；
进行指定的初始化

成员方法：

在正常的情况下，需要定义成员方法（方法）。为什么呢？我们上面定义了一个Cat类，猫除了有那些属性外，还能跑，叫，跳等，这用属性没有办法很好地表示，所以我们需要成员方法。

import java.util.Scanner;
public class Method01{

	public static void main(String[] args){
		// 方法使用：
		// 1.若不被调用，是没有输出的；
		// 2.先创建一个对象，然后调用方法
		Person p1 = new Person();
		Scanner myScanner = new Scanner(System.in);
		System.out.print("n=");
		int n = myScanner.nextInt(); 
		p1.name = "江弦";
		p1.age = 21;
		p1.speak();
		p1.cal01();
		p1.cal02(n);
		System.out.println(p1.getSum(1,1));
	}
}

class Person{
	String name;
	int age;
	// method
	// 1.public 表示方法是公开的；
	// 2.void 表示方法没有返回值。
	// 3.spark() 是方法名，()为形参列表。
	// 4.{} 方法体，可以写我们要执行的代码。
	public void speak(){
		System.out.println("我是一个好人。");
	}

	public void cal01(){
		int res = 0;
		for(int i = 1; i <= 1000; i++){
			res += i;
		}
		System.out.println("1+...+1000=" + res);
	}

	// (int n)表示形参列表，表示当前有一个int类型的形参n，可以接受用户输入。
	public void cal02(int n){
		int res = 0;
		for(int i = 1; i <= n; i++){
			res += i;
		}
		System.out.println("1+...+" + n + "=" + res);
	}

	// 1.int表示方法执行后，返回一个int类型；
	// 2.getSum为方法名；
	// 3.(int num1, int num2)为形参列表，有两个int类型的形参用于接受用户输入。
	public int getSum(int num1, int num2){
		int res = num1 + num2;
		return res;
	}
}

方法调用：

当程序执行到方法时，就会开辟一个独立的空间（栈空间）；
当方法执行完毕，或者执行到 return 语句时，就会返回；
返回到调用方法的地方。
返回后，继续执行方法后面的代码。
当main方法（栈）执行完毕，整个程序退出。

成员方法的意义：

便于我们减少重复代码的编写。我们可以把需要反复调用的代码，写成一个成员方法，当我们需要再次使用的时候就调用该方法即可。

好处：

提高代码的复用性；
可以将实现的细节封装起来，然后供其它用户来调用即可。

成员方法的定义：

语法：

访问修饰符 返回数据类型 方法名(参数列表){
	语句;
	return 返回值;
}

参数列表：表示成员方法的输入；
数据类型：表示成员方法输出类型，void表示没有返回值；
方法主体：表示为了实现某一功能代码块；
return 语句不是必须的。

成员方法的细节：

一个方法最多有一个返回值（这和C++很像，和Python不像），若有多个值要返回，将其放入数组中返回；
返回类型可以为任意的类型，包含基本类型或引用类型；
若方法要求有返回数据类型，那么方法体的最后执行语句必须时return 值语句，而且要求返回值类型必须和return的值类型一致或兼容；
若为void类型，那么方法体可以没有return语句，或者只写return后面不跟值
遵循驼峰命名法（第一个单词不大写，后面的单词首字母大写）。
不写访问修饰符就是默认访问。

形参列表的细节：

一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开；
参数类型时可以任意的，包含基本数据类型和引用类型；
调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数；
方法定义时的参数称为形参；方法调用时的参数称为实参；实参和形参的类型要一致或兼容、个数、顺序必须一致。

方法体细节：

里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但是里面不能够再定义方法。

方法调用细节说明：

同一类中的方法调用：直接调用即可——不用加对象名；
跨类中的方法A类调用B类方法：需要通过对象名调用
特别说明：跨类的调用和方法的访问修饰符相关。（暂时只提一嘴）。

练习：

import java.util.Scanner;

public class MethodExercise{
	
	public static void main(String[] args){
		System.out.println("请输入一个整数：");
		Scanner myScanner = new Scanner(System.in);
		AA a = new AA();
		int n = myScanner.nextInt();
		boolean res = isOdd(n);
		if(res){
			System.out.println(n + "是奇数。");
		}else{
			System.out.println(n + "是偶数。");
		}

		a.print(10,10,'*');
	}

	// 需要注意，由于java中，非静态方法不能直接被静态方法调用，所以需要再AA前用static修饰
	public static boolean isOdd(int n){
		boolean res = false;
		if(n % 2 != 0){res = true;}
		return res;
	}
}

class AA{
	public void print(int row, int col, char c){
		for(int i = 0; i < row; i++){
			for(int j = 0; j < col; j++){
				System.out.print(c);
			}
			System.out.println();
		}
	}
}

类的完整定义（暂时）：

class 类名{
	属性；
    构造方法;
	成员方法；
}

传参机制：

基本数据类型的传参机制：

基本数据类型，传递的是值（值传递/值拷贝），形参的任何改变不影响实参。

public class MethodParameter{
	public static void main(String[] args){
		AA a = new AA();
		int num1 = 10;
		int num2 = 20;
		a.swap(num1, num2);
		System.out.println("num1=" + num1 + " num2=" + num2);
	}
}

class AA{
	public void swap(int a, int b){
		// 仅仅操作的是swap中的a和b，对main中的num1和num2处于两个独立的空间中
		// 且是值传递，实际上互不影响。
		int tmp = a;
		a = b;
		b = tmp;
		System.out.println("a=" + a + " b=" + b);
	}
}

引用数据类型的传参机制：

引用类型传递的是地址（传递的是值，但是值是地址），可以通过形参影响实参。

public class MethodParameter02{
	public static void main(String[] args){
		B b = new B();
		int[] arr = {1,2,3,4,5};
		b.change(arr);
		for(int i = 0; i < arr.length; i++){
			System.out.print(arr[i] + "\t");
		}
	}
}

class B{
	// B类中编写一个方法test100；
	// 可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化
	// 引用类型传递的是地址！所以新空间里的arrb也指向arr指向的空间，所以会同步修改。
	public void change(int[] arrb){
		arrb[0] = 100000;
	}
}

public class CopyPerson{
	public static void main(String[] args){
		Person p1 = new Person();
		p1.name = "江弦";
		p1.age = 21;

		Person p2 = p1.copy();
		p1.age = 1000;

		System.out.println("p1.age:" + p1.age);
		System.out.println("p2.age:" + p2.age);
	}
}

class Person{
	String name;
	int age;

	public Person copy(){
		Person newp = new Person();
		newp.name = name;
		newp.age = age;
		return newp;
	}
}

方法递归调用：

基本介绍：

递归就是自己调用自己，每次调用时传入不同的变量，递归有助于编程者解决复杂问题（每次缩减问题的规模），同时可以让代码变得简洁。


public class Recursion01{

	public static void main(String[] args){
		T t = new T();
		int n = 10;
		t.test(n);
	}
}

class T{
	public void test(int n){
		if(n>2){
			test(n-1);
		}
		System.out.println("n=" + n);
	}
}

重要规则：

执行一个方法时，就创建一个新的受保护的独立空间（栈空间）；
方法的局部变量是独立的，不会相互影响；
若方法中使用的时引用类型变量，就会共享该引用类型的数据；
递归必须向退出递归的条件逼近，否则就是无限递归（问题规模要缩小）；
当一个方法执行完毕，或者遇到return，就会返回，遵循谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也将执行完毕

练习：


public class RecursionExercise01{
	public static void main(String[] args){
		T t = new T();
		System.out.println("第六个数的fibonacci数为：" + t.fibonacci(6));
		System.out.println("第一天有多少个桃子：" + t.peach(1));
	}
}

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

	// 猴子吃桃：
	public int peach(int day){
		if(day == 10){
			return 1;
		}else if(day >= 1 && day <= 9){
			return (peach(day+1)+1) * 2;
		}else{
			System.out.println("不在范围内。");
			return -1;
		}
	}
}

走迷宫：

对findWay的一些解释：

只要终点位置不为2就继续递归（若起点位置为3会退出函数）；
每次将当前位置假设为通路（2），向四个方向探测，只要有一个方向的值为0，就视为假设正确，否则将当前位置设置为3，返回到上一个位置（回溯）。
不同的寻路策略，对路径是有影响的。


public class MiGong{
	public static void main(String[] args){
		// 思路：
		// 1、先创建迷宫，用二维数组表示 int[][] map = new int[8][7];
		// 2、规定 map 数组的元素值：0表示可走，1表示障碍物。
		
		int[][] map = new int[8][7];
		
		// 3、将最上面的一行和最下面的一行全部设置为1；
		for(int i = 0; i < 7 ; i++){
			map[0][i] = 1;
			map[7][i] = 1;
		}

		// 4、将最左边一行和最右边一行全部设置为1；
		for(int i = 0; i < 8; i++){
			map[i][0] = 1;
			map[i][6] = 1;
		}

		// 5、单独设置障碍物：
		map[3][1] = 1;
		map[3][2] = 1;
		map[2][2] = 1;

		// 输出当前的地图：
		for(int i = 0; i < 8;i++){
			for(int j = 0; j < 7; j++){
				System.out.print(map[i][j] + " ");
			}
			System.out.println();
		}

		// 使用findWay找路；
		T t1 = new T();
		t1.findWay(map, 1, 1);
		System.out.println("找到的路径如下：");
		for(int i = 0; i < 8;i++){
			for(int j = 0; j < 7; j++){
				System.out.print(map[i][j] + " ");
			}
			System.out.println();
		}

	}
}

class T{
	// 使用递归回溯的思想来解决：
	// 
	// 1、 findWay方法就是用来专门找出路径的；
	// 2、 若找到，返回true，否则为false；
	// 3、 map为二维数组，即表示迷宫；
	// 4、 i，j就是老鼠的位置，初始化的位置为(1，1);
	// 5、 因为我们是递归找路，所以需要预先规定各个值的意义：
	// 		0 表示可以走； 1 表示障碍物； 2 表示可以走； 3 表示走过，但是走不通。
	// 6、什么时候可以退出呢？终点位置为2，说明走通了，即map[6][5]为2，就可以结束了。否则就继续找。
	// 7、找路的策略对路径是会有影响的:
	// 		我们使用先找下，再走右面，右面走不通走上面，上面走不通找左面；
	// 		下-》右-》上-》左
	public boolean findWay(int[][] map, int i, int j){
		if(map[6][5] == 2){
			return true;
		}else{
			if(map[i][j] == 0){// 当前位置为0说明可以走
				// 假定可以走通：
				map[i][j] = 2;
				// 使用找路策略，来确定该位置是否可以走通；
				if(findWay(map, i+1, j)){
					return true;
				}else if(findWay(map, i, j+1)){
					return true;
				}else if(findWay(map, i-1, j)){
					return true;
				}else if(findWay(map, i, j-1)){
					return true;
				}else{
					map[i][j] = 3;
					return false;
				}
			}else{// 不等于0，只可能为1，2，3，说明已经测试过了
				return false;
			}
		}
	}
}

扩展：如何找到最短路径？

穷举法；
使用图（在数据结构和算法中讲解。）

汉诺塔：

核心思想就是简化。

public class HanoiTower{
	public static void main(String[] args){
		T t = new T();
		t.move(5, 'A', 'B', 'C');
	}
}

class T{
	// a,b,c分别表示A柱，B柱，C柱
	public void move(int num, char a, char b, char c){
		if(num == 1){
			System.out.println(a + "->" + c);
		}else{
			// 将上面的盘看作一个整体，挪到中间盘,c柱现在为过度。
			move(num - 1, a, c, b);
			// 把下面的盘挪动到c
			System.out.println(a + "->" + c);
			// 再把b柱上的所有盘移动到c盘，借助a：
			move(num-1, b, a, c);
		}
	}
}

方法重载（OverLoad）：

基本介绍：

java中允许一个类中，多个同名方法的存在，但要求i 形参列表不一致。

好处：

减轻了起名的麻烦；
减轻了记名的麻烦。

注意事项和使用细节：

方法名：必须相同；
形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）；
返回类型：无要求（若方法名相同，形参列表完全相同，仅有返回类型不同，这不是重载，是错误的）。

可变参数：

基本概念：

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

基本语法：

访问修饰符 返回类型 方法名(数据类型... 形参名){
}

注意事项和使用细节：

可变参数的实参可以为 0 个或任意多个；
可变参数的实参为数组；
可变参数的本质是数组；
可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数再最后；
一个形参列表中只能出现一个可变参数。

作用域：

再面向对象中，变量作用域是非常重要的知识点。

再java编程中，主要的变量就是属性（成员变量）和局部变量；
局部变量：一般指的是成员方法中定义的变量，也可以是代码块中定义的变量；
作用域的分类：
1. ==全局变量：==就是属性，作用域是整个类体；
2. ==局部变量：==就是除了属性之外的其它变量，作用域为所在的代码块。
==全局变量（属性）==可以不用赋值，直接使用，因为其有默认值（同数组）；局部变量必须赋值后，才能使用，因为没有默认值。

注意事项和使用细节：

属性和局部变量可以重名，访问遵循就近原则；
在同一个作用域（代码块）中，不允许两个局部变量重名；
属性的生命周期长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量的生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的销毁而销毁（即一次方法调用）。
作用域范围不同：
1. 全局变量/属性——只能被本类使用，或其它类使用（通过对象调用，即引用传递）；
2. 局部变量——只能在本类中对应的方法中使用。
修饰符不同：
1. 全局变量/属性——可以加修饰符；
2. 局部变量——不能加修饰符。

构造器方法/构造器：

便于我们在创建完对象后，就指定对象的年龄和姓名。类似于C++中的构造函数。

基本语法：

[修饰符] 方法名(形参列表){
	方法体;
}

构造器的修饰符可以默认，也可以是public、protected、private；
构造器没有返回值；
方法名必须和类名一致；
参数列表和成员方法类似；
构造器的调用由系统完成。
在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。

使用细节和注意事项：

一个类可以定义多个不同的构造器，即构造器重载；
构造器名和类名要相同；
构造器没有返回值；
构造器是完成对象的初始化，而不是创建对象；
在创建对象时，系统自动的调用该类的构造方法；
若程序员没有定义构造器，系统会自动给类生成一个默认无参构造器（默认构造器）；
一旦定义了自己的构造器，默认的构造器就被覆盖了，不能再使用默认的无参构造器了。

对象创建的流程分析：

加载类信息，只会加载一次；
在堆中分配空间；
完成对象初始化
1. 默认初始化，即在类中的属性定义完便有默认值；
2. 显示初始化，即在类中对属性赋值；
3. 构造器的初始化
把对象在堆中的地址，返回给对象名（在栈中）。

this关键字：

使用细节和注意事项：

this关键字可以用来访问本类的属性、方法、构造器；
this用于区分当前类的属性和局部变量。 this.age = age;this后面的是属性，没有this的age是局部变量；
访问成员方法的语法： this.方法名(参数列表);
访问构造器语法：this(参数列表);需要注意的是，只能在构造器中使用，即只能在构造器中访问另外一个构造器，必须放在第一条语句；
this不能再类定义的外部定义。

Homework：

题一：

public class Homework01{
	public static void main(String[] args){
		T t = new T();
		double[] arr = {1,2,3,4,5};
		double max = t.max(arr);
		System.out.println("max:" + max);
	}
}

class T{
	public double max(double[] arr){
		double res = 0.0;
		for(int i = 0; i < arr.length; i++){
			if(res <= arr[i]){
				res = arr[i];
			}
		}
		return res;
	}
}

题二：

public class Homework02{
	public static void main(String[] args){
		A02 a = new A02();
		String s1 = "Hello";
		String[] ss = {"Hello","world"};
		System.out.println(a.find(s1, ss));
	}
}

class A02{
	public int find(String s1, String[] ss){
		for(int i = 0; i < ss.length; i++){
			if(s1.equals(ss[i])){
				return i;
			}
		}
		return -1;
	}
}

题三：

public class Homework03{
	public static void main(String[] args){
		Book b = new Book();
		int price1 = 190, price2 = 110;
		System.out.println(b.updatePrice(price1));
		System.out.println(b.updatePrice(price2));
	}
}

class Book{
	public int updatePrice(int price){
		if(price > 150){
			price = 150;
		}else if(price > 100){
			price = 100;
		}
		return price;
	}
}

题四：

public class Homework04{
	public static void main(String[] args){
		int arr[] = {1,2,3,4,5};
		A03 a = new A03();
		int[] newarr = a.copyArr(arr);
		for(int i = 0; i < newarr.length; i++){
			System.out.print(newarr[i] + "\t");
		}
	}
}

class A03{
	public int[] copyArr(int[] arr){
		int[] newarr = new int[arr.length];
		for(int i = 0; i < arr.length; i++){
			newarr[i] = arr[i];
		}
		return newarr;
	}
}

题五：

public class Homework05{
	public static void main(String[] args){
		Circle c = new Circle();
		c.r = 3.0;
		c.showPerimeter();
		c.showArea();
	}
}

class Circle{
	double r;
	double pi = 3.14;

	public void showPerimeter(){
		System.out.println("周长为：" + 2*pi*r);
	}

	public void showArea(){
		System.out.println("面积为：" + pi*r*r);
	}
}

题六：

public class Homework06{
	public static void main(String[] args){
		Cale c1 = new Cale();
		Cale c2 = new Cale();
		c1.op1 = 10.0;
		c1.op2 = 2.0;
		System.out.println("add:" + c1.add());
		System.out.println("sub:" + c1.sub());
		System.out.println("mul:" + c1.mul());
		System.out.println("div:" + c1.div());

		c2.op1 = 9;
		c2.op2 = 0;
		System.out.println("add:" + c2.add());
		System.out.println("sub:" + c2.sub());
		System.out.println("mul:" + c2.mul());
		System.out.println("div:" + c2.div());
	}
}

class Cale{
	double op1;
	double op2;

	public double add(){
		return op1 + op2;
	}
	public double sub(){
		return op1 - op2;
	}
	public double mul(){
		return op1 * op2;
	}
	public double div(){
		if(op2 == 0){
			System.out.println("非法参数！");
			return -1;
		}
		return op1 / op2;
	}
}

题七：

public class Homework07{
	public static void main(String[] args){
		Dog d = new Dog("小白","white",5);
		d.show();
	}
}

class Dog{
	String name;
	String color;
	int age;
	public Dog(String name, String color, int age){
		this.name = name;
		this.color = color;
		this.age = age;
	}

	public void show(){
		System.out.println("name:" + name + " color:" + color + " age:" + age);
	}
}

题十四：

import java.util.Random;
import java.util.Scanner;

public class Homework14{
	public static void main(String[] args){
		Tom t = new Tom();
		int num = t.fingerGuessingGame();
		System.out.println(num);
	}
}

class Tom{
	public int fingerGuessingGame(){
		Scanner myScanner = new Scanner(System.in);
		Random rand = new Random(); 
		int count = 0;

		while(true){
			System.out.println("开始猜拳游戏，0代表石头，1代表剪刀，2代表布：");
			int player = myScanner.nextInt();
			int n = rand.nextInt(3); 

			switch(player){
				case 0:
				if(n == 0) {
					System.out.println("平局。");
				}else if(n == 1) {
					System.out.println("你获胜了！");
					count++;
				}else if(n == 2){
					System.out.println("你输了。");
				}
				break;

				case 1:
				if(n == 1) {
					System.out.println("平局。");
				}else if(n == 2) {
					System.out.println("你获胜了！");
					count++;
				}else if(n == 0){
					System.out.println("你输了。");
				}
				break;

				case 2:
				if(n == 2) {
					System.out.println("平局。");
				}else if(n == 0) {
					System.out.println("你获胜了！");
					count++;
				}else if(n == 1){
					System.out.println("你输了。");
				}
				break;

				default:
				System.out.println("你的输入非法！");
			}

			System.out.println("是否要继续？");
			char c = myScanner.next().charAt(0);
			if(c == 'n'){
				break;
			}
		}
		return count;
	}
}