10.20（java方法的重载、可变个数形参的方法、方法参数值的传递机制）

 一、方法的重载（overload）  loading...

  
  1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
      
   "两同一不同":同一个类、相同方法名
             参数列表不同：参数个数不同，参数类型不同
  
  2. 举例：
     Arrays类中重载的sort() / binarySearch()
  
  3.判断是否是重载：
     跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
     
  4. 在通过对象调用方法时，如何确定某一个指定的方法：
       方法名 ---> 参数列表
 

public class OverLoadTest {
	public static void main(String[] args) {
		
		OverLoadTest test = new OverLoadTest();
		test.getSum(1,2);
		test.getSum("abc",3);
		
	}
	
	//如下的4个方法构成了重载
	public void getSum(int i,int j){
		System.out.println("1");
	}
	
	public void getSum(double d1,double d2){
		System.out.println("2");
	}
	
	public void getSum(String s ,int i){
		System.out.println("3");
	}
	
	public void getSum(int i,String s){
		System.out.println("4");
	}
	
	//如下的3个方法不能与上述4个方法构成重载
//	public int getSum(int i,int j){
//		return 0;
//	}
	
//	public void getSum(int m,int n){
//		
//	}
	
//	private void getSum(int i,int j){
//		
//	}
	
	
}

二、可变个数形参的方法

  1.jdk 5.0新增的内容
  2.具体使用：
    2.1 可变个数形参的格式：数据类型 ... 变量名
    2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
    2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
    2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
    2.5 可变个数形参在方法的形参中，必须声明在末尾
       2.6  可变个数形参在方法的形参中,最多只能声明一个可变形参。
  

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){
//		
//	}
	
	//The variable argument type String of the method 
	//show must be the last parameter
//	public void show(String ...strs,int i){
//		
//	}
	
}

 

 三、方法参数的值传递机制

 
  关于变量的赋值：
   ①如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
   ②如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

public class ValueTransferTest {
	
	public static void main(String[] args) {
		
		System.out.println("***********基本数据类型：****************");
		int m = 10;
		int n = m;
		
		System.out.println("m = " + m + ", n = " + n);
		
		n = 20;
		
		System.out.println("m = " + m + ", n = " + n);
		
		System.out.println("***********引用数据类型：****************");
		
		Order o1 = new Order();
		o1.orderId = 1001;
		
		Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
		
		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
		
		o2.orderId = 1002;
		
		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
		
	}
	
}

class Order{
	
	int orderId;
	
}

  方法的形参的传递机制：值传递
  
  1.形参：方法定义时，声明的小括号内的参数
    实参：方法调用时，实际传递给形参的数据
  
  2.值传递机制：
  如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
  如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

public class ValueTransferTest1 {
	public static void main(String[] args) {
		
		int m = 10;
		int n = 20;
		
		System.out.println("m = " + m + ", n = " + n);
		//交换两个变量的值的操作
//		int temp = m ;
//		m = n;
//		n = temp;
		
		ValueTransferTest1 test = new ValueTransferTest1();
		test.swap(m, n);
		
		System.out.println("m = " + m + ", n = " + n);
		
	
		
	}
	
	
	public void swap(int m,int n){
		int temp = m ;
		m = n;
		n = temp;
	}
}

  

 传递基本数据类型实参进入无法实现交换，得使用引用类型，具体该如何做呢？

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);
		
	}
	
	public void swap(Data data){
		int temp = data.m;
		data.m = data.n;
		data.n = temp;
	}
	
}

class Data{
	
	int m;
	int n;
	
}

 

 

再看一个案例加深下理解