Java方法与递归

目录

 前言

1.什么是方法

2.语法的定义

3.方法调用的执行过程

 4.实参和形参的关系

5.没有返回值的方法

5.方法的重载

为什么会有方法的重载？

方法重载概念

5.递归 

 递归的概念

递归执行过程分析

递归练习 

---

 前言

     在我们日常在代码的过程中，会遇到有些情况会写大量重复的代码。这样我们的程序就会效率很低，做了大量重复的工作，不利于维护，不利于代码复用。

     因此，在编程中，我们可以将这些频繁使用的代码封装成一个“方法"，需要的时候直接拿方法名使用即可，避免了一遍一遍的去写代码，提升了开发效率。

1.什么是方法

方法就是一个代码片段，相当于c语言中的函数，方法存在的意义（肯定会深有体会）

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

那么方法是如何定义的呢？

2.语法的定义

方法的语法格式

修饰符 返回值类型 方法名称([参数类型 形参 ...]){
         方法体代码;
         [return 返回值];
}

【示例】 

实现一个函数，检查是否为闰年

实现一个两数相加的方法

public class Method{
    // 方法的定义
    public static int add(int x, int y) {
        return x + y;
    }
}

 【注意事项】

• 1.修饰符：现阶段直接使用public  static 固定搭配
• 2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成void
• 3. 方法名字：采用小驼峰命名
• 4. 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
• 5. 方法体：方法内部要执行的语句
• 6. 在java当中，方法必须写在类当中
• 7. 在java当中，方法不能嵌套定义
• 8. 在java当中，没有方法声明一说

3.方法调用的执行过程

【注意事项】 

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

一个方法可以调用多次

【示例】

计算1！+2！+3！+4！+5！

public static int fac(int n){
        System.out.print("计算"+n+"的阶乘中");
        int ret = 1;
        for (int i = 1; i <=n ; i++) {
            ret*=i;
        }
        System.out.println(ret);
        return ret;
    }
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <=5 ; i++) {
            sum+=fac(i);
        }
        System.out.println(sum);
    }

运行结果：

 4.实参和形参的关系

Java中方法的形参，是用来接收函数调用时传递的值的，形参的名字可以随意取，对方法没有任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值

比如说：

public static int add(int a, int b){
    return a + b;
} 
add(2, 3); // 2和3是实参，在调用时传给形参a和b

在Java中，形参是实参的一份临时拷贝，形参的实参本质上是两个实体。

如果我要交换两个整形变量

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

 运行结果

     可以看到，是不能完成交换的，形参x和y的值发生了改变，但是main方法中的a和b还是交换之前的值。 

【原因分析】

   实参是运行在mian方法的栈中，形参是运行在swap的栈中（在swap方法调用时，只是将实参a和b中的值拷贝了一份传递给了形参x和y），实参和形参是两个没有任何关联的东西，因此对形参进行操作不会对实参产生任何影响。

5.没有返回值的方法

方法的返回值是可以选择的，有些时候可以没有的，没有是返回值类型必须写成void

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

我们刚才那个swap函数就是没有返回值的。

5.方法的重载

为什么会有方法的重载？

    假设有一个场景，我们要多次使用add函数，但是使用的数据类型和参数不一样是，我们是不是就要重新定义一个add函数，又要提供很多不同的方法名，而取名字本来就是让人头疼的事情。那能否将所有的名字都给成 add 呢？

方法重载概念

            中国文化博大精深，有些词语会有多种意思，比如说“好人”，这个词语是不是有多种意思啊？ 一个词语如果有多重含义，那么就说该词语被重载了，具体代表什么含义需要结合具体的场景。在Java中方法也是可以重载的。

 在Java中，名字相同，参数列表不同，的方法就构成重载。

比如说：

  public static int add(int x, int y){
        return x+y;
    }
    public static int add(int x, int y,int z){
        return x+y+z;
    }
    public static double add(double x ,double y){
        return x+y;
    }
    public static void main(String[] args) {
        add(a,b);   //调用add（int int）
        add(a,b,c);  //调用add（int int int）
        add(a,b);    //调用add（double double）
    }

注意：

• 1. 方法名必须相同
• 2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)
• 3. 与返回值类型是否相同无关（两个方法如果仅仅只是因为返回值类型不同，是不能构成重载的）

编译器在编译代码时，会对实参类型进行推演，根据推演的结果来确定调用哪个方法

5.递归 

举一个小栗子就是我们小时候，会听的比较多的故事

从前有坐山，山上有座庙，庙里有个老和尚给小和尚将故事，讲的就是：
"从前有座山，山上有座庙，庙里有个老和尚给小和尚讲故事，讲的就是：
"从前有座山，山上有座庙..."
"从前有座山……"
 

    这个故事是不是没完没了？自身中又包含了自己，该种思想在编程中非常有用，因为有些时候，我们遇到的问题直接并不好解决，但是发现将原问题拆分成其子问题之后，子问题与原问题有相同的解法，等子问题解决之后，原问题就迎刃而解了。（相当于大事化小）

 递归的概念

一个方法在执行过程中调用自身, 就称为 "递归".
递归相当于数学上的 "数学归纳法", 有一个起始条件, 然后有一个递推公式
例如我们要求N！，我们是不是可以先求出N*（N-1）的阶乘

递归的必要条件：

• 1.将原问题划分成其子问题（大事化小）
•  2.递归出口（结束条件）

【示例】 

 递归求N的阶乘

  public static int fac(int n){
        if(n==1){
            return 1;
        }
        int tmp = n*fac(n-1);  //fac函数调用自身
        return tmp;
  }
  public static void main(String[] args) {
        int ret = fac(5);
        System.out.println(ret);
  }

递归执行过程分析

递归的程序执行过程不太容易理解，比较抽象，简单来说递归就两个过程：递推 + 回归 

我用一个代码来演示一下

如果我们要算N的阶乘，肯定要知道递推公式啊

由此得知我们得递推公式可以为：N * （N - 1） 

先看代码：

  public static int fac(int n){
        if(n==1){
            return 1;
        }
        int tmp = n*fac(n-1);  //fac函数调用自身
        return tmp;
  }
  public static void main(String[] args) {
        int ret = fac(5);
        System.out.println(ret);
  }

画图理解

 温馨提示：递归是一个非常抽象的东西，不可能一下子就学会了，要多画图，多思考，可以借助编译器的调试去理解。

递归练习 

 代码示例1 按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)

    public static void Print(int n){
        if(n<10){
            System.out.print(n+" ");
            return;
        }
        Print(n/10);
        System.out.print(n%10+" ");
    }
    public static void main(String[] args) {
        Print(1234);
    }

 代码示例2 递归求 1 + 2 + 3 + ... + 10

    public static int fun(int n){
        if(n == 1){
            return 1;
        }
        int sum = n+fun(n-1);
        return sum;
    }
    public static void main(String[] args) {
         int ret = fun(10);
        System.out.println(ret);
    }

代码示例3 写一个递归方法，输入一个非负整数，返回组成它的数字之和. 例如，输入 1729, 则应该返回1+7+2+9，它的和是19
 

    public static int  print(int n){
        if(n<10){
            return 1 ;
        }
        int sum = n%10+print(n/10);
        return sum;
    }

    public static void main(String[] args) {
       int ret = print(1729);
        System.out.println(ret);
    }

好啦！今天的文章就到这里了，如果喜欢记得点个赞，有问题打在评论区！

有时间我会出一期递归求汉诺塔！