夹哇基础知识总结part4（方法的使用）

Java当中方法的使用

一、方法是什么？

1、java方法 对应 c语言的函数。
2、方法就是一个代码片段，可以看做是一个功能。
3、能够模块化的组织代码。让代码能够被重复使用，简化开发。
4、main（）也是一个方法

二、方法的书写规范

   public static 返回值（int char void等） 方法名称 （形式参数列表）｛
            方法体；
    ｝
其中：
  方法名：采用“小驼峰”形式
  加public static的原因：因为当前所有的方法写完后，会在main方法中调用，因为main方法是public static的。
   返回值：可有可无，看具体业务需求。;如果有返回值 那么返回值的类型需要和方法的返回值类型匹配，
  形式参数列表：形参->>实参的一份拷贝。
  方法体｛｝：具体方法的实现。
  return : 代表着方法（函数）的结束，一旦return，下面的代码都不执行了。

下面使用几个方法来具体介绍一下方法的含义以及定义方法：

public class Method01 {
    //方法：求两个数的最大值
    public static int maxNum(int num1, int num2) {
        return num1 > num2 ? num1 : num2;
    }
    //方法：求三个数的最大值
    public static int maxThreeNum(int num1, int num2, int num3) {
        return maxNum(maxNum(num1, num2), num3);          //函数的重复调用，在一个函数里可以调用另一个函数。
    }
    //方法：实现两个整数相加
    public static int numAdd(int num1,int num2){
        return num1+num2;
    }
    //方法：计算n的阶乘和(可优化)
    public static int factor(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {            //产生1-n
         //**************************************
         //  int ret = 1;                         //
         //  for (int j = 1; j <= i; j++) {       //这部分的功能是求一个数字的阶乘，
         //       ret *= j;                       //所以可以单独封装成一个方法。
         //  }                                    //
         //**************************************
            sum +=fac(i);
        }
        return sum;
    }
    //方法5的延伸：求一个数字的阶乘
    public  static int fac(int num){
        int ret = 1;
        for (int i = 1; i <= num; i++) {
            ret *= i;
        }
        return ret;
    }
//main方法在这！！！！
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n1 = sc.nextInt();                         //n1,n2,n3在方法内，称之为局部变量，在内存中存在栈上，
        int n2 = sc.nextInt();
        int n3 = sc.nextInt();
        System.out.println(maxNum(n1, n2));
        System.out.println(maxThreeNum(n1, n2, n3));   //如果函数有返回值就可以直接写在sout里
        System.out.println(numAdd(n1, n2));
        System.out.println(factor(5));
    }
}

三、实参与形参的关系

Java中方法的传参方式是“按值传递”的

	//方法1：交换两个数的值，
    public static void swap(int x, int y ){
        int tmp = x;
        x = y;
        y = tmp;
    }
       /**
    *@Describle: 方法中实参和形参的关系
    *@Author: Pryor_Pan
    *@Date: 2021/03/31
   */
    public static void main1(String[] args) {
        int a = 10;
        int b = 20;
        //这是在main中普通的交换a和b的值
//        int tmp = a;
//        a = b;
//        b = tmp;
        //***************
        swap(a,b);                      //这一步只交换了方法中形参的值，实参的值并没有发生改变。此处要想使用该方法交换两个数的值，需要用到类和对象，或者数组。
        System.out.println(a+" " + b);  //output: 10  20
    }

  上面我们可以看到，我们定义了一个用于交换两个整数的值的方法，调用了该方法以后a和b的值并没有发生改变，这是为什么呢？
  由于Java按值传递的特性，在调用方法的时候，传到方法中的值叫做形参，方法只是对形参的值作了交换，而实际上实参的值并没有发生改变，所以这礼物我们看到a的值还是10，b的值还是20.

四、方法的重载

在数据类型的学习中，我们知道，Java中变量名是不能重复的，比如：
我一开始定义了一个int型的变量a：
      int a = 10；
当我们再尝试定义另一个叫做a的变量时，系统会提示异常：
      double a = 9.9；

但是，对于方法来说，不存在这样的约束：

    //方法2：分别计算两（三）个整（浮点）数的和
    public static int sum(int a, int b){                        //方法名为sum，参数为 两个 int
        return a+b;
    }
    public static double sum(double a,double b){                //方法名为sum，参数为 两个 double
        return a+b;
    }
    public static double sum(double a,double b,double c){       //方法名为sum，参数为 三个 double
        return a+b+c;
    }
    
    public static void main1(String[] args) {
        int a = 10;
        int b = 20;
        double x = 5.5;
        double y = 4.5;
        double z = 2.0;
        System.out.println(sum(a, b));              //这三条语句虽然调用的方法名都是sum，
        System.out.println(sum(x, y));              //但是由于他们的形参参数类型（个数）不同
        System.out.println(sum(x, y, z));           //所以调用的时候并不会报错。
    }

  在定义方法时，我们可以同时定义多个方法，他们的方法名可以相同，但前提是，他们的返回类型、参数个数之中，必须至少有一个不同，满足了这个条件，我们就可以使用同一个方法名来给多个方法命名了。
这就是方法的重载！！

五、递归（我调我自己）

1、方法的递归：一个方法在执行的过程中调用自身，就称之为“递归” (我调我自己)
    他是一个把一个大问题化解小的问题，因为，大问题的处理方式
    和小问题的处理方式是一样的，比如：求n的阶乘，那么求4的阶乘和求3的
    阶乘的方法是一样的
 要满足的条件：
   1)、要调用自己本身
   2)、要有一个趋近于终止的条件
   3)、推导出递归的公式（重要）

经典的可用递归求解的问题

1、求一个数的阶乘（递归）

//方法1：求一个数的阶乘（递归）
    public static int fac(int n) {
        //如果没有这个终止条件，就会一直递归下去，最终就把栈挤爆了。一个栈一般就1M~2M大小。报错：StackOverflowError
        if (n == 1) {
            return 1;
        }
        return n * fac(n - 1);
    }

2、按顺序打印一个数字的每一位

//方法2：按顺序打印一个数字的每一位,
    public static void func1(int n) {
        //首先终止条件:如果是一个数字，那不用执行递归，直接输出。
        if (n > 9) {
            func1(n / 10);                  //当不是个位数的时候，除以10，尝试把它变成个位数，因为只有个位数才能被输出
        }
        System.out.print(n % 10 + " ");
    }

3、求1+2+3+4+…+n

//方法3：求1+2+3+4+.....+n
    public static int addNum(int n){
        if (n == 1){
           return 1;
        }
        return n+addNum(n-1);
    }

4、斐波那契数列

//方法5：用递归求斐波那契数列第n项，第n项等于前两项的和.
// 这是一个双路递归，了不得了，每次递归要找两个前置项，又要找前四项，又要找前八项，又要找前十六项，子子孙孙无穷尽也。
    public static int fabonaci1(int n){
        if (n == 1 || n == 2){
            return 1;
        }
        return fabonaci1(n-1)+fabonaci1(n-2);         //所以，一般不建议用递归实现斐波那契数列，，用迭代（循环）
    }

斐波那契数列也有非递归的写法：

//方法5.1：用循环求斐波那契数列第n项（非递归）
    public static int fabonaci2(int n){
        int f1 = 1;
        int f2 = 1;
        int f3 = 1;             //f3的初始值设为1的原因是因为当n等于1的时候直接是f3的初始值。
        for(int i = 3 ;i<=n ; i++){
            f3 = f1+f2;
            f1 = f2;
            f2 = f3;
        }
        return f3;
    }