Java —— 方法的使用

最新推荐文章于 2024-05-16 20:42:16 发布

玖汐」

最新推荐文章于 2024-05-16 20:42:16 发布

阅读量83

点赞数

分类专栏： JavaSE 文章标签： java 算法开发语言

本文链接：https://blog.csdn.net/yezh1yong_cr/article/details/133968681

版权

JavaSE 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

编程中, 某段功能的代码可能频繁使用到, 如果在每个位置都重新实现一遍, 会：
1. 使程序变得繁琐
2. 开发效率低下，做了大量重复性的工作
3. 不利于维护，需要改动时，所有用到该段代码的位置都需要修改
4. 不利于复用
因此，在编程中，我们也可以将频繁使用的代码封装成"方法"，需要时直接拿来链接(即方法名--方法的入口地址)使用即可，避免了一遍一遍的累赘。

1. 方法的概念及使用

1.1 什么是方法(method)

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

1. 是能够模块化的组织代码(当代码规模比较复杂的时候).

2. 做到代码被重复使用, 一份代码可以在多个位置使用.

3. 让代码更好理解更简单.

4. 直接调用现有方法开发, 不必重复造轮子.

在目前我们写方法的时候, 我们是这样写的:
开头为 public static这个是必须写的,
其次, 后续的样子为:
public static 返回值类型方法名(形式参数列表){
方法体;
}

public static void add(int a, int b) {
    System.out.println(a + b);
}

在上面这个例子当中, 和上面的语法形式都是对应的, 返回值是无返回类型void, 方法名为add, 形参列表可以有多个int a, int b, 方法体就是sout.

当我们运行的时候, 会发现什么都没有, 因为要执行方法需要调用.

完整代码:

public class Test {
    public static void add(int a, int b) {
        System.out.println(a + b);
    }

    public static void main(String[] args) {
        int x = 1;
        int y = 2;
        // 方法的使用, 将方法的名称写在这里, 通过 方法名() 调用, ()中写的参数是实际参数
        add(x, y);  // ()中的 个数和类型 需要和上面的 add() 一一匹配
    }
}

执行结果:

这就是Java中一个方法的调用过程.

注意本篇文章中的所有方法都必须加上 public static, 具体原因以后再说.

1.2 方法定义

方法语法格式

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

示例: 实现一个两个整数相加的方法

public class Test {
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int x = 1;
        int y = 2;
        int ret = add(x, y);
        System.out.println(ret);
    }
}

执行结果:
3

【注意事项】

1. 修饰符：现阶段直接使用public static 固定搭配

2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成void

3. 方法名字：采用小驼峰命名

4. 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开

5. 方法体：方法内部要执行的语句

6. 在java当中，方法必须写在类当中

7. 在java当中，方法不能嵌套定义

8. 在java当中，没有方法声明一说

到这里我们就清楚了: 为什么要定义方法? 方法由几部分组成?

1.3 方法调用的执行过程

方法调用过程

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

【注意事项】

定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行.
一个方法可以被多次调用.

1.4 实参和形参的关系

由于Java的方法和C语言的函数类似, 所以在这里省略该部分内容, 具体参考本人C语言函数博客.
http://t.csdnimg.cn/uz5la
以及传参过程:
http://t.csdnimg.cn/ugQr8

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

注意：在Java中，实参的值永远都是拷贝到形参中，形参和实参本质是两个实体

形参是实参的一份临时拷贝.

2. 方法重载

2.1 为什么需要方法重载

如果我们想求两个数的和, 会写出如下代码:

public class Test {

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

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

接下来我们的需求变了, 我们要求两个小数的和:

double d1 = 12.3;
double d2 = 12.5;
double ret2 = sum(d1, d2);
System.out.println(ret2);

那么能否直接把d1, d2传入上面的sum? 显然不行. 因为函数的调用需要满足类型, 个数都匹配, 而这是两个double类型, sum方法却是两个int类型的参数, 所以我们就要用别的方法.

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

// main方法改为:
double d1 = 12.3;
double d2 = 12.5;
double ret2 = sumDouble(d1, d2);
System.out.println(ret2);

到这里就会有一个问题, 如果要加其他类型的加法方法, 又得再多写一个方法, 又要重新命名, 这样就十分的麻烦, 那么Java中是支持两个方法的名字是相同的.

也就是说, 可以不用改名字, 方法名都为sum, IDEA并不会报错.

此时上述两个返回值为不同类型的sum方法就构成了方法的重载.

public class Test {

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

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

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

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

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

    public static void main22(String[] args) {
        int a = 10;
        int b = 20;
        int ret = sum(a, b);
        System.out.println(ret);

        double d1 = 12.3;
        double d2 = 12.5;
        double ret2 = sum(d1, d2);
        System.out.println(ret2);
    }

2.2 方法重载概念

在自然语言中，一个词语如果有多重含义，那么就说该词语被重载了，具体代表什么含义需要结合具体的场景。

在Java中方法也是可以重载的。

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

注意：

1. 方法名必须相同

2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)

3. 与返回值类型是否相同无关

对于使用者来说, 省略了很多记忆成本.

3. 递归

想象一下，你正在试图解决一个复杂的拼图游戏。这个拼图游戏由许多小块的拼图组成，每一块都代表了一部分图像。为了解决这个问题，你首先尝试找到拼图的边缘部分。这些边缘部分的拼图通常会有一些特殊的标记，如颜色或形状，这使得它们更容易从其他拼图中识别出来。
当你找到一块边缘拼图后，你会试图将其放入拼图的适当位置。然后，你可以看到拼图的其余部分是如何与此拼图配合的。一旦你正确地放置了第一块拼图，你可以用同样的方法来解决剩余的拼图。但是，如果没有正确的边缘拼图，你将不得不回到起点并重新开始搜索。
这个寻找和放置拼图的过程就是一个递归的过程。每次你找到一个新的边缘拼图并将其放置到正确的位置时，你都在减小问题的规模。通过递归地解决这个问题，你可以最终完成整个拼图。
在编程中，递归被广泛用于处理这种类型的问题。例如，你可以使用递归来遍历一个树形结构（如HTML文档）或解决一些需要分治策略的问题（如排序或搜索算法）。

有些时候，我们遇到的问题直接并不好解决，但是发现将原问题拆分成其子问题之后，子问题与原问题有相同的解法，等子问题解决之后，原问题就迎刃而解了。

3.1 递归的概念

一个方法在执行过程中调用自身, 就称为 "递归".

递归相当于数学上的 "数学归纳法", 有一个起始条件, 然后有一个递推公式.

例如, 我们求 N!
起始条件: N = 1 的时候, N! 为 1. 这个起始条件相当于递归的结束条件.
递归公式: 求 N! , 直接不好求, 可以把问题转换成 N! => N * (N-1)!

递归的必要条件：

1. 将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同

2. 递归出口

3.2 递归执行过程分析

    // 递归输出有序数字
    public static void function(int a) {
        if(a == 1) {
            System.out.println(a);
            return;
        }
        function(a-1);
        System.out.println(a);
    }

    public static void main(String[] args) {
        function(3);
    }

观察执行流程:

每次递归的时候, 这个函数只执行了一部分, 就去执行另一部分了;
归的时候, 会把当前方法的剩余部分执行完毕;
递的次数和归的次数是一样的.

汉诺塔问题

    /**
     * @param pos1 起始位置
     * @param pos2 中转位置
     * @param pos3 目标位置
     * @param n
     */
    public static void hanio(int n,char pos1,
                             char pos2,char pos3) {
        if(n == 1) {
            move(pos1,pos3);
            return;
        }
        hanio(n-1,pos1,pos3,pos2);
        move(pos1,pos3);
        hanio(n-1,pos2,pos1,pos3);
    }

    /**
     * @param pos1 起始位置
     * @param pos2 目标位置
     */
    public static void move(char pos1,char pos2) {
        System.out.print (pos1+" -> " + pos2+" ");
    }

测试一下:

    public static void main(String[] args) {
        hanio(1,'A','B','C');
        System.out.println();
        hanio(2,'A','B','C');
        System.out.println();
        hanio(3,'A','B','C');
    }