复习_方法和包

1.为什么要使用方法？
达到代码的复用，让代码更加清晰简单，直接调用现有的方法，不必重复造轮子
代码示例: 计算 1! + 2! + 3! + 4! + 5!

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

2.形参和实参的关系

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

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

以上代码并没有完成两个值的交换，原因：
对于基础类型来说，形参相当于实参的拷贝，即，传值调用

解决办法：传引用类型参数（比如数组）

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

3.方法的重载：同一个方法名字，提供不同版本的实现
代码示例：使用重载达到对int类型和对double类型的数值求和

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); 
 double a3 = 10.5; 
 double b3 = 10.5; 
 double c3 = 20.5; 
 double ret3 = add(a3, b3, c3); 
 System.out.println("ret3 = " + ret3); 
 }
 //以下三个方法名字都是add，只是参数不同（个数，类型），返回值类型不同
 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; 
 } 
}

重载的规则：

• 方法名相同
• 参数类型不同（参数个数，参数类型）
• 方法返回值类型不同
• 当两个方法名字相同，参数相同，但返回值类型不同时，不构成重载

4.方法递归
一个方法在执行的过程中调用自身，称为递归
递归执行的过程分析

代码示例: 递归求 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) { 
 System.out.println("函数开始, n = " + n); 
 if (n == 1) { 
 System.out.println("函数结束, n = 1 ret = 1"); 
 return 1; 
 } 
 int ret = n * factor(n - 1); 
 System.out.println("函数结束, n = " + n + " ret = " + ret); 
 return ret; 
}
// 执行结果
函数开始, n = 5 
函数开始, n = 4 
函数开始, n = 3 
函数开始, n = 2 
函数开始, n = 1 
函数结束, n = 1 ret = 1 
函数结束, n = 2 ret = 2 
函数结束, n = 3 ret = 6 
函数结束, n = 4 ret = 24 
函数结束, n = 5 ret = 120 
ret = 120

执行过程图：

程序按1—>8执行