对方法的理解：自定义数组的工具类、方法重载、方法参数的值传递机制

自定义一个数组的工具类

将数组中的内容封装到一个方法中

创建一个ArrayUtil类

public class ArrayUtil {

	// 求数组的最大值
	public int getMax(int[] arr) {
		int maxValue = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (maxValue < arr[i]) {
				maxValue = arr[i];
			}
		}
		return maxValue;
	}

	// 求数组的最小值
	public int getMin(int[] arr) {
		int minValue = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (minValue > arr[i]) {
				minValue = arr[i];
			}
		}
		return minValue;
	}

	// 求数组的总和
	public int getSum(int[] arr) {

		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		return sum;
	}

	// 求数组的平均值
	public int getAvg(int[] arr) {

		return getSum(arr) / arr.length;//方法中调用方法
	}

	// 反转数组
	public void reverse(int[] arr) {
		for (int i = 0; i < arr.length / 2; i++) {
			int temp = arr[i];
			arr[i] = arr[arr.length - i - 1];
			arr[arr.length - i - 1] = temp;
		}
	}

	// 复制数组
	public int[] copy(int[] arr) {
		int[] arr1 = new int[arr.length];
		for (int i = 0; i < arr1.length; i++) {
			arr1[i] = arr[i];
		}
		return arr1;
	}

	// 数组排序
	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
				}
			}
		}
	}
	

	// 遍历数组
	public void print(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
		System.out.println();
	}

	// 查找指定元素
	public int getIndex(int[] arr, int dest) {
		// 线性查找：

		for (int i = 0; i < arr.length; i++) {

			if (dest == arr[i]) {
				return i;
			}
		}
		return -1;//返回一个负数，表示没有找到
	}

}

再创建一个ArrayUtilTest类，对ArrayUtil中的方法进行调用

public class ArrayUtilTest {
	public static void main(String[] args) {
		
		ArrayUtil util = new ArrayUtil();
		int[] arr = new int[]{32,34,32,5,3,54,654,-98,0,-53,5};
		int max = util.getMax(arr);
		System.out.println("最大值为：" + max);
		
		System.out.println("排序前：");
		util.print(arr)
		

		util.sort(arr);
		System.out.println("排序后：");
		util.print(arr);
		System.out.println();
		
		System.out.println("查找：");
		int index = util.getIndex(arr, -5);//-5即为要查找的数
		if(index >= 0){
			System.out.println("找到了，索引地址为：" + index);
		}else{
			System.out.println("未找到");
		}
		util.reverse(arr);
	}
}

方法的重载

1. 重载概念：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同发即可.

   两同一不同：同一个类，相同方法名。参数列表不同，参数个数不同，参数类型不同

2. 重载的特点:与返回值类型无关，只看参数列表，且参数列表必须不同。（参数个数或参数类型）调用时，根据方法参数列表的不同来区别

3. 在通过对象调用方法时，如何确定某一个指定的方法：
   方法名------>参数列表

4. 重载示例：

//返回两个整数的和
int add(int x,int y){

return x+y;

}
//返回三个整数的和
int add(int x,int y ,int z){

return x+y+z;

}
//返回两个小数之和
double add(double x,double y){

return x+y;

}

---

public class OverLoadTest{
	public static void main(String [] args){
	OverLoadTest test = new OverLoadTest();
	test.getSum(1,2);//请问，此时调用的是那个方法
	}//回答：调用的是第一个方法。因为参数类型为int。如果方法一不存在，则会自动进行类型提升，选择方法二

	//如下的4个方法构成重载
	public void getSun(int i,int j){//如果调用的是此方法则输出方法一，下面相同
		System.out.println("方法一");
	}
	public void getSun(double d1, double d2){
		System.out.println("方法二");
	}
	public void getSun(String s,int i){
		System.out.println("方法三");
	}
	public void getSun(int i,Strgin s){
		System.out.println("方法四");
	}
	//下面的这个方法不能和上面的构成重载， 他是同一个类，相同方法名，但是参数列表和第一个相同，所以不行
	public int getSun(int i, int j){
	
	return 0;
	}
	//下面的这个也不行，形参列表还是和第一个相同 int ，int 与形参变量名无关 
	public void getSun(int m,int j){
	}
	//下面的这个也不行，形参列表还是和第一个相同 int ，int 与方法的权限修饰符无关
	private void getSun(int i,int j){
	}
}

**总结：判断方法是否重载：跟方法的权限修饰符、返回值类型、形参变量名、方法体都无关

**

方法重载的练习：

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

2、定义三个重载方法max()
第一个方法求两个int值中的最大值
第二个方法求两个double值中的最大值
第三个方法求三个double值中的最大值
并分别调用三个方法。

public class OverloadExer{	

	//题一
	//如下三个方法构成重载
	public void mOL(int i){
	System.out.println(i * i);
	}
	public void mOL(int i，int j){
	System.out.println(i * j);
	}
	public void mOL(String s){
	System.out.println(s);
	}
	
	//题二
	//如下三个方法可以构成重载
	public int max(int i ,int j){
	return (i>j)? i : j;
	}
	public double max(double d1 ,double d2){
	return (d1 > d2)? d1 : d2;
	}
	public double max(double d1 ,double d2,double d3){
	double max = (d1 > d2)? d1 : d2;
	return(max >d3)? max :d3; 
	}
	
}

可变个数形参的方法

具体使用

/*
 * 可变个数形参的方法
 * 
 * 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){
//		
//	}
	
}

方法参数的值传递机制

1、 方法，必须由其所在类或对象调用才有意义。若方法含有参数：
形参：方法声明时的参数，方法定义时，声明的小括号内的参数
实参：方法调用时实际传给形参的参数值

2、Java中的实参值如何传入方法的？
Java里的方法参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响
① 形参是基本数据类型，将实参基本数据类型变量的“数据值”传递给形参
② 形参是引用数据类型，将实参引用数据类型变量的“地址值”传递给形参

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;//这里给新地址值赋值了1002，所以o1的也会发生改变
		
		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
		
	}
	
}

class Order{
	
	int orderId;
	
}

方法重载和方法重写的区别？