方法 方法的重载 可变参数 递归

方法

//语法
修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...  
    return 返回值;
}

public static void main(String[] args) {
       int sum = add(1, 2);
}
//加法
    public static int add(int a, int b) {
        return a+b;
    }

//比大小
    public static void main(String[] args) {

        int max=max(10,50);
        System.out.println(max);
    }
    public static int max(int num1,int num2){

        int result;

        if(num1==num2){
            System.out.println("num1==num2");
            return 0;//终止方法
        }
        if (num1>num2){
            result=num1;
        }else{
            result=num2;
        }
        return result;
    }

方法的重载

在一个类中，有相同的函数名称，但形象不同的函数

方法名称相同时，编译器会根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，若匹配失败，编译器会报错

public static void main(String[] args) {
        int sum=add(1,2);
        System.out.println(sum);
    }

    public static int add(int a,int b){
        return a+b;
    }

    public static int add(int a,int b,int c){
        return a+b+c;
    }
    public static double add(double a,double b){
        return (a+b);
    }
//方法名都为add
//若要使用double，最上面的main方法应改为double sum=...

不定长参数

//使用不定长参数重载加法运算方法
public class Demo01 {
    public static int add(int...a){//定义不定长参数方法
        int sum=0;
        for (int i = 0; i < a.length; i++) {     //根据参数个数做循环操作
            sum +=a[i];//sum=sum+a[i]
        }
        return sum;//返回结果
    }

    public static void main(String[] args) {
        System.out.println(add(1,5,8,2));
    }
}

规则

1. 方法名必须相同
2. 参数列表必须不同(个数，或类型，或参数排列顺序不同等)
3. 方法的返回类型可以相同也可以不同
4. 仅仅返回类型不同不足以成为方法的重载

可变参数

在方法声明中，在指定参数类型后加一个省略号...

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

public static void main(String[] args) {
        v3 v3 = new v3();
        v3.test(1,64,69,6);

    }
    //int x 即为普通参数
    //int...i 可变参数，不限制个数

    public void test(int x,int...i){
        System.out.println(i[1]);
        //[]中的为输出可变参数中的第n-1个数
        //此处输出69
    }

递归

自己调用自己

//阶乘
public class D1 {
    public static void main(String[] args) {
        System.out.println(f(10));
    }

    public static int f(int n){
        if (n==1){
            return 1;
        }else{
            return n*f(n-1);
        }
    }
}

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

递归体:什么时候需要调用自身方法