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开头,以;结尾,中间是引用类型的全类名

你可能感兴趣的:(Java,java,jvm,开发语言)