目录
方法的重载(overload)
可变个数的形参
方法参数的值传递机制
基本数据类型的参数传递
引用数据类型的参数传递
递归(recursion)方法
总结
方法的重载(overload)
- 重载的概念 ：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数 类型不同即可。
- 重载的特点： 与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类 型)。调用时，根据方法参数列表的不同来区别。
//返回两个整数的和
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"});
}方法参数的值传递机制
方法，必须由其所在类或对象调用才有意义。若方法含有参数：
- 形参：方法声明时的参数
- 实参：方法调用时实际传给形参的参数值
Java
的实参值如何传入方法呢？
Java
里方法的参数传递方式只有一种：
值传递
。 即将实际参数值的副本 （复制品）传入方法内，而参数本身不受影响。
- 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
- 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
基本数据类型的参数传递
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);
}
}
}
