可变参数和递归详细讲解

可变参数

package method;

public class Day04 {
    public static void main(String[] args) {
    }
    public void method(){}
    public void method(int i){}
    public void method(int i,int i2){}
    public void method(double i ,double i2) {}
}

有时候我们的方法参数有时候可能需要写几十次，这样就比较麻烦了

我们可以使用可变参数来代替他

语法

public static void printMax( double...numbers){
    if (numbers.length == 0){
        System.out.println("No argument passed");
        teturn;
    }
    double result = numbers[0];
    //排序！
    for (int i = 1; i< numbers.length;i++){
        if(numbers[i] > result){
            reult = numbers[i];
        }
    }
    System.out.println("The max value is" + result);
}

• 在方法声明中，在指定参数类型后加一个省略号(…)。

  什么意思呢？

  public static void printlnMax( **double…**numbers)

  我们在这个double参数类型后面加一个…（省略号） 这个地方就是 可变参数了！！！！

  但是一个方法中只能指定一个可变参数，他必须是方法的最后一个参数、任何普通参数必须在他之前声明。

示列

package method;

public class Day04 {
    public static void main(String[] args) {
        Day04 day04 = new Day04();
        //      day04   对象
        //new  Day04();   然后创建新变量， 就会得出Day04 day04 = new Day04();
            day04.test(10,20,30,40,50,100);
    }
    public void test(int...i){
    //我们想传递一个i，但是有时候会需要传递多个i，也不知道要传递几个，我们只要在int后面加上...   就可以无限传了
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[3]);
        System.out.println(i[2]);
        System.out.println(i[4]);
        System.out.println(i[5]);
        }
}

这次我们不要static传递，用第二中传递方式

我们先new Day04()；, 然后给他添加一个新的变量 就变成了

Day04 day04 = new Day04();

day04 就是对象

然后再day04.test(int…i 10,20,30,40,50,100);

你就会发现括号里面会自动添加一个int…i

我们输出一下就会发现

输出的数字的位置，是由可变参数的

  System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[3]);
        System.out.println(i[2]);
        System.out.println(i[4]);
        System.out.println(i[5]);

来排序的

简单来说，数组就是省略了，我们要排序一个数值，然后输入一大堆变量 类型

比如

System.out.println(i);
System.out.println(k);
System.out.println(j);
int i = 10;
int j = 20;
int k = 30;

就是来省略这种写法，让我们简单快捷轻松很多

至于第二种调用是什么意思，我是这样理解的

我们先new 一个类 也就是把我们写的这个类给新建一下

new Day04；然后我们给他一个新变量，就会返回一个当前

Day04 day04 = new Day04();
//     day04 就是我们的对象

然后再输入一个

day04.test（);
//对象.方法

意思就是

Day04 day04 = new Day04();

来创建这个day04 这个类

然后这个day04这个类里面存在test这个方法

public void test(int...i){
        System.out.println(i[0]);    
        }

这个test的方法就在day04对象的里面

所以我们要通过day04来调用test方法

可变参数只能放在后面

我们再在后面加个int x

就会发现报错

他必须放到最后面

他所有的条件参数必须是统一个类型

我在里面加入一个double就不行了

递归★ (重点也是难点)

• A方法调用B方法，我们很容易理解！

• 递归就是：A方法调用A方法，自己调用自己

  package method;
  
  public class Day05 {
      public static void main(String[] args) {
          Day05 test = new Day05();   //new 一个Day05   创建这个类的对象
          // Day05  类型  test  变量名    new Day05  变量值
          test.test();   //就是test  代替了day05 这个类，  这个类里面就有test这个方法
      }
      public void test(){
          test();    //旁边的绿色箭头就是调用自己
      }
  }
  

new 一个Day05 创建这个类的对象**
Day05 类型 test 变量名 new Day05 变量值
test.test(); 就是test 代替了day05 这个类， 这个类里面就有test这个方法**

我们运行一下，就会发现出错了

显示占异初异常，我们电脑的内存不够了

递归不是这样使用的

递归解释

• 利用递归可以用简单的程序来解决一些复杂的问题。他通常把一个大型复杂的问题层层转化为一个与原问题像是的规模较小的问题来求解，大大的减少程序的代码量。递归的能力在与用有限语句来定义对象的无线集合。

递归结构包括两个部分

• 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。

• 递归体：什么时候需要调用自身方法。

package method;

public class Day06 {
    //1! 1
    //2! 2*1      阶乘的概念
    //3! 3*2*1    感叹号是数学里面表示阶乘的方式
    //5! 5*4*3*2*1
    // 2   2*f(1)
    //3   3 *f(2)
    public static void main(String[] args) {
        System.out.println(f(4));
    }
    public static  int f(int n){
        if (n==1){    //如果 n就是传递的这个参数等于1 的时候     就让他return  1    因为1的阶乘是他的本身
            return 1;
        }else {
            return n*f(n-1);
        }
    }
}

我们写一个计算阶乘的代码

​ if （n==1）如果 n传递的参数等于1 ，那么将直接return 返回一个值 1

如果不等于1 ，则返回一个return n*f(n-1)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PPXLzb5B-1613891397667)(I:\Java图片\可变参数\7.PNG)]

我们输入System.out.println(f(5));

如果f为5的话，if函数就会先求出f(5)的值，然后再return返回这个值，在执行f(4)的值，然后返回，在执行f（3）的值，然后f(2),f(1)

当n等于1的时候将不会在继续执行

最后产生了一个结果，在吧这个值以此传给f(2 ),f(3)

public static  int f(int n)

这里int f 为f（5）的值（20），然后再乘（int n） int n 为4 不等于1 ，

在走一次

else {
                return n*f(n-1);
            }

此时 return返回的值是3*20 n=（4-1）

然后n=3 不等于1 继续执行

此时return返回的值是2*60 n=（3-1）

以此推类

边界条件：就是到最后一个数的时候，程序会执行到底

我们的边界是当f=1的时候所有的值都一步一步返回

前阶段：当我们这个参数不等于1的时候就会不停的调用自身，知道等于1的时候，在返回结果

*返回阶段： 就是f(5)f(4) 就是 5 * 5-1

就是n * （n-1）

使用递归的前提必须是基数比较小的情况下，太大的会会物理影响电脑的性能

简单来说就是能不用就不用