保姆级教程：java构造函数及递归调用

java基础补充

1.函数入门

public class Main {
    public static void main(String[] args) {
         f01();//调用，没返回值的函数是不能接受
         f02();//调用
        int i=f02();//有返回值的函数可以接收也可以不接受
        System.out.println(i);
        f03(18,"zhangsan");//参数必须给定，且参数顺序不能给错,直接输入参数值就可以了
    }
    /*
    共有的访问修饰符public 静态的static 没有返回值void 方法名(参数列表){
    方法体；
   return ;(有返回值)
    }
    方法不调用就不执行,只有在主函数中才调用和执行
 */
    public static void f01(){
        System.out.println("fo1()被调用");
    }
    //有返回值
    public static int f02(){
        System.out.println("f02被调用");
        return 100;
    }
    //参数列表
    public static void f03(int age,String name){
        System.out.println("f03被调用"+age+",名字"+name);
        //这时候参数必须给定，不能忽略
    }
}

函数重载

就是函数同命，但参数列表不一样的问题，函数是支持同名的

public class Main {
    /*
    函数重载原则：
          方法名相同
          参数列表不同，参数类型要不一样
       注意：
          与返回值无关
     */
    public static void main(String[] args) {
         f01(1);//具体调用哪个跟参数类型有关
    }
​
    public static void f01(String[] args){
        System.out.println("args被调用");
    }
    public static int f01(double money){
        System.out.println("money被调用");
        return 100;
    }
}

函数可变个数参数

public class Main {
    public static void main(String[] args) {
         f01(1);//具体调用哪个跟参数类型有关
        f01(1,2);
        f01(1,2,3);
    }
​
    public static void f01(int x1){//int
        System.out.println("f01(int)被调用");
    }
    public static void f01(int x1,int x2){//int int
        System.out.println("f01(int,int)被调用");
    }
    public static void f01(int x1,int x2,int x3){//int int int
        System.out.println("f01(int,int,int)被调用");
    }
    /*
    上面只是参数个数不一样，但类型一样,返回值一样，函数名也一样的情况下
    能不能简化，只用一个参数
     */
   }

通过设置断点，我们能发现x是数组

public class Main {
    public static void main(String[] args) {
        f01();
        f01(1);//具体调用哪个跟参数类型有关
        f01(1,2);
        f01(1,2,3);
        f01(new int[]{1,2,3,4,5});//直接传入一个数组
    }
    public static void f01(int...x){//所以这里的x是一个int型的一维数组
        System.out.println("f01(int...x)被调用");
        System.out.println(Arrays.toString(x));//通过数组遍历也能看出x是数组
    }
}

foreach输出

import java.util.Arrays;
​
public class Main {
    public static void main(String[] args) {
        f01();
        f01(1);//具体调用哪个跟参数类型有关
        f01(1,2);
        f01(1,2,3);
        f01(new int[]{1,2,3,4,5});//直接传入一个数组
    }
    public static void f01(int...x){//所以这里的x是一个int型的一维数组
        System.out.println("f01(int...x)被调用");
        //自动循环x数组，每次去除一个送到变量i上,会自动结束
        for (int i : x) {//输入x.for就会自动弹出，这就是foreach输出（增强版for循环），没有下表
            System.out.println(i);
        }
    }
}

传参—基本数据类型

import java.util.Arrays;
​
public class Main {
    public static void main(String[] args) {
        int y=10;//实参，都是值传递，所以形参x发生变化时，y是不会发生变化的
        f01(y);
    }
    /*
       x是形参
     */
    public static void f01(int x){//形参接受实参的值
        x++;
    }
}

传参引用数据类型

如果实参是地址，那么传给形参的是地址传递，所以形参改变的时候，实参也会发生变化

文件夹展示所有的文件

为什么会有递归调用？

将文件夹下面所有的文件枚举出来

1.根文件夹下有没有文件夹

2.根文件夹下的文件打印出来

每次进入到一个文件夹，都需要反复执行该段代码

import java.io.File;
import java.util.Arrays;
​
public class Main {
    public static void main(String[] args) {
        showFiles(new File());
    }
    /*
      展示文件夹下所有的文件，包含子文件夹下的文件
     */
    public static void showFiles(File file){
        //showFiles(File file)显示该文件下面所有的文件
        File[] files=file.listFiles();//listFiles()枚举该文件file对象下的文件夹对象
        for (File f : files){
            if (f.isFile()) System.out.println(f.getName());//打开文件
            if (f.isDirectory()) showFiles(f);//递归调用文件夹
        }
    }
}

在实际开发中，能不用递归就不用递归

1加到100的递归调用

import java.io.File;
import java.util.Arrays;
import java.util.Scanner;
​
public class Main {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int count=scanner.nextInt();
        System.out.println(sum(count));
    }
    public static int sum(int count){//递归函数
        if (count==1) return 1;
        return sum(count-1)+count;//
    }
}