[Java知识库] 【Java 基础语法】（3）方法的使用

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> 【Java 基础语法】（3）方法的使用 -> 正文阅读

[Java知识库]【Java 基础语法】（3）方法的使用

文章目录

一、方法的基本用法

1. 什么是方法

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

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

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

2. 语法格式

方法的定义

public static 方法的返回值 方法名称 ([参数类型 形参]){
    // 方法体代码
    [return 返回值;]
}

方法的调用

定义方法时，不会执行代码，调用时才执行
当方法被调用时，会将实参赋值给形参
参数传递完毕后，就会执行到方法体代码
当方法执行完毕后护（遇到 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

注意事项
- 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. 什么是递归

概念

一个方法在执行过程中调用自身，就称为“递归”
实行条件
- 存在限制条件，当满足这个限制条件的时候，递归便不再继续
- 每次递归调用之后越来越接近这个限制条件
递归其实就是调用自己嘛，如果不存在限制条件只是调用自己的话，就可能有错误，如
```
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

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

分析方法一

递归其实可以分为递和归两部分，如上图，红色路线就是递（将新的数值传递给方法调用），橙色路线就是归（从最后的限制条件得到的值，依次往回传回去）

分析方法二
我们可以直接把这个方法放到栈上面去看，我们知道栈的特点是后进后出。最左边的图表示是四次调用方法，往右，由于 n == 1 时遇到限制条件，fac(1) 方法返回1并且结束（该方法在栈上随即销毁）。再往右，fac(2) 方法返回2并且结束（该方法在栈上随即销毁）。再往右，fac(3) 方法返回6并且结束（该方法在栈上随即销毁）。最后，fac(4) 方法返回24并且结束（该方法在栈上随即销毁）。

3. 递归练习

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

按顺序打印一个数字的每一位

public static void print(int num){
    if(num < 10)
        System.out.print(num);
    else{
        print(num / 10);
        System.out.print(num % 10);
    }
}

求 1 + 2 + … + n 的和

public static int sum(int num){
	if(num == 1)
		return 1;
	else
		return num + sum(num - 1);
}

写一个递归方法，输入一个非负整数，返回组成它的数字之和

 public static int sum(int num){
    if(num < 10)
        return num;
    else
        return num % 10 + sum(num / 10);
}

求斐波那契数列数列的第 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;
}