[Java知识库] Java基础之方法的调用、重载以及简单的递归

int sum = 0;
for (int i = 1; i <= 5; i++) {
 ? ?int tmp = 1;
 ? ?for (int j = 1; j <= i; j++) {
 ? ? ? ?tmp *= j;
 ? }
 ? ?sum += tmp; }
System.out.println("sum = " + sum);

这个代码运用的嵌套，容易写错，接下里通过方法来优化代码。

class Test {
 public static void main(String[] args) {
 int sum = 0;
 for (int i = 1; i <= 5; i++) {
 sum += factor(i);
 }
 System.out.println("sum = " + sum);
 }
 public static int factor(int n) {
 System.out.println("计算 n 的阶乘中! n = " + n);
 int result = 1
for (int i = 1; i <= n; i++) {
 result *= i;
 }
 return result;
 }
}
// 执行结果
计算 n 的阶乘中! n = 1
计算 n 的阶乘中! n = 2
计算 n 的阶乘中! n = 3
计算 n 的阶乘中! n = 4
计算 n 的阶乘中! n = 5
sum = 153

1.2 方法调用过程

定义方法的时候 , 不会执行方法的代码 . 只有调用的时候才会执行 .

当方法被调用的时候 , 会将实参赋值给形参 .

参数传递完毕后 , 就会执行到方法体代码 .

当方法执行完毕之后 ( 遇到 return 语句 ), 就执行完毕 , 回到方法调用位置继续往下执行 .

// 方法定义

public static 方法返回值方法名称（ [ 参数类型形参 ...]){

方法体代码 ;

[ return 返回值 ];

}

// 方法调用

返回值变量 = 方法名称 ( 实参 ...);

class Test {

public static void main ( String [] args ) {

int a = 10 ;

int b = 20 ;

? ? ? ?

? ? ? ? // 方法的调用

int ret = add ( a , b );

System . out . println ( "ret = " + ret );

}

? ? // 方法的定义

public static int add ( int x , int y ) {

return x + y ;

}

// 执行结果

ret = 30

一个方法可以被多次调用 .

1.3 形参和实参的关系

代码示例 : 交换两个整型变量

class Test {
 public static void main(String[] args) {
 int a = 10;
 int b = 20;
 swap(a, b);
 System.out.println("a = " + a + " b = " + b);
 }
 public static void swap(int x, int y) {
 int tmp = x;
 x = y;
 y = tmp;
 }
}
// 运行结果
a = 10 b = 20

原因分析

刚才的代码 , 没有完成数据的交换 .

对于 基础类型 来说 , 形参相当于实参的拷贝. 即 传值调用

int a = 10;
int b = 20;
int x = a;
int y = b;
int tmp = x; x = y; y = tmp;

可以看到 , 对 x 和 y 的修改 , 不影响 a 和 b.

解决办法 : 传引用类型参数 ( 例如数组来解决这个问题 )

class Test {
 public static void main(String[] args) {
 int[] arr = {10, 20};
 swap(arr);
 System.out.println("a = " + arr[0] + " b = " + arr[1]);
 }
 public static void swap(int[] arr) {
 int tmp = arr[0];
 arr[0] = arr[1];
 arr[1] = tmp;
 }
}
// 运行结果
a = 20 b = 10

1.4? 没有返回值的方法

方法的返回值是可选的 . 有些时候可以没有的 .

代码示例

class Test {
 public static void main(String[] args) {
 int a = 10;
 int b = 20;
 print(a, b);
 }
 public static void print(int x, int y) {
 System.out.println("x = " + x + " y = " + y);
 }
}

另外 , 如刚才的交换两个整数的方法 , 就是没有返回值的 .

2. 方法的重载

有些时候我们需要用一个函数同时兼容多种参数的情况 , 我们就可以使用到方法重载 .

2.1 重载要解决的问题

代码示例

class Test {
 public static void main(String[] args) {
 int a = 10;
 int b = 20;
 int ret = add(a, b);
 System.out.println("ret = " + ret);
 double a2 = 10.5;
 double b2 = 20.5;
 double ret2 = add(a2, b2);
 System.out.println("ret2 = " + ret2);
 }
 public static int add(int x, int y) {
 return x + y;
 }
}
// 编译出错
Test.java:13: 错误: 不兼容的类型: 从double转换到int可能会有损失
 ? ? ? ? ? ? ? ?double ret2 = add(a2, b2);
 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?^

由于参数类型不匹配 , 所以不能直接使用现有的 add 方法

那么是不是应该创建这样的代码呢 ?

代码示例

class Test {
 public static void main(String[] args) {
 int a = 10;
 int b = 20;
 int ret = addInt(a, b);
 System.out.println("ret = " + ret);
 double a2 = 10.5;
 double b2 = 20.5;
 double ret2 = addDouble(a2, b2);
 System.out.println("ret2 = " + ret2);
 }
 public static int addInt(int x, int y) {
 return x + y;
 }
 public static double addDouble(double x, double y) {
 return x + y;
 }
}

这样的写法是对的 ( 例如 Go 语言就是这么做的 ), 但是 Java 认为 addInt 这样的名字不友好 , 不如直接就叫 add

2.2 使用重载

代码示例

 public static void main(String[] args) {
 int a = 10;
 int b = 20;
 int ret = add(a, b);
 System.out.println("ret = " + ret);
 double a2 = 10.5;
 double b2 = 20.5;
 double ret2 = add(a2, b2);
 System.out.println("ret2 = " + ret2);
 double a3 = 10.5;
 double b3 = 10.5;
 double c3 = 20.5;
 double ret3 = add(a3, b3, c3);
 System.out.println("ret3 = " + ret3);
 }
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;
 }
}

方法的名字都叫 add. 但是有的 add 是计算 int 相加 , 有的是 double 相加 ; 有的计算两个数字相加 , 有的是计算三个数

字相加 .

同一个方法名字 , 提供不同版本的实现 , 称为 方法重载

2.3 重载的规则

针对同一个类 :

方法名相同

方法的参数不同 ( 参数个数或者参数类型 )

方法的返回值类型不影响重载

3. 方法递归

3.1 递归的概念

一个方法在执行过程中调用自身 , 就称为 " 递归 ".

递归相当于数学上的 " 数学归纳法 ", 有一个起始条件 , 然后有一个递推公式 .

例如 , 我们求 N!

起始条件 : N = 1 的时候 , N! 为 1. 这个起始条件相当于递归的结束条件 .

递归公式 : 求 N! , 直接不好求 , 可以把问题转换成 N! => N * (N-1)！

代码示例：递归求n的阶乘

public static void main(String[] args) {
 ? ?int n = 5;
 ? ?int ret = factor(n);
 ? ?System.out.println("ret = " + ret);
}
public static int factor(int n) {
 ? ?if (n == 1) {
 ? ? ? ?return 1;
 ? }
 ? ?return n * factor(n - 1); // factor 调用函数自身
}
// 执行结果
ret = 120

注：初来乍到，才疏学浅，如有不当之处，多多指教，我自己也会坚持学习，期待更好的自己！

[Java知识库]Java基础之方法的调用、重载以及简单的递归