方法的使用

牧..

已于 2023-02-01 16:05:01 修改

阅读量310

点赞数 14

分类专栏： java 文章标签： java jvm 开发语言

于 2022-08-02 16:30:56 首次发布

本文链接：https://blog.csdn.net/mu_tong_/article/details/126124911

版权

java 专栏收录该内容

16 篇文章 2 订阅

订阅专栏

文章目录

方法的使用
1.什么是方法
2.方法定义
方法调用的执行过程
方法重载
方法递归
- 递归求 N 的阶乘

方法的使用

1.什么是方法

举个例子：

有一天，老师布置作业，他将班长找来了办公室，跟班长讲了今天的作业，让班长传递，班长得到指

令，到班级上跟同学们说，今天的作业是什么，

他告诉了同学 A 然后告诉了同学 B ，这时班长就会重复做很多次（将作业内容一个一个告诉同学

们），班长心想这不要累死我，此时班长就将

作业写到了黑板上，这时就减少了重复将作业告诉大家只要同学看黑板即可。

这里就是方法的好处，将作业内容写到黑板上，减少了重复性的工作（一个一个告诉同学），这时班长

就可以干自己的事情，同学们看黑板就能够知道今天的作业是什么，而不是然班长一遍一遍的重复。

这里对于编程也是一样：

在编程中也是一样，某段功能的代码可能频繁使用到，如果在每个位置都重新实现一遍，会：

使程序变得繁琐

开发效率低下，做了大量重复性的工作

不利于维护，需要改动时，所有用到该段代码的位置都需要修改

不利于复用

因此，在编程中，我们也可以将频繁使用的代码封装成(方法)，需要时直接拿来(即方法名–方法的入口
地址)使用即可，避免了一遍一遍的累赘。

那么我们大致了解了方法，下面就来看一下概念。

方法就是一个代码片段. 类似于 C 语言中的 “函数” 。方法存在的意义:

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

了解了方法，直接来几个例题我们就能很好的了解方法。

2.方法定义

语法格式：

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

1.实现一个方法，检测一个年份是否为闰年

   // 使用 方法 判断 一个年份是否 为 闰年

    public static void main(String[] args) {
        int x = 2000;
        System.out.println(Examine(x));
    }
    public static boolean Examine(int x){
        if(x % 4 == 0 && x % 100 != 0 || x % 400 == 0){
            return true;
        }
        return false;
    }

可以我们就看到这里我们就完成了一个方法，判断 x 是否为闰年，这里相比与 c 语言，我们可以看到

Java 中的方法是没有声明的，这里就与 c 语言有区别在 java中是没有函数声明的概念，要用的时候直

接使用即可。

另外，我们传递的参数是形参， main 方法内的是实参， 形参相当于实参的一份拷贝，我们在 c 中

肯定，学过两种传参方式，方式一：按值传参（传值）方式二：按地址传参（传地址）而 java 中没有传

址的概念，只有传值，这里就只需要注意形参和实参的类型和个数是否匹配。

相比大家肯定有疑问如果没有传址那么我们想要交换变量如 a = 10 ， b = 20 变为 b = 10， a = 20，要如何改变呢？

下面我们就来看看 :

在这里插入图片描述

这里我们就创建了一个 swap 方法来交换 a 和 b ，那么这里我们能不能交换完成呢?

在这里插入图片描述

可以看到我们编译后，发现没有交换，其实这里就是按值传参，这时方法 swap 中的变量 a 和 b 是形参，形参的改变，不会影响实参，那么

这里到底如何改变呢？

方法一：通过数组：

方法二：通过对象（这里会在类和对象中讲到）。

这里两种方法其实都是传递对象，数组是引用类型，存放的是堆区的地址（一块空间），这里也是对象。

按照我们现在的知识储备还不能完成这道例题，这里我们就在留下一个坑，等到数组和类和对象在来填这个坑。

下面就来看一下方法的注意事项

【注意事项】

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

知道了方法的定义，那么我们来看一下方法的执行过程。

方法调用的执行过程

【方法调用过程】
调用方法—>传递参数—>找到方法地址—>执行被调方法的方法体—>被调方法结束返回—>回到主调方法继续往下

执行

如：

在这里插入图片描述

【注意事项】

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

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

方法只有调用时才能被执行：

public static int sum(int a, int b) {

    System.out.println("这里 执行 了 sum 方法");
    return a + b;

}

public static void main(String[] args) {
    int a = 10;
    int b = 20;
    System.out.println("hhhhhh");
}

在这里插入图片描述

可以看到没有调用 sum 方法 ,sum 就没有执行，

方法可以多次使用

    public static int sum(int a, int b) {

//        System.out.println("这里 执行 了 sum 方法");
        return a + b;

    }

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("第一次使用 sum 方法");
        int ret = sum(a,b);
        System.out.println(ret);
        System.out.println("第二次使用 sum 方法");
        int ret2 = sum(ret,a);
        System.out.println(ret2);
        System.out.println("第三次使用 sum 方法");
        int ret3 = sum(ret,b);
        System.out.println(ret3);
    }

在这里插入图片描述

方法其实也没多难，就是将可能多次使用的代码封装起来，需要使用的时候调用即可，下面我们来看一下方法的重载。

注意：重载这里我们需要留意一下，并不是多难，因为在类和对象中，会有一个重写，这里就容易被问道重载和重写的区别

方法重载

有些时候我们需要用一个函数同时兼容多种参数的情况, 我们就可以使用到方法重载

我们这里来看两张图片：

在这里插入图片描述

这里就很形象的说明了重载， “好人” 的两种状态。

这里我们假设一个场景，我们要相加两个整数，两个浮点类型，相加三个整数

  public static int sum(int a, int b) {
        return a + b;
    }

    public static double SomDouble(double a, double b) {
        return a + b;
    }

    public static int sum2(int a, int b, int c) {
        return a + b + c;
    }

这里我们可以定义三个方法，创建了三个方法名 sum， SumDouble , sum2, 可以发现本来就是一个简单的 a + b 或 a + b + c , 却写了 3 个方法名，如果在继续，是不是要写更多，这里我们就可以使用重载。

重载概念：在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了。

    public static int sum(int a, int b) {
        return a + b;
    }

    public static double sum(double a, double b) {
        return a + b;
    }

    public static int sum(int a, int b, int c) {
        return a + b + c;
    }

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        double f = 10.5;
        double e = 20.5;
        System.out.println(sum(a,b));
        System.out.println(sum(a,b,c));
        System.out.println(sum(f,e));
    }

在这里插入图片描述

这里就将 3 个方法名变为了一个。这就是方法的重载。

这里就需要记住：

方法重载的重点在于函数名要相同，参数个数或者类型要不同。（两者中必有一者不同）

而返回值不重要，只要你接收返回的值的类型是相匹配的就行，要不然无法进行赋值。

注意：

在这里插入图片描述

这我们看这两个 sum 除了返回值不同其他相同，这里就报错了，也更加验证了，返回值不重要，只要你接收返回的值的类型是相匹配的就行，要不然无法进行赋值。

重载总结：

方法名要相同

方法的参数不同（参数个数或者类型，两者选其一，或者都选，反正至少有一个因素是不同的）

方法的返回值类型不影响重载

当两个方法的名字相同, 参数也相同, 但是返回值不同的时候, 不构成重载

重载学完，那么我们了解一下递归，相比学过 c 的同学就听过递归吧，那么 java 同样可以，这里我们就来了解一下。

方法递归

递归的概念：一个方法在执行过程中调用自身, 就称为 “递归”.

递归相当于数学上的 “数学归纳法”, 有一个起始条件, 然后有一个递推公式递推公式是递归的重点，推出它，递归就很好写。

没推出。就。。。嗯~~~

在使用递归是我们要考虑递归的几个条件

将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同（大事化小 , 小事化了）
递归出口（递归的终止条件）

比如：我们求 N!

起始条件: N = 1 的时候, N! 为 1. 这个起始条件相当于递归的结束条件.

递归公式: 求 N! , 直接不好求, 可以把问题转换成 N! => N * (N-1)!

这里如果没有终止条件，我们的栈就会溢出。

如：

在这里插入图片描述

这我们就通过 func 一直调用自己，每次调用 func 都会在栈区开辟一块空间，这样永无止境的调用 func 就会一直开辟，直到栈被堆满，然后溢出报错。

下面就通过几个例题来了解一下递归。

递归求 N 的阶乘

求 N 的阶乘先来看一下迭代如何求解。

    public static void main(String[] args) {
        int n = 5;
        int ret = 1;
        for (int i = 1; i <= n; i++) {
            ret *= i;
        }
        System.out.println(ret);
    }

这里我们能的 ret 是不是通过 1 * 2 * 3 * 4 * 5 得出了 5 的阶乘，

那么递归差不多是反过来，传入参数 5 ，第一次 5 * 4 * 3 * 2 * 1 , 当 n == 1 是就是我们结束递归的终止条件，

递推公式也很好得到 n * func（n -1）

    public static int func(int n){
        if(n == 1){
            return n;
        }
        return n * func(n - 1);
    }

下面继续

题目二：按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)

这里我们想要打印 1 2 3 4 ，我们就可以通过：

这里要打印 4 只需要 1234 % 10 —》 4 ， 4 搞定了，我们要搞定 3 只需要 1234 / 10 == 123 就去掉了最后一位

同理 123 % 10 == 3 ， 123/10 = 12

12 % 10 = 2 , 12 / 10 = 1

这里我们就惊奇的发现，n 为个位数了这里终止条件，就是 n < 10 这时直接打印 n 即可，然后开始归。

        public static void  printf(int n){
            if(n < 10){
                System.out.print(n + " ");
                return;
            }
            printf(n / 10);
            System.out.printf(n % 10 + " ");
        }

题目三：递归求 1 + 2 + 3 + … + 10

这里递归求 1 + 到 10 ，也非常简单，我们只需要直到当 n = 1 是就为终止条件

   public static int sum(int n) {
        if (n == 1) {
            return n;
        }
        return n + sum(n - 1);
    }

题目四：写一个递归方法，输入一个非负整数，返回组成它的数字之和

. 例如，输入 1729, 则应该返回 1+7+2+9，它的和是19

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

题目五：求斐波那契数列的第 N 项

 public static int fib(int n) {
        if (n == 1 || n == 2) {
            return 1;
        }
        return fib(n - 1) + fib(n - 2);
    }

因为递归回重复计算多次 n - 1 和 n -2 ，这里建议使用迭代写斐波那契数列


    public static void main(String[] args) {
        int a = 1;
        int b = 1;
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for (int i = 3; i <= n; i++) {
            int c = a + b;
            a = b;
            b = c;
        }
        System.out.println(b);
    }