Java方法重载

方法的概念

什么是方法

方法就是一个代码片段. 类似于 C 语言中的 “函数”。方法存在的意义.

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

方法定义

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

//实现一个两个整数相加的方法
public static int add(int a, int b) {
        return a+b;
    }
    public static void main(String[] args) {
        int ret = add(10,20);
        System.out.println(ret);
    }

//错误示例
//1.
    public static boolean add(int a, int b) {
        return a+b;//此时return的数据类型是int，但是方法接收的返回值类型是boolean
    }
    public static void main(String[] args) {
        int ret = add(10,20);
        System.out.println(ret);
    }
//2.
 public static void add(int a,int b) {
        return;//方法接受的返回值类型是void，直接return代表方法的结束
        System.out.println(a+b);//代码不能正常执行
    }
    public static void main(String[] args) {
        int ret = add(10,20);
        System.out.println(ret);
    }

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

方法调用

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

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

//方法的调用，每次都会在栈上开辟内存
//每个方法都有其独立的空间
    public static void main(String[] args) {
        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(20,30);
        System.out.println("第二次调用方法之后");
        System.out.println("ret= "+ ret);
    }
    public static int add(int a,int b) {
        System.out.println("调用方法中 a =" + a +" "+ "b = "+b);
        return a+b;
    }
    public static void main2(String[] args) {
        int x = 2022;
        boolean ret = isLeapYear(x);
        System.out.println(ret);
        if (ret == true) {
            System.out.println(x+" 是闰年");
        } else {
            System.out.println(x+" 不是闰年");
        }
    }
    //执行结果
    //第一次调用方法之前
    //调用方法中 a =10 b = 20
    //第一次调用方法之后
    //ret= 30
    //第二次调用方法之前
    //调用方法中 a =20 b = 30
    //第二次调用方法之后
    //ret= 50

//求阶乘的和
    public static int facSum(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {

            sum += fac(i);
        }
        return sum;
    }
    //求某个数的阶乘
    public static int fac(int num) {
        int ret = 1;
        for (int j = 1; j <= num; j++) {
            ret = ret * j;
        }
        return ret;
    }
    public static void main(String[] args) {
        Scanner scan1 = new Scanner(System.in);
        int n = scan1.nextInt();
        int ret = facSum(n);
        System.out.println(ret);
    }

**Java中方法的形参就相当于sum函数中的自变量n，用来接收sum函数在调用时传递的值的。**形参的名字可以随意取，对方法都没有任何影响(作用域不同)，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值。
在Java中，实参的值永远都是拷贝到形参中，形参和实参本质是两个实体

//交换两个整型变量
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        swap(a, b);
        System.out.println("main: a = " + a + " b = " + b);
    }
    public static void swap(int x, int y) {
        int tmp = x;
        x = y;
        y = tmp;
        System.out.println("swap: x = " + x + " y = " + y);
    }
    //swap: x = 20 y = 10
    //main: a = 10 b = 20

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

//解决办法
//传引用类型参数 交换0下标和1下标
 public static void main(String[] args) {
        int[] arr = {10, 20};
        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;
    }
    //arr[0] = 20 arr[1] = 10

方法重载

    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        int ret = sum(x,y);
        System.out.println(ret);
        double d1 = 12.5;
        double d2 = 20.5;
        double ret2 = sum(d1,d2);
        System.out.println(ret2);
    }
    public static int sum(int a,int b) {
        return a+b;
    }
    //不兼容的类型: 从double转换到int可能会有损失
    //解决办法：
    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        int ret = sum(x,y);
        System.out.println(ret);
        double d1 = 12.5;
        double d2 = 20.5;
        double ret2 = sum(d1,d2);
        System.out.println(ret2);
    }
    public static int sum(int a,int b) {
        return a+b;
    }
    public static double sum(double a, double b) {
        return a+b;
    }

方法重载概念

在自然语言中，一个词语如果有多重含义，那么就说该词语被重载了，具体代表什么含义需要结合具体的场景。在Java中方法也是可以重载的。
在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了

1. 方法名必须相同
2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)
3. 与返回值类型是否相同无关,不影响重载

方法签名

在同一个作用域中不能定义两个相同名称的标识符。比如：方法中不能定义两个名字一样的变量，那为什么类中就可以定义方法名相同的方法呢？
方法签名即：经过编译器编译修改过之后方法最终的名字。具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。

 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 字节码文件名字即可

特殊字符	数据类型
V	void
Z	boolean
B	byte
C	char
S	short
I	int
J	long
F	float
D	double
[	数组(以[开头，配合其他的特殊字符，表述对应数据类型的数组，几个[表述几维数组)
L	引用类型，以L开头，以;结尾，中间是引用类型的全类名