Java中的方法详解——初学者也能玩明白

傷城~ 2024-03-23 12:23 70阅读 0赞

## Java中的方法详解 ##

### 一、什么是方法？ ###

**方法就是一个代码片段. 类似于 C 语言中的 “函数”。方法存在的意义(不要背, 重在体会):**

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

**比如写一个打印函数：**

![在这里插入图片描述][2c3180244c26441791583cea63dc4bc6.png_pic_center]

**那么方法该如何定义呢？**

### 二、方法的定义 ###

#### 1.方法定义格式 ####

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

**示例1：实现判断一个年份是否是闰年**

public class Test {
        
        public static boolean judgeLeap (int year) {
        
            if((0 == year % 4 && 0 != year % 100) || 0 == year % 400) {
        
                return true;
            } else {
        
                return false;
            }
        }
        public static void main(String[] args) {
        
            System.out.println("请输入一个年份：");
            Scanner scanner = new Scanner(System.in);
            int year = scanner.nextInt();
            System.out.println(judgeleap(year));
        }
    }

**示例二：实现两个数相加**

public class Test {
        
        public class static int add (int num1,int num2) {
        
            int sum = num1 + num2;
            return sum;
        }
        public static void main(String[] args) {
        
            int num1 = 10;
            int num2 = 20;
            System.out,println(Add(a,b));
        }
    }

#### 2.注意事项 ####

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

#### 3. 方法调用的执行过程 ####

**（1）方法调用过程**

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

public class Test {
        
        public static int add (int n1,int n2) {
        
            System.out.println("调用方法中 n1 = " + n1 + " n2 = " + n2);
            return n1 + n2;
        }
        public static void main (String[] args) {
        
            int num1 = 10;
            int num2 = 20;
            int num3 = 30;
            int num4 = 40;
            System.out.println("第一次调用方法之前");
            add(num1,num2);
            System.out.println("第一次调用方法之后");
            System.out.println("ret = " + ret);
            
            add(num3,num4);
            System.out.println("第二次调用方法之前");
            add(num3,num4);
            System.out.println("第二次调用方法之后");
            System.out.println("ret = " + ret);
        }
    }
    
    //执行的结果
      第一次调用方法之前
      调用方法中 n1 = 10 n2 = 20
      第一次调用方法之后
      ret = 30
          
      第二次调用方法之前
      调用方法中 n1 = 30 n2 = 40
      第二次调用方法之后
      ret = 70

**【注意事项】**

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

#### 4.形参和实参的关系 ####

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

public static int add (int n1,int n2) {
        
        //n1和n2就是形参
        return n1 + n2;
    }
    
    add(num1,num2);//num1和num2就是实参，在方法被调用时，形参n1用来保存num1的数值，形参n2用来保存num2的数值

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

**代码示例：交换两个数的值**

public class Test {
        
        public static void swap (int num1,int num2) {
        
            int tmp = num1;
            num1 = num2;
            num2 = tmp;
            System.out.println("swap: num1 = " + num1 +"num2 = " + num2;
        }
        public static void main(String[] args) {
        
            int a = 10;
            int b = 20;
            swap(a, b);
            System.out.println("main: a = " + a + " b = " + b);
        }
    }
    
    //运行结果
    //swap:num1= 20num2 = 10
    //main:a = 10b = 20

**可以看到，在swap函数交换之后，形参x和y的值发生了改变，但是main方法中a和b还是交换之前的值，即没有交**  
**换成功。**

**原因：**

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

**解决方法：可用数组来解决此问题**

public class TestMethod {
        
        public static void swap(int[] arr) {
        
            int tmp = arr[0];
            arr[0] = arr[1];
            arr[1] = tmp;
    }
        public static void main(String[] args) {
        
            int[] arr = {
        10, 20};
            swap(arr);
            System.out.println("arr[0] = " + arr[0] + " arr[1] = " + arr[1]);
        }
    }
    
    // 运行结果
    arr[0] = 20 arr[1] = 10

**关于这个代码的运行过程, 后面学习数组的时候再详细解。**

#### 5.没有返回值的方法 ####

**关于方法返回值的有无是可以自己选择的，没有返回值的方法写成void。**

**代码示例：**

public class Test {
        
        public static void Print (int a) {
        
            System.out.println(a);
        }
        public static void main (String[] args) {
        
            int a = 10;
            Print(a);
        }
    }
    
    //此代码就没有返回值，

#### 6.带返回值的方法和调用 ####

**关于带返回值的方法，类型根据返回值类型确定。**

**代码示例：**

public class Test {
        
        public static int Sum (int num1,int num2,int num3) {
        
            int result = num1 + num2 + num3;
            retuirn result;
        }
        public static void main (String[] args) {
        
            //直接调用
            getSum(10,20,30);
            
            //赋值调用
            int sum = getSum(10,20,30);
            System.out.println(sum);
            
            //输出调用
            System.out.println(getSum(10,20,30));
        }
    }

#### 7.方法的重载 ####

> **概念：在同一个类中，定义了多个同名的方法，这些同名的方法具有相同的功能，且每一个方法具有不同的参数或者参数个数不同，这些同名的方法构成了重载关系。**

**简单记忆：在同一个类中，方法名称相同，参数（个数，类型，顺序）不同的方法，与返回值无关。**

**示例代码一：**

public static int sum (int a,int b) {
        
        return a + b;
    }
    public static int sum (int a,int b,int c) {
        
        return a + b + c;
    }
    
    //构成重载关系，以为个数不一样

**示例代码二：**

public static void func (int a) {
        
        //方法体
    }
    public static int func (int a) {
        
        //方法体
    }
    
    //不构成重载关系，因为参数都一样，不用管返回值！

**示例代码三：**

public static float func (int a) {
        
        //方法体
    }
    public static int func (int a,int b) {
        
        //方法体
    }
    
    //构成重载，因为参数个数不同

**示例代码四：**

public class Test1 {
        
        public static void func (int a) {
        
            //方法体
        }
    }
    
    public class Test2 {
        
        public static int func (double b) {
        
            //方法体
        }
    }
    
    //不构成重载关系，因为分别在两个类中

**【注意事项】**

*  **方法名必须相同。**
 *  **参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)。**
 *  **与返回值类型是否相同无关。**
 *  **编译器在编译代码时，会对实参类型进行推演，根据推演的结果来确定调用哪个方法。**

#### 8.方法中的签名 ####

**方法签名，是来区分不同方法的标示符。**

**Java方法签名包括两部分：方法名和参数列表。**

**方法名不同或者参数列表不同都可以用来区分不同的方法。**

> **具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。**

**Java中就是根据此来判断应该调用哪一个函数的。**

**示例代码：**

public class TestMethod {
        
      public static int add(int x, int y){
        
        return x + y;
     }
      public static double add(double x, double y){
        
        return x + y;
     }
      public static void main(String[] args) {
        
        add(1,2);
        add(1.5, 2.5);
     }
    }

**上述代码经过编译之后，然后使用JDK自带的javap反汇编工具查看，具体操作：**

1.  **先对工程进行编译生成.class字节码文件**
2.  **在控制台中进入到要查看的.class所在的目录**
3.  **输入：javap -v 字节码文件名字即可**

### 三、递归 ###

#### 1.概念 ####

**一个方法在执行过程中调用自身，就称为递归。**

**示例代码: 用递归求N的阶乘**

public class Test {
        
        public static int fac (int n) {
        
            if(n==1) {
        
                return n;
            }
            int num = n * fac(n-1);
            return num;      
    }
        public static void main (String[] args) {
        
            System.out.println("请输入一个数字：");
            Scanner scanner = new Scanner();
            int n = scanner.nextInt();
            int end = fac(n);
            System.out.println("end="+end);
        }
    }

**代码讲解：**

![在这里插入图片描述][9731d34e8d264708bcab98efcc699010.png_pic_center]

> ***当我们从键盘输入n=5，通过方法调用将n=5传过去，在方法中，n=5，不满足if语句，num=5fac(4),再次调用方法，此时形参n=4，不满足if语句，num=4*  
> *fac(3),再次调用方法fac，n=3，不满足if语句，num=3 \* fac(2),再次调用fac，n=2，不满足if语句，num=2 fac (1)，最后调用fac，n=1，然后return 1，返回到上一步的fac，num=2，又返回到上一个fac中，num=6，直到最后返回到第一次调用此函数中，num=120.***

#### 2.规则 ####

*  **执行一个方法时，就会创建一个新的受保护的栈空间。**
 *  **方法的局部变量是独立存在的，不会相互影响。**
 *  **如果方法中使用的是引用变量（如数组），就会共享此引用类型中的数据。**
 *  **递归必须向退出递归的条件逼近，否则就会无限递归，最终出现StackOverflowError。**
 *  **当一个方法执行完毕，或者遇到return，就会返回，遵循谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。**

#### 3.代码练习 ####

**用递归方法求斐波那契数列的第n个数字**

**关于斐波那契数列的介绍：**[黄金分割数列——斐波那契数列 - 知乎 (zhihu.com)][- _ _zhihu.com]

**简单来理解，斐波那契数列是前两项和等于第三项，以此类推。**

**Demo：**

import java.util.Scanner;
    
    public class Test1 {
        
        public static int fib (int num) {
        
            if (num <= 2)//因为在一开始就有最初的两项，1和1，所以要<=2
                return 1;
            else
                return fib(num - 1) + fib(num - 2);
        }
        public static void main(String[] args) {
        
            System.out.println("请输入你想求的斐波那契数列的第几项：");
            Scanner scanner = new Scanner(System.in);
            int n = scanner.nextInt();
            int end = fib(n);
            System.out.println("斐波那契数列的第"+n+"项为："+end);
        }
    }

**代码讲解：**

**由于用递归求斐波那契数列第n项太麻烦，我这里就简单求第四项，在平常咱们都是用循环去写的，**

**斐波那契数列：1,1,2,3,5,8,13··········**

![在这里插入图片描述][c92f9245e0b742bf982717786e2af625.png_pic_center]

**以上就是关于Java中方法的基本介绍，如果各位小伙伴发现文章有什么问题或者不懂的地方，欢迎提出和咨询！！！**

[2c3180244c26441791583cea63dc4bc6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/0e99e0800cd848c2aed09af2c74d991d.png
[9731d34e8d264708bcab98efcc699010.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/99c4c7bb6e984c9b9799d9ba5b6967c0.png
[- _ _zhihu.com]: https://zhuanlan.zhihu.com/p/89580957
[c92f9245e0b742bf982717786e2af625.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/0185aaece618466d90e95cb913f9f9dd.png