对于Java中方法、方法重载、方法递归的理解

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

#方法存在的意义：
1.是能够模块化的组织代码(当代码规模比较复杂的时候).
2.做到代码被重复使用, 一份代码可以在多个位置使用.
3.让代码更好理解更简单.
4.直接调用现有方法开发, 不必重复造轮子
#方法的语法结构

 // 方法定义
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

```c
##注意事项
1. public 和 static 两个关键字在此处具有特定含义, 我们暂时不讨论, 后面会详细介绍.
2. 方法定义时, 参数可以没有. 每个参数要指定类型
3. 方法定义时, 返回值也可以没有, 如果没有返回值, 则返回值类型应写成 void
4. 方法定义时的参数称为 "形参", 方法调用时的参数称为 "实参".
5. 方法的定义必须在类之中, 代码书写在调用位置的上方或者下方均可.
6. Java 中没有 "函数声明" 这样的概念.

 #方法调用规则
1、定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行.
2、当方法被调用的时候, 会将实参赋值给形参.
3、参数传递完毕后, 就会执行到方法体代码.
4、当方法执行完毕之后(遇到 return 语句), 就执行完毕, 回到方法调用位置继续往下执行.
5、一个方法可以被多次调用
 #方法重载
1、针对同一个类
2、方法名相同
3、方法的参数不同(参数个数或者参数类型)
4、方法的返回值类型不影响重载.

//代码示例
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;
}
}
class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
int ret = add(a, b);
System.out.println("ret = " + ret);
}
//当两个方法的名字相同, 参数也相同, 但是返回值不同的时候, 不构成重载.

#方法递归
递归采用分治的思想，分而治之，大事化小。
如果我们要利用递归算法，就要看程序是否要调用自身，那么我们就要找到两个条件：
1、一个使程序趋于终止的条件
2、递归公式

//如果没有终止条件，那么栈会溢出。因为方法的调用是在栈上开辟空间，而这个空间大小只有1-2M。

//递归是一种重要的编程解决问题的方式.
//有些问题天然就是使用递归方式定义的(例如斐波那契数列, 二叉树等), 此时使用递归来解就很容易.
//有些问题使用递归和使用非递归(循环)都可以解决. 那么此时更推荐使用循环, 相比于递归, 非递归程序更加高效.

#实例：递归求 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、代码简洁
 2、经常被用作复杂问题
 3、逻辑清晰
 缺点：
 1、会经常进行重复运算
 2、耗费内存
 3、栈上开辟内存，栈存在溢出可能
 4、不宜与思考问题