java方法，方法调用机制

article/2025/10/8 15:36:08

方法使用

public class Target1{public static void main(String[] args) {//方法使用Person jia = new Person();jia.speak();//调用方法jia.cal01();jia.cal02(5);//给n一个5；jia.cal02(10);int returnRes = jia.getSum(1,2);System.out.println("getSum方法返回的值="+returnRes);}
}
class Person{int age;String name;//1.public 表示方法是公开的，//2.void：表示方法没有返回值。//3.speak():speak是方法名，()形参列表//4.{}：方法体，可以写我们要执行的代码public void speak(){System.out.println("我是一个好人");}public void cal01(){int sum=0;for(int i=1;i<=1000;i++){sum+=i;}System.out.println("cal01的计算结果："+sum);}public void cal02(int n){//(int n)形参列表，表示当前有一个形参，可以接收用户输入int sum=0;for(int i=1;i<=n;i++){sum+=i;}System.out.println("cal02的计算结果："+sum);}//1.int:表示方法执行后，返回一个int值public int getSum(int a,int b){int res = a+b;return res;//表示把res值返回。//System.out.println(a+"+"+b+"的和为"+(a+b));}}

方法调用机制
方法调用小结
1. 当程序执行到方法时，就会开辟一个独立的空间（栈空间）。
2. 当方法执行完毕，或者执行到return语句时，就会返回。
3. 返回到调用方法的地方
4. 返回后，继续执行方法后面的代码
5. 当main方法（栈）执行完毕，整个程序退出。
成员方法的好处
1. 提高代码的复用性
2. 可以将实现的细节封装起来，然后供其他用户来调用即可。

返回数据类型

public class Method02{public static void main(String[] args) {addAndsub num = new addAndsub();int res[] = num.getSumAndSub(2,3);System.out.println("和："+res[0]);System.out.println("差："+res[1]);}
}class addAndsub{//1.一个方法最多有一个返回值//【思考，如何返回多个结果，返回数组】public int[] getSumAndSub(int n1,int n2){int arr[] = new int[2];arr[0] = n1+n2;arr[1] = n1-n2;return arr;}
}

如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return 值；二且要求返回值类型必须和return的值类型一致或兼容。
如果方法是void，则方法体中可以没有return语句，或者只写return；
方法名：getSum,驼峰命名法。

形参列表细节
1. 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开。
2. 参数类型可以为任意类型，包含基本类型或引用类型。
3. 调用参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数。
4. 方法定义时的参数称为形式参数，简称形参，方法调用时传入参数称为实际参数，简称实参。实参和形参的类型要一致或兼容，个数，顺序必须一致
5. 方法体里面不能在定义方法。方法不能嵌套定义。

方法调用细节说明

public class Method03{public static void main(String[] args) {A a = new A();//a.seeOk();//同一个类中的方法调用：直接调用即可。a.m1();}
}class A{public void print(int n){System.out.println("执行print()方法。n="+n);}public void seeOk(){print(10);System.out.println("执行完print()方法又回到seeOk");}//跨类中的方法A类调用B类方法：需要通过对象名调用。public void m1(){System.out.println("m1()方法被调用");//创建B类对象，然后调用方法即可。B b = new B();b.inBi();//========================System.out.println("又回到了A类中的m1方法。");}}
class B{public void inBi(){System.out.println("执行B类中的inBi方法。");}
}

成员方法传参机制（重要）

public class Method05{public static void main(String[] args) {int a = 1;int b = 2;change jia = new change();jia.swap(a,b);//基本数据类型传递的是值（值拷贝），形参的任何改变不影响实参。System.out.println(a+"\t"+b);//1       2}
}
class change{public void swap(int a,int b){System.out.println("交换前的a="+a+",b="+b);//交换前的a=1,b=2int temp = a;a = b;b = temp;System.out.println("交换后的a="+a+",b="+b);//交换后的a=2,b=1//这里只是修改的是swap栈里的a，b。//调用方法之后会开辟一块独立的空间。//mian和swap是两块独立的空间，} 
}

基本数据类型传递的是值（值拷贝），形参的任何改变不影响实参。

引用数据类型的传参机制

public class Method06{public static void main(String[] args) {B b = new B();int arr[] = {1,2,3,5};System.out.println(arr[0]);b.test100(arr);System.out.println(arr[0]);}
}
class B{public void test100(int arr[]){arr[0] = 200;System.out.println(arr[0]+"test100方法中");}
}
/*输出
1
200test100方法中
200*/

引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参。

类中的基本数据类型放在堆中，引用数据类型放在方法区
是把新开辟的test空间里的p的地址给赋null

练习，克隆

public class Method08{public static void main(String[] args) {//克隆，得到的新对象和原来的对象是两个独立的对象，//只是他们的属性相同。abb hang = new abb();Person jing = new Person();jing.name = "张晶";jing.age = 23;jing.weight = 100.9;Person zhang = hang.copyPerson(jing);//jing和zhang是两个独立的对象，只是属性相同。System.out.println("zhang的属性 age="+zhang.age);System.out.println("jing的属性 age="+jing.age);}
}class abb{public Person copyPerson(Person p){Person jia = new Person();jia.name = p.name;jia.age = p.age;jia.weight = p.weight;return jia;}
}
class Person{String name;int age;double weight;
}

方法递归调用
1. 递归调用机制
2. 执行一个方法时，就创建一个新的受保护的独立空间（栈空间）
3. 如果方法中使用的是引用类型变量（数组，对象），就会共享该引用类型的数据
4. 方法的局部变量是独立的，不会相互影响，比如n变量。
5. 递归必须向退出递归的条件逼近，否则就是无限递归。
6. 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。