一、方法的重载（overload）
1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
"两同一不同":同一个类、相同方法名
参数列表不同：参数个数不同，参数类型不同
2. 举例：
Arrays类中重载的sort() / binarySearch()
3.判断是否是重载：
跟方法的权限修饰符、返回值类型、形参变量名（不是形参类型）、方法体都没有关系！
4. 在通过对象调用方法时，如何确定某一个指定的方法：
方法名 ---> 参数列表
二、可变个数形参的方法
1.jdk 5.0新增的内容。允许直接定 义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可 变的实参。
采用可变个数形参来定义方法，传入多个同一类型变量 public static void test(int a ,String…books);
2.具体使用：
2.1 可变个数形参的格式：数据类型 ... 变量名
2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
2.5 可变个数形参在方法的形参中，必须声明在末尾。
2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。
public void test(String[] msg){
System.out.println(“含字符串数组参数的test方法 ");
}
public void test1(String book){
System.out.println(“****与可变形参方法构成重载的test1方法****");
}
public void test1(String ... books){
System.out.println("****形参长度可变的test1方法****");
}
public static void main(String[] args){
TestOverload to = new TestOverload();
//下面两次调用将执行第二个test方法
to.test1();
to.test1("aa" , "bb");
//下面将执行第一个test方法
to.test(new String[]{"aa"});
}
具体实例代码：
public class MethodArgsTest {
public static void main(String[] args) {
MethodArgsTest test = new MethodArgsTest();
test.show(12);
// test.show("hello");
// test.show("hello","world");
// test.show();
test.show(new String[]{"AA","BB","CC"});
}
public void show(int i){
}
public void show(String s){
System.out.println("show(String)");
}
public void show(String ... strs){
System.out.println("show(String ... strs)");
for(int i = 0;i < strs.length;i++){//类似数组遍历
System.out.println(strs[i]);
}
}
//不能与上一个方法同时存在
// public void show(String[] strs){
}//可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
// public void show(String ...strs,int i){
}//The variable argument type String of the method show must be the last parameter（报错信息）
// 可变个数形参在方法的形参中，必须声明在末尾。
}
三、方法参数的值传递机制:值传递
1.关于变量的赋值：
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
int m=1;int n=m; n=2; //m=1,n=2
//如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId); //1002,1002
2.方法，必须由其所在类或对象调用才有意义。若方法含有参数：
形参：方法声明时的参数
实参：方法调用时实际传给形参的参数值
3.Java的实参值如何传入方法呢？
Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本 （复制品）传入方法内，而参数本身不受影响。
形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参。
形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参。
1）形参是基本数据类型
public class ValueTransferTest1 {
public static void main(String[] args) {
int m=10;int n=20;
ValueTransferTest1 test = new ValueTransferTest1();
test.swap(m, n);
System.out.println("m = " + m + ", n = " + n);//m=10,n=20(没有交换成功）
}
public void swap(int m,int n){
int temp = m ;
m = n;
n = temp;
}
}
main(){
int m = 10; int n = 20;
v.swap(m,n);swap()执行完，出栈
sysout(m,n); //m=10,n=20
}
swap(int m ,in n){
int temp = m; m = n; n = temp;
sysout(m,n); //m=20,n=10
}
2）形参是引用数据类型
public class ValueTransferTest2 {
public static void main(String[] args) {
Data data = new Data();
data.m = 10;
data.n = 20;
System.out.println("m = " + data.m + ", n = " + data.n);
//交换m和n的值
// int temp = data.m;
// data.m = data.n;
// data.n = temp;
ValueTransferTest2 test = new ValueTransferTest2();
test.swap(data);
System.out.println("m = " + data.m + ", n = " + data.n); //m=20,n=10
}
public void swap(Data data){
int temp = data.m;
data.m = data.n;
data.n = temp;
}
}
// 数组排序
public void sort(int[] arr) {
// 冒泡排序
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
// int temp = arr[j];
// arr[j] = arr[j + 1];
// arr[j + 1] = temp;
//错误的：
// swap(arr[j],arr[j + 1]);
//正确的：
swap(arr,j,j + 1);
}
}
}
}
//错误的：交换数组中指定两个位置元素的值
// public void swap(int i,int j){
// int temp = i;
// i = j;
// j = temp;
// }
//正确的：交换数组中指定两个位置元素的值
public void swap(int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
四、递归方法
递归方法：一个方法体内调用它自身。
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执 行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死 循环。
//计算1-100之间所有自然数的和
public int sum(int num){
if(num == 1){
return 1;
}else{
return num + sum(num - 1);
}
}
