【Java 基础语法】方法的使用

曾经终败给现在 2021-09-13 19:42 414阅读 0赞

### 文章目录 ###

*   *  一、方法的基本用法
     *   *  1. 什么是方法
         *  2. 语法格式
         *  3. 实参和形参的关系
     *  二、方法的重载
     *   *  1. 重载要解决的问题
         *  2. 什么是重载
     *  三、方法递归
     *   *  1. 什么是递归
         *  2. 递归执行过程分析
         *  3. 递归练习
         *  4. 递归小结
     *  四、总结

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

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

方法就是一个代码片段，类似于 C 语言中的函数。它是一个语句的集合，它们在一起执行一个功能

那么方法存在的意义是什么呢？

> 1.  能够模块化的组织代码
> 2.  做到让代码被重复使用，一份代码可以用在多个位置
> 3.  让代码更好理解、更简单
> 4.  直接调用现有方法，不必重复造轮子

### 2. 语法格式 ###

1.  方法的定义
    
        public static 方法的返回值 方法名称 ([参数类型 形参]){ 
            // 方法体代码
            [return 返回值;]
        }
2.  方法的调用
    
    >  *  定义方法时，不会执行代码，调用时才执行
    >  *  当方法被调用时，会将实参赋值给形参
    >  *  参数传递完毕后，就会执行到方法体代码
    >  *  当方法执行完毕后护（遇到 return 语句），就会回到方法调用位置继续往下执行
    
    接下来我们写一个求两个整数相加的方法，体验一下
    
        public class Test{ 
            public static void main(String[] args){ 
                int a = 10;
                int b = 20;
                int ret = add(a, b);
                System.out.println("ret = " + ret);
            }
            public static int add(int a, int b){ 
            	return a + b;
        	}
        }
        // 结果为 ret = 30
3.  注意事项
    
    >  *  public 和 static 两个关键字在此处具有特定含义，后面再介绍
    >  *  方法定义时，参数可以没有，但如果有一定要指定类型
    >  *  方法定义时，返回值可以没有，但如果没有，返回类型应该写出 void
    >  *  方法定义时的参数为“形参”，方法调用时的参数为“实参”
    >  *  方法定义必须在类中
    >  *  和 C 语言不同的是 Java 中没有“函数声明”的概念，所以方法的定义可以写在 main 方法的上方或者下方
    >  *  一个方法可以被多次调用
    >  *  方法的调用需要开辟栈帧，方法结束栈帧就随即结束

其实 Java 中的方法和 C 语言太类似了，不过还是会有不同的，所以接下来继续了解方法吧！

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

我们先来看一个代码

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

为啥呢？不过在 C 语言里这样写也是错的，因为形参只是实参的一份临时拷贝，swap 方法里只将形参的值互换了，但是实参的值没有互换。

那么就使用指针传值吧！可惜 Java 中没有指针，那怎么办呢？我们可以使用引用类型，如数组实行两个数的交换，如

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

## 二、方法的重载 ##

### 1. 重载要解决的问题 ###

什么是重载呢？大家可能都会有这个疑问，接下来我们直接用一个代码，揭开重载的面纱

public class Test{ 
        public static void main(String[] args){ 
            //当我们求两个整数和时
            int a1 = 10;
            int b1 = 20;
            int ret1 = add(a1, b1);
            System.out.println("ret1 = " + ret1);
            //当我们求两个浮点数和时
            double a2 = 1.5;
            double b2 = 2.4;
            double ret2 = a2 + b2;
            System.ouy.println("ret2 =" + ret2);
        }
        public static int addInt(int a, int b){ 
        	return a + b;
    	}
        public static double addDouble(double a, double b){ 
        	return a + b;
    	}
    }

上面我们分别对整数和浮点数求和都写了一个方法，这个做法也是对的。但是 Java 认为 addInt 这样的名字不友好，不如直接就叫 add。啥意思呢，在 Java 中上述代码可以写出这样

public class Test{ 
        public static void main(String[] args){ 
            //当我们求两个整数和时
            int a1 = 10;
            int b1 = 20;
            int ret1 = add(a1, b1);
            System.out.println("ret1 = " + ret1);
            //当我们求两个浮点数和时
            double a2 = 1.5;
            double b2 = 2.4;
            double ret2 = a2 + b2;
            System.ouy.println("ret2 =" + ret2);
        }
        public static int add(int a, int b){ 
        	return a + b;
    	}
        public static double add(double a, double b){ 
        	return a + b;
    	}
    }

细心的可以发现我们把方法名都叫作了 add，这个就叫做重载

### 2. 什么是重载 ###

1.  含义
    
    > 同一个方法名字相同，提供不同版本的实现，称为重载
2.  满足要求
    
    >  *  方法名相同
    >  *  参数列表不同（参数的个数或者参数的类型不同）
    >  *  返回值不作要求
    
    以上条件都满足时，才是重载。后面我们还会讲到重写，这是面试时时常会被问到的问题
3.  注意事项
    
    > 重载不是必须在一个类当中（继承）

## 三、方法递归 ##

### 1. 什么是递归 ###

1.  概念
    
    > 一个方法在执行过程中调用自身，就称为“递归”
2.  实行条件
    
    >  *  存在限制条件，当满足这个限制条件的时候，递归便不再继续
    >  *  每次递归调用之后越来越接近这个限制条件
    
    递归其实就是调用自己嘛，如果不存在限制条件只是调用自己的话，就可能有错误，如
    
        public class Test{ 
            public static void main(String[] args){ 
                func();
            }
            public static void func(){ 
                func();
            }
        }
    
    上述代码就会栈溢出（StackOverflowError），因为方法调用时都会在栈上开辟内存，无休止的调用就会导致无休止的开辟，使栈溢出

### 2. 递归执行过程分析 ###

既然知道什么是递归后，我们先来看一个求 n 的阶乘的例子

public class Test{ 
        public static void main(String[] args){ 
            int num = 4;
            int ret = factor(num);
            System.out.println(ret);
        }
        public static int factor(int n){ 
            if(n == 1 || n == 0) 
                return 1;
            else
                return n * factor(n-1);
        }
    }
    // 结果为24

而接下来我用两种方法为大家分析一下递归的执行过程

> 1.  分析方法一
>     
>     ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTM2Nzg0NQ_size_16_color_FFFFFF_t_70_pic_center]  
>     递归其实可以分为递和归两部分，如上图，红色路线就是递（将新的数值传递给方法调用），橙色路线就是归（从最后的限制条件得到的值，依次往回传回去）
> 2.  分析方法二![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTM2Nzg0NQ_size_16_color_FFFFFF_t_70_pic_center 1]  
>     我们可以直接把这个方法放到栈上面去看，我们知道栈的特点是后进后出。最左边的图表示是四次调用方法，往右，由于 n == 1 时遇到限制条件，fac(1) 方法返回1并且结束（该方法在栈上随即销毁）。再往右，fac(2) 方法返回2并且结束（该方法在栈上随即销毁）。再往右，fac(3) 方法返回6并且结束（该方法在栈上随即销毁）。最后，fac(4) 方法返回24并且结束（该方法在栈上随即销毁）。

### 3. 递归练习 ###

接下来我们做几个练习，让方法递归的理解更加深刻一些吧！

1.  按顺序打印一个数字的每一位
    
        public static void print(int num){ 
            if(num < 10)
                System.out.print(num);
            else{ 
                print(num / 10);
                System.out.print(num % 10);
            }
        }
2.  求 1 + 2 + … + n 的和
    
        public static int sum(int num){ 
        	if(num == 1)
        		return 1;
        	else
        		return num + sum(num - 1);
        }
3.  写一个递归方法，输入一个非负整数，返回组成它的数字之和
    
        public static int sum(int num){ 
            if(num < 10)
                return num;
            else
                return num % 10 + sum(num / 10);
        }
4.  求斐波那契数列数列的第 N 项
    
        public static int fic(int num){ 
            if(num == 1 || num == 2) 
                return 1;
            else 
                return fic(num - 1) + fic(num -2);
        }

### 4. 递归小结 ###

递归是一种重要的编程解决问题的方式，我们已经知道了递归的用法，但是我们还应该知道什么时候使用递归更好。就比如上述求斐波那契数列的第 N 项，其实并不推荐使用递归去求，因为 N 越大，重复计算的次数就越多，这时就更推荐迭代法，如

public static int fic(int num){ 
        int f1 = 1;
        int f2 = 1;
        int f3 = 1;
        int i = 0;
        for(i = 3; i <= num; i++){ 
            f3 = f1 + f2;
            f1 = f2;
            f2 = f3;
        }
        return f3;
    }

## 四、总结 ##

这次学习了 Java 中方法的使用，其实学习的过程很轻松，因为和 C 语言的函数太像了。如果大家上述有什么没有理解的话，可以给我私信或者浏览我之前写过的 C 语言函数的文章 [第五章 C世界函数的故事（1）][C_1] 和 [第六章 C世界函数的故事（2）][C_2] 以加深理解。  
希望大家喜欢哦！  
![在这里插入图片描述][3cd7abce69db4094917abf0694dc1920.jpg_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTM2Nzg0NQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20210913/5497666ca4dc46cb922aadeab1d5c3c2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTM2Nzg0NQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20210913/206159907b9746f0a75ca78034159e24.png
[C_1]: https://blog.csdn.net/weixin_51367845/article/details/115806078
[C_2]: https://blog.csdn.net/weixin_51367845/article/details/115975440
[3cd7abce69db4094917abf0694dc1920.jpg_pic_center]: /images/20210913/9f71f7c54c8b4e21b66b3b9029e341af.png