Java面向对象(3)(方法的重载、可变个数的形参、值传递机制、递归方法的使用)

一.方法的重载

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

public class OverloadTest {
	
	//如下的4个方法构成了重载
	public void getSum(int i,int j) {
		System.out.println(i+j);
		System.out.println("1");
	}
	
	public void getSum(double d1,double d2) {
		System.out.println(d1+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");
	}
}

---

二.方法重载的练习题

/*
1.编写程序，定义三个重载方法并调用。方法名为mOL。
①三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别
执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
②在主类的main ()方法中分别用参数区别调用三个方法。
 */
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 class OverloadExerTest {
	//测试类
	public static void main(String[] args) {
		OverloadExer oExer=new OverloadExer();
		oExer.mOL(2);
		oExer.mOL(2, 3);
		oExer.mOL("Hello");
	}
}

---

/*
2.定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方
法求两个double值中的最大值，第三个方法求三个double值中的最大值，
并分别调用三个方法
 */
public class OverloadExer1 {
	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;
	}
}

public class OverloadExerTest1 {
	//测试类
	public static void main(String[] args) {
		OverloadExer1 o1=new OverloadExer1();
		System.out.println(o1.max(1, 2));
		
		System.out.println(o1.max(8.9, 2.6));
		
		System.out.println(o1.max(1.3, 9.7, 7.1));
	}
}

---

三.可变个数的形参(新特性)

/*
 * 可变个数的形参(了解)
 * JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，
 * 允许直接定义能和多个实参相匹配的形参。
 * 从而，可以用一种更简单的方式，来传递个数可变的实参。
 * 
 * 
 * 具体使用:
 * 1.可变个数形参的格式:数据类型 ... 变量名
 * 2.当调用可变个数形参的方法时,传入的参数个数可以是:0个,1个,2个,...,多个
 * 3.可变个数形参的方法与本类中方法名相同,形参不同的方法之间构成重载
 * 4.可变个数形参的方法与本类中方法名相同,形参类型也相同的数组之间不构成重载,换句话说,二者不能共存
 * 5.可变个数形参在方法的形参中,必须声明在末尾
 * 
 */

public class Test1 {
	
	public static void main(String[] args) {
		Test1 test1=new Test1();
		test1.show(1);//1
		test1.show("a");//String s
		test1.show();//String ... s
		test1.show("a","a","a");//String ... s
	}
	
	public void show(int i) {
		System.out.println(i);
	}
	
	public void show(String s) {
		System.out.println("String s");
	}
	
	//可变个数的形参
	public void show(String ... s) {
		System.out.println("String ... s");
	}
	
	/* 不能共存
	 * public void show(String[] s) {
	 * 
	 * }
	 */
	
	//正确的
	public void show(int i,String ... s) {
		
	}
	
	/*错误的
	 * public void show(String ... s,int i) {
	 * 
	 * }
	 */
}

---

四.方法参数的值传递机制(重难点)

1.关于变量的赋值:

/*
 * 关于变量的赋值:
 * 
 * 如果变量时基本数据类型,此时赋值的是变量所保存的数据
 * 如果变量时引用数据类型,次时赋值的变量所保存的数据的地址值
 */
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);//m=10,n=10
		n=20;
		System.out.println("m="+ m +",n=" + n);//m=10,n=20

		
		System.out.println("*****引用数据类型*****");
		Order o1=new Order();
		o1.orderId=1001;
		
		Order o2=o1;
		System.out.println("o1=" + o1.orderId + ",o2=" + o2.orderId);//o1=1001,o2=1001
		
		o2.orderId=1002;
		System.out.println("o1=" + o1.orderId + ",o2=" + o2.orderId);//o1=1002,o2=1002

		
	}
}

class Order{
	int orderId;
}

2.方法的形参的传递机制:值传递

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

public class ValueTransferTest1 {
	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=10,n=20
		
		ValueTransferTest1 v1=new ValueTransferTest1();
		v1.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;

	}
}
class Data{
	int m;
	int n;
}

3.值传递机制的练习:

/*
 * （1）定义一个Circle类，包含一个double型的radius属性代表圆的半径，
 * 一个findArea()方法返回圆的面积
 */

public class Circle {
	double radius;//半径
		
	public double findArea() {
		return Math.PI * radius * radius;
	}
}

/*
（2）定义一个类PassObject，在类中定义一个方法printAreas()，
该方法的定义如下：public void printAreas(Circle c, int time)
在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。
例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。

（3）在main方法中调用printAreas()方法，调
用完毕后输出当前半径值。程序运行结果如图所示
 */

public class PassObject {
	public static void main(String[] args) {
		PassObject test=new PassObject();
		
		Circle c=new Circle();
		
		test.printAreas(c, 5);
		
		System.out.println(" now radius is " + c.radius);
	}
	
	public void printAreas(Circle c, int time) {
		System.out.println("Radius\t\tArea");
		for (int i = 1; i <= time; i++) {
			//设置圆的半径
			c.radius = i;
			System.out.println(c.radius + "\t\t" + c.findArea());
		}
		c.radius = time + 1;
	}
}

五.递归方法的使用

递归方法的使用(了解)

1.递归方法:一个方法体内调用了它自身
2.方法递归包含了一种隐式的循环,它会重复执行某段代码,但这种重复执行无须循环控制
递归一定要向已知方向递归,否则这种递归就变成了无穷递归,类似于死循环

public class RecursionTest {
	public static void main(String[] args) {
		

		//方式一:可以用for循环去写
		int sum=0;
		for (int i = 1; i <=100; i++) {
			sum+=i;
		}
		System.out.println("for循环:"+sum);//5050
		
		RecursionTest test=new RecursionTest();
		test.getSum(100);
		System.out.println("递归方法:"+test.getSum(100));//5050
		
		System.out.println("例题二:"+test.getRide(10));//3628800
		
		System.out.println("例题三"+test.f(10));//10497
	}
	
	
	//例一:计算1-n之间所有自然数的和
	//方式二:递归方法
	public int getSum(int n) {
		if (n == 1) {
			return 1;
		}else {
			return n+getSum(n-1);
		}
	}
	
	//例二:计算1-n之间所有自然数的乘积
	public int getRide(int n) {
		if (n==1) {
			return 1;
		}else {
			return n*getRide(n-1);
		}
	}
	
	
	/*例题三:已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
	其中n是大于0的整数，求f(10)的值*/
	public int f(int n) {
		if (n==0) {
			return 1;
		}else if (n==1) {
			return 4;
		}else {
			return 2*f(n-1) + f(n-2);
		}
	}
}

---