连接视频

类与对象

类与对象引出

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

使用现有技术解决

1）单独的定义变量解决
2）使用数组解决

现有技术解决缺点分析

不利于数据的管理
效率低

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

public class Object01{
	//编写一个main方法
	public static void main(String[] args){
		/*
		张老太养了两只猫：一只名字叫小白，今年3岁，白色。
		还有一只叫小花，今年100岁，花色。
		请编写一个程序，当用户输入小猫的名字时，
		就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，
		则显示 张老太没有这只猫猫。

		*/
		//单独的定义变量解决  ==> 不利于数据的管理（把一只猫的信息拆解）
		//第1只猫信息
		String catName1 = "小白";
		int carAge1 = 3;
		String carColor1 = "白色";

		//第2只猫信息
		String catName2 = "小花";
		int carAge2 = 100;
		String carColor2 = "花色";

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

类与对象概述

一个程序就是一个世界，有很多事物（对象【属性，行为】）

类与对象的关系示意图：

1、类就是数据类型，比如：cat

2、对象就是一个具体的实现

注意： 从猫类到对象，目前有几种说法：1、创建一个对象；2、实例化一个对象；3、把类实例化…
注意： 上面的猫也可是鱼、狗、人… java最大特点就是面向对象。

快速入门

面向对象的方式解决养猫的问题

public class Object01{
	//编写一个main方法
	public static void main(String[] args){
		/*
		张老太养了两只猫：一只名字叫小白，今年3岁，白色。
		还有一只叫小花，今年100岁，花色。
		请编写一个程序，当用户输入小猫的名字时，
		就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，
		则显示 张老太没有这只猫猫。

		*/
		
		//使用OOP面向对象解决
		//实例化一只猫[创建一只猫]
		//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;
		//创建第2只猫 并赋给 cat2
		// cat2 也是一个对象 （猫对象）
		Cat cat2 = new Cat();
		cat2.name = "小花";
		cat2.age = 100;
		cat2.color = "花色";
		cat2.weight = 20;

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

	}
}

//使用面向对象的方式来解决养猫问题
//
//定义一个猫类 Cat -> 自定义的数据类型
class Cat{
	//属性
	String name;//名字
	int age;//年龄
	String color;//颜色
	double weight;//体重

	//行为

}

类与对象的区别和联系

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

1）类是抽象的，概念的，代表一类事物，比如：人类，猫类…，它是数据类型。

2）对象是具体的，实际的，代表一个具体事物，即 是实例

3）类是对象的模板，对象是类的一个个体，对应一个实例

对象在内存中存在形式

Cat cat = new Cat();
cat.name = "小白";
cat.age = 12;
cat.color = "白色";

示意图：

属性/成员变量/字段

基本介绍

1、从概念或者叫法上看：成员变量 = 属性 = field（字段）（即 成员变量是用来表示属性的，统一叫 属性）

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

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


	}
}

class car{
	 String name;//属性 成员变量 字段 feild
	 double price;
	 String color;

	 String[] master;//属性可以是基本类型，也可以是引用类型（对象，数组）
}

注意事项和细节说明

1）属性的定义语法同变量，示例：访问修饰符 属性类型 属性名；【访问修饰符 ：控制属性的访问范围，有四种访问修饰符 public，protected，默认，private】

2）属性的定义类型可以任意类型，包含基本类型或引用类型

3）属性如果不赋值，有默认值，规则和数组一致。具体来说： int 0，short 0，byte 0，long 0，float 0.0，double 0.0，char u0000，boolean false，String null
案例演示：[Person类]

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当前p1的信息");
		System.out.println("age=" + p1.age + " name=" + p1.name
			+ " sal=" + p1.sal + " isPass=" + p1.isPass);

	}
}

class Person{
	//4个属性
	int age;
	String name;
	double sal;
	boolean isPass;
}

如何创建对象

1、先声明再创建

Cat cat;//声明对象 cat
cat = new Cat();//创建

2、直接创建

Cat cat = new Cat();

如何访问属性

基本语法

对象名.属性名

案例演示赋值和输出

cat.name;
cat.age;
cat.color;

类和对象内存分配机制（重点）

看一个思考题
我们定义一个人类（Person）(包括 名字 年龄)

我们看看下面一段代码：
Person p1 = new Person();
p1.age = 10;
p1.name = "小明";
Person p2 = p1;//把 p1 赋给了 p2，让p2指向p1
System.out.println(p2.age);//10

请问：p2.age 是多少？

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

		Person p1 = new Person();
		p1.age = 10;
		p1.name = "小明";
		Person p2 = p1;//把 p1 赋给了 p2，让p2指向p1
		System.out.println(p2.age);//10
	}
}

class Person{
	int age;
	String name;
}

内存示意图

Java内存结构分析
1、栈： 一般存放基本数据类型（局部变量）

2、堆： 存放对象（Cat cat ，数组等）

3、方法区： 常量池（常量，比如字符串），类加载信息

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

Person p = new Person;
p.name = "jack";
p.age = 10;

1、先加载Person类信息（属性和方法信息，类加载只会加载一次）【方法区】

2、在堆中分配空间，进行默认初始化

3、把地址赋给 p，p 就指向对象

4、进行指定初始化，比如：

p.name = “jack”;
p.age = 10;

对象机制练习

看一个练习题，

//我们看看下面一段代码，会输出什么信息：
Person a  = new Person();
a.age = 10;
a.name = "小明";
Person b;
b = a;
System.out.println(b.name);//小明
b.age = 200;
b = null;
System.out.println(a.age);//200
System.out.println(b.age);//b.age 会出现异常 ==> b = null;

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

		Person a  = new Person();
		a.age = 10;
		a.name = "小明";
		Person b;
		b = a;
		System.out.println(b.name);//小明
		b.age = 200;
		b = null;
		System.out.println(a.age);//200
		System.out.println(b.age);//b.age 会出现异常 ==> b = null;
	}
}

class Person{
	int age;
	String name;
}

分析图：

成员方法

基本介绍

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

成员快速入门

1）添加 speak 成员方法，输出 “我是一个好人”
2）添加 cal01 成员方法，可以计算从 1+2+3…+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 成员方法，输出 “我是一个好人”
	//1. public 表示方法是公开的
	//2. void 表示方法没有返回值
	//3. speak() speak方法名 () 形参列表
	//4. {} 方法体 可以写我们要执行的代码
	//5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话
	public void speak(){
		System.out.println("我是一个好人");
	}

	//添加 cal01 成员方法，可以计算从 1+2+3…+1000的结果
	public void cal01(){
		//循环完成
		int res = 0;
		for(int i = 0; i <= 1000; i++){
			res += i;
		}
		System.out.println("cal01 计算结果=" + res);
	}

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

	//添加 getSum 成员方法，可以计算两个数的和
	//1. public 表示方法是公开的
	//2. int 表示方法执行后，返回一个 int 值
	//3. getSum 方法名
	//4. (int num1,int num2) 形参列表，2个形参，可以接收用户传入的2个数
	//5. return res; 表示把 res 的值 ，返回
	public int getSum(int num1,int num2){
		int res = num1 + num2;
		return res;
	}
}

方法的调用机制原理（重要）

为什么需要成员方法

看一个需求
请遍历一个数组，输出数组的各个元素值
解决思路1，传统的方法，就是使用单个for循环，将数组输出，【代码冗余】
解决思路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();
		//使用方法完成输出
		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] + " ");
		// 	}
		// 	System.out.println();
		// }

		//
		//要求再次遍历map数组
			
		//使用方法完成输出
		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] + " ");
			}
			System.out.println();
		}
	}
}

成员方法的好处

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

成员方法的定义

访问修饰符[public] 返回数据类型 方法名 (形参列表..){ //方法体
	语句;
	return 返回值;
}

1、形参列表：表示成员方法输入，比如：cal(int n)
2、返回数据类型（返回类型）：表示成员方法输出，void 表示没有返回值
3、方法主体：表示为了实现某一功能代码块
4、return 语句不是必须的。

注意事项和使用细节

访问修饰符（作用是控制 方法使用的范围）
如果不写默认访问，[有四种:public，protected，默认，private]

返回数据类型

1、一个方法最多有一个返回值 [思考，如果返回多个结果 返回数组]

2、返回类型可以为任意类型，包含基本类型或引用类型（数组，对象）

3、如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值；而且要求返回值的类型必须和return 的值类型一致或兼容

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

方法名

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

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

		AA a = new AA();
		int[] res = a.getSumSub(1,4);
		System.out.println("和=" + res[0]);//5
		System.out.println("差=" + res[1]);//-3

	}	
}
class AA{

	//得到两数之和 之差
	//1. 一个方法最多有一个返回值 [思考，如果返回多个结果 返回数组]
	public int[] getSumSub(int n1,int n2){

		int[] resArr = new int[2];//创建一个数组
		resArr[0] = n1 + n2;
		resArr[1] = n1 - n2;
		return resArr;
	}

	//2. 返回类型可以为任意类型，包含基本类型或引用类型（数组，对象）
	// 具体看 getSumSub

	//3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值；
	//	而且要求返回值的类型必须和return 的值类型一致或兼容
	//
	public double f1(){
		double d1 = 1.1 * 3;
		int n = 100;
		// return 1.1;
		return n;//ok  int -> double 兼容
	}

	//4.如果方法是 void，则方法体中可以没有 return语句，或者 只写 return;
	//在实际工作中，我们方法都是为了完成某个功能，所以方法名要有一点含义
	// 最好是 见名知意
	public void f2(){
		System.out.println("hello world");
		int n = 10;
		//return ;//ok
	}
}

形参列表

1、一个方法可以有 0 个参数，也可以有多个参数，中间用逗号隔开，比如：

getSum(int n1, int n2)

2、参数类型可以为任意类型，包含基本数据类型或引用类型，比如：

printArr(int[][] map)

3、调用带参数的方法时，一定对应着参数列表存入相同类型或兼容类型 的参数！【getSum】

4、方法定义时的参数称为形式参数，简称形参；方法调用时的传入参数称为实际参数，简称实参，实参和形参的类型要一致或兼容、个数、顺序必须一致！

方法体

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

class AA{
	//方法不能嵌套定义
	public void f1(){
	
		public void f2(){}//错误 不能嵌套定义
	}
}

方法调用细节说明

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

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

2、跨类中的方法A类调用B类方法：需要提过对象名调用。比如 对象名.方法名(参数);

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

3、特别说明一下：跨类的方法调用和方法的访问修饰符相关

public class MethodDetail02{
	//编写一个main方法
	public static void main(String[] args){
		A a = new A();
		a.sayOk();

		a.m1();
	}
}
class A{

	//同一个类中的方法调用：直接调用即可。比如 print(参数);
	public void print(int n){
		System.out.println("print()方法调用n=" + n);
	}

	public void sayOk(){//sayOk 调用print(直接调用)
		print(10);
		System.out.println("继续执行sayOk()");
	}

	//跨类中的方法A类调用B类方法：需要提过对象名调用。比如 对象名.方法名(参数);
	public void m1(){
		System.out.println("m1()方法被调用");
		//先创建B类
		B b = new B();
		//调用 hi()方法
		b.hi();
		System.out.println("m1()方法继续执行");
	}
}

class B{

	public void hi(){
		System.out.println("B类中的 hi()方法被执行");
	}
}

练习题

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

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

public class MethodExercise01{
	//编写一个main方法
	public static void main(String[] args){
		AA aa = new AA();
	
		if(aa.isOdd(1)){
			System.out.println("是奇数");
		}else{
			System.out.println("是偶数");
		}

		//使用print
		aa.print(4,4,'#');
	}
}

//编写类AA ，有一个方法：判断一个数是奇数odd还是偶数，返回boolean
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;
	}

	//根据行、列、字符打印 对应行数和列数的字符，
	//比如：行：4，列：4，字符#，则打印响应的效果
	/*
		####
		####
		####
		####
	*/
	//思路
	//1. 方法的返回值 void
	//2. 方法的名称 print
	//3. 方法的形参 (int row, int column,char c)
	//4. 方法体 , 循环
	public void print(int row, int column,char c){
		for(int i = 0; i < row; i++){
			for(int j = 0; j < column; j++){//输出每一行
				System.out.print(c);
			}
			System.out.println();//换行
		}
	}
}

成员方法传参数机制（重要）

基本数据类型的传参机制

1）看一个案例，分析结果是什么？

public void swap(int a, int b){
	int tmp= a;
	a = b;
	b = tmp;
	System.out.println("a=" + a + "tb=" + b);
}

public class MethodParameter01{
	//编写一个main方法
	public static void main(String[] args){
		int a = 10;
		int b = 20;
		//创建AA对象
		AA aa = new AA();
		aa.swap(a,b);//调用swap方法

		System.out.println("main方法 a=" + a + " b=" + b);//a=10 b=20
	}
}

class AA{

	public void swap(int a, int b){
		System.out.println("n a和b交换前的值na=" + a + "tb=" + b);//a=10 b=20
		//完成了 a 和 b 的交换
		int tmp = a;
		a = b;
		b = tmp;
		System.out.println("n a和b交换后的值na=" + a + "tb=" + b);//a=20 b=10
	}
}

2）结论

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

引用数据类型的传参机制

1、看一个案例

B类中编写一个方法test100，可以接收一个数组，在方法中修改该数组，看看原来数组是否变化？

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

public class MethodParameter02{
	//编写一个main方法
	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] + " ");
		}

		//测试
		Person p = new Person();
		p.name = "jack";
		p.age = 20;

		b.test200(p);
		System.out.print("nmain 的p.age = " + p.age);//100

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

	public void test200(Person person){
		person.age = 100;//修改对象属性
	}

	//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] + " ");
		}
		System.out.println();
	}
}

2、结论

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

3、在看一个案例，下面的方法会对原来的对象有影响吗？不会

p = null; 和 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 = 20;

		b.test200(p);
		//测试题，如果 test200 执行是 person = null,下面的结果是 20
		System.out.print("nmain test200后 的p.age = " + p.age);//20
		b.test300(p);
		//测试题，如果 test300 执行是 person = new Person()...,下面的结果是 20
		System.out.print("nmain test300后 的p.age = " + p.age );//20

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

	public void test200(Person person){
		//person.age = 100;//修改对象属性
		//思考
		person = null;
	}

	public void test300(Person person){
		//思考
		person = new Person();//创建新的对象Person
		person.age = 300;
		person.name = "tom";
	}
}

克隆对象

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

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

		Person p = new Person();
		p.name = "milan";
		p.age = 100;
		//创建tools
		MyTools tools = new MyTools();
		Person p2 = tools.copyPerson(p);

		//到此 p 和 p2是Person对象，但是是两个独立的对象，属性相同
		System.out.println("p的属性 age=" + p.age + " name=" + p.name);
		System.out.println("p2的属性 age=" + p2.age + " name=" + p2.name);
		//可以通过 对象比较看看是否为同一个对象
		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.name
		p2.age = p.age;//把原来的对象的年龄赋值p2.age

		return p2;
	}
}	

方法递归调用

基本介绍

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

递归能解决什么问题？

1、各种数学问题，如：8皇后问题，汉诺塔，阶乘问题，迷宫问题，球和篮子的问题（google编程大赛）

2、各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等。

3、将用栈解决的问题–>递归代码比较简洁

递归举例

列举两个小案例，来帮助大家理解递归调用机制
1.打印问题
2.阶乘问题

//输出什么？
public void test(int n){
	if(n > 2){
		test(n - 1);
	}
	System.out.println("n=" + n);//n=2 n=3 n=4
}

public class Recursion01{
	//编写一个main方法
	public static void main(String[] args){
		T t1 = new T();
		t1.test(4);
		
	}
}

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

示意图：

//阶乘
public int factorail(int n){
	if(n == 1){
		return 1;
	}else{
		return factorail(n - 1) * n;
	}
}

public class Recursion01{
	//编写一个main方法
	public static void main(String[] args){
		T t1 = new T();
		int res = t1.factorail(5);
		System.out.println("res=" + res);
		
	}
}

class T {
	//阶乘
	public int factorail(int n){
		if(n == 1){
			return 1;
		}else{
			return factorail(n - 1) * n;
		}
	}
}

示意图：

递归重要规则

1、执行一个方法时，就创建一个新的受保护的独立空间（栈空间）

2、方法的局部变量是独立的，不会相互影响，比如n变量

3、如果方法中使用的是引用类型变量（比如数组，对象），就会共享该引用类型的数据。

4、递归必须向退出的条件逼近，否则就是无限递归，出现 StackOverflowError 栈溢出

5、当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

练习

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

public class RecursionExercise01{
	//编写一个main方法
	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;
		}
	}
}

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

public class RecursionExercise02{
	//编写一个main方法
	public static void main(String[] args){
		A a1 = new A();
		int day = 0;
		int peachNum = a1.peach(day);
		if(peachNum != -1){
			System.out.println("第" + day + "天有" + peachNum + "个桃子");
		}	
	}
}
class A{
	/*
	猴子吃桃子问题：有一堆桃子，猴子第一天吃了一半，并再多吃了一个！
	以后每天猴子吃其中的一半，然后再吃多一个。
	当到第10天时，想再吃时（即还没有吃），发现只有1个桃子 。问题：最初共多少个桃子？
	
	思路分析： 逆推
	1. day = 10 时 有 1个桃子
	2. day = 9 时 有 (day10 + 1) * 2 = 4个桃子
	3. day = 9 时 有 (day9 + 1) * 2 = 10个桃子
	4. 规律就是 前一天的桃子 = （后一天的桃子 + 1）*2
	5. 递归
	*/
	public int peach(int day){
		if(day == 10){//第10天，只有1个桃子
			return 1;
		}else if(day >= 1 && day <= 9){
			return (peach(day + 1) + 1) * 2;//规则
		}else{
			System.out.println("day在1-10天");
			return -1;
		}
	}
}

递归调用应用案例 - 迷宫问题

1、小球得到的路径，和程序员设置的找路策略有关即：找路的上下左右的顺序相关

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 {

	//使用递归回溯的思想来解决老鼠出迷宫
	//说明：
	//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-1,j)) {//尝试走 上
					return true;
				}else if(findWay(map,i,j-1)) {//尝试走 左
					return true;
				}else{
					map[i][j] = 3;
					return false;
				}
			}else{//map[i][j] = 1,2,3
				return false;
			}
		}
	}
}

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();
		}

		//使用findWay给老鼠找路
		T t1 = new T();
		t1.findWay2(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 {

	//使用递归回溯的思想来解决老鼠出迷宫
	//说明：
	//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){
		...
	}

	//修改找路策略 看看路径是否有变化
	// 下->右->上->左 ==> 上->右->下->左
	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{//map[i][j] = 1,2,3
				return false;
			}
		}
	}
}

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 {

	//使用递归回溯的思想来解决老鼠出迷宫
	//说明：
	//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-1,j)) {//尝试走 上
					return true;
				}else if(findWay(map,i,j-1)) {//尝试走 左
					return true;
				}else{
					map[i][j] = 3;
					return false;
				}
			}else{//map[i][j] = 1,2,3
				return false;
			}
		}
	}

}

4、扩展思考：如何求出最短路径？
(1)穷举 （2）图 ->求出最短路径

递归调用应用案例 - 汉诺塔问题

汉诺塔传说
汉诺塔：汉诺塔（有称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三个金刚石柱子，在一根柱子上从下往上按照大小顺序摞者64片圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大盘，在三根柱子之间一次只能移动一个圆盘。

假如每秒钟移动一次，共需多少时间呢？移完这些金属需要5845.54亿年以上，太阳系的预期寿命据说也就是数百亿年。真的过了5845.54亿年，地球上的一切生命，连同梵塔、庙宇等，都早已经灰飞烟灭

汉诺塔代码实现

public class HanoiTower{
	//编写一个main方法
	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);
		}
	}
}

递归调用应用案例 – 八皇后问题

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

八皇后思路分析：
1. 第一个皇后先放第一行第一列
2. 第二个皇后放在第二列第一列、然后判断是否OK，如果不OK，
	继续放第二列、第三列，依次把所有列都放完，找到一个合适
3. 继续第三个皇后，还是第一列、第二列...直到第8个皇后也能放在一个不冲突的位置，
	算是找到一个正确解
4. 当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，
	即将第一个皇后，放到第一列的所有正确解，全部得到
6. 然后回头继续第一个皇后放到第二列，后面继续循环执行 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 列 

public class Queue8  {

    int max = 8;    //皇后个数
    static int count = 0;  //判断有几种解法
    static int num = 0;  //判断检测冲突次数
    int[] arr = new int[max];

    //编写一个main方法
    public static void main(String[] args){
        Queue8 queue8 = new Queue8();
        queue8.check(0);
        System.out.println(count);
        System.out.println(num);
    }

    //递归
    private void check(int n) {//n 为0-7，代表第n+1个皇后
        if (n == max) {
            print();  //n=8 退出
            return;
        }
        //依次放，并判断OK?
        for (int i = 0; i < max; i++) {
            arr[n] = i;
            if (adjust(n)) {
                check(n + 1);  //如果不冲突，接着放n+1

            } else {//关键
                //adjust(4)在i=0时不冲突，进入adjust（5），如果冲突了，即adjust（5）=i(i=0)冲突了，将不执行adjust（6），而是进行for循环，adjust（5）=i（i=1），继续判断冲突...
                //如果adjust（5）=i遍历全部仍然冲突，将回溯到adjust(4)，进行遍历，即adjust(4)在i=1时
                //包含了多层嵌套
            }
        }
    }

    //检测是否冲突
    private boolean adjust(int n) {
        num++;
        for (int i = 0; i < n; i++) {
            if (arr[i] == arr[n] || Math.abs(n - i) == Math.abs(arr[n] - arr[i])) //同一列或者||斜线  类似斜率 arr[i]代表的是第i+1个的所在列数+1
                return false;
        }
        return true;
    }

     //打印输出 ，每输出一次，即为一种解法，参考check（）的该方法的使用
    private void print() {
        for (int i = 0; i < arr.length; i++) {

            System.out.print(arr[i] + " ");
        }
        count++;
        System.out.println();
    }
}

方法重载（overload）

基本介绍

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

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

public class OverLoad01{
	//编写一个main方法
	public static void main(String[] args){
		System.out.println(100);
		System.out.println("hello,world");
		System.out.println(1,1);
		System.out.println(true);
	}
}

重载的好处

1）减轻了起名的麻烦
2）减轻了记名的麻烦

快速入门案例

案例：类：MyCalculator 方法 calculate
calculate(int n1, int n2)//两个整数的和
calculate(int n1, double n2)//一个整数 一个double 的和
calculate(double n1, int n2)//一个double 一个整数 的和
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));

	}
}

class MyCalculator {

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

	//一个整数 一个double 的和
	public double calculate(int n1, double n2){
		return n1 + n2;
	}

	//一个double 一个整数 的和
	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 + n3;
	}
}

注意事项和使用细节

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

重载练习

1、判断题：
与 void show(int a,char b, double c){} 构成重载的有：[ b c d e ]

a) void show(int x, char y, double z){} //不是
b) int show(int a, double c, char b){} //是
c) void show(int a, double c, char b){}//是
d) boolean show(int c,char b){}//是
e) void show(double c){}//是
f) double show(int x, char y, double z){} //不是
g) void shows(){}//不是

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

public class OverLoadExercise{
	//编写一个main方法
	public static void main(String[] args){
		Methods m1 = new Methods();
		m1.m(2);
		m1.m(2,3);
		m1.m("中");
	}
}
/*
编写程序，类Methods中定义三个重载方法并调用。方法名为m，
三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，
相乘并输出结果，输出字符串信息。在主类的main() 方法中分别用参数区别调用三个方法
*/
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);
	}
}

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

public class OverLoadExercise{
	//编写一个main方法
	public static void main(String[] args){
		Methods m1 = new Methods();
		//测试
		System.out.println(m1.max(10, 24));//24
		System.out.println(m1.max(10.1, 24.2));//24.2
		System.out.println(m1.max(10.1, 24.2, 199));//199.0
	}
}
/*
在Methods类，定义三个重载方法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;
	}
}

可变参数

基本介绍

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

基本语法

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

快速入门案例

看一个案例 类 ZzpMethod，方法 sun 【可以计算 2个数的和，3个数的和 4，5，…】

public class VarParameter01{
	//编写一个main方法
	public static void main(String[] args){
		ZzpMethod z = new ZzpMethod();
		System.out.println(z.sum(1,2,3));
		System.out.println(z.sum(5,6,7));
	}
}
class ZzpMethod{
	//可以计算 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;
	// }
	//.....
	//上面的三个方法名称相同，功能相同，参数个数不同-> 使用可变参数优化

	//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）可变参数的实参可以为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);//3个实参
	}
}
class T {
	public void f1(int... nums){
		System.out.println("f1方法参数个数=" + nums.length);
	}
	//细节：可变参数可以和普通类型的参数一起放在形参列表，
	//	但必须保证可变参数在最后
	public void f2(String str,double... nums){

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

练习

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

类名 ZzpMethod 方法名 showScore

public class VarParameterExercise{
	//编写一个main方法
	public static void main(String[] args){
		ZzpMethod z = new ZzpMethod();
		System.out.println(z.showScore("milan",90.1,80.0));
		System.out.println(z.showScore("terry",90.1,80.0,10,30.5,70));
		
	}
}
class ZzpMethod {
	/*
	有三个方法，分别实现返回姓名和两门课成绩（总分），
	返回姓名和三门课成绩（总分），返回姓名和五门课成绩（总分）。
	封装成一个可变参数的方法
	*/
	//分析：
	//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. 在java编程中，主要的变量就是属性（成员变量）和局部变量

2. 我们说的局部变量一般是指在成员方法中定义的变量。【举例 Cat类：cry】

3. java中作用域的分类
   全局变量：也就是属性，作用域为整个类体 Cat类：cry eat 等方法使用属性
   局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中！

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 h1(){
		//局部变量必须赋值后，才能使用，因为没有默认值。
		int num = 1;
		System.out.println("num=" + num);
	}

	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、修饰符不同：
全局变量/属性可以加修饰符
局部变量不可以加修饰符

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..）
	//		局部变量不可以加修饰符
	private int age = 20;

	String name = "jack";

	public void say(){
		//		局部变量不可以加修饰符
		//public int age = 10;//错误

		//属性和局部变量可以重名，访问是遵守就近原则。
		String name = "king";
		System.out.println("say() name=" + name);//king
	}

	public void hi(){
		//在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名。
		String address = "深圳";
		// String address = "上海";//错误，重复定义变量
		String name = "zzp";//可以
	}

}

构造方法/构造器

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

基本语法

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

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

## 基本介绍

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

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

快速入门

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

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;

	//构造器
	//1. 构造器没有返回值,也不能写 void
	//2. 构造器的名称和类名Person一样
	//3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样

	public Person(String pName, int pAge){
		System.out.println("构造器被调用~~ 完成对象的属性初始化");
		name = pName;
		age = pAge;
	}
}

注意事项和使用细节

1. 一个类可以定义多个不同的构造器，即构造器重载
   比如：我们可以定义再给Person类定义一个构造器，用来创建对象的时候，只指定人名，不需要指定年龄
2. 构造器名和类名要相同
3. 构造器没有返回值
4. 构造器是完成对象的初始化，并不是创建对象
5. 在创建对象时，系统自动的调用该类的构造方法

public class ConstructorDetail{
	//编写一个main方法
	public static void main(String[] args){
		Person p1 = new Person("king",80);//第1个构造器
		Person p2 = new Person("tom");//第2个构造器
	}
}

class Person {
	String name;
	int age;//默认0

	//第1个构造器
	public Person(String pName, int pAge){
		name = pName;
		age = pAge;
	}
	//第2个构造器 只指定人名，不需要指定年龄
	public Person(String pName){
		name = pName;
	}
}

6. 如果程序员没有定义构造方法，系统会自动给生成一个默认无参构造方法（也叫默认构造方法），比如：Dog(){} ，使用javap指令 反编译看看

public class ConstructorDetail{
	//编写一个main方法
	public static void main(String[] args){
		Dog dog1 = new Dog();//使用的是默认的无参构造器
	}
}
class Dog {
	//如果程序员没有定义构造方法，
	//系统会自动给生成一个默认无参构造方法（也叫默认构造方法）
	/*
		默认构造器
		Dog(){
	
		}
	*/
}

7. 一旦定义了自己的构造器，默认的构造器就覆盖，就不能再使用默认的无参构造器，除非显示的定义一下，即： Dog () {} 声明

public class ConstructorDetail{
	//编写一个main方法
	public static void main(String[] args){
		Dog dog1 = new Dog();
	}
}
class Dog {
	//如果程序员没有定义构造方法，
	//系统会自动给生成一个默认无参构造方法（也叫默认构造方法）
	/*
		默认构造器
		Dog(){
	
		}
	*/
	// 一旦定义了自己的构造器，默认的构造器就覆盖，
	//就不能再使用默认的无参构造器，除非显示的定义一下，
	//即： Dog () {} 声明
	public Dog(String dName){
		//...
	}
	Dog(){//显示的定义一下 无参构造器
	}
}

练习

在前面定义的Person类中添加两个构造器：
第一个无参构造：利用构造器设置所有人的age属性初始值都为18

第二个带pName和pAge两个参数的构造器：使得每次创建Person对象的同时初始化对象的age属性值和name属性值。分别使用不同的构造器，创建对象

public class ConstructorExercise{
	//编写一个main方法
	public static void main(String[] args){
		Person p1 = new Person();//无参构造器
		System.out.println("p1的信息 name=" + p1.name);//null
		System.out.println("p1的信息 age=" + p1.age);//18

		Person p2 = new Person("zhangsan",30);//有参构造器
		System.out.println("p2的信息 name=" + p2.name);//zhangsan
		System.out.println("p2的信息 age=" + p2.age);//30
	} 	
}
class Person {
	String name;//默认值 null
	int age;//默认 0

	//第一个无参构造：利用构造器设置所有人的age属性初始值都为18
	public Person() {
		age = 18;//
	}

	//第二个带pName和pAge两个参数的构造器：
	//使得每次创建Person对象的同时初始化对象的age属性值和name属性值。
	//分别使用不同的构造器，创建对象
	public Person(String pName, int pAge) {
		name = pName;
		age = pAge;
	}
}

对象创建的流程发现

看一个案例：

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

流程分析

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 是对象名，也可以理解成是对象的引用)

this关键字

先看一段代码，并分析问题

class Dog {
	public String name;
	public int age;
	public Dog (String dName, int dAge){
		name = dName;
		age = dAge;
	}
	public void info(){
		System.out.println(name + "t" + age);
	}
}

问题：构造器方法输入参数名不是非常好，如果能够将dName 改成 name 就好了，但是我们会发现按照变量的作用域原则，name的值就是null，怎么解决 --> this

public class This01{
	//编写一个main方法
	public static void main(String[] args){
		Dog dog1 = new Dog("小黄",3);
		dog1.info();
	}
}
class Dog {//类

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

	public void info(){//成员方法，输出属性信息
		System.out.println(name + "t" + age);
	}
}

什么是this

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

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

public class This01{
	//编写一个main方法
	public static void main(String[] args){
		Dog dog1 = new Dog("小黄",3);
		dog1.info();
	}
}
class Dog {//类

	public String name;
	public int age;

	public Dog (String name, int age){//构造器
		//this.name 就是当前对象的属性name
		this.name = name;	
		//this.age 就是当前对象的属性age
		this.age = age;
	}

	public void info(){//成员方法，输出属性信息
		System.out.println(name + "t" + age);
	}
}

深入理解this

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

class Dog {
	public String name;
	public int age;
	public Dog (String dName, int dAge){
		name = dName;
		age = dAge;
	}
	public void info(){
		System.out.println(this.name + "t" + this.age
			+ "t" + "当前对象的hashCode是:" + this.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();
		Dog dog2 = new Dog("大黄",5);
		System.out.println("dog2的hashCode=" + dog2.hashCode());
		dog2.info();
	}
}
class Dog {//类

	public String name;
	public int age;

	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(){//成员方法，输出属性信息
		System.out.println(this.name + "t" + this.age
			+ "t" + "当前对象的hashCode是:" + this.hashCode());
	}
}

小结：简单来说，哪个对象调用，this就是代表哪个对象

this的注意事项和使用细节

1. this关键字可以用来访问本类属性、方法、构造器
2. this用于区分当前类的属性和局部变量
3. 访问成员方法的语法：this.方法名(参数列表)
4. 访问构造器语法：this(参数列表); 注意只能在构造器中使用（即只能在构造器中访问另外一个构造器，必须放在第一条语句）
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 = "tom";
	int age = 10;

	/*
	细节：
	访问构造器语法：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 + " age=" + age);//smith 10
		//也可以使用this访问属性
		System.out.println("name=" + this.name + " age=" + this.age);//tom 10
	}


	//细节：访问成员方法的语法：this.方法名(参数列表)
	public void f1(){
		System.out.println("f1() 方法被调用..");
	}
	public void f2(){
		System.out.println("f2() 方法被调用..");
		//调用本类的  f1 方法
		//第一种方法
		f1();//直接调用
		//第二种方法
		this.f1();//使用this
	}
}

this的案例

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

public class TestPerson{
	//编写一个main方法
	public static void main(String[] args){
		Person p1 = new Person("mary",20);
		Person p2 = new Person("smith",30);
		System.out.println("p1和p2比较的结果=" + p1.compareTo(p2));
		Person p3 = new Person("mary",20);
		System.out.println("p1和p3比较的结果=" + p1.compareTo(p3));
	}
}
/*
定义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、编写类A01，定义方法max，实现求某个double数组的最大值，并返回

public class Homework01{
	//编写一个main方法
	public static void main(String[] args){
		A01 a01 = new A01();
		double[] arr = null;
		Double res = a01.max(arr);
		if(res != null){
			System.out.println("arr的最大值=" + res);
		}else{
			System.out.println("arr的输入有误，数组不能为null，或者{}");
		}

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

思路分析：
1. 类名 A01
2. 方法名 max
3  形参 (double[])
4. 返回值 double

*/
class A01 {

	public Double max(double[] nums){//double[] 是引用类型 可能为null
		// 先判断nums是否为null 然后判断 nums至少有一个元素
		if( nums == null || nums.length <= 0){
			return null;
		}
		double max = nums[0];
		for(int i = 1; i < nums.length; i++){
			if(max < nums[i]){
				max = nums[i];
			}
		}
		return max;
	}
}

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

public class Homework02{
	//编写一个main方法
	public static void main(String[] args){
		A02 a02 = new A02();
		String[] strs = {"张","李","赵"};
		int index = a02.find("中",strs);
		System.out.println("查询索引结果=" + index);
	}
}
/*
编写类A02，定义方法find，
实现查询某个字符串是否在数组中，并返回索引，如果找不到，返回-1。
思路分析：
1. 类名 A02
2. 方法名 find
3  形参 (String,String[])
4. 返回值 int

*/
class A02 {

	public int find(String findStr, String[] strs){
		if( strs == null || strs.length <= 0){
			return -1;
		}
		//直接遍历
		for(int i = 0; i < strs.length; i++){
			if(findStr.equals(strs[i])){
				return i;
			}
		}
		return -1;
	}
}

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

public class Homework03{
	//编写一个main方法
	public static void main(String[] args){
		Book book = new Book("西游记",110);
		book.info();
		book.updatePrice();//更新价格
		book.info();
	}
}
/*
编写类Book，定义方法updatePrice，实现改某本书的价格，
具体：如果价格>150,则更改为150，如果价格>100，更改为100，否则不变

思路分析：
1. 类名 Book
2. 属性 price name
3  方法名 updatePrice
4. 形参 ()
5. 返回 void
6. 提供一个构造器

*/
class Book {
	public String name;
	public double price;

	public Book(String name,double price){
		this.name = name;
		this.price = price;
	}

	public void updatePrice(){
		//如果方法中，没有price 局部变量，this.price 等价 price
		if(price > 150){
			price = 150;
		}else if(price > 100){
			price = 100;
		}
	}

	//显示书籍情况
	public void info(){
		System.out.println("书名=" + this.name + " 价格=" + this.price);
	}
}

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

public class Homework04{
	//编写一个main方法
	public static void main(String[] args){
		int[] oldArr = {10,20,30};
		A03 a03 = new A03();
		int[] arr = a03.copyArr(oldArr);
		System.out.println("=返回新的arr数组==");
		for(int i = 0; i < arr.length; i ++){
			System.out.print(arr[i] + " ");
		}
	}
}
/*
编写类A03，实现数组的复制功能copyArr，
输入旧数组，返回一个新的数组，元素和旧数组一样
*/
class A03 {

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

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

public class Homework05{
	//编写一个main方法
	public static void main(String[] args){
		Circle circle = new Circle(5);
		System.out.println("面积=" + circle.area());
		System.out.println("周长=" + circle.len());
	}
}
/*
定义一个圆类Circle，
定义属性：半径，提供显示圆周长功能的方法，提供显示圆面积的方法
*/
class Circle {
	public double radius;

	public Circle(double radius){//构造器
		this.radius = radius;
	}

	public double area(){//面积
		return Math.PI * radius * radius;
	}
	public double len(){//周长
		return Math.PI * radius * 2;
	}
}

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

public class Homework06{
	//编写一个main方法
	public static void main(String[] args){
		Cale cale = new Cale(2,0);
		System.out.println("和=" + cale.sum());
		System.out.println("差=" + cale.minus());
		System.out.println("乘=" + cale.mul());
		Double divRes = cale.div();
		if(divRes != null){
			System.out.println("除=" + divRes);
		}
	}
}
/*
编程创建一个Cale计算类，在其中定义2个变量表示两个操作数，
定义四个方法实现求和、差、乘、商(要求除数为0的话，要提示)并创建两个对象，分别测试
*/
class Cale {
	double num1;
	double num2;
	public Cale(double num1,double num2) {
		this.num1 = num1;
		this.num2 = num2;
	}
	//和
	public double sum(){
		return num1 + num2;
	}
	//差
	public double minus(){
		return num1 - num2;
	}
	//乘积
	public double mul(){
		return num1 * num2;
	}
	//除法
	public Double div(){
		//判断
		if(num2 == 0){
			System.out.println("num2不能为0");
			return null;
		}
		return num1 / num2;
	}
}

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

public class Homework07{
	//编写一个main方法
	public static void main(String[] args){
		Dog dog = new Dog("小白",3,"白色");
		dog.show();
	}
}
/*
设计一个Dog类，有名字、颜色和年龄属性，
定义输出方法show()显示其信息。并创建对象，进行测试。【提示 this 属性】
*/
class Dog {
	String name;
	int age;
	String color;
	public Dog(String name,int age,String color){
		this.name = name;
		this.age = age;
		this.color = color;
	}
	public void show(){
		System.out.println("name=" + name + " age=" + age 
			+ " color=" + color);
	}
}

8、给定一个Java程序的代码如下，则编译运行后，输出结果是（10，9,10 ）

public class Test {
	int count = 9;
	public void count1(){
		count = 10;
		System.out.println("count1=" + count);
	}
	public void count2(){
		System.out.println("count1=" + count++);
	}
	public static void main(String[] args) {
		new Test().count1();
		Test t1 = new Test();
		t1.count2();
		t1.count2();
	}
}

public class Homework08{

	int count = 9;//属性

	public void count1(){//成员方法
		count = 10;//这个count就是属性 改成10
		System.out.println("count1=" + count);//10
	}

	public void count2(){//成员方法
		System.out.println("count1=" + count++);//9 -> 10
	}

	// main方法 任何一个类，都可以有main
	public static void main(String[] args){
		//1. new Test() 是匿名对象 匿名对象使用后，就不能使用了
		//2. new Test().count1(); 创建号匿名对象后，就调用count1()
		new Homework08().count1();

		Homework08 t1 = new Homework08();
		t1.count2();
		t1.count2();
	}
}

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

public class Homework09{
	//编写一个main方法
	public static void main(String[] args){
		Music music = new Music("笑傲江湖",300);
		music.play();
		System.out.println(music.getInfo());
	}
}
/*
定义Music类，里面有音乐名name、音乐时长times属性，
并有播放play功能和返回本身属性信息的功能方法getInfo
*/
class Music {
	String name;
	int times;
	public Music(String name, int times){
		this.name = name;
		this.times = times;
	}
	//播放play功能
	public void play(){
		System.out.println("音乐 " + name + " 正在播放中... 时长为" + times + "秒");
	}
	//返回本身属性信息的功能方法getInfo
	public String getInfo(){
		return "音乐 " + name + " 播放时长为" + times + "秒";
	}
}

10、试写出以下代码的运行结果（）

class Demo{
	int i = 100;
	public void m () {
		int j = i++;
		System.out.println("i=" + i);
		System.out.println("j=" + j);
	}
}
class Test{
	public static void main(String[] args) {
		Demo d1 = new Demo();
		Demo d2 = d1;
		d2.m();
		 System.out.println(d1.i);
		 System.out.println(d2.i);
	}
}

public class Homework10{
	//编写一个main方法
	public static void main(String[] args){
		Demo d1 = new Demo();
		Demo d2 = d1;
		d2.m();
		System.out.println(d1.i);//101
		System.out.println(d2.i);//101
	}
}
class Demo{
	int i = 100;
	public void m () {
		int j = i++;
		System.out.println("i=" + i);//101
		System.out.println("j=" + j);//100
	}
}

11、在测试方法中，调用method方法，代码如下，编译正确，试写出method方法的定义形式，调用语句为：

 System.out.println(method(method(10.0, 20.0),100));

/*
在测试方法中，调用method方法，代码如下，编译正确，
试写出method方法的定义形式，调用语句为：
 System.out.println(method(method(10.0, 20.0),100));
*/
class Test {
	public double method(double d1,double d2){
	}
}

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

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

		System.out.println("i=");
	}	
}
/*
创建一个Employee类，属性有(名字，性别，年龄，职位，薪水)，
提供3个构造器方法，可以初始化 
(1)(名字，性别，年龄，职位，薪水)，
(2)(名字，性别，年龄) 
(3)(职位，薪水)，要求充分复用构造器
*/
class Employee {
	//名字，性别，年龄，职位，薪水
	String name;
	char gender;
	int age;
	String job;
	double sal;
	//因为要求可以复用构造器，因此先属性少的构造器
	//职位，薪水
	public Employee(String job,double sal){
		this.job = job;
		this.sal = sal;
	}
	//名字，性别，年龄
	public Employee(String name,char gender,int age){
		this.name = name;
		this.gender = gender;
		this.age = age;
	}
	//名字，性别，年龄，职位，薪水
	public Employee(String name,char gender,int age,String job,double sal){
		this(name,gender,age);//使用到前面的构造器
		this.job = job;
		this.sal = sal;
	}
}

13、将对象作为参数传递给方法
题目要求：
（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()方法，调用完毕后输出当前半径值

public class Homework13{
	//编写一个main方法
	public static void main(String[] args){
		Circle c = new Circle();
		PassObject po = new PassObject();
		po.printAreas(c,5);
	}	
}
/*
将对象作为参数传递给方法
题目要求：
（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()方法，调用完毕后输出当前半径值

*/
class Circle {
	double radius;
	public Circle(){//无参构造器
	}
	public Circle(double radius){
		this.radius = radius;
	}
	//findArea()方法返回圆的面积
	public double findArea(){//返回面积
		return Math.PI * radius * radius;
	}
	//添加方法setRadius，修改对象的半径值
	public void setRadius(double radius){
		this.radius = radius;
	}
}
class PassObject {
	public void printAreas(Circle c, int times){//方法签名
		System.out.println("radiustarea");
		for(int i = 1; i <= times; i++){//输出1到times之间的整数半径值
			c.setRadius(i);//修改半径的值
			System.out.println((double)i +"t" + c.findArea());
		}
	} 
}

14、扩展题
有个人 Tom 设计他的成员变量，成员方法，可以电脑猜拳。电脑每次都会随机生成 0,1，2
0 表示 石头 1 表示剪刀 2 表示 布
并要求可以显示 Tom的输赢次数

import java.util.Random;
import java.util.Scanner;
/*
有个人 Tom 设计他的成员变量，成员方法，可以电脑猜拳。
电脑每次都会随机生成 0,1，2
0 表示 石头 1 表示剪刀 2 表示 布
并要求可以显示 Tom的输赢次数

*/
public class Homework14 {

    //编写一个main方法
    public static void main(String[] args)throws Exception{
        // 创建一个玩家对象
        Tom t  = new Tom();
        //用来记录最后输赢的次数
        int isWinCount = 0;

        //创建一个二维数组，用来接收局数，Tom出拳情况以及电脑出拳情况
        int[][] arr1 = new int[3][3];
        int j = 0;

        //创建一个一维数组，用来接收输赢情况
        String[] arr2 = new String[3];

        Scanner sc = new Scanner(System.in);
        for(int i = 0; i < 3; i++){ //比赛3次
            //获取玩家出的拳
            System.out.println("请输入你要出的拳（0-拳头 1-剪刀 2-布）：");
            int num = sc.nextInt();
            t.setTomGuessNum(num);
            int tomGuess = t.getTomGuessNum();
            arr1[i][j + 1] = tomGuess;

            //获取电脑出的拳
            int comGuess = t.computerNum();
            arr1[i][j + 2] = comGuess;

            //将玩家猜的拳与电脑做比较
            String isWin = t.vsComputer();
            arr2[i] = isWin;
            arr1[i][j] = t.count;

            //对每一局的情况进行输出
            System.out.println("===============================");
            System.out.println("局数t玩家的出拳t电脑的出拳t输赢情况");
            System.out.println(t.count + "t" + tomGuess + "tt" + comGuess + "ttt" + isWin);
            System.out.println("===============================");
            System.out.println("nn");
            isWinCount = t.winCount(isWin);
        }

        //对游戏的最终结果进行输出
        System.out.println("局数t玩家的出拳t电脑的出拳t输赢情况");
        for(int a = 0; a < arr1.length; a++){
            for(int b = 0; b < arr1[a].length; b++){
                System.out.print(arr1[a][b] + "tt");
            }
            System.out.print(arr2[a]);
            System.out.println();
        }
        System.out.println("你赢了" + isWinCount + "次");
    }
}
//Tom类
class Tom {
    //玩家出拳的类型
    int tomGuessNum;//0,1,2
    //电脑出拳的类型
    int comGuessNum;//0,1,2
    //玩家赢的次数
    int winCountNum;
    //比赛的次数
    int count = 1;//一共比赛3次

    public void showInfo(){
        //...
    }

    /**
     * 电脑随机生成猜拳的数字的方法
     * @return
     */
    public int computerNum(){
        Random r = new Random();
        comGuessNum = r.nextInt(3); // 方法 返回 0-2的随机数
        System.out.println("电脑出拳=" + comGuessNum);
        return comGuessNum;
    }

    /**
     * 设置玩家猜拳的数字的方法
     * @return
     */
    public void setTomGuessNum(int tomGuessNum) throws IllegalAccessException {
        if(tomGuessNum > 2 || tomGuessNum < 0){
            //抛出一个异常
            throw new IllegalAccessException("数字输入有误");
        }
        this.tomGuessNum = tomGuessNum;
    }

    public int getTomGuessNum(){
        return tomGuessNum;
    }

    /**
     * 比较猜拳的结果
     * @return 玩家赢返回true，否则返回false
     */
    public String vsComputer(){
        //比较巧
        if(tomGuessNum == 0 && comGuessNum == 1){
            return "你赢了";
        }else if(tomGuessNum == 1 && comGuessNum == 2){
            return "你赢了";
        }else if(tomGuessNum == 2 && comGuessNum == 0){
            return "你赢了";
        }else if(tomGuessNum ==  comGuessNum ){
            return "平手";
        }else{
            return "你输了";
        }
    }

    /**
     * 记录玩家赢的次数
     * @return
     */
    public int winCount(String s){
        count++; //控制玩的次数
        if(s.equals("你赢了")){ // 统计赢的次数
            winCountNum++;
        }
        return winCountNum;
    }
}

最后

以上就是玩命滑板为你收集整理的java零基础Ⅰ-- 6.面向对象编程（基础部分）类与对象成员方法成员方法传参数机制（重要）方法重载（overload）可变参数作用域构造方法/构造器this关键字作业的全部内容，希望文章能够帮你解决java零基础Ⅰ-- 6.面向对象编程（基础部分）类与对象成员方法成员方法传参数机制（重要）方法重载（overload）可变参数作用域构造方法/构造器this关键字作业所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。