Java 方法（基本用法、方法重载、方法递归）

一、方法的基本用法

1.方法的定义

方法就是一个代码片段，类似于C语言中的“函数”，每个方法都能表示一种能力或行为。

2.方法的定义语法

//方法定义    
public static 返回值声明  方法名称 ([参数类型] [参数名称]){
        方法体代码；
        [return 返回值];        
    }

注意事项：

方法定义时，参数可以没有。每个参数要指定类型。

方法定义时，返回值也可以没有，如果没有返回值，则返回值类型应该写为void。（判断一个方法有没有返回值取决于该方法的功能，在没有返回值的方法中依然可以使用return;表示提前结束方法的调用过程。）

方法定义时的参数称为“形参”，方法调用时的参数称为“实参”。

方法的定义必须在类中，调用该方法与其定义的位置无关，可以在方法实现代码之前调用方法。

方法中没有函数声明的概念，一旦定义了一个方法，就必须同步写它的实现。

3.方法调用的执行过程

基本规则：

定义方法的时候，不会执行方法的代码，只有调用时才执行。

当方法被调用时，会将实参赋值给形参。

参数传递完毕后，就会执行到方法体代码；当方法执行完毕之后（遇到return语句），就执行完毕，回到方法调用位置继续往下执行。

一个方法可以被多次调用。

代码示例1：

public class FacSum {//求1！+2！+3！+4！+........+n!的和.
    public static void main(String[] args) {
    int sum = 0;
        for (int i = 1; i <= 5; i++) {
        sum += factor(i);
    }
        System.out.println("sum = " + sum);
}

    private static int factor(int n) {
        System.out.println("计算n的阶乘中！n = " + n);
        int result = 1;
        for (int i = 1; i <= n ; i++) {
            result *= i;
        }
        return result;
    }
}

4.实参和形参的关系

形参：方法定义时，声明小括号内的参数

实参：方法调用时，声明小括号内的参数

参数传递机制：

如果参数类型是基本类型，此时实参赋给形参的是实参真实存储的数据值；

如果参数类型是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

可以先看看下面的例子：交换两个整形变量

 输出结果：

a =10,b =20

结果分析：

a，b没有交换，原因：对基础类型来说，形参相当于实参的拷贝，即传值调用。（将实参的值复制一份给形参）

int a = 10;
int b = 20;


int x = a;
int y = b;

int tmp = x;
x = y;
y = tmp;
//可以看到，对x和y的修改，不会影响a和b的值

解决办法：传引用类型参数（例如数组）来解决问题

class Test{
    public static void main(String[] args) {

        int[] arr ={10,20};
        swap(arr);
        System.out.println("a =" + arr[0] + ","  +"b =" + arr[1]);
    }

    private static void swap(int[] arr) {
        int tmp = arr[0];
        arr[0] = arr[1];
        arr[1] = tmp;
    }
}

输出结果：

a = 20,b = 10

5.没有返回值的方法

方法的返回值是可选的，有些时候可以没有。例如刚才交换两个整数的例子中，就是没有返回值的。

二、方法的重载

1.方法重载：在同一个类中，定义了若干个方法名称相同，参数列表不同（参数类型或个数不同），与返回值无关，这样的一组方法称为重载方法。

代码示例：

//方法重载的实例
public class Demo01 {
    public static void main(String[] args) {
        System.out.println(add1(10, 20));
        System.out.println(add2(10, 20,30));
        System.out.println(add3(10.0, 20.0));
    }
    public static int add1(int x, int y) {
        return x + y;
    }
    public static int add2(int x,int y,int z){//参数类型相同，参数个数不同
        return x+y+z;
}
    public static double add3(double x, double y) {//参数个数相同，参数类型不同
        return x + y;
    }
}

2.重载规则

针对同一个类：方法名相同；方法的参数不同（参数个数或参数类型）；方法的返回值类型不影响重载，当两个方法名字相同、参数也相同，但是返回值不同的时候，不构成重载。

三、方法的递归

1.一个方法在执行过程中调用自身，就称为“递归”。

条件：

（1）调用自身（隐式循环，重复执行某段代码，但是重复执行某段代码无须循环控制）
（2）有终止条件

2.哪些情况可以考虑使用递归来解决问题？

（1）一个大问题可以拆分为多个子问题的解；

（2）拆分后的子问题和原问题除了数据规模不一样，它们的解决思路完全相同。

（3）存在递归终止条件。

3.写递归需要时刻注意的问题：不要纠结于这个递归过程如何实现，要思考如何使用这个方法来解决问题！！

接下来还是看一个例子，递归求N的阶乘

class Test{
    public static void main(String[] args) {
        int n = 5;
        int ret = factor(n);
        System.out.println("ret = " + ret);
    }

    private static int factor(int n) {
        if(n == 1){
            return 1;
        }
        return n * factor(n-1);//factor 调用函数自身
    }
}
//执行结果
ret = 120