JavaSE语法(4)——详解解读Java中的方法与方法重载

目录

 

✏️方法概念及使用

1.什么是方法

2.方法的定义

3.方法调用的执行过程

4.实参和形参的关系

5.没有返回值的方法

✏️方法重载

1.引入

2.方法重载概念

3.方法签名

✏️递归

1.递归的概念

2.递归执行过程分析


前言:该篇里的“static、public”的用法会在后续更新,现将方法的格式就默认为“public static 类型 方法名 ()”。

✏️方法概念及使用


1.什么是方法

        方法相当于C语言中的“函数”用法大都是相同的。其意义:

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

2.方法的定义

格式:

// 方法定义
修饰符 返回值类型 方法名称([参数类型 形参 ...]){
    //方法体代码;
    return 返回值;//没有返回值就不写
}

(ps:修饰符就是 public、private……、static,这些后面会更新,可能有点久。)

例:检测一个年份是否为闰年、

    public class Product{
        /**
         * @param year 传入一个年数
         * @return 是闰年返回 true,否则返回false
         */
        public static boolean isLeapYear(int year){
            if((0 == year % 4 && 0 != year % 100) || 0 == year % 400){
                return true;
            }else{
                return false;
            }
        }
    }

例:实现一个两个整数相乘的方法

    public class Product{
        /**
         *
         * @param x 传入一个int型的数
         * @param y 传入一个int型的数
         * @return 返回 x 与 y 的乘积
         */
        public static int add(int x, int y) {
            return x * y;
        }
    }

注意:

  • 返回值类型:如果方法有返回值,返回值类型必须要与返回的实体类型一致,如果没有返回值,必须写成void。
  • 方法名字:采用小驼峰命名,也就是第一个单词首字母小写,后继的单词首字母大写
  • 参数列表:如果方法没有参数,()中什么都不写,如果有参数,需指定参数类型,多个参数之间使用逗号隔开。
  • 方法体:方法内部要执行的语句。
  • 在java当中,方法必须写在类当中。
  • 在java当中,方法不能嵌套定义。
  • 在java当中,没有方法声明一说

3.方法调用的执行过程

过程:

        调用方法--->传递参数--->找到方法地址--->执行被调方法的方法体--->被调方法结束返回--->回到调方法继续往下执行。
JavaSE语法(4)——详解解读Java中的方法与方法重载_第1张图片

 注意:Java中方法的定义位置没有严格要求,定义在main方法后也行,且没有像C语言中的“函数声明”这种东西。

例:计算两个整数相加。

public class Method {
    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(30, 50);
        System.out.println("第二次调用方法之后");
        System.out.println("ret = " + ret);
    }
    public static int add(int x, int y) {
        System.out.println("调用方法中 x = " + x + " y = " + y);
        return x + y;
    }
}

        结果:

第一次调用方法之前
调用方法中 x = 10 y = 20
第一次调用方法之后
ret = 30
第二次调用方法之前
调用方法中 x = 30 y = 50
第二次调用方法之后
ret = 80

4.实参和形参的关系

        方法的形参相当于数学函数中的自变量,比如:1 + 2 + 3 + … + n的公式sum(n) =n*(a1+an)/ 2

        Java中方法的形参就相当于sum函数中的自变量n用来接收sum函数在调用时传递的值的。形参的名字可以随意取,对方法都没有任何影响,形参只是方法在定义时需要借助的一个变量,用来保存方法在调用时传递过来的值。

    public static int getSum(int N){ // N是形参
        return (1+N)*N / 2;
    }

    public static void main(String[] args) {
        int a = getSum(10); // 10是实参,在方法调用时,形参N用来保存10
        int b = getSum(100); // 100是实参,在方法调用时,形参N用来保存100        
    }

 注意:在Java中,实参的值永远都是拷贝到形参中形参和实参本质是两个实体。

例: 交换两个整型变量

public class TestMethod {
    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

        可以看到,在swap函数交换之后,形参x和y的值发生了改变,但是main方法中a和b还是交换之前的值,即没有交换成功。

原因:

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

JavaSE语法(4)——详解解读Java中的方法与方法重载_第2张图片

注意:对于基础类型来说,形参相当于实参的拷贝。传值调用。

解决办法:传引用类型参数 (例如数组来解决这个问题),在Java中没有指针,所以得用引用类型来解决这类问题。(ps:详细的在下一篇文章(与数组的内容一起)。后面再补

public class TestMethod {
    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

5.没有返回值的方法

        方法的返回值是可选的。有些时候可以没有的,没有时返回值类型必须写成void。

例:

class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        print(a, b);
    }
    public static void print(int x, int y) {
        System.out.println("x = " + x + " y = " + y);
    }
}


✏️方法重载


1.引入

        我想要分别对(int a    int  b)与(double c   double  d)求和:

class TestMethod {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a, b);
        System.out.println("ret = " + ret);
        double a2 = 10.5;
        double b2 = 20.5;
        double ret2 = add(a2, b2);
        System.out.println("ret2 = " + ret2);
    }
    public static int add(int x, int y) {
        return x + y;
    }
}

结果:

// 编译出错
Test.java:13: 错误: 不兼容的类型: 从double转换到int可能会有损失
double ret2 = add(a2, b2);

        结果显然是错的,因为add的形参是int类型,不能传double类型如何解决问题呢?可以重新写一个double类型的addDouble()方法,但是还有其它办法吗?如下。


2.方法重载概念

        上面的问题可以用重载解决,什么是重载?

        重载相当于一词多义,比如:扶老奶奶过马路的人叫好人;跟女神表白时,女神说:“你是个好人”。这两个“好人”就有多重意义。

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

        回到上一个add的问题,我们可以写一个add的重载:

class TestMethod2 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a, b);
        System.out.println("ret = " + ret);
        double a2 = 10.5;
        double b2 = 20.5;
        double ret2 = add(a2, b2);
        System.out.println("ret2 = " + ret2);

        int a3 = 10;
        int b3 = 20;
        int c3 = 30;
        int ret3 = add(a3,b3,c3);
        System.out.println("ret3 = " + ret3);

        double a4 = 10.5;
        double b4 = 20.5;
        double c4 = 30.5;
        double ret4 = add(a4,b4,c4);
        System.out.println("ret4 = " + ret4);
    }
    public static int add(int x, int y) {
        return x + y;
    }

    public static double add(double x, double y) {
        return x + y;
    }

    public static int add(int x, int y,int z){
        return x + y + z;
    }
    public static double add(double x, double y,double z){
        return x + y + z;
    }
}

结果:

ret = 30
ret2 = 31.0
ret3 = 60
ret4 = 61.5

注意:

  • 方法名必须相同
  • 参数列表必须不同(参数的个数不同、参数的类型不同类型的次序(不是形参变量的次序)必须不同)
  • 与返回值类型是否相同无关
  • 两个方法如果仅仅只是因为返回值类型不同,是不能构成重载的。

例:

public class TestMethod {
    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 x, int y) {
        return x + y;
    }
    public static double add(int x, int y) {
        return x + y;
    }
}

结果:

        // 编译出错
        Test.java:13: 错误: 已在类 Test中定义了方法 add(int,int)
public static double add(int x, int y) {
                ^
        1 个错误

        编译器在编译代码时,会对实参类型进行推演,根据推演的结果来确定调用哪个方法,如果两个方法仅仅只是因为返回值类型不同,那么编译器就推不出来。


3.方法签名

        在同一个作用域中不能定义两个相同名称的标识符。比如:方法中不能定义两个名字一样的

变量,那为什么类中就可以定义方法名相同的方法呢?

        方法签名即:经过编译器编译修改过之后方法最终的名字。具体方式:方法全路径名+参数

列表+返回值类型,构成方法完整的名字。

        例:

public class TestMethod {
    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反汇编工具查看,具体操作:

  • 找到该类所在项目的文件位置,找到 out

JavaSE语法(4)——详解解读Java中的方法与方法重载_第3张图片

  •  一直点,直到看到.class文件

JavaSE语法(4)——详解解读Java中的方法与方法重载_第4张图片

  •  在上面写cmd进入命令行窗口

JavaSE语法(4)——详解解读Java中的方法与方法重载_第5张图片

 JavaSE语法(4)——详解解读Java中的方法与方法重载_第6张图片

  •  输入:javap -v 字节码文件名字   (回车)即可

JavaSE语法(4)——详解解读Java中的方法与方法重载_第7张图片

 可以看到:

JavaSE语法(4)——详解解读Java中的方法与方法重载_第8张图片

         其中的D表示double类型,I表示int类型,add真正的名字会被类型决定。



✏️递归


1.递归的概念

        一个方法在执行过程中调用自身, 就称为 "递归"。

递归的必要条件:

  • 将原问题划分成其子问题,注意:子问题必须要与原问题的解法相同
  • 递归出口

例: 递归求 N 的阶乘

public class TestMethod {
    public static void main(String[] args) {
        int n = 5;
        int ret = factor(n);
        System.out.println("ret = " + ret);
    }
    public static int factor(int n) {
        if (n == 1) {
            return 1;
        }
        return n * factor(n - 1); // factor 调用函数自身
    }
}

结果:

ret = 120

2.递归执行过程分析

例:递归求 N 的阶乘

public class TestMethod {
    public static void main(String[] args) {
        int n = 5;
        int ret = factor(n);
        System.out.println("ret = " + ret);
    }
    public static int factor(int n) {
        System.out.println("函数开始, n = " + n);
        if (n == 1) {
            System.out.println("函数结束, n = 1 ret = 1");
            return 1;
        } 
        int ret = n * factor(n - 1);
        System.out.println("函数结束, n = " + n + " ret = " + ret);
        return ret;
    }
}

结果:

函数开始, n = 5
函数开始, n = 4
函数开始, n = 3
函数开始, n = 2
函数开始, n = 1
函数结束, n = 1 ret = 1
函数结束, n = 2 ret = 2
函数结束, n = 3 ret = 6
函数结束, n = 4 ret = 24
函数结束, n = 5 ret = 120
ret = 120

 过程:JavaSE语法(4)——详解解读Java中的方法与方法重载_第9张图片

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