方法

方法的重载

1. 概念：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。
2. “两同一不同”：
   • 同一个类、相同方法名；
   • 形参列表不同：个数不同、类型不同
3. 重载跟方法的权限修饰符、返回值类型、形参变量名、方法体无关
4. 举例：

class Util {
	public int sum(int a, int b) {
		return a + b;
	}

	public double sum(double a, double b) {
		return a + b;
	}

	public double sum(double a, double b, double c) {
		return a + b + c;
	}

	public String sum(String a, int b) {
		return a + b;
	}
}

可变个数形参的方法

1. 允许直接定义能和多个实参相匹配的形参
2. 从而使用更简单的方式来传递个数可变的实参
3. jdk 5.0新增的内容
4. 格式：权限修饰符 返回值类型 方法名(数据类型... 变量名){}
5. 举例：publi void data(String... atrs){}
6. 当调用可变个数形参的方法时，传入的参数可以是0个、1个....
7. 可变个数形参的方法与类中方法名相同，形参不同之间构成重载
8. 可变个数形参的方法与类中方法名相同，形参类型也相同的数组形参不构成重载。
9. 可变形参，必须放在所有重载方法的最后一个。
10. 可变形参方法，只能存在一个。
11. 可变个数形参数据的调用，与数组一样。

举例

public class MethodTest {
	public static void main(String[] args) {
		Method md = new Method();
		//多个参数，首先会匹配是否有形参数量一样的方法，有的话调用此方法，没有的话调用可变个数形参方法
		md.data(11, 22);
		md.data(1);
		md.data(11,22,33);
		//调用0个形参。会进入可变个数形参，可以说明可变个数形参的数量可以是0个，1个。。。。N个。
		md.data();
	}
}

class Method {
	
	// 单个的方法
	public void data(int n) {
		System.out.println("n = " + n);
	}

	// 两个的方法
	public void data(int n, int m) {
		System.out.println("n = " + n + ",m =" + m);
	}

	// 可变个数的形参
	public void data(int... dt) {
		System.out.println("已进入可变参数方法：");
		// 获取可变个数的形参
		for (int i = 0; i < dt.length; i++) {
			System.out.println("A可变个数的形参" + dt[i]);
		}
	}
	
//	// 对比如下两个，第二个错误，说明可变形参必须放到所有参数的最后一个
//	public void data(String a,int... dt) {
//
//	}
//	// 错误的写法
//	public void data(int... dt,String a) {
//
//	}
}

方法参数的值传递机制（重点）

• 值传递：
• 如果参数是基本数据类型，此时实参给形参的是真实存储的数据值。
• 如果参数是引用数据类型，此时实参给形参的是存储的地址值。

举例

public class ArgsTest {
	public static void main(String[] args) {
		// 使用基本数据类型
		int m = 10;
		int n = 20;
		ArgsTest test = new ArgsTest();
		test.swap(n, m);
		System.out.println("m = " + m + ",n = " + n);// 通过调用swap，发现没有改变m10，n20

		// 使用引用数据类型
		Args ag = new Args();
		ag.m = 10;
		ag.n = 20;
		test.swap(ag);
		System.out.println("ag.m = " + ag.m + ",ag.n = " + ag.n);//引用类型指向的是内存地址
	}

	private void swap(Args ag) {
		int temp = ag.m;
		ag.m = ag.n;
		ag.n = temp;
	}

	private void swap(int n, int m) {
		int temp = m;
		m = n;
		n = temp;
	}
}

class Args {
	int m;
	int n;
}

内存解析

		int m = 10;
		int n = 20;
		ArgsTest test = new ArgsTest();
		test.swap(n, m);
		System.out.println("m = " + m + ",n = " + n);

	private void swap(int n, int m) {
		int temp = m;
		m = n;
		n = temp;
	}

// 使用引用数据类型
		Args ag = new Args();
		ag.m = 10;
		ag.n = 20;
		test.swap(ag);
		System.out.println("ag.m = " + ag.m + ",ag.n = " + ag.n);//引用类型指向的是内存地址

		private void swap(Args ag) {
		int temp = ag.m;
		ag.m = ag.n;
		ag.n = temp;
	}

		class Args {
			int m;
			int n;
		}

递归方法

一个方法体内自己调用它自身。

• 递归方法包含了一种隐式的循环，他会重复执行末端代码，但这种重复代码执行无需循环控制。
• 递归一定要向已知的方向递归，否则中递归进程了无穷递归，类似于死循环。

实例

1-n的自然数的和

Day09 问题

1. 什么是方法的重载

• 在同一类中方法名相同，形参类型不同、形参个数不同的方法，构成了方法的重载。
• 简称：两同一不同：同一个类，相同方法名，不同参数列表

2. 说明java方法中参数传递机制的具体体现

• 实参是基本数据类型，实参传递给形参，传递的是真实的值。
• 实参是引用数据类型，实参传递给形参，传递的是内存地址值。

3. 成员变量和局部变量在声明的位置上、是否有默认初始化值上、是否能有权限修饰符上、内存分配位置上有何不同。

• 声明的位置：
  • 成员变量声明在类{}中
  • 局部变量声明在方法中
• 默认初始化值：
  • 成员变量有默认初始化值。
    • 整数类型：0
    • 浮点类型：0.0
    • 布尔类型：false
    • 字符类型：'\u0000'
    • 引用数据类型：null
  • 局部变量没有默认初始化值。
• 权限修饰符：
  • 成员变量有权限修饰符
    • public
    • proteted
    • 缺省
    • private
  • 局部变量没有权限修饰符
• 内存分配位置：
  • 成员变量：堆空间
  • 局部变量：栈空间

4. 谈谈return关键字的使用

• 结束方法
• 针对有返回值的方法，可以返回数据

5. 提供如下代码的内存解析