一看就会的Java方法

一、方法的定义和使用

🍑1、为什么引入方法？

📝举个例子：现在要写一段代码实现两个整数相加的功能，我们可以这样写：

public static void main(String[] args) {
    int x=2;
    int y=3;
    int sum=x+y;
}
1
2
3
4
5

但是如果我们在之后还需要用到这个功能的话，难道每次都要写一段这种代码吗？假如实现功能的代码很复杂呢？显然这种这种方法是存在以下缺陷：

1. 使程序变得繁琐
2. 开发效率低下，做了大量重复性的工作
3. 不利于维护，需要改动时，所有用到该段代码的位置都需要修改
4. 不利于复用

为了解决以上缺陷，在编程中，我们也可以将频繁使用的代码封装成方法，需要时直接拿来方法名（方法的入口地址）使用即可，避免了一遍一遍的累赘。

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

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

🍑2、方法的定义

注释：

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

注意：

1. 在 java当中，方法必须写在类当中
2. 在 java当中，方法不能嵌套定义
3. 在 java当中，没有方法声明一说，直接调用

🍑3、方法调用的执行过程

1.调用方法--->2.传递参数--->3.找到方法地址--->4.执行被调方法的方法体--->5.被调方法结束返回--->6.回到主调方法继续往下执行

📝例如：计算 1! + 2! + 3! + 4! + 5!

注意： 定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行

🍑4、实参和形参的关系

方法的形参相当于数学函数中的自变量，比如：1 + 2 + 3 + … + n的公式为sum(n) = $\frac{(1+n)\ast n}{2}$

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

但是需要注意的是： 在Java中，实参的值永远都是拷贝到形参中，形参和实参本质是两个实体。在Java中，对于基础类型来说, 形参相当于实参的拷贝. 即 传值调用

📝例如：Java中不能直接交换两个整数的值

public class TestDemo2 {

    //交换两个数的值
    public static void swap(int x,int y) {
        int tmp=x;
        x=y;
        y=tmp;
    }

    public static void main(String[] args) {
        int a=10;
        int b=10;
        System.out.printf("交换前：a=%d b=%d\n",a,b);

        swap(a,b);
        System.out.printf("交换后：a=%d b=%d\n",a,b);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

分析：

解决办法: 传引用类型参数（这里剧透一下数组，大家看下就好，下期讲解）

public class TestDemo2 {

        public static void main(String[] args) {
            int[] arr = {10, 20};
            System.out.println("交换前arr[0] = " + arr[0] + " arr[1] = " + arr[1]);
            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;
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

二、方法重载

🍑1、为什么需要方法重载

📝假如我们现在要计算两个数相加，这就要分为整数和浮点数，我们可能会写出如下代码：

public class TestDemo2 {
    public static int addInt(int x, int y) {
        return x + y;
    }
    public static double addDouble(double x, double y) {
        return x + y;
    }

    public static void main(String[] args) {
        int sum1=addInt(1,2);
        double sum2=addDouble(1.5,1.2);
        System.out.println("计算两个整形相加，调用addInt："+sum1);
        System.out.println("计算两个整形相加，调用addDouble："+sum2);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

上述代码虽然可以解决问题，但不友好的地方是：需要提供许多不同的方法名，而取名字本来就是让人头疼的事情。那能否将所有的名字都给成 add 呢？这就引出了方法重载，那么我们应该如何重载呢？

🍑2、方法重载的概念和特点

概念： 在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了。

public class TestDemo2 {

    //=======方法重载========
    public static int add(int x, int y) {
        return x + y;
    }
    public static double add(double x, double y) {
        return x + y;
    }
    public static double add(double x, double y, double z) {
        return x + y + z;
    }

    //=======方法的调用=======
    public static void main(String[] args) {
        add(1, 2); // 调用add(int, int)
        add(1.5, 2.5); // 调用add(double, double)
        add(1.5, 2.5, 3.5); // 调用add(double, double, double)
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

方法重载的特点：

1. 方法名必须相同
2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)
3. 与返回值类型是否相同无关
4. 编译器在编译代码时，会对实参类型进行推演，根据推演的结果来确定调用哪个方法
5. 两个方法如果仅仅只是因为返回值类型不同，是不能构成重载的，运行时报错

🍑3、方法签名

我们知道同一个作用域中不可以定义两个相同的标识符。如：方法中不能定义两个相同的变量，那么为什么类中可以定义方法名相同的方法呢？其实实际存储的方法信息的名字叫做方法签名：经过编译器编译修改过之后方法最终的名字。具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。

public class TestDemo2 {
    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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

我们可以对上面这段代码进行编译，利用反汇编工具可以观察到重载方法的真正名字——方法签名：

上图中的两个方法签名：add:(II)I表示两个参数为int，返回值为int的方法；add(DD)D表示两个参数为double，返回值为double的方法。

对于方法签名中的一些特殊符号说明大家可以了解一下：

三、递归

程序调用自身的编程技巧称为递归（ recursion）。递归能否成功在于两个必要条件是否实现：

1.存在限制条件，当满足这个限制条件的时候，递归便不再继续。

2.每次递归调用之后越来越接近这个限制条件

对于递归，笔者在C语言函数部分做过一些介绍，感兴趣欢迎阅读《C语言函数》，下面就以两道例题向大家介绍一下递归的基本思想，如果对递归感兴趣，千万不要错过文末的《汉诺塔》哦！

🍑1、递归例题详解

📃1、甲到底多少岁？

已知有5人，他们的年龄有如下关系：

1. 第5个人说比第4个人大2岁
2. 第4个人说比第3个人大2岁
3. 第3个人说比第2个人大2岁
4. 第2个人说比第1个人大2岁
5. 第1个人说他今年10岁
   
   

求第5个人今年多少岁？

显然，这是一个递归问题，我们可以用递归的方法求解
递归思想图解：

📝代码展示：

public class TestDemo2 {
    public static int age(int n) {
        if(n==1) {//限制条件
            return 10;
        } else {
            return 2+age(n-1);
        }
    }

    public static void main(String[] args) {
        System.out.println(age(5));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

📃2、编写函数，接受一个整型值（无符号），按照顺序打印它的每一位。
📝代码展示：

public class TestDemo2 {
    public static void print(int n) {
        if(n>9) {
            print(n/10);
        }
        System.out.println(n%10);
    }

    public static void main(String[] args) {
        print(1234);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

🍑2、汉诺塔

汉诺塔是一道非常经典的递归问题，笔者已经对汉诺塔进行了一个总结，如感兴趣，欢迎阅读：《深入浅出『汉诺塔』》

总结

本章对Java中的方法进行了一个较为全面的介绍，重点理解Java中方法重载的概念。笔者重在整理，浅浅介绍，如有不足，敬请斧正！

------------------ （下期见！）------------------