java的方法即函数

• 一、方法的基本用法
• • 1、方法语法
  • 2、实参与形参的基本关系
  • 3、没有返回值的方法
• 二、方法的重载
• • 什么是方法的重载
  • 2、 重载的规则
• 三、 方法递归
• • 1、 什么是递归;
  • 2、执行过程图解
  • 3、 调用栈

• 方法就是一个代码片段. 类似于 C 语言中的 "函数"

// 方法定义
public static 方法返回值 方法名称（[参数类型 形参 ...]){
 方法体代码;
 [return 返回值];
}
// 方法调用
返回值变量 = 方法名称(实参...);

• 水仙花数

在这里插入代码片

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

class Test {
 public static void main(String[] args) {
 int a = 10;
 int b = 20;
 System.out.println("第一次调用方法之前");
 int ret = add(a, b);
 System.out.println("第一次调用方法之后");
 System.out.println("ret = " + ret);
 System.out.println("第二次调用方法之前");
 ret = add(30, 50);
 System.out.println("第二次调用方法之后");
 System.out.println("ret = " + ret);
 }
 public static int add(int x, int y) {
 System.out.println("调用方法中 x = " + x + " y = " + y);
 return x + y;
 }

• Java中由于没有“指针”，所以形参只能相当于实参的拷贝. 即 传值调用
• 但如果需要“址”调用时，该如何？例如，交换变量
• 此时可用数组，数组也是相当于一种指针，即传引用类型参数如下，交换两个整形

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;
 }
}

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

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);
 }
}

• 当一个函数同时兼容多种参数的情况, 我们就可以使用到方法重载
• 什么是重载呢？
  即用一个函数调用多种不同类型的参数，例如

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但是有的add是计算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);
 }
 public static int add(int x, int y) {
 return x + y;
 }
 public static double add(int x, int y) {
 return x + y;
 }
}
//会导致编译错误；
因为参数的类型相同了，所以不构成重载。

• 一个方法在执行过程中调用自身, 就称为 “递归”.
  递归相当于数学上的 “数学归纳法”, 有一个起始条件, 然后有一个递推公式.
  例如:求 N!
  起始条件: N = 1 的时候, N! 为 1. 这个起始条件相当于递归的结束条件.
  递归公式: 求 N! , 直接不好求, 可以把问题转换成 N! => N * (N-1)。

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

• 方法调用的时候, 会有一个 “栈” 这样的内存空间描述当前的调用关系. 称为调用栈.