第7章：面向对象编程（基础部分）

7.1 类与对象

7.1.1 看一个养猫猫问题

张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。还有一只叫小花,今年 100 岁,花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示 张老太没有这只猫猫。

7.1.2 使用现有技术解决

【常规操作】

• 1. 单独的定义变量解决 => 不利于数据的管理
• 2. 使用数组解决
  • (1)数据类型体现不出来
  • (2) 只能通过[下标]获取信息，造成变量名字和内容的对应关系不明确
  • (3) 不能体现猫的行为（猫的方法）

public class Object01{
	public static void main(String[] args){
		//需求：
		//张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。
		//还有一只叫小花,今年 100 岁,花色。
		//请编写一个程序，当用户 输入小猫的名字时，就显示该猫的名字，年龄，颜色。
		//如果用户输入的小猫名错误，则显示 张老太没有这只猫猫。
		//思路分析：
		//单独变量来解决 => 不利于数据的管理(你把一只猫的信息拆解)
		//
		//第一只猫的信息
		String cat1Name = "小白";
		int cat1Age = 3;
		String cat1Color = "白色";

		//第二只猫的信息
		String cat2Name = "小花";
		int cat2Age = 100;
		String cat2Color = "花色";

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

		//第二只猫的信息
		String[] cat2 = {"小花", "100", "花色"};
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

7.1.3 现有技术解决的缺点分析

不利于数据的管理，以往的技术使用效率低 ===》 引出我们的新知识点 类与对象；

Java 设计者 引入 类与对象(OOP) ，根本原因就是现有的技术，不能完美的解决新的需求。

public class Object01 { 

	//编写一个main方法
	public static void main(String[] args) {

		/*
		张老太养了两只猫猫:一只名字叫小白,今年3岁,白色。 
		还有一只叫小花,今年100岁,花色。请编写一个程序，当用户输入小猫的名字时，
		就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，
		则显示 张老太没有这只猫猫。
		 */

		//使用OOP面向对象解决
		//实例化一只猫[创建一只猫对象]
		//爱摸鱼的TT~解读
		//1. new Cat() 创建一只猫(猫对象【真实】)
		//2. Cat cat1 = new Cat(); 把创建的猫赋给 cat1【别称/名】 
		//3. cat1 就是一个对象（对象的引用）
		Cat cat1 = new Cat();
		cat1.name = "小白";
		cat1.age = 3;
		cat1.color = "白色";
		cat1.weight = 10;
		//创建了第二只猫，并赋给 cat2
		//cat2 也是一个对象(猫对象)
		Cat cat2 = new Cat();
		cat2.name = "小花";
		cat2.age = 100;
		cat2.color = "花色";
		cat2.weight = 20;

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

		System.out.println("第2只猫信息" + cat2.name 
			+ " " + cat2.age + " " + cat2.color + " " + cat2.weight);
	}
}
//使用面向对象的方式来解决养猫问题
//
//定义一个猫类 Cat -> 自定义的数据类型
class Cat {
	//属性/成员变量/filed字段
	String name; //名字
	int age; //年龄
	String color; //颜色
	double weight; //体重

	//行为

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

7.1.4 类与对象的关系示意图

1. 

2. 

7.1.5 类和对象的区别和联系

通过上面的案例和讲解，我们可以看出：

• 1. 类是抽象的，概念的，代表一类事物,比如人类,猫类…，即它是数据类型；
• 2. 对象是具体的，实际的，代表一个具体事物, 即 是实例；
• 3. 类是对象的模板，对象是类的一个个体，对应一个实例。
     

7.1.6 对象在内存中存在形式(重要的)

对象在内存中存在堆内存里

7.1.7 属性/成员变量/field字段

基本介绍

• 1. 从概念或叫法上看： 成员变量 = 属性 = field(字段) （即 成员变量是用来表示属性的，在之后统一叫 属性) 案例演示：Car(name,price,color) Object02.java

public class Object02 { 

	//编写一个main方法
	public static void main(String[] args) {
	}
}

class Car {
	String name;//属性, 成员变量, 字段 field
	double price;
	String color;
	String[] master;//属性可以是基本数据类型，也可以是引用类型(对象，数组)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

• 2. 属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。比如我们前面定义猫类 的 int age 就是属性。
     

注意事项和细节说明

PropertiesDetail.java

• 1. 属性的定义语法同变量一致，示例：访问修饰符 属性类型 属性名;

这里简单的介绍访问修饰符： 控制属性的访问范围
有四种访问修饰符 public, proctected, 默认, private ，后面我会详细介绍

• 2. 属性的定义类型可以为任意类型，包含基本类型或引用类型
• 3. 属性如果不赋值，有默认值，规则和数组一致。

默认值: int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000， boolean false，String null

public class PropertiesDetail { 

	//编写一个main方法
	public static void main(String[] args) {
		//创建Person对象
		//p1 是对象名(对象引用)
		//new Person() 创建的对象空间(数据) 才是真正的对象
		Person p1 = new Person();

		//对象的属性默认值，遵守数组规则:
		//int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
	
		System.out.println("\n当前这个人的信息");
		System.out.println("age=" + p1.age + " name=" 
				+ p1.name + " sal=" + p1.sal + " isPass=" + p1.isPass) ;
	}
}

class Person {
	//四个属性
	int age;
	String name;
	double sal;
	boolean isPass;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

7.1.8 如何创建对象

• 1. 先声明再创建

Cat cat ; //声明对象 cat是对象名(对象引用)，在栈空间，指向为null【因为没有真正的对象空间（没分配空间）】
cat = new Cat(); //创建 new Cat() 创建的对象空间(数据)，在堆内存 才是真正的对象
1
2

• 2. 直接创建

Cat cat = new Cat();// 先在堆内存分配好空间，然后赋值给栈内存，栈内存就指向该地址
1

7.1.9 如何访问属性

基本语法

对象名（对象引用）.属性名; 
1

案例演示赋值和输出

cat.name ; 
cat.age; 
cat.color; 
1
2
3

7.1.10 类和对象的内存分配机制(重要)

我们先思考一道题：


采用内存分析方法来解决：

Java 内存的结构分析

• 1. 栈： 一般存放基本数据类型(局部变量)
• 2. 堆： 存放对象(Cat cat , 数组等)
• 3. 方法区：常量池(常量，字符串…)， 类加载信息
     

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

Person p = new Person(); 
p.name = “jack”; 
p.age = 10;
1
2
3

1. 先加载 Person 类信息(属性和方法信息到方法区, 只会加载一次)
   2) 在堆中分配空间, 进行默认初始化(看和数组规则一样) 【有数据就有地址】
   3) 把地址赋给 p , p 就指向该对象
   4) 进行指定初始化， 比如 p.name =”jack” p.age = 10

例如：看一个练习题，并分析画出内存布局图，进行分析


分析（一步到位）：你们在分析过程可以一步一步执行，就能明白了。

7.2 成员方法

7.2.1 基本介绍

在某些情况下，我们要需要定义成员方法(简称方法)。比如人类：除了有一些属性外( 年龄，姓名…)，我们人类还有一些行为比如：可以说话、跑步… 通过学习，还可以做算术题。这时就要用成员方法才能完成。现在要求对 Person 类进行完善。

7.2.2 成员方法快速入门

下面有4个方法实例进行实现：
1) 添加 speak 成员方法，输出 “我是一个好人”
2) 添加 cal01 成员方法，可以计算从 1+…+1000 的结果
3) 添加 cal02 成员方法，该方法可以接收一个数 n，计算从 1+…+n 的结果
4) 添加 getSum 成员方法，可以计算两个数的和

public class Method01 { 

	//编写一个main方法
	public static void main(String[] args) {
		//方法使用
		//1. 方法写好后，如果不去调用(使用)，不会输出
		//2. 先创建对象 ,然后调用方法即可
		Person p1 = new Person();
		p1.speak(); //调用方法
		p1.cal01(); //调用cal01方法
		p1.cal02(5); //调用cal02方法，同时给n = 5
		p1.cal02(10); //调用cal02方法，同时给n = 10
		
		//调用getSum方法，同时num1=10, num2=20
		//把 方法 getSum 返回的值，赋给 变量 returnRes
		int returnRes = p1.getSum(10, 20); 
		System.out.println("getSum方法返回的值=" + returnRes);
	}
}

class Person {
	
	String name;
	int age;
	//方法(成员方法)
	//添加speak 成员方法,输出 “我是一个好人”
	//爱摸鱼的TT~解读
	//1. public 表示方法是公开
	//2. void ： 表示方法没有返回值
	//3. speak() : speak是方法名， () 形参列表
	//4. {} 方法体，可以写我们要执行的代码
	//5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话
	
	public void speak() {
		System.out.println("我是一个好人");
	}

	//添加cal01 成员方法,可以计算从 1+..+1000的结果
	public void cal01() {
		//循环完成
		int res = 0;
		for(int i = 1; i <= 1000; i++) {
			res += i;
		}
		System.out.println("cal01方法 计算结果=" + res);
	}
    
	//添加cal02 成员方法,该方法可以接收一个数n，计算从 1+..+n 的结果
	//爱摸鱼的TT~解读
	//1. (int n) 形参列表， 表示当前有一个形参 n, 可以接收用户输入
	public void cal02(int n) {
		//循环完成
		int res = 0;
		for(int i = 1; i <= n; i++) {
			res += i;
		}
		System.out.println("cal02方法 计算结果=" + res);
	}

	//添加getSum成员方法,可以计算两个数的和
	//爱摸鱼的TT~解读
	//1. public 表示方法是公开的
	//2. int :表示方法执行后，返回一个 int 值
	//3. getSum 方法名
	//4. (int num1, int num2) 形参列表，2个形参，可以接收用户传入的两个数
	//5. return res; 表示把 res 的值， 返回
	public int getSum(int num1, int num2) {
		int res = num1 + num2;
		return res;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

那底层是如何呢？

7.2.3 方法的调用机制原理(重要!-示意图!!!)

提示：画出程序执行过程[就针对getSum()方法分析]+说明

7.2.4 为什么需要成员方法

我们先看一个需求：请遍历一个数组 , 输出数组的各个元素值。

• 解决思路 1，传统的方法，就是使用单个 for 循环，将数组输出，大家看看问题是什么？
  • 假如我们需要输出很多数组值，那采用该思路就只能不断重复写for循环这几行代码
  • 要修改for循环代码，那也只能每个代码都需修改

public class Method02 { 

	//编写一个main方法
	public static void main(String[] args) {

		//请遍历一个数组 , 输出数组的各个元素值
		int [][] map =  {{0,0,1},{1,1,1},{1,1,3}};

		//遍历map数组
		//传统的解决方式就是直接遍历
		for(int i = 0; i < map.length; i++) {
		 	for(int j = 0; j < map[i].length; j++) {
		 		System.out.print(map[i][j] + "\t");
		 	}
		 	System.out.println();
		}

		//....
		//
		//要求再次遍历map数组
		for(int i = 0; i < map.length; i++) {
		 	for(int j = 0; j < map[i].length; j++) {
				System.out.print(map[i][j] + "\t");
		 	}
		 	System.out.println();
		}

		//...再次遍历
		//
		for(int i = 0; i < map.length; i++) {
		 	for(int j = 0; j < map[i].length; j++) {
		 		System.out.print(map[i][j] + "\t");
		 	}
		 	System.out.println();
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

• 解决思路 2: 定义一个类 MyTools ,然后写一个成员方法，调用方法实现,看看效果又如何。

public class Method02 { 

	//编写一个main方法
	public static void main(String[] args) {

		//请遍历一个数组 , 输出数组的各个元素值
		int [][] map =  {{0,0,1},{1,1,1},{1,1,3}};

		//使用方法完成输出, 创建MyTools对象 
		MyTools tool = new MyTools();

		//遍历map数组
		//传统的解决方式就是直接遍历
		// for(int i = 0; i < map.length; i++) {
		// 	for(int j = 0; j < map[i].length; j++) {
		// 		System.out.print(map[i][j] + "\t");
		// 	}
		// 	System.out.println();
		// }
		//使用方法
		tool.printArr(map);

		//....
		//
		//要求再次遍历map数组
		// for(int i = 0; i < map.length; i++) {
		// 	for(int j = 0; j < map[i].length; j++) {
		// 		System.out.print(map[i][j] + "\t");
		// 	}
		// 	System.out.println();
		// }
		tool.printArr(map);


		//...再次遍历
		//
		// for(int i = 0; i < map.length; i++) {
		// 	for(int j = 0; j < map[i].length; j++) {
		// 		System.out.print(map[i][j] + "\t");
		// 	}
		// 	System.out.println();
		// }
		tool.printArr(map);

	}
}

//把输出的功能，写到一个类的方法中,然后调用该方法即可
class MyTools {
	//方法，接收一个二维数组
	
	public void printArr(int[][] map) {
		System.out.println("=======");
		//对传入的map数组进行遍历输出
		for(int i = 0; i < map.length; i++) {
			for(int j = 0; j < map[i].length; j++) {
				System.out.print(map[i][j] + "\t");
			}
			System.out.println();
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

7.2.5 成员方法的好处

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

7.2.6 成员方法的定义

访问修饰符 返回数据类型 方法名（形参列表..） {//方法体 
	语句； 
	return 返回值; 
}
1
2
3
4

1. 形参列表：表示成员方法输入 cal(int n) ， getSum(int num1, int num2)
   2) 返回数据类型：表示成员方法输出, void 表示没有返回值
   3) 方法主体：表示为了实现某一功能代码块
   4) return 语句不是必须的。 【如果有返回值那就需要return，反之可以不写】
   5) 爱摸鱼的TT~提示：结合前面的题示意图, 来理解
   

7.2.7 注意事项和使用细节

1. 访问修饰符 (作用：控制方法使用的范围)

• 如果不写，就为默认访问，[有四种: public, protected, 默认, private], 具体在后面说。
  

2. 返回数据类型

1. 一个方法最多有一个返回值 [思考，如何返回多个结果？—>采用 返回“数组” ]

//1. 一个方法最多有一个返回值  [思考，如何返回多个结果？]
	public int[] getSumAndSub(int n1, int n2) {

		int[] resArr = new int[2]; 
		resArr[0] = n1 + n2;
		resArr[1] = n1 - n2;
		return resArr;
	}
1
2
3
4
5
6
7
8

2. 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
   
   3) 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的值类型一致或兼容

//3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 
//   而且要求返回值类型必须和return的值类型一致或兼容
	public double f1() {

		double d1 = 1.1 * 3;
		int n = 100;
		return n; // int ->double 
		//return d1; //ok? double -> int （x）
	}
1
2
3
4
5
6
7
8
9

4. 如果方法是 void，则方法体中可以没有 return 语句，或者 只写 return ;

//如果方法是void，则方法体中可以没有return语句，或者 只写 return ; 
//爱摸鱼的TT~提示：在实际工作中，我们的方法都是为了完成某个功能，所以方法名要有一定含义最好是见名知意
	public void f2() {

		System.out.println("hello1");
		System.out.println("hello1");
		System.out.println("hello1");
		int n = 10;
        //return n; // 错误
		return ;
	}
1
2
3
4
5
6
7
8
9
10
11

3. 方法名

• 遵循驼峰命名法，最好见名知义，表达出该功能的意思即可, 比如 得到两个数的和 getSum, 开发中按照规范。
  

4. 形参列表

1. 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开，比如：getSum(int n1, int n2)
2. 参数类型可以为任意类型，包含基本类型或引用类型，比如：printArr(int[][] map)
3. 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数！
4. 方法定义时的参数称为形式参数，简称形参；方法调用时的传入参数称为实际参数，简称实参，实参和形参的类型要一致或兼容、个数、顺序必须一致。

5. 方法体

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

6. 方法调用细节说明(!!!)

1. 同一个类中的方法调用：直接调用即可。比如 print(参数);

案例演示：A类 sayOk 调用 print()

2. 跨类中的方法A类调用B类的方法：需要通过对象名调用。比如 对象名.方法名（参数）;

案例演示：B类 sayHello 调用 print()

3. 特别说明一下：跨类的方法调用和方法的访问修饰符相关，先暂时这么提一下，后面我们讲到访问修饰符时，还要再细说。
   

7.2.8 巩固习题

1. 编写类 AA ，有一个方法：判断一个数是奇数 odd 还是偶数, 返回 boolean

public class MethodExercise01{
	public static void main(String[] args){
		//需求：
		//编写类 AA ，有一个方法：判断一个数是奇数 odd 还是偶数, 返回 boolean
		AA a = new AA();
        
		if(a.isOdd(12)){
			System.out.println("该数为奇数");
		}else{
			System.out.println("该数为偶数");
		}
	}
}
class AA{

	//思路
	//1. 方法的返回类型 boolean
	//2. 方法的名字 isOdd
	//3. 方法的形参 (int num)
	//4. 方法体 , 判断
	//
	public boolean isOdd(int num){
		
		/*if(num % 2 != 0){
			return true;
		}else{
			return false;
		}*/
		//return num % 2 != 0 ? true; false;
		
		return num % 2 != 0;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

2. 根据行、列、字符打印 对应行数和列数的字符，比如：行：4，列：4，字符#,则打印相应的效果

public class MethodExercise01 { 

	//编写一个main方法
	public static void main(String[] args) {

		AA a = new AA();
	
		// 使用print方法
		a.print(4, 4, '#');


		
	}
}

class AA {

	//根据行、列、字符打印 对应行数和列数的字符，
	//比如：行：4，列：4，字符#,则打印相应的效果
	/*
		####
		####
		####
		####
	 */
	//思路
	//1. 方法的返回类型 void
	//2. 方法的名字 print
	//3. 方法的形参 (int row, int col, char c)
	//4. 方法体 , 循环
	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(); //换行
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

7.3 成员方法传参机制(非常非常重要!)

方法的传参机制对我们今后的编程非常重要，一定要搞的清清楚楚明明白白。我们通过案例来学习：

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

我们看一个案例，分析结果是什么？

public class MethodParameter01{
	public static void main(String[] args){

		int a = 12;
		int b = 5;
		//创建 AA 对象 名字 obj1
		AA obj1 = new AA();
		obj1.swap(a, b);//调用 swap

		System.out.println("\nmain 方法 a=" + a + " b=" + b);
	}
}
class AA{

	public void swap(int a, int b){
		System.out.println("\na 和 b 交换前的值\na=" + a + "\tb=" + b);
		//完成了 a 和 b 的交换
		int temp = a;
		a = b;
		b = temp;
		System.out.println("\na 和 b 交换后的值\na=" + a + "\tb=" + b);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

大家先自己思考分析下，看看输出结果是什么？

不管大家结果对与否，我们接下来用内存分析进行底层的研究，到底发生了什么变化！

从上面可以得出结论：

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

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

我们继续看一个案例，分析结果：

• B 类中编写一个方法 test100，可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化？
• B 类中编写一个方法 test200，可以接收一个 Person(age,sal)对象，在方法中修改该对象属性，看看原来的对象是否变化？

首先，我们先分析 B 类中编写一个方法 test100 这道题目：

public class MethodParameter02{
	public static void main(String[] args){

		//测试
		B b = new B();
		int[] arr = {1, 2, 3};
		b.test100(arr);//调用方法
		System.out.println(" main的 arr数组 ");
		//遍历数组
		for(int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
		System.out.println();
	}
}
class B{

	//B类中编写一个方法test100，
	//可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化
	public void test100(int[] arr) {
		arr[0] = 200;//修改元素
		//遍历数组
		System.out.println(" test100的 arr数组 ");
		for(int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
		System.out.println();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

运行结果：

从运行结果看出，有问题！那我们用内存分析法进行分析一波！

然后，我们再次分析 B 类中编写一个方法 test200 这道题目：

public class MethodParameter02{
	public static void main(String[] args){

		//测试
		B b = new B();
		Person p = new Person();
		p.name = "jack";
		p.age = 10;
		b.test200(p);

		System.out.println("main 的p.age=" + p.age);
	}
}

class Person {
	String name;
	int age; 
}
class B{

	public void test200(Person p) {
		p.age = 10000; //修改对象属性
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

我们继续对内存分析一波！

从以上分析可以得出结论：

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

【思考题】
以上内存分析相信大家基本掌握了吧，那我将上面题目再进行改变下，继续进行内存分析，看看输出结果又有什么不同。

• 改编1：p=null;

public class MethodParameter02 { 
	//编写一个main方法
	public static void main(String[] args) {

		//测试
		Person p = new Person();
		p.name = "jack";
		p.age = 10;
		b.test200(p);
		//测试题, 如果 test200 执行的是 p = null ,下面的结果是 10
		System.out.println("main 的p.age=" + p.age);
	}
}
class Person {
	String name;
	int age; 
}
class B {
	public void test200(Person p) {
		//思考1
		p = null; 
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

内存分析：

• 改编2：p = new Person();

public class MethodParameter02 { 
	//编写一个main方法
	public static void main(String[] args) {
		//测试
		B b = new B();
		Person p = new Person();
		p.name = "jack";
		p.age = 10;
		b.test200(p);
		//测试题, 如果 test200 执行的是 p = null ,下面的结果是 10
		//测试题, 如果 test200 执行的是 p = new Person();..., 下面输出的是10
		System.out.println("main 的p.age=" + p.age);
	}
}
class Person {
	String name;
	int age; 
}
class B {
	public void test200(Person p) {

		//思考
		p = new Person();
		p.name = "tom";
		p.age = 99;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

内存分析：

好了，对这块知识 大家掌握应该还是蛮不错的吧，接下来我们用习题巩固巩固。

7.3.3 成员方法返回类型是引用类型 应用实例(克隆对象)

编写一个方法 copyPerson，可以复制一个 Person 对象，返回复制的对象。克隆对象， 注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同 。

public class MethodExercise02{
	public static void main(String[] args){
		Person p = new Person();
		p.name = "Jack"；
		p.age = 18;
		MyTools tools = new MyTools();
		Person p2 = tools.copyPerson(p);

		//到此 p 和 p2是Person对象，但是是两个独立的对象，属性相同
		System.out.println("p的属性 age=" + p.age  + " 名字=" + p.name);
		System.out.println("p2的属性 age=" + p2.age  + " 名字=" + p2.name);
		//这里爱摸鱼的TT~提示： 可以 对象比较看看是否为同一个对象
		System.out.println(p == p2);//false,则不是同一个对象
	}
}
class Person{
	String name;
	int age;
}
class MyTools{
	//编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象。克隆对象， 
	//注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同
	//
	//编写方法的思路
	//1. 方法的返回类型 Person
	//2. 方法的名字 copyPerson
	//3. 方法的形参 (Person p)
	//4. 方法体, 创建一个新对象，并复制属性，返回即可
	public Person copyPerson(Person p){
		//创建一个新的对象
		Person p2 = new Person();
		p2.name = p.name;
		p2.age = p.age;
		return p2;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

内存分析：

7.4 方法递归调用(非常非常重要，比较难)

7.4.1 基本介绍

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

7.4.2 递归能解决什么问题？

1. 各种数学问题，如：8皇后问题，汉诺塔，阶乘问题，迷宫问题，球和篮子的问题（google编程大赛）
2. 各种算法中也会使用到递归，比如快排、归并排序、二分查找、分治算法等。
3. 将用栈解决的问题 —> 递归代码比较简洁。

7.4.3 递归举例

列举两个小案例，来帮助大家理解递归调用机制

1. 打印问题

public class Recursion01{

	public static void main(String[] args){

		T t1 = new T(); 
		t1.test(4);//输出什么？ n=2 n=3 n=4 
		
	}
}
class T{
	//分析
	public void test(int n){
		if(n > 2){
			test(n -1);
		}
		System.out.println("n =" + n);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

运行结果：

内存分析：

2. 阶乘问题

public class Recursion01{

	public static void main(String[] args){

		T t1 = new T();
		int res = t1.factorial(5); 
		System.out.println("5的阶乘 res =" + res); 

	}
}
class T{
	//factorial 阶乘
	public  int factorial(int n) {
		if (n == 1) {
			return 1;
		} else {
			return factorial(n - 1) * n;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

内存分析：

7.4.4 递归重要规则

1. 执行一个方法时，就会创建一个新的受保护的独立空间（栈空间）；
2. 方法局部变量是独立的，不会相互影响，比如n变量；
3. 如果方法中使用的是引用类型变量（比如数组，对象），就会共享该引用类型的数据；
4. 递归必须向退出递归的条件逼近（比如factorial(n - 1)*n），否则就是无限递归，出现StackOverflowError，死龟了；
5. 当一个方法执行完毕，或者调用return，就会返回，遵守 谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。
   

7.4.5 巩固练习

1. 请使用递归的方式求出斐波那契数 1,1,2,3,5,8,13…给你一个整数n，求出它的值是多少？

public class RecursionExrecise01{

	public static void main(String[] args){

		T t1 = new T();
		int n = 7; 
		int res = t1.fibonacci(n); 
		if(res != -1) { 
			System.out.println("当 n= "+ n +" 对应的斐波那契数=" + res);
		}
	}
}
class T{

	/*请使用递归的方式求出斐波那契数 1,1,2,3,5,8,13...给你一个整数 n，求出它的值是多 
		思路分析 
		1. 当 n = 1 斐波那契数 是 1 
		2. 当 n = 2 斐波那契数 是 1 
		3. 当 n >= 3 斐波那契数 是前两个数的和 
		4. 这里就是一个递归的思路 
	*/

	public int fibonacci(int n){
		if(n >= 1){
			if(n == 1 || n ==2){
				return 1;
			}else{
				return fibonacci(n - 1) + fibonacci(n - 2);
			}
		}else{
			System.out.println("要求输入的 n>=1 的整数");
			return -1;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

2. 猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天，想再吃时（即还没吃），发现只有1个桃子了。问题：最初共多少个桃子？

public class RecursionExrecise02{

	public static void main(String[] args){

		T t = new T();
		int day = 1;
		int peachNum = t.peach(day);
		if(peachNum != -1){
			System.out.println("第 " + day + "天有" + peachNum + "个桃子");
		}
	}
}
class T{
	/*
		猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！
		以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，
		想再吃时（即还没吃），发现只有1个桃子了。问题：最初共多少个桃子？
		
		思路分析 逆推
		1. day = 10 时 有 1个桃子
		2. day = 9 时  有 (day10 + 1) * 2 = 4
		3. day = 8 时  有 (day9 + 1) * 2 = 10
		4. 规律就是  前一天的桃子 = (后一天的桃子 + 1) *2//就是我们的能力
		5. 递归
		 */
	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("day需在在1-10");
			return -1;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

7.4.6 递归调用应用实例-迷宫问题

1. 小球得到的路径，和程序员设置的找路策略有关即：找路的上下左右的顺序相关。
2. 再得到小球路径时，可以先使用（下右上左），再改成（上右下左），看看路径是不是又变化；
3. 测试回溯现象；
4. 扩展思考：如何求出最短路径？思路（1）穷举（2）图 -> 求出最短路径

首先，我们将整个迷宫地图用代码写出来。

public class MiGong { 

        //编写一个main方法
        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;
                }
                map[3][1] = 1;
                map[3][2] = 1;

                //输出当前的地图
                System.out.println("=====当前地图情况======");
                for(int i = 0; i < map.length; i++) {
                        for(int j = 0; j < map[i].length; j++) {
                                System.out.print(map[i][j] + " ");//输出一行
                        }
                        System.out.println();
                }
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

接着，就是小鼠找路走出迷宫的代码了；

public class MiGong { 

        //编写一个main方法
        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;
                }
                map[3][1] = 1;
                map[3][2] = 1;

                //输出当前的地图
                System.out.println("=====当前地图情况======");
                for(int i = 0; i < map.length; i++) {
                        for(int j = 0; j < map[i].length; j++) {
                                System.out.print(map[i][j] + " ");//输出一行
                        }
                        System.out.println();
                }

                //使用findWay给老鼠找路
                T t1 = new T();
                //下右上左
                t1.findWay(map, 1, 1);

                System.out.println("\n=====找路的情况如下======");
                for(int i = 0; i < map.length; i++) {
                        for(int j = 0; j < map[i].length; j++) {
                                System.out.print(map[i][j] + " ");//输出一行
                        }
                        System.out.println();
                }
        }
}
class T{
        //使用递归回溯的思想来解决老鼠出迷宫
        
        //爱摸鱼的TT~解读
        //1. findWay方法就是专门来找出迷宫的路径
        //2. 如果找到，就返回 true ,否则返回false
        //3. map 就是二维数组，即表示迷宫
        //4. i,j 就是老鼠的位置，初始化的位置为(1,1)
        //5. 因为我们是递归的找路，所以我先规定 map数组的各个值的含义
        //   0 表示可以走，但没走过 1 表示障碍物 2 表示可以走，通路 3 表示走过，但是走不通是死路
        //6. 当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, j - 1)){//上
                                        return true;
                                }else if(findWay(map, i - 1, j)){//左
                                        return true;
                                }else{
                                        map[i][j] = 3;
                                        return false;
                                }
                        }else{
                                return false;
                        }
                }
        }
        
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

关于找路的思路，必须要确定好以下三要素：

1. 退出条件：找到什么时候迷宫走完可以退出；
2. 制定规则：什么数字表示什么含义；
3. 确定策略：要怎么判断怎么走。

通过上面找路代码，我们也可以改变策略，将策略从下右上左改成上右下左。

//修改找路策略，看看路径是否有变化
        //下->右->上->左 ==> 上->右->下->左
        public boolean findWay2(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(findWay2(map, i - 1 , j)){//先走上
                                        return true;
                                }else if(findWay2(map, i , j + 1)){//右
                                        return true;
                                }else if(findWay2(map, i + 1, j)){//下
                                        return true;
                                }else if(findWay2(map, i , j - 1)){//左
                                        return true;
                                }else{
                                        map[i][j] = 3;
                                        return false;
                                }
                        }else{
                                return false;
                        }
                }
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

最后，我们测试下回溯现象，也就是假定在map[2][2] = 1设为墙，就会发现第一种策略中map[3][1] = 3现象

public class MiGong { 

        //编写一个main方法
        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;
                }
                map[3][1] = 1;
                map[3][2] = 1;
                map[2][2] = 1;//测试回溯现象

                //输出当前的地图
                System.out.println("=====当前地图情况======");
                for(int i = 0; i < map.length; i++) {
                        for(int j = 0; j < map[i].length; j++) {
                                System.out.print(map[i][j] + " ");//输出一行
                        }
                        System.out.println();
                }

                //使用findWay给老鼠找路
                T t1 = new T();
                //下右上左
                t1.findWay(map, 1, 1);

                System.out.println("\n=====找路的情况如下======");
                for(int i = 0; i < map.length; i++) {
                        for(int j = 0; j < map[i].length; j++) {
                                System.out.print(map[i][j] + " ");//输出一行
                        }
                        System.out.println();
                }
        }
}
class T{
        //使用递归回溯的思想来解决老鼠出迷宫
        
        //爱摸鱼的TT~解读
        //1. findWay方法就是专门来找出迷宫的路径
        //2. 如果找到，就返回 true ,否则返回false
        //3. map 就是二维数组，即表示迷宫
        //4. i,j 就是老鼠的位置，初始化的位置为(1,1)
        //5. 因为我们是递归的找路，所以我先规定 map数组的各个值的含义
        //   0 表示可以走，但没走过 1 表示障碍物 2 表示可以走，通路 3 表示走过，但是走不通是死路
        //6. 当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, j - 1)){//上
                                        return true;
                                }else if(findWay(map, i - 1, j)){//左
                                        return true;
                                }else{
                                        map[i][j] = 3;
                                        return false;
                                }
                        }else{
                                return false;
                        }
                }
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

7.4.7 递归调用应用实例-汉诺塔

• 汉诺塔传说

汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着 64 片圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
假如每秒钟移动一次，共需多长时间呢？移完这些金片需要 5845.54 亿年以上，太阳系的预期寿命据说也就是数百亿年。 真的过了 5845.54 亿年，地球上的一切生命，连同梵塔、庙宇等，都早已经灰飞烟灭 。

public class HanoiTower{

	public static void main(String[] args){

		Tower tower = new Tower();
		tower.move(5, 'A', 'B', 'C');

	}
}
class Tower{

	//方法
	//num 表示要移动的个数, a, b, c 分别表示A塔，B 塔, C 塔
	public void move(int num, char a, char b, char c){
		//如果只有一个盘 num = 1
		if(num == 1){
			System.out.println(a + "->" + c);
		}else{
			//如果有多个盘，可以看成两个 , 最下面的和上面的所有盘(num-1)
			//(1)先移动上面所有的盘到 b, 借助 c
			move(num - 1, a, c, b);
			//(2)把最下面的这个盘，移动到 c
			System.out.println(a + "->" + c);
			//(3)再把 b塔的所有盘，移动到c ,借助a
			move(num - 1, b, a, c);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

7.4.8 递归调用应用实例-八皇后问题

[大家先尝试做，后面会评讲]

• 八皇后问题说明

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于 1848 年，提出：在 8×8 格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

八皇后思路分析，爱摸鱼的TT~说下：

1. 第一个皇后先放第一行第一列
2. 第二个皇后放在第二行第一列，然后判断是否OK，如果不OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适
3. 继续第三个皇后，还是第一列、第二列…直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确解
4. 当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到
5. 然后回头继续第一个皇后放第二列，后面继续循环执行1,2,3,4的步骤

说明：理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题 arr[8] = {0,4,7,5,2,6,1,3} //对应arr下标表示第几行，即第几个皇后，arr[i] = val，val表示第i + 1个皇后，放在第i + 1行的第val + 1列。

7.5 方法重载(OverLoad)

7.5.1 基本介绍

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

比如：System.out.println(); out 是 PrintStream 类型

7.5.2 重载的好处

• 减轻了起名的麻烦
• 减轻了记名的麻烦
• 便于接口式编程
  

7.5.3 快速入门案例

案例：类：MyCalculator 方法：calculate
1) calculate(int n1, int n2) //两个整数的和
2) calculate(int n1, double n2) //一个整数，一个 double 的和
3) calculate(double n2, int n1)//一个 double ,一个 Int 和
4) calculate(int n1, int n2, int n3)//三个 int 的和

public class OverLoad01 { 

	//编写一个main方法
	public static void main(String[] args) {

		MyCalculator mc = new MyCalculator();
		System.out.println(mc.calculate(1, 2));
		System.out.println(mc.calculate(1.1, 2));
		System.out.println(mc.calculate(1, 2.1));
	}
}

class MyCalculator  {

	//下面的四个 calculate方法构成了重载
	//两个整数的和
	public int calculate(int n1, int n2)  {
		System.out.println("calculate(int n1, int n2) 被调用");
		return n1 + n2;
	}

	//没有构成方法重载, 仍然是错误的，因为是方法的重复定义
	// public void calculate(int n1, int n2)  {
	// 	System.out.println("calculate(int n1, int n2) 被调用");
	// 	int res =  n1 + n2;
	// } 

	//看看下面是否构成重载, 没有构成，而是方法的重复定义,就错了
	// public int calculate(int a1, int a2)  {
	// 	System.out.println("calculate(int n1, int n2) 被调用");
	// 	return a1 + a2;
	// } 

	//一个整数，一个double的和
	public double calculate(int n1, double n2) {
		return n1 + n2;
	}
	//一个double ,一个Int和 
	public double calculate(double n1, int n2) {
		System.out.println("calculate(double n1, int n2) 被调用..");
		return n1 + n2;
	}
	//三个int的和
	public int calculate(int n1, int n2,int n3) {
		return n1 + n2 + n2;
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

7.5.4 注意事项和使用细节

1. 方法名：必须相同
2. 形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）
3. 返回类型：无要求
   

7.5.5 巩固练习

1. 编写程序，类Methods中定义三个重载方法并调用。方法名为m。三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，相乘并输出结果，输出字符串参数。在主类的main()方法中分别用参数区别调用三个方法。

public class OverLoadExercise { 

	//编写一个main方法
	public static void main(String[] args) {

		//在主类的main ()方法中分别用参数区别调用三个方法
		Methods method = new Methods();
		method.m(10);//100
		method.m(10, 20);//200
		method.m("爱摸鱼的TT~ hello");//字符串信息

	}
}

class Methods {

	//分析
	//1 方法名 m
	//2 形参 (int) 
	//3.void
	public void m(int n) {
		System.out.println("平方=" + (n * n));
	} 

	//1 方法名 m
	//2 形参 (int, int) 
	//3.void
	public void m(int n1, int n2) {
		System.out.println("相乘=" + (n1 * n2));
	}

	//1 方法名 m
	//2 形参 (String) 
	//3.void
	public void m(String str) {
		System.out.println("传入的str=" + str);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

2. 在Methods类，定义三个重载方法max()，第一个方法，返回两个int值中的最大值、第二个方法，返回两个double值中的最大值，第三个方法，返回三个double值中的最大值，并分别调用三个方法。

public class OverLoadExercise { 

	//编写一个main方法
	public static void main(String[] args) {

		Methods method = new Methods();
		//测试
		System.out.println(method.max(10, 24)); // 24
		System.out.println(method.max(10.0, 21.4)); // 21.4
		System.out.println(method.max(10.0, 1.4, 30.0)); // 30.0
	}
}

/*
编写程序，类Methods中定义三个重载方法并调用。方法名为m。
三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，
相乘并输出结果，输出字符串信息。在主类的main ()方法中分别用参数区别调用三个方法


定义三个重载方法max()，第一个方法，返回两个int值中的最大值，
第二个方法，返回两个double值中的最大值，第三个方法，
返回三个double值中的最大值，并分别调用三个方法
 */
class Methods {

	//分析
	//1 方法名 max
	//2 形参 (int,int) 
	//3.int
	public int max(int n1, int n2) {
		return n1 > n2 ? n1 : n2;
	}

	//分析
	//1 方法名 max
	//2 形参 (double,double) 
	//3.double
	public double max(double n1, double n2) {
		return n1 > n2 ? n1 : n2;
	}

	//分析
	//1 方法名 max
	//2 形参 (double,double,double) 
	//3.double
	public double max(double n1, double n2, double n3) {
		
		System.out.println("max(double n1, double n2, double n3)");
		//求出n1 和  n2的最大值
		double max1 = n1 > n2 ? n1 : n2;
		return max1 > n3 ? max1 : n3;
	}

	public double max(double n1, double n2, int n3) {
		
		System.out.println("max(double n1, double n2, int n3)");
		//求出n1 和  n2的最大值
		double max1 = n1 > n2 ? n1 : n2;
		return max1 > n3 ? max1 : n3;
	}	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

7.6 可变参数

7.6.1 基本概念

java 允许将同一个类中多个同名 同功能 但参数个数不同的方法，封装成一个方法，就可以通过可变参数实现。

7.6.2 基本语法

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

}
1
2
3

7.6.3 快速入门案例

看一个案例 类 HspMethod，方法 sum 【可以计算 2 个数的和，3 个数的和 ， 4. 5， 。。】

public class VarParameter01 { 

	//编写一个main方法
	public static void main(String[] args) {

		HspMethod m = new HspMethod();
		System.out.println(m.sum(1, 5, 100)); //106
		System.out.println(m.sum(1,19)); //20
	}
}

class HspMethod {
	//可以计算 2个数的和，3个数的和 ， 4. 5， 。。
	//可以使用方法重载
	// public int sum(int n1, int n2) {//2个数的和
	// 	return n1 + n2;
	// }
	// public int sum(int n1, int n2, int n3) {//3个数的和
	// 	return n1 + n2 + n3;
	// }
	// public int sum(int n1, int n2, int n3, int n4) {//4个数的和
	// 	return n1 + n2 + n3 + n4;
	// }
	//.....
	//上面的三个方法名称相同，功能相同, 参数个数不同-> 使用可变参数优化
	//爱摸鱼的TT~解读
	//1. int... 表示接受的是可变参数，类型是int ,即可以接收多个int(0-多) 
	//2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
	//3. 遍历 nums 求和即可
    
	public int sum(int... nums) {
		//System.out.println("接收的参数个数=" + nums.length);
		int res = 0;
		for(int i = 0; i < nums.length; i++) {
			res += nums[i];
		}
		return res;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

7.6.4 注意事项和使用细节

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

public class VarParameterDetail { 

	//编写一个main方法
	public static void main(String[] args) {
		//细节: 可变参数的实参可以为数组
		int[] arr = {1, 2, 3};
		T t1 = new T();
		t1.f1(arr);
	}
}

class T {

	public void f1(int... nums) {
		System.out.println("长度=" + nums.length);
	}

	//细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
	public void f2(String str, double... nums) {

	}
	//细节: 一个形参列表中只能出现一个可变参数
	//下面的写法是错的.
	// public void f3(int... nums1, double... nums2) {

	// }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

7.6.5 巩固练习

有三个方法，分别实现返回姓名和两门课成绩（总分），返回姓名和三门课成绩（总分），返回姓名和五门课成绩（总分）。封装成一个可变参数的方法。类名HspMethod 方法名showScore

public class VarParameterExercise { 

	//编写一个main方法
	public static void main(String[] args) {
		HspMethod hm = new HspMethod();
		System.out.println(hm.showScore("milan" , 90.1, 80.0 ));
		System.out.println(hm.showScore("terry" , 90.1, 80.0,10,30.5,70 ));
	}
}

class HspMethod  {

	/*
	有三个方法，分别实现返回姓名和两门课成绩(总分)，
	返回姓名和三门课成绩(总分)，返回姓名和五门课成绩（总分）。
	封装成一个可变参数的方法
	 */
	
	//分析1. 方法名 showScore  2. 形参(String ,double... ) 3. 返回String
	//听课小伙伴，要求必须自己动手写
	public String  showScore(String name ,double... scores ) {

		double totalScore = 0;
		for(int i = 0; i < scores.length; i++) {
			totalScore += scores[i];
		}
		return name + " 有 " +scores.length + "门课的成绩总分为=" + totalScore;
	}
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

7.7 作用域

7.7.1 基本使用

面向对象中，变量作用域是非常重要的知识点，相对来说不是特别好理解，大家注意学习，认真思考，要求深刻掌握变量的作用域。

1. 在Java编程中，主要的变量就是属性（成员变量）和局部变量
2. 我们说的局部变量一般是指在成员方法中定义的变量；【举例Cat类：cry】
3. Java中作用域的分类
   1. 全局变量（属性）：也叫属性，作用域为整个类体【Cat类：cry eat 等方法使用属性】
   2. 局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中！
4. 全局变量（属性）可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值。

public class VarScope { 

	//编写一个main方法
	public static void main(String[] args) {
	}
}
class Cat {
	//全局变量：也就是属性，作用域为整个类体 Cat类：cry eat 等方法使用属性
	//属性在定义时，可以直接赋值
	int age = 10; //指定的值是 10

	//全局变量(属性)可以不赋值，直接使用，因为有默认值，
	double weight;  //默认值是0.0

	public void hi() {
		//局部变量必须赋值后，才能使用，因为没有默认值
		int num = 1;
		String address = "北京的猫";
		System.out.println("num=" + num);
		System.out.println("address=" + address);
		System.out.println("weight=" + weight);//属性
	}
	
	public void cry() {
		//1. 局部变量一般是指在成员方法中定义的变量
		//2. n 和  name 就是局部变量
		//3. n 和 name的作用域在 cry方法中
		int n = 10;
		String name = "jack";
		System.out.println("在cry中使用属性 age=" + age);
	}

	public void eat() {

		System.out.println("在eat中使用属性 age=" + age);
		
		//System.out.println("在eat中使用 cry的变量 name=" + name);//错误
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

7.7.2 注意事项和细节使用

1. 属性（全局变量）和局部变量可以重名，访问时遵循就近原则
2. 在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名；
3. 属性（全局变量）生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中；
4. 作用域范围不同
   1. 全局变量/属性：可以被本类使用，或其他类使用（通过对象调用）
   2. 局部变量：只能在本类中对应的方法中使用；
5. 修饰符不同：
   1. 全局变量/属性：可以加修饰符（public、protected…）
   2. 局部变量：不能加修饰符

public class VarScopeDetail { 

	//编写一个main方法
	public static void main(String[] args) {
		Person p1 = new Person();
		/*
		属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
		局部变量，生命周期较短，伴随着它的代码块的执行而创建，
		伴随着代码块的结束而销毁。即在一次方法调用过程中
		 */
		//p1.say();//当执行say方法时，say方法的局部变量比如name,会创建，当say执行完毕后
		//name局部变量就销毁,但是属性(全局变量)仍然可以使用
		//
		T t1 = new T();
		t1.test(); //第1种跨类访问对象属性的方式

		t1.test2(p1);//第2种跨类访问对象属性的方式

	}
}

class T {

	//全局变量/属性：可以被本类使用，或其他类使用（通过对象调用)
	public void test() {
		Person p1 = new Person();
		System.out.println(p1.name);//jack
	}

	public void test2(Person p) {
		System.out.println(p.name);//jack
	}
}

class Person {
	//细节: 属性可以加修饰符(public protected private 默认..)
	//      局部变量不能加修饰符
	public int age = 20;

	String name = "jack";

	public void say() {
		//细节 属性和局部变量可以重名，访问时遵循就近原则
		String name = "king";
		System.out.println("say() name=" + name);
	}

	public void hi() {
		String address = "北京";
		//String address = "上海";//错误,重复定义变量
		String name = "hsp";//可以
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

7.8 构造方法/构造器

7.8.1 看一个需求

我们来看一个需求：前面我们在创建人类的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如果现在我要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，该怎么做? 这时就可以使用构造器。

7.8.2 基本语法

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

爱摸鱼的TT~说明：
1) 构造器的修饰符可以默认， 也可以是 public protected private
2) 构造器没有返回值
3) 方法名 和类名字必须一样
4) 参数列表 和 成员方法一样的规则
5) 构造器的调用, 由系统完成

7.8.3 基本介绍

构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：

• 1. 方法名和类名相同
• 2. 没有返回值
• 3. 在创建对象时，系统会自动的调用该类的构造器完成对象的属性初始化。
     

7.8.4 快速入门

现在我们就用构造方法来完成刚才提出的问题:在创建人类的对象时，就直接指定这个对象的年龄和姓名

public class Constructor01 { 

	//编写一个main方法
	public static void main(String[] args) {
		//当我们new 一个对象时，直接通过构造器指定名字和年龄
		Person p1 = new Person("smith", 80);
		System.out.println("p1的信息如下");
		System.out.println("p1对象name=" + p1.name);//smith
		System.out.println("p1对象age=" + p1.age);//80
	}
}

//在创建人类的对象时，就直接指定这个对象的年龄和姓名
//
class Person {
	String name;
	int age;
	//构造器
	//爱摸鱼的TT~解读
	//1. 构造器没有返回值, 也不能写void
	//2. 构造器的名称和类Person一样
	//3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样
	public Person(String pName, int pAge) {
		System.out.println("构造器被调用~~ 完成对象的属性初始化");
		name = pName;
		age = pAge;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

7.8.5 注意事项和使用细节

1. 一个类可以定义多个不同的构造器，即构造器重载
   1. 比如：我们可以再给Person类定义一个构造器，用来创建对象的时候，只指定人名，不需要指定年龄。
2. 构造器名和类名要相同
3. 构造器没有返回值
4. 构造器是完成对象的初始化，并不是创建对象
5. 在创建对象时，系统自动的调用该类的构造方法
6. 如果程序员没有定义构造器，系统会自动给该类生成一个默认无参构造器（也叫默认构造器），比如Dog(){}，使用javap指令 反编译看看

public class ConstructorDetail { 

	//编写一个main方法
	public static void main(String[] args) {
        
		Dog dog1 = new Dog();//使用的是默认的无参构造器

	}
}
class Dog {
	//如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)
	//使用javap指令 反编译看看
	/*
		默认构造器
		Dog() {
			
		}
	 */
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

7. 一旦定义了自己的构造方法，默认的构造器就覆盖了，就不能再自动使用默认的无参构造方法，除非显式（就是要自己定义）的定义一个，即：Dog(){}写**（这点很重要）**

public class ConstructorDetail { 

	//编写一个main方法
	public static void main(String[] args) {

		Dog dog1 = new Dog();//使用的是默认的无参构造器

	}
}
class Dog {
	//如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)
	//使用javap指令 反编译看看
	/*
		默认构造器
		Dog() {
			
		}
	 */
	//一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，
	//除非显式的定义一下,即:  Dog(){}  写 (这点很重要)
	//
	public Dog(String dName) {
		//...
	}
	Dog() { //显式的定义一下 无参构造器

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

7.8.6 巩固练习

在前面定义的 Person 类中添加两个构造器：

• 第一个无参构造器：利用构造器设置所有人的 age 属性初始值都为 18
• 第二个带 pName 和 pAge 两个参数的构造器：使得每次创建 Person 对象的同时初始化对象的 age 属性值和 name 属性值。

分别使用不同的构造器，创建对象。

public class ConstructorExercise { 

	//编写一个main方法
	public static void main(String[] args) {
		Person p1 = new Person();//无参构造器

		//下面输出 name = null, age = 18
		System.out.println("p1的信息 name=" + p1.name + " age=" + p1.age);

		Person p2 = new Person("scott", 50);
		//下面输出 name = scott, age = 50
		System.out.println("p2的信息 name=" + p2.name + " age=" + p2.age);

	}
}

/**
 * 在前面定义的Person类中添加两个构造器:
 * 第一个无参构造器：利用构造器设置所有人的age属性初始值都为18
 * 第二个带pName和pAge两个参数的构造器：
 * 使得每次创建Person对象的同时初始化对象的age属性值和name属性值。
 * 分别使用不同的构造器，创建对象.
 */

class Person {
	String name;//默认值 null
	int age;//默认 0
	//第一个无参构造器：利用构造器设置所有人的age属性初始值都为18
	public Person() {
		age = 18;//
	}
	//第二个带pName和pAge两个参数的构造器
	public Person(String pName, int pAge) {
		name = pName;
		age = pAge;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

7.9 对象创建的流程分析

7.9.1看一个案例

class Person{ // 类Person
    int age = 90;
    String name;
    Person(String n, int a){ // 构造器
        name = n;// 给属性赋值
        age = a;// 给属性赋值
    }
}

Person p = new Person("小倩", 20);
1
2
3
4
5
6
7
8
9
10

7.9.2 流程分析（面试题）

分析步骤：

1. 加载Person类信息（Person.class），只会加载一次
2. 在堆中分配空间（地址）
3. 完成对象初始化【3.1 默认初始化 age=0 name=null 3.2 显式初始化age = 90，name = null 3.3 构造器的初始化 age = 20，name = 小倩】
4. 把对象在堆中的地址，返回给p（p是对象名，也可以理解成是对象的引用）

学习完构造器后,我们类的定义就应该更加完善了

7.10 this 关键字

7.10.1 先看一段代码,并分析问题

问题：构造方法的输入参数名不是非常的好，如果能够将dName改成name、dAge改成age就好了，但是我们会发现按照变量的作用域原则name的值就是null，age的值就是0。

那怎么解决这个问题呢？就需要引出this关键字来解决

7.10.2 什么是this

Java虚拟机会给每个对象分配this，代表当前对象。坦白的讲，要明白this不是件容易的事，慢慢到来。

7.10.2 使用this解决前面变量命名的问题

public class This01 { 

	//编写一个main方法
	public static void main(String[] args) {

		Dog dog1 = new Dog("大壮", 3);
		//dog1调用了 info()方法
		dog1.info(); 
	}
}

class Dog{ //类

	String name;
	int age;
	// public Dog(String dName, int  dAge){//构造器
	// 	name = dName;
	// 	age = dAge;
	// }
	//如果我们构造器的形参，能够直接写成属性名，就更好了
	//但是出现了一个问题，根据变量的作用域原则
	//构造器的name 是局部变量，而不是属性
	//构造器的age  是局部变量，而不是属性
	//==> 引出this关键字来解决
	public Dog(String name, int  age){//构造器
		//this.name 就是当前对象的属性name
		this.name = name;
		//this.age 就是当前对象的属性age
		this.age = age;
	}
	public void info(){
		System.out.println(this.name + "\t" + this.age );
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

7.10.3 深入理解 this

为了进一步理解 this,我们再看一个案例

public class This01 { 

	//编写一个main方法
	public static void main(String[] args) {

		Dog dog1 = new Dog("大壮", 3);
		//dog1调用了 info()方法
		dog1.info(); 

		System.out.println("============");
		Dog dog2 = new Dog("大黄", 2);
		dog2.info();
	}
}

class Dog{ //类

	String name;
	int age;
	// public Dog(String dName, int  dAge){//构造器
	// 	name = dName;
	// 	age = dAge;
	// }
	//如果我们构造器的形参，能够直接写成属性名，就更好了
	//但是出现了一个问题，根据变量的作用域原则
	//构造器的name 是局部变量，而不是属性
	//构造器的age  是局部变量，而不是属性
	//==> 引出this关键字来解决
	public Dog(String name, int  age){//构造器
		//this.name 就是当前对象的属性name
		this.name = name;
		//this.age 就是当前对象的属性age
		this.age = age;
	}

	public void info(){//成员方法,输出属性x信息
		System.out.println(name + "\t" + age + "\t");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

我们来分析下main方法的两个对象，针对于this这个关键字着重研究下。

从上面分析可以看出，this的本质，它是隐藏的属性，指向对象的本身地址。那有同学会问，给我验证下这个结论咯，把this/对象的地址输出出来呗。

实不相瞒，在Java中，它是在JVM中运行的，获取得是JVM的地址，无法获取本身地址，那咋办呢？我们可以用**hashCode( ) 方法 ，**可以简单的当作对象地址，但是呢他不是真正的地址。

接下来，使用hashCode()看看对象（地址）的情况，将代码再次改善下。

public class This01 { 

	//编写一个main方法
	public static void main(String[] args) {

		Dog dog1 = new Dog("大壮", 3);
		System.out.println("dog1的hashcode=" + dog1.hashCode());
		//dog1调用了 info()方法
		dog1.info(); 

		System.out.println("============");
		Dog dog2 = new Dog("大黄", 2);
		System.out.println("dog2的hashcode=" + dog2.hashCode());
		dog2.info();
	}
}

class Dog{ //类

	String name;
	int age;
	// public Dog(String dName, int  dAge){//构造器
	// 	name = dName;
	// 	age = dAge;
	// }
	//如果我们构造器的形参，能够直接写成属性名，就更好了
	//但是出现了一个问题，根据变量的作用域原则
	//构造器的name 是局部变量，而不是属性
	//构造器的age  是局部变量，而不是属性
	//==> 引出this关键字来解决
	public Dog(String name, int  age){//构造器
		//this.name 就是当前对象的属性name
		this.name = name;
		//this.age 就是当前对象的属性age
		this.age = age;
		System.out.println("this.hashCode=" + this.hashCode());
	}

	public void info(){//成员方法,输出属性x信息
		System.out.println("this.hashCode=" + this.hashCode());
		System.out.println(name + "\t" + age + "\t");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

运行结果：

讲解这么多，总结 this关键 一句话：简单来说，哪个对象调用，this就代表哪个对象
（这一小节记住两大点内容：a. 上面那句经典总结 b. this关键字的分析图【this是隐藏的属性，指向对象的本身地址】）

7.10.3 this 的注意事项和使用细节

1. this 关键字可以用来访问本类的属性、方法、构造器
   2) this 用于区分当前类的属性和局部变量

public class ThisDetail { 

	//编写一个main方法
	public static void main(String[] args) {

		// T t1 = new T();
		// t1.f2();
		T t2 = new T();
		t2.f3();

	}
}

class T {

	String name = "jack";
	int num = 100;

	//this关键字可以用来访问本类的属性
	public void f3() {
		String name = "smith";
		//以下两种方式是有区别的：
		//1. 传统方式
		//a. 如果该方法中含有局部变量，那么下面语句的name和num就是访问局部变量，而不是属性
		//b. 如果没有局部变量，就和第2小点的作用一样，都是访问当前对象的属性
		System.out.println("name=" + name + " num=" + num);//smith  100
		//2. 也可以使用this访问属性（有且仅能访问属性）
		System.out.println("name=" + this.name + " num=" + this.num);//jack 100
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

3. 访问成员方法的语法：this.方法名(参数列表);

public class ThisDetail { 

	//编写一个main方法
	public static void main(String[] args) {

		T t1 = new T();
		t1.f2();
	}
}

class T {

	//细节: 访问成员方法的语法：this.方法名(参数列表);
	public void f1() {

		System.out.println("f1() 方法..");
	}

	public void f2() {
		System.out.println("f2() 方法..");
		//调用本类的 f1
		//第一种方式
		f1();
		//第二种方式
		this.f1();
		//上面两种方式是有区别的：
		//具体的区别会在继承这块讲解（学东西是循序渐进的过程）
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

4. 访问构造器语法：this(参数列表); 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句)

public class ThisDetail { 

	//编写一个main方法
	public static void main(String[] args) {

		// T t1 = new T();
		// t1.f2();
		T t2 = new T();

	}
}

class T {

	/*
	细节: 访问构造器语法：this(参数列表); 
	注意只能在构造器中使用(即只能在构造器中访问另外一个构造器)

	注意： 访问构造器语法：this(参数列表); 必须放置第一条语句 
		   为什么呢？还是在继承这版块讲解！！！
	 */
	
	public T() {
		//这里去访问 T(String name, int age) 构造器
		this("jack", 100);
		System.out.println("T() 构造器");
		
	}

	public T(String name, int age) {

		System.out.println("T(String name, int age) 构造器");
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

5. this 不能在类定义的外部使用，只能在类定义的方法中使用。

以上综代码：

public class ThisDetail { 

	//编写一个main方法
	public static void main(String[] args) {

		// T t1 = new T();
		// t1.f2();
		T t2 = new T();
		t2.f3();

	}
}

class T {

	String name = "jack";
	int num = 100;

	/*
	细节: 访问构造器语法：this(参数列表); 
	注意只能在构造器中使用(即只能在构造器中访问另外一个构造器)

	注意： 访问构造器语法：this(参数列表); 必须放置第一条语句 
	 */
	
	public T() {
		//这里去访问 T(String name, int age) 构造器
		this("jack", 100);
		System.out.println("T() 构造器");
		
	}

	public T(String name, int age) {

		System.out.println("T(String name, int age) 构造器");
	}

	//this关键字可以用来访问本类的属性
	public void f3() {
		String name = "smith";
		//传统方式
		System.out.println("name=" + name + " num=" + num);//smith  100
		//也可以使用this访问属性
		System.out.println("name=" + this.name + " num=" + this.num);//jack 100
	}
	//细节: 访问成员方法的语法：this.方法名(参数列表);
	public void f1() {

		System.out.println("f1() 方法..");
	}

	public void f2() {
		System.out.println("f2() 方法..");
		//调用本类的 f1
		//第一种方式
		f1();
		//第二种方式
		this.f1();
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

7.10.4 巩固练习

定义 Person 类，里面有 name、age 属性，并提供 compareTo 比较方法，用于判断是否和另一个人相等，提供测试类 TestPerson 用于测试, 名字和年龄完全一样，就返回 true, 否则返回 false。

public class TestPerson { 

	//编写一个main方法
	public static void main(String[] args) {

		Person p1 = new Person("黄仙女", 20);
		Person p2 = new Person("爱摸鱼的TT~", 20);

		System.out.println("p1和p2比较的结果=" + p1.compareTo(p2));
	}
}

/*
定义Person类，里面有name、age属性，并提供compareTo比较方法，
用于判断是否和另一个人相等，提供测试类TestPerson用于测试, 
名字和年龄完全一样，就返回true, 否则返回false

 */
class Person {
	String name;
	int age;
	//构造器
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	//compareTo比较方法
	public boolean compareTo(Person p) {
		//名字和年龄完全一样
		// if(this.name.equals(p.name) && this.age == p.age) {
		// 	return true;
		// } else {
		// 	return false;
		// }
		return this.name.equals(p.name) && this.age == p.age;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

7.11 本章巩固习题

1. 编写类A01，定义方法max，实现求某个double数组的最大值，并返回

2. 编写类A02，定义方法find实现查找某字符串是否在字符串数组中，并返回索引，如果找不到，返回-1。

3. 编写类Book，定义方法updatePrice，实现更改某本书的价格，具体：如果价格>150，则更改为150，如果价格>100，则更改为100，否则不变。

4. 编写类A03，实现数组的复制功能copyArr，输入旧数组，返回一个新数组，元素和旧数组一样。

5. 定义一个圆类Circle，定义属性：半径，提供显示圆周长功能的方法，提供显示圆面积的方法。

6. 编程创建一个Cale计算类，在其中定义2个变量表示两个操作数，定义四个方法实现求和、差、乘、商（要求除数为0的话，要提示）并创建两个对象，分别测试。

7. 设计一个Dog类，有名字、颜色和年龄属性，定义输出方法show（）显示其信息，并创建对象，进行测试（提示this.属性）。

8. 定义Music类，里面有音乐名name、音乐时长times属性，并有播放play功能和调回本身属性的功能方法getInfo。

9. 在测试方法中，调用method方法，代码如下，编译正确，试写出method方法的定义形式，调用语句为：System.out.println(method(method(10,0,20,0),100));

public double method(double d1, double d2){…}

10. 创建一个Employee类，属性有（名字、性别、年龄、职位、薪水），提供3个构造方法，可以初始化（1）（名字、性别、年龄、职位、薪水），（2）（名字、性别、年龄），（3）（职位、薪水），要求充分使用构造器。

11. 将对象座位参数传递给方法。

题目要求：
（1）定义一个Circle类，包含一个double型的radius属性代表圆的半径，findArea（）方法返回圆的面积。
（2）定义一个PassObject，在类中定义一个方法printAreas（），该方法的定义如下：public void printAreas(Circle c, int times)
（3）在printAreas方法打印输出1到times之间的每个整数半径值，以及对应的面积。例如：times为5，则输出半径1,2,3,4,5，以及对应的圆面积。
（4）在main方法中调用printAreas（）方法，调用完毕后输出当前半径值。程序运行结果如图所示，爱摸鱼的TT~提示，如果还是不明确，自己画一个内存图，一定可以搞定。

12. 扩展题

有个人Tom设计他的成员变量，成员方法，一电脑猜拳，电脑（机器）每次都会随机生成0,1,2（0表示石头、1表示剪刀、2表示布）并要可以显示Tom的输赢次数（清单）

本手册会持续更新，感谢大家的阅读~

对学习Java感兴趣的小伙伴、有任何问题都欢迎大家加我的WeChat：Zxutt_996 一起探讨
一起遇到志同道合的我们吧，让我们一起在学习Java的路上打怪升级！加油，未来是我们的~