day07

再谈方法

方法的重载

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表不同来区别。

例如：

System.out.println()方法就是典型的重载方法，其内部的声

明形式如下：

public void println(byte x)

public void println(short x)

public void println(int x)

public void println(long x)

public void println(float x)

public void println(double x)

public void println(char x)

public void println(double x)

public void println()

练习：

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

//定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方法求两个double值中的最大值，第三个方法求三个double值中的最大值
public int max(int i,int j) {
		return i>j?i:j;
	}
	public double max(double x,double y) {
		return x>y?x:y;
	}
	public double max(double x,double y,double z) {
		return x>y?(x>z?x:z):(y>z?y:z);
	}

int[] arr = new int[10];
System.out.println(arr);//这个打印地址
char[] arr1 = new char[10];
System.out.println(arr1); //这个打印默认值
//System.out.println()不同的方法重载

可变形参的方法

JavaSE 5.0 中提供了**Varargs(variable number of arguments)**机制，允许直接定义能和多个实参相匹配的形参从而，可以用一种更简单的方式，来传递个数可变的实参。

格式：

声明格式：方法名(参数的类型名 …参数名)

可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个

可变个数形参的方法与同名的方法之间，彼此构成重载

可变参数方法的使用与方法参数部分使用数组是一致的

方法的参数部分有可变形参，需要放在形参声明的最后

在一个方法的形参位置，最多只能声明一个可变个数形参

//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String…books);

注意：这两者不能形成重载

	//错误演示：Duplicate method(方法重复了)
	public static void test(int a ,String[] books) {
		
	}
	public static void test(int a ,String... books) {
		
	}

使用：当成数组使用即可

public class OverRideTest2 {
	public static void main(String[] args) {
		OverRideTest2 rideTest = new OverRideTest2();
		rideTest.print("dqd","dqw","dqw");
		rideTest.print("dqd");//优先去匹配一个参数的，没有再去匹配可变参数，如果改成rideTest.print(new String[] {"dws"});则会去匹配多个参数，因为形参类型匹配
        
	}
	public void print(String arg) {
		System.out.println("一个参数");
		System.out.println(arg);
	}
    
	public void print(String... args) {
		System.out.println("多个参数");
		int n = args.length;
		for(int i = 0;i < n;i++) {
			System.out.print(args[i]+"  ");
		}
        System.out.println();
	}
}
/*
结果：
    多个参数
	dqd  dqw  dqw  
	一个参数
	dqd
*/

方法参数的值传递机制

Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参

形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

基本数据类型

public static void main(String[] args) {
		int a = 5;
		int b = 10;
		OverRideTest3 overTest = new OverRideTest3();
		System.out.println("交换之前：a = "+a+",b = "+b);
		overTest.swap(a, b);
		System.out.println("交换之后：a = "+a+",b = "+b);
	}
	public void swap(int i,int j) {
		int temp = i;
		i = j;
		j = temp;
	}
/*
结果：
	交换之前：a = 5,b = 10
	交换之后：a = 5,b = 10
*/

内存解析：

调用swap方法，会把5和10的实际的值给形参i，j。并不会对main中a，b产生影响

引用数据类型

public static void main(String[] args) {
		OverRideTest3 overTest = new OverRideTest3();
		int arr[] = {5,10};
		System.out.println("调用之前："+arr[0]+"   "+arr[1]);
		overTest.swap(arr);
		System.out.println("调用之后："+arr[0]+"   "+arr[1]);
	}
	public void swap(int[] arr) {
		int temp = arr[0];
		arr[0] = arr[1];
		arr[1] = temp;
	}
/*
结果：
调用之前：5   10
调用之后：10   5
*/

内存解析：

练习：

/*
	 * 定义一个int型的数组：int[] arr = new int[]{12,3,3,34,56,77,432};
	 * 让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组。
	 */
	public static void main(String[] args) {
		OverTestExer testExer = new OverTestExer();
		int arr[] = {12,3,3,34,56,77,432};
		System.out.println("调用之前：");
		for(int i = 0;i < arr.length;i++) {
			System.out.print(arr[i]+"  ");
		}
		testExer.change(arr);
		System.out.println("\n调用之后：");
		for(int i = 0;i < arr.length;i++) {
			System.out.print(arr[i]+"  ");
		}
		System.out.println();
	}
	public void change(int arr[]) {//不能正向遍历哦，因为首先就改变了首元素
		for(int i = arr.length-1;i>=0;i--) {
			arr[i] = arr[i]/arr[0];
		}
	}
/*
调用之前：
12  3  3  34  56  77  432  
调用之后：
1  0  0  2  4  6  36  
*/

递归方法

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

方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。

递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环

//计算1到100的和
public static void main(String[] args) {
		digui d = new digui();
		int sum = d.getSum(100);
		System.out.println(sum);
	}
	public int getSum(int n) {
		if(n == 1) {//退出条件，n无限向此逼近
			return 1;
		}
		return n + getSum(n-1);
	}