Java 方法的使用:
1.方法的基本用法:
1.1 方法—— 方法就是一个代码片段,类似于C语言的“函数”
方法存在的意义:
(1)能够欧模块化的组织代码;
(2)是代码得到可重用性提高;
(3)使读者更容易理解代码;
(4)可直接实现对方法的调用,不必多次写同功能的代码。
1.2方法定义语法:
//方法定义
public static 方法返回值 方法名称([参数类型 形参...]){
方法代码;
[return 返回值];
}
//方法调用
返回值变量 = 方法名称(实参...);
//举例1:——实现一个方法实现两个整数相加
//1.写方法——实现两个整数相加
public class Test {
//方法的定义
public static int Add(int num1,int num2){
return (num1 + num2);
}
public static void main(String[] args) {
int a = 3;
int b = 7;
//方法的调用
int ret = Add(a ,b);
System.out.println(ret);
}
}
(1)方法定义时,参数可以没有,每个参数要指定类型;
(2)方法定义时,返回值可以没有,如果没有返回值,则返回值类型要写成void;
(3)方法定义时的参数称为——形参,方法调用时的参数——实参
(4)方法的定义必须在类中,到吗书写在调用位置的上方或者下方均可。
1.3方法调用的执行过程
基本规则
(1)定义方法的时候,不会执行方法的代码,只有调用的时候才会执行;
(2)当你方法被调用的饿时候,会将实参赋值给形参;
(3)参数传递完毕后,就会执行到方法体代码;
(4)当方法执行完毕之后(遇到return语句),就执行完毕,回到方法调用位置继续往下执行;
(5)一个方法可以被多次调用。
举例2——计算两个整数相加
举例3——计算1! +2! +3! +4! + 5!
1.4实参和形参的关系
举例4:——交换两个变量
public class Test {
//2.实参和形参的关系——交换两个变量
public static void swap(int num1,int num2){
int tmp = num1;
num1 = num2;
num2 = tmp;
}
public static void main(String[] args) {
int a = 10;
int b = 20;
swap(a,b);
System.out.println("a = " + a+",b =" + b);
}
}
代码截图:
原因分析:——此代码并没有完成数据的交换
对于基础类型——形参相当于实参的拷贝——即传值调用
//观察可发现,对x 和y 的修改,不影响a 和 b
int a = 10;
int b = 20;
int x = a;
int y = b;
int tmp = x;
x = y;
y = tmp;
解决方法——传引用类型——例如数组来解决此问题
代码实现:
public class Test {
//3.实现数据的交换——传引用类型参数——如传数组
public static void swap(int[] arr){
int tmp = arr[0];
arr[0] = arr[1];
arr[1] = tmp;
}
public static void main(String[] args) {
int[] arr = {10,20};
swap(arr);
System.out.println("a = " + arr[0] + ",b =" + arr[1]);
}
}
结果截图:
1.5没有返回值的方法
方法的返回值是可选,有些时候可以没有返回值。
举例:
public class Test {
//4.方法是可以没有返回值类型的
public static void print(int x,int y){
System.out.println("x = " + x + ",y = " + y);
}
public static void main(String[] args) {
int a = 10;
int b = 20;
print(a,b);
}
}
结果截图:
2.方法的重载
2.1使用重载
举例1———实现各类型及个数数据的求和
代码实现:
public class Test {
//5.重载——同一个方法名字,参数类型几个数不同
public static int add(int x,int y){
return x + y;
}
public static double add(double x,double y){
return x + y;
}
public static double add(double x,double y,double z){
return x + y + z;
}
public static void main(String[] args) {
int a = 10;
int b = 20;
int ret = add(a,b);
System.out.println("ret = " + ret);
double a1 = 20.5;
double b1= 30.1;
double ret1 = add(a1,b1);
System.out.println("ret1 = "+ ret1);
double a2 = 20.3;
double b2 = 20.5;
double c2 = 23.1;
double ret2 = add(a2,b2,c2);
System.out.println("ret2 = "+ ret2);
}
}
结果截图:
2.2重载的规则
针对同一个类:
(1)方法名相同
(2)方法的参数不同(参数个数或者参数类型不同)
(3)方法的返回值类型不影响重载
3.方法递归
3.1方法递归的概念
一个方法在执行过程中调用本身——即递归——有一个起始条件,一个递推公式。
举例1——求n!——使用递归
代码实现:
public class Test {
//6.递归——求n!
public static int factor(int n){
if(n == 1){
return 1;
}
return n * factor(n - 1);//factor调用函数自身
}
public static void main(String[] args) {
int n = 5;
int ret = factor(n);
System.out.println("ret = " + ret);
}
}
结果截图:
调用栈——方法在调用的时候,会有一个“栈”这样的内存空间描述当前的调用关系。
每一次的方法调用就称为一个“栈帧”,每个栈帧包含了这次调用的参数是哪些,返回到哪里继续执行等信息。
3.2递归执行过程分析
举例:
代码实现:
public class Test {
//递归求n的阶乘分析
public static int factor(int n){
System.out.println("函数开始,n = " + n);
if(n == 1){
System.out.println("函数结束,n = 1 ret= 1");
return 1;
}
int ret;
ret = n * factor(n - 1);
System.out.println("函数结束,n = " + n + ",ret = " + ret);
return ret;
}
public static void main(String[] args) {
int n = 5;
int ret = factor(n);
System.out.println( "ret = "+ ret);
}
}
结果截图: