Java之方法的使用

1.方法的概念及使用

1.1什么是方法

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

那么方法为什么会出现呢？

当我们在写代码时会经常出现一段代码重复出现，每次都要我们来写真的很麻烦，于是出现了方法，将重复的代码块构成一个方法，那么我们只需要写一遍就能够多次调用这个方法。例如：在数组中，我们需要多次判断数组是否为空，那么我们就可以定义一个判断数组是否为空的方法。

那么应该如何定义方法？

1.2方法的定义

在Java中，方法是一段用来执行特定任务的代码，它包括方法名称、参数、返回类型和方法体。（在java当中，方法必须写在类当中）

语法格式

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

示例一：实现两个整数相加的方法

public class test1 {
    public static int add(int a,int b){
        return a + b;
    }
}

示例二：实现判断一个年份是否为闰年的方法

public class test1 {
    public static boolean isLeapYear(int year){
        if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0){
            return true;
        }else{
            return false;
        }
    }
}

注意：

1. 修饰符：现阶段直接使用public static 固定搭配（我们刚开始学习java,先这样使用，等到后面会有）。
2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成
   void
3. 方法名字：采用小驼峰命名
4. 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
5. 方法体：方法内部要执行的语句
6. 在java当中，方法不能嵌套定义

1.3方法调用的执行过程

方法调用的过程

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

这里我们要注意

方法在定义时，并不会被执行，而是在调用的时候才执行，并且可以被多次调用，一定要记住哦！！！

为了加深印象，我们用一段代码来说明

计算两个整数相加

public class test2 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println("方法调用前：");
        int result = add(a,b);
        System.out.println("方法调用后");
        System.out.println("result=" + result);

    }
    public static int add(int x,int y){
        System.out.println("调用方法中 x = " + x + " y = " + y);
        return x + y;
    }
}


// 执行结果
方法调用前：
调用方法中 x = 1 y = 2
方法调用后
result=3

现在是不是清楚明白了 ，嘿嘿

1.4实参和形参的关系

实参*，顾名思义，实际的参数
形参，顾名思义，形式上的参数

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

public class test3 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        int result = add(a,b);
        System.out.println("result=" + result);
    }
    public static int add(int x,int y){
        return x + y;
    }
}

我们要注意……

莫？

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

示例一：交换两个整数

public class test4 {
    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 temp = x;
        x = y;
        y = temp;
        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产生任何影响

注意：对于基础类型来说, 形参相当于实参的拷贝. 即 传值调用（对 x 和 y 的修改, 不影响 a 和 b）

那么如果想交换a和b的值难道不能用方法了吗？

可以的，我们可以传引用类型参数，例如数组

public class test5 {
    public static void main(String[] args) {
        int arr[] = new int[]{10,20};
        swap(arr);
        System.out.println("arr[0] = " + arr[0] + " arr[1] = " + arr[1]);
    }
    public static void swap(int[] arr){
        int temp = arr[0];
        arr[0] = arr[1];
        arr[1] = temp;
    }
}

//运行结果
arr[0] = 20 arr[1] = 10

1.5方法的返回值

当方法没有返回值时，返回值类型为void，例如上述代码。

2.方法的重载

2.1为什么需要方法重载

首先，我们来实现两数相加的代码

两个数有可能是整型，也有可能是浮点型

public class test6 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int intResult = addInt(a,b);
        System.out.println("intResult=" + intResult);

        double c = 1.21;
        double d = 3.14;
        double doubleResult = addDouble(c,d);
        System.out.println("doubleResult=" + doubleResult);
    }
    public static int addInt(int x,int y){
        return x + y;
    }

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

上述代码确实可以解决问题，但是取名字本来就是为了方便，为什么不能都取名为add呢？

2.2方法重载的概念

在Java中，重载是指在同一个类中或者在一个子类中允许存在有多个同名的方法，但这些方法的参数类型、参数个数、参数顺序至少有一个不同。返回类型不能用来区分重载的方法

例如：

public class test7 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        int result1 = add(a,b);
        System.out.println("result1=" + result1);
        int result2 = add(a,b,c);
        System.out.println("result2=" + result2);

        double d = 3.14;
        double e = 1.21;
        double result3 = add(d,e);
    }
    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;
    }
}

注意

1. 方法名必须相同
2. 参数列表必须不同（即上面提到的参数类型、参数个数、参数顺序至少有一个不同）
3. 重载与方法的返回值是否相同无关（即两个方法只有返回值类型不同，无法构成重载）

那java是如何区分调用的是哪个方法呢？

编译器在编译代码时，会对实参类型进行推演，根据推演的结果来确定调用哪个方法

3.递归

3.1生活中的案例

上述图片中，自身中又包含了自己。

3.2递归的概念

在Java中递归就是一个方法调用自己，直到达到某个基本条件（终止条件）。在这种情况下，方法将不再调用自己，从而避免无限循环。

举一个数学当中的例子

例如, 我们求 N!
起始条件: N = 1 的时候, N! 为 1. 这个起始条件相当于递归的结束条件.
递归公式: 求 N! , 直接不好求, 可以把问题转换成 N! => N * (N-1)!

public class test8 {
    public static void main(String[] args) {
        int a = 8;
        int result = factor(a);
        System.out.println("result=" + result);
    }
    public static int factor(int a){
        if(a == 1){
            return 1;
        }
        return a * factor(a - 1);
    }
}

//执行结果
result=40320

3.3递归执行过程的分析

如图所示就是递归的过程，先递再归，逐个递用，再归还回去。

4.练习

要自己做完再看哦

练习1：按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)

public class test9 {
    public static void main(String[] args) {
        int number = 1234;
        Print(number);
    }
    public static void Print(int number){
        if(number > 9){
            Print(number / 10);
        }
        System.out.print(number%10 + " ");
    }
}

练习2：写一个递归方法，输入一个非负整数，返回组成它的数字之和. 例如，输入 1729, 则应该返回
1+7+2+9，它的和是19

public class test10 {
    public static void main(String[] args) {
        int number = 1729;
        int sum = sum(number);
        System.out.println("sum=" + sum);
    }
    public static int sum(int number){
        if(number <= 9){
            return number;
        }
        return number % 10 + sum(number/10);
    }
}

练习3：求斐波那契数列的第 N 项

public class test11 {
    public static void main(String[] args) {
        int number = 8;
        int n = fib(number);
        System.out.println("n=" + n);
    }
    public static int fib(int number){
        if(number == 1 || number == 2){
            return 1;
        }
        return fib(number - 1) + fib(number - 2);
    }
}

学完的你们 be like