java面向对象-----再谈方法

//返回两个整数的和
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;}

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

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

• 1. 声明格式：方法名(参数的类型名 ...参数名)
• 2. 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
• 3. 可变个数形参的方法与同名的方法之间，彼此构成重载
• 4. 可变参数方法的使用与方法参数部分使用数组是一致的
• 5. 方法的参数部分有可变形参，需要放在形参声明的最后
• 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 static void main(String[] args) {
int x = 5;
System.out.println("修改之前x = " + x);// 5
// x是实参
change(x);
System.out.println("修改之后x = " + x);// 5
}
public static void change(int x) {
System.out.println("change:修改之前x = " + x);
x = 3;
System.out.println("change:修改之后x = " + x);
}

 引用数据类型的参数传递

public static void main(String[] args) {
Person obj = new Person();
obj.age = 5;
System.out.println("修改之前age = " + obj.age);// 5
// x是实参
change(obj);
System.out.println("修改之后age = " + obj.age);// 3
}
public static void change(Person obj) {
System.out.println("change:修改之前age = " + obj.age);
obj.age = 3;
System.out.println("change:修改之后age = " + obj.age);
}
其中Person类定义为：
class Person{
int age; 
}

 递归(recursion)方法

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

//计算1-100之间所有自然数的和
public int sum(int num){
if(num == 1){
    return 1;
}else{
    return num + sum(num - 1);
    }
}

总结

/*
 ① 方法的重载（overload）
 定义：在同一个类中，允许存在一个以上的同名方法，只有他们的参数个数，
 或者参数类型不同
	“两同一不同” 同一个类，相同方法名 
				参数列表不同,参数个数不同，参数类型不同
 判断是否是重载
	跟方法的权限修饰，返回值类型，形参变量名，方法体都没有关系
 
 在通过对象调用方法时：如何确定某一个指定的方法
	方法名---》参数列表
 
 ② 可变个数形参的方法
	具体使用
		1.可变个数形参的格式，数据类型...变量名
		2.当调用可变个数形参的方法时，传入的参数个数 可以是 0个 1个 多个
		3.可变个数形参的方法与本类中方法名相同，形参不同的方法直接构成重载
		4.可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载
		5.可变个数形参的方法中，必须声明在末尾
		6.可变个数形参在形参方法中，最多声明一个可变形参
 
 ③ 关于变量的赋值
	如果变量是基本数据类型 此时赋值的是变量所保存的数据值
	如果变量是引用数据类型 此时赋值的是变量所保存的地址值
 
 ④ 方法形参的传递机制 ：值传递
	形参：方法定义时，声明在小括号内的参数
	实参：方法调用时，实际传递给形参的数据
	
	值传递机制
	如果参数是基本数据类型，实参赋给形参的是，实参真实存储的数据值
 ⑤ 递归方法 一个方法体内调用它自身
	方法递归包含了一种隐式的循环，他会重复的执行某段代码，但是这种重复是无需循环控制的
	递归一定要向指定方向递归，否则这种递归就造成了无穷递归 类似于死循环
	
 
*/
class instanceTest {
	public static void main(String[] args) {
		System.out.println("*****基本数据类型******");
		int m=10;
		int n=10;
		System.out.println("m="+m+",n="+n);
		n=20;
		System.out.println("m="+m+",n="+n);
		System.out.println("*****引用数据类型******");
		order o1=new order();
		o1.id=100;
		order o2=o1;
		System.out.println("o1.id="+o1.id+",o2.id="+o2.id);	
		o2.id=200;
		System.out.println("o1.id="+o1.id+",o2.id="+o2.id);	
		int[] arr=new int[]{5,8,4,7,0};
 
		// 形参的传递机制:基本数据类型
			order test=new order();
			test.swap(m,n);
			System.out.println("m="+m+",n="+n);
		// 形参的传递机制:复杂数据类型
		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]){
				test.swap2(arr,j,j+1);
				}
			}
		}
       //输出查看
		for(int i=0;i<arr.length;i++)	{
		      System.out.println(arr[i]);
		}
		int sum=test.sum(3);
		System.out.println(sum);
 
 
}
 
	//重载
	public void getSum(int i, int j){
		System.out.println(i+j);
	}
 
	public void getSum(String i, int j){
		System.out.println(i+j);
	}
	//可变个数形参的方法
	public void show(String ...strs){
		System.out.println("String ...strs");
	}
 
}
class order{
 int id;
 int m;
 int n;
 public void swap(int m,int n){
	int temp=m;
	m=n;
	n=temp;
 }
  public void swap2(int[] arr, int i,int j){
	int temp=arr[i];
	arr[i]=arr[j];
	arr[j]=temp;
 }
 public int sum( int n){
	if(n==1){
		 return 1;
	}else{
		//n=3+sum(2)
		//n=3+sum(1)
		//n=2+1=3
		//n=3+3=6
		return n+sum(n-1);
		}
	 }
}