java中方法的使用

1.方法存在的意义

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

2.方法中的注意点

1. Java当中的方法一定是写在类里面的，代码书写在调用位置的上方或者下方均可
2. 方法的名称一定是小驼峰maxNum
3. 方法需要运行在栈上，任何一个方法调用，需要在栈上开辟一个栈帧
4. 方法定义时, 参数可以没有. 每个参数要指定类型
5. 方法定义时, 返回值也可以没有, 如果没有返回值, 则返回值类型应写成 void
6. 方法定义时的参数称为 “形参”, 方法调用时的参数称为 “实参”.
7. Java 中没有 “函数声明” 这样的概念，和C不一样，写在哪里不影响

3.方法执行过程

• 在栈上开辟main函数的栈帧，程序继续在main函数中往后执行
• 遇到方法后又开辟一块栈帧，程序跳转到方法体中执行函数
• 待执行完方法体后，该函数栈帧消失，并继续main函数中执行
• 待main函数执行完，main函数栈帧消失，栈变为空，程序执行完成
  
  基本规则
• 定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行.
• 当方法被调用的时候, 会将实参赋值给形参.
• 参数传递完毕后,就会执行到方法体代码.
• 当方法执行完毕之后(遇到 return 语句), 就执行完毕, 回到方法调用位置继续往下执行
• 一个方法可以被多次调用

示例：计算 1! + 2! + 3! + 4! + 5!

public class test {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += factor(i);
        }
        System.out.println("sum = " + sum);
    }
    public 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;
    }
    // 执行结果
//    计算 n 的阶乘中! n = 1
//    计算 n 的阶乘中! n = 2
//    计算 n 的阶乘中! n = 3
//    计算 n 的阶乘中! n = 4
//    计算 n 的阶乘中! n = 5
//    sum = 153
}

4.形参与实参

• 形参：用于定义方法的时候使用的参数，是用来接收调用者传递的参数的。
• 用于调用时传递给方法的参数。实参在传递给别的方法之前是要被预先赋值的。

我们先来看这样一段代码

    public static void swap(int a,int b){
        int tmp = a;
        a = b;
        b = tmp;
    }

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

执行这段代码，a和b能够交换值吗？

答案是否定的，这里仅仅是按值传递，只在方法内部形参交换了值，而实参并没有改变
学过C的小伙伴都应该知道，这时需要用指针，传入地址来使实参改变

但是java中可没有指针这种东西，所以我们要用的就是传引用类型参数来解决
如下代码

        public static void main(String[] args) {
            int[] arr = {10, 20};
            swap(arr);
            System.out.println("a = " + arr[0] + " b = " + arr[1]);
        }
        public static void swap(int[] array) {
            int tmp = array[0];
            array[0] = array[1];
            array[1] = tmp;
        }

引用说白了就是一个变量，来存放地址
数组使一个引用类型的对象，数组里面的元素存放在堆上

若是打印数组名，则会显示这样一个东西

在栈上的地址我们使无法获取的，我们只能获取到这样一个地址的哈希码，它是唯一的。

具体过程：

形参和实参所指向的都是一个对象，改变形参中的值则也就改变了实参中的值，所以能够完成交换的任务。

5.方法的重载

面试问题：重载（overload）和重写（覆盖/覆写）（override）的区别？

重载：

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 double add(double x, double y, double z) {
        return x + y + z;
    }
    /**
     * 可变参数变成
     * int... 变量
     * @param array
     * @return
     */
    public static int add(int... array) {
        int add = 0;
        for (int x : array) {
            add = add + x;
        }
        return add;
    }

    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);
        double a3 = 10.5;
        double b3 = 10.5;
        double c3 = 20.5;
        double ret3 = add(a3, b3, c3);
        System.out.println("ret3 = " + ret3);

        System.out.println("ret4 = " + add(1,2,3,4,5,6,7,8,9,10));
    }

重写后面再补充！

6.递归

思路：将大问题化解为小问题，意味着处理大问题的方式和处理小问题的方式是一样的。
去找递归的递推公式

1. 有一个趋近于终止的条件
2. 调用自己本身

对于递归来说，我们可以看作两步。

1. 递
2. 归

例子：递归求 N 的阶乘

    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;
    }

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

再这个程序中是这样一个过程：