【JAVA】 第五期——方法

标签：JAVA 递归 int 第五期 System static 方法 public

文章目录

• 1. 方法的概念及使用
• • • 1.1 什么是方法
    • 1.2 方法的定义
    • 1.3 方法调用的执行过程
    • 1.3 实参和形参
    • • 1.3.1 实参将数据传递给形参的方式
  • 2. 方法重载
  • 2. 递归

Hello小伙伴们！我们又见面了，本期我们将学习JAVA中 方法的使用，希望对你有所帮助。

1. 方法的概念及使用

1.1 什么是方法

方法是程序中的一个代码片。那方法有什么存在的意义呢？

1. 是能够模块化的组织代码；
2. 是代码能够被重复使用，且能够在多个位置使用；
3. 让代码更好理解更简单；
4. 直接调用现有方法开发，不必重复编写；

1.2 方法的定义

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

代码示例： 编写一个函数，检测输入的年份是否位闰年

    public static boolean isLeapYear(int year) {
        if (year%400==0 ||(year%4==0 &&year%100!=0)) {
            return true;
        }else{
            return false;
        }
    }
    public static void main(String[] args) {
        System.out.println("请输入数字：");
        Scanner scanner = new Scanner(System.in);
        int year = scanner.nextInt();
        if (isLeapYear(year)) {
            System.out.println(year+"年是闰年");
        }else {
            System.out.println(year+"不年是闰年");
        }
    }

注意：

• 如果在定义方法时有返回值，那么返回值类型必须要与返回的实体类型一致，如果没有返回值，返回值类型必须写成void；
• 方法名一般建议用小驼峰命名；
• 如果方法中没有参数，（）中什么都不写，如果有参数需要指定参数类型，多个参数间使用逗号隔开；
• 在JAVA中，方法必须写在类当中，且不能嵌套定义，而且JAVA中没有声明一说；
• 定义方法的时候不会执行方法的代码。只有调用的时候才会执行
• 一个方法可以被多次调用

1.3 方法调用的执行过程

【方法调用过程】：
调用方法----->传递参数----->找到方法地址----->执行被调方法的方法体----->被调方法结束返回----->回到主调方法继续向下执行
代码示例： 两数相加

//两数相加
    public static  int add(int a,int b) {
        System.out.println("调用方法中x = "+a+",y = "+b);
        return a + b;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a,b);
        System.out.println(ret);
    }

1.3 实参和形参

形参： 是指在定义函数时使用的参数，目的是用于接收调用该函数时传入的参数。简单理解，就是所有函数（即方法）的参数都是形参。
实参： 在调用有参函数时，主调函数和被调函数之间有数据传递关系。在主调函数中调用一个函数时，函数名后面括号中的参数称为“实际参数”。

1.3.1 实参将数据传递给形参的方式

1. 按值传递
2. 按引用传递

按值传递：指在调用函数时，将实际参数复制一份传递给函数，在函数中修改参数时，不会影响到实际参数。简单的来说，按值传递时，实参和形参本质来说是两个实体。
代码示例：交换两个整形变量

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

你会发现，swap函数将a，b，两个变量的值交换后，形参中的a，b值发生了变化
但是main 函数中的a，b量变量的值并没有发生变化。

解决办法：按引用传递

按引用传递：是指在调用函数时，将实际参数的地址传递给函数，这样在函数中对参数的修改，将影响到实际参数。

在以下实例中，我们以数组来解决办法：

    //引用数据类型解决交换两值
    public static void swap(int[] arr) {
        int temp = arr[0];
        arr[0] = arr[1];
        arr[1] = temp;
    }
    public static void main(String[] args) {
        int[] arr = {10,20};
        System.out.println("调用swap前：arr[0] = " + arr[0]+",arr[1] = " + arr[1]);
        swap(arr);
        System.out.println("调用swap前：arr[0] = " + arr[0]+",arr[1] = " + arr[1]);
    }

2. 方法重载

在JAVA中，如果多个方法的名字相同，参数列表不同（参数的个数不同、参数的类型不同、类型的次序不同），则称该机种方法被重载了。编译器在编译代码时，会对参数类型进行推演，根据推演的结果来决定调用哪个方法。

注意：

如果两个方法仅仅是参数类型不同，是不能构成方法重载的；
与返回值类型是否相同无关；

    public static  int add(int a,int b) {
        System.out.println("调用方法中x = "+a+",y = "+b);
        return a + b;
    }
    public static  double add(double a,double b) {
        System.out.println("调用方法中x = "+a+",y = "+b);
        return a + b;
    }
    public static  double add(double a,double b,double c) {
        System.out.println("调用方法中x = "+a+",y = "+b);
        return a + b + c;
    }
    public static void main(String[] args) {
        add(1,2);
        add(1.5,2.5);
        add(1.5,2.5,3.5);
    }

方法签名：
经过编译器编译修改过之后方法最终的名字。具体方式： 方法全路径名 + 参数列表 + 返回值类型来构成一个方法完整的名字。

2. 递归

一个方法在执行过程中调用自身，称“ 递归 ”。

递归在解决这些问题时，能够简化代码逻辑，提高代码的可读性和可维护性。

递归的应用场景：

• 数学问题：如计算阶乘、斐波那契数列等。
• 数据结构操作：如遍历树的节点、链表反转等。
• 搜索和回溯算法：如深度优先搜索、回溯法等。
• 分治法：如归并排序、快速排序等。

递归的必要条件：

1. 终止条件：定义递归结束的条件，避免陷入无限循环。
2. 递归调用：在方法的定义中调用自身，处理更小规模的子问题。

代码示例：递归实现 n 的阶乘

    //递归实现n的阶乘
    public static int fun(int n) {
        if(n == 1) {
            return 1;
        }else {
            return n*fun(n-1);
        }
    }
    public static void main(String[] args) {
        System.out.println("请输入数字：");
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = fun(n);
        System.out.println(ret);
    }

当我们输入n=5时，执行效果大致为下图：

递归优点：

• 简化问题：递归能够将复杂问题分解成更小子问题，简化了问题的解决过程。
• 提高代码了可读性：递归能够更为直观地表达问题解决的思路，提高了代码的可读性。
• 实现高效算法：递归在一些算法中能够实现高效的解决方法。
  递归缺点
• 栈溢出风险：递归可能导致方法调用栈过深，造成栈溢。
• 性能损耗：递归调用需要创建多个栈帧，对系统资源有一定的消耗。
• 可能造成代码难以理解：递归的使用需要谨慎，过度使用可能使代码难以理解和调试。

如果一段代码需要重复使用很多次（几万、千万次），这是就不建议使用递归了。

好了那下面我们一起来练习一下递归的使用吧！

代码示例1：按顺序打印一个数的每一位

   //递归按顺序打印一个数的每一位
    public static void print(int num){
        if (num>9)
            print(num/10);
        System.out.println(num%10);
    }
    public static void main(String[] args) {
        int num = 1234;
        print(num);
    }

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

    //递归求1 + 2 + 3 + .....+ 10
    public static int sun(int num){
        if(num == 1)
            return 1;
        return num + sun(num-1);
    }

代码示例3：写一个递归方法，输入一个非负整数，返回组成它的数字之和

    public static int sum(int num){
        if (num<10)
            return num;
        return num%10 + sum(num/10);
    }

好啦，本期我们对于方法的学习就到这里

如果这篇文章有帮到你的话记得三连呀！

我们下期再见！

标签：JAVA,递归,int,第五期,System,static,方法,public
From： https://blog.csdn.net/m0_71834203/article/details/143255007