Java--方法的使用_。使用方法-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_74882234/article/details/144068650

前言:

在编程中,某段功能的代码可能频繁使用到,如果在每个位置都写一遍就会有以下问题:

使程序变得繁琐
开发效率低下，做了大量重复性的工作
不利于维护，需要改动时，所有用到该段代码的位置都需要修改
不利于复用

所以我们在编程中,可以将频繁使用代码封装成方法,使用时直接调用,就可以完全避免上面的问题,接下来通过几点来帮助大家掌握和使用Java中的方法.

1.方法的概念及使用

1.1 什么是方法 (method)

方法就是一个代码片段. 类似于数学中的 "函数"

是能够模块化的组织代码(当代码规模比较复杂的时候效果更显著).
直接调用现有方法开发,让一段代码被重复使用, 一段代码可以在多个位置使用.
让代码更好理解更简单.

1.2 方法定义

语法格式:

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

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

1.3 方法调用的执行过程【方法调用过程】

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

代码示例1:(计算两个整数相加)

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = 10;
        int b = 20;
        System.out.println("第一次调用方法之之前");
        int ret = add(a,b);
        System.out.println("第一次调用方法之之后");
        System.out.println("ret=" + ret);

        System.out.println("第二次调用方法之之前");
        ret = add(30,50);
        System.out.println("第二次调用方法之之后");
        System.out.println("ret=" + ret);
    }
    public static int add(int x,int y){
        System.out.println("调用方法中x="+ x + "y=" + y);
        return x + y;
    }
}

这个示例也验证了我们上面所说的几点

1.4实参(实际参数)与形参(形式参数)的关系

在Java方法中,形式参数是用来接收方法调用时传递过来的实际参数的一份拷贝,形式参数只是方法在定义时需要借助的一个变量,形参的名字可以任意,对方法没有影响.

上述例子中的 a 和 b 就是实际参数,

方法 add 中的 x 和 y 就是形式参数,对应着 a 和 b 的拷贝

代码示例2:(交换两个整型变量)

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("交换前a=" + a + "b=" + b);
        swap(a,b);
        System.out.println("交换后a=" + a + "b=" + b);
    }
    public static void swap(int x ,int y){
        int tmp = y;
        y = x;
        x = tmp;
        System.out.println("交换中x=" + x + "y=" + y);
    }
}

可以看到我们在方法中写的交换已经实现了,但是 a 和 b 的值并没有被交换,这是因为:

实参 a 和 b 是 main 方法中的两个变量，其空间在 main 方法的栈(一块特殊的内存空间)中，而形参 x 和 y 是 swap 方法中的两个变量，x 和 y 的空间在 swap 方法运行时的栈中，因此:实参 a 和 b 与形参 x 和 y 是两个没有任何关联性的变量， 在 swap 方法调用时，只是将实参a和b中的值拷贝了一份传递给了形参 x 和 y ，因此对形参x和y操作不会对实参 a 和 b 产生任何影响。

注意：对于基础类型来说, 形参相当于实参的拷贝. 即 传值调用

解决方法:传引用数据类型参数(例如数组来解决这个问题)

public class Test {
    public static void main(String[] args) {
        int[] arr = {10,20};
        System.out.println("交换前arr[0]=" + arr[0] + "  arr[1]=" + arr[1]);
        swap(arr);
        System.out.println("交换后arr[0]=" + arr[0] + "  arr[1]=" + arr[1]);
    }
    public static void swap(int[] arr){
        int tmp = arr[0];
        arr[0] = arr[1];
        arr[1] = tmp;
    }
}

执行结果:

可以看到两个数就交换成功啦

1.5没有返回值的方法

方法的返回值是可选的. 有些时候可以没有的，没有时返回值类型必须写成void,如代码示例2中的方法

2.方法重载

2.1为什么需要方法重载

我们来看一段代码

public class TestMethod {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a, b);
        System.out.println("ret = " + ret);

        double a2 = 10.5;
        double b2 = 20.5;
        double ret2 = add(a2, b2);
        System.out.println("ret2 = " + ret2);
    }

    public static int add(int x, int y) {
        return x + y;
    }
}

这段代码执行时,会出现编译错误,因为传入方法的参数与方法定义的参数类型不匹配

解决方法有很多种,比如说我们再定义一个方法叫做 addDouble ,可以,但不友好的地方是：需要提供许多不同的方法名.那我们能不能将所有的名字都改成 add 呢.

2.2方法重载概念

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

代码示例3:

public class Test {
    public static void main(String[] args) {
        add(1, 2);// 调用add(int, int)
        add(1.5, 2.5);// 调用add(double, double)
        add(1.5, 2.5, 3.5);// 调用add(double, double, double)
    }
    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;
    }
}

这段代码中,通过定义不同参数类型或者参数个数就可以实现一个名字多种方法,这就是方法重载.

注意事项:

方法名必须相同
参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)
与返回值类型是否相同无关

3.递归

3.1递归的概念

递归是方法的一种特殊使用方法,就是在方法中调用自己,就称为 "递归".

该种思想在数学和编程中非常有用，因为有些时候，我们遇到的问题直接并不好解决，但是发现将原问题拆分成其子问题之后，子问题与原问题有相同的解法，等子问题解决之后，原问题就迎刃而解了。

代码示例4:(通过递归,求1+2+3+...+10)

public class Test {
    public static void main(String[] args) {
        int a = sum(10);
        System.out.println(a);
    }
    public static int sum(int num){
        if(num == 1){
            return 1;
        }
        return num+sum(num-1);
    }
}

这段代码中,定义了一个方法sum,当进入方法中,会因为值并没有满足要求 ( num == 1 ),于是返回num+sum(num-1) ,但是这个返回中包含了 sum 方法,于是又进到这个方法中,根据题目要求,这次的值是上一次的 -1,通过这种方法,从一开始的10,不断的-1-1,直到==1时开始返回,每进入一次就会出来一次,每出来一次就会把计算的值加上给num,最后返回总和.

这就是递归的思想,通过将大问题拆分成小问题,再用方法进行不断的调用来完成任务.

感谢阅读,希望对您有帮助