Java方法的基本用法

我不是女神ヾ 2023-10-02 18:53 16阅读 0赞

> 本文主要介绍了什么是方法以及方法的重载，并展示了几个示例，希望能对大家关于这方面的学习有所帮助。

## 一、方法的基本用法 ##

#### 1.什么是方法 ####

方法就是一个代码片段，类似于c语言中的函数。其中方法的最重要的意义就是复用性（已经写好的代码块，可能会被重复利用多次，就可以把这段代码抽象成方法）

#### 2.方法的定义语法 ####

public static 方法返回值  方法名称（参数类型 形式参数列表） \{

方法体代码；

\[return 返回值\]；

**注意事项：**

1.方法名：要采用小驼峰的形式，如printNum

2.public static :因为main方法是static的，当前的所写的方法，在写完之后，会在main方法中调用

3.返回值：该方法是否有返回值，要看这个方法的作用或者功能是什么。如果有返回值，那么返回值的类型需要和方法的返回值类型匹配

4.形式参数列表：方法定义时的参数是“形参”，方法调用时的参数称为“实参”。形参是实参的一份拷贝

5.方法体：具体方法的实现

6.方法的定义必须在类之中

#### 3.方法的调用 ####

返回值变量=方法名称（参数）

**基本规则：**

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

2.方法被调用时，会将实参赋值给形参。且Java中只有按值传递

3.参数传递完毕后，会执行到方法体代码

4.当方法遇到return语句或者执行完毕后，会回到调用位置继续往下执行

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

#### 4.示例 ####

4.1有返回值的方法

public class Test {
    //定义两个整数相加的方法有返回值，返回值为int型
        //num1、num2称为形参
        public static int add(int num1,int num2) {
            //方法体
            int sum= num1 + num2;
            //返回值
            return sum;
        }
    
        public static void main(String[] args) {
            int a = 10;
            int b = 20;
            //add(a, b)中的a、b称为实参
            //调用add方法，把实参的值传递给形参，然后执行方法体
            //返回值的类型要与方法的方法的返回值类型匹配
            int c = add(a,b);
            //add方法中的方法体执行完毕，回到方法调用位置继续往下执行
            System.out.println(c);
        }
    }

4.2无返回值的方法

public class Test {
    //逆序输出一个整数的每一位，该方法无返回值
    //num为形参
    public static  void printNum(int num ) {
    //方法体
            if(num <10 ) {
                System.out.println(num);
            }
            if (num >=10) {
                System.out.println(num%10);
                printNum(num/10);
            }
        }
    //代码从main方法执行
         public static void main(String[] args) {
    //因方法无返回值，所以不能用System.out.println
            printNum(123);
        }
    }

##  ##

### 二、方法重载 ###

#### 1、什么是方法重载？ ####

方法重载（overload）:

方法重载是指发生在同一个类中，定义了若干个方法名称相同，参数列表不同的(参数类型、参数个数不同)，且与返回值无关的一组方法，叫做方法重载。

#### 2、方法重载的使用 ####

public class Test {
        //定义两个数相加的方法
        //两个整型相加的方法
        public static int add(int a, int b) {
            return a + b;
        }
    
        //三个整型相加
        public static int add(int a, int b, int c) {
            return a + b + c;
        }
    
        //两个double型相加
        public static double add(double d, double e) {
            return d + e;
        }
        
        //两个double型、一个整型相加
        public static double add(double x, double y, int z) {
            return x + y + z;
        }
    
        public static void main(String[] args) {
            System.out.println(add(10,20));
            System.out.println(add(10,20,30));
            System.out.println(add(1.1,2.2));
            System.out.println(add(2.2,3.3,5));
        }
    }

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZXhwbG9yZXIzNjM_size_20_color_FFFFFF_t_70_g_se_x_16][]

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZXhwbG9yZXIzNjM_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

**若方法参数相同（参数类型、参数个数相同），而只有返回值（类型）不同，则会编译报错！**

### 三、方法递归 ###

#### （一）、什么是方法递归 ####

方法递归就是在一个方法执行的内部，自己调用了自己的过程。

递归分为两个子过程：

1.递过程：函数不断调用自身，直到走到函数的终止条件，第一阶段结束

2.归过程：函数不断返回的过程

#### （二）、方法递归的使用条件 ####

1.一个大问题可以拆分为若干个子问题的解

2.拆分后的子问题和原问题除了数据规模不同，解决思路完全相同

3.必须存在递归的终止条件（不会无限的拆分下去）

#### （三）如何写出递归代码？ ####

在写递归时，不要纠结方法内部是如何实现的，而是要注意方法到底有什么功能。（可以假设此方法别人已经写好了，我们只是在调用它）

步骤：

1.终止条件

2.不借助任何方法就能实现的步骤

3.剩下的利用该方法去解决

程序实现方法递归的核心原因：

当在程序中调用另一个函数时，当前程序会暂缓执行，知道调用函数结束后，当前程序才会继续执行

示例1：求n!

public class Test {
      //功能：传入一个num，就能求出这个数的阶乘值
      //n! = n * (n-1) !
        public static int factor(int num) {
    //终止条件，拆到1就不能再继续往下拆了
    //无须借用任何外部力量，就知道num =1的阶乘值就是1
          if(num == 1) {
            return 1;
          }
          //如果传入一个数num为5，我们就只知道num的值，(num-1)!我们不知道
          // 交给factor（）方法去处理
          return num*factor (num-1);
        }
    
      public static void main(String[] args) {
        System.out.println(factor(5));
      }
    }

示例2： 求1 + 2 + 3+...+n 的和

public class Test {
      //功能：传入一个num，就能求出1至这个数的和
      //1 + 2 + 3+...+n 的和 =  n + 1至(n-1)的和
        public static int sum(int num) {
    //终止条件，拆到1就不能再继续往下拆了
    //无须借用任何外部力量，就知道num =1的和就是1
          if(num == 1) {
            return 1;
          }
          //如果传入一个数num为5，我们就只知道num的值，1至(num-1)的和我们不知道
          // 交给sum（）这个方法去处理
          return num + sum (num-1);
        }
    
      public static void main(String[] args) {
        System.out.println(sum(5));
      }
    }

示例3：输入一个非负整数，返回组成它的数字之和

public class Test {
      //功能：传入一个num，就能求出组成这个数的数字之和
      //1729 = 1+7+2+9
        public static int sum(int num) {
    //终止条件，拆到1就不能再继续往下拆了
    // 无须借用任何外部力量，就知道组成num<10的数的数字之和就是该数本身
          if(num < 10) {
            return num;
          }
          //如果传入一个数>=10，我们就只知道至少是个两位数
          //我们只能知道num的个位数是num%10 ，至于其他位的数字我们不知道
          // 交给sum（）这个方法去处理
          return num % 10+ sum (num/10);
        }
    
      public static void main(String[] args) {
        System.out.println(sum(1234));
      }
    }

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZXhwbG9yZXIzNjM_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/14a82895cebf489faacbae52a38dd363.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZXhwbG9yZXIzNjM=,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZXhwbG9yZXIzNjM_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/1c472b95b620448a9278f16270a934e8.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZXhwbG9yZXIzNjM=,size_20,color_FFFFFF,t_70,g_se,x_16