方法的定义、调用、重载、、可变参数、递归

方法

方法就是语句块的集合，包含于类或者对象中，实现某一个功能，相当于类的一个行为。

方法的设计原则：方法的本质就是一个功能。设计方法的时候，一个方法只完成一个功能，保持方法的原子性，有利于后期扩展。方法的命名规则采用驼峰标识法。

return 0；终止方法。

方法的定义

方法包含方法头和方法体，没有具体实现方法的方法属于抽象方法，方法头包含修饰符、返回值类型、方法名、参数类型。方法体包含具体的语句，定义该方法的功能。

• 修饰符：（可选）定义该方法的访问类型，告诉编译器如何调用该方法。
• 返回类型：有的方法功能实现完需要返回值，根据值的类型需要声明对应的数据类型，有的方法实现完功能但是没有返回值，这种情况返回值类型需要使用关键字void。
• 方法名：方法的实际名称，标识符。方法名与参数列表（参数个数，参数类型，参数排列顺序）共同构成方法签名。（唯一）
• 参数类型：（可选）方法可以不包含参数。
• 方法体：定义该方法的功能，方法体包含具体的实现语句。

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

---

方法的调用

• 调用方法(没有static修饰)：对象名.方法名（实参列表）
• 当方法有返回值时，方法的调用通常被当作一个值，即把方法当成一个值赋值给变量。

int max = max(5,55);

• 如果方法的返回类型是void的时候，方法的调用一定是一条语句。

System.out.println();

示例：

package method;

public class MaxDemo {
    public static void main(String[] args) {
        //这里a，b为实际参数，把5赋值给a，55赋值给b
        int max = max1(5,55);
        System.out.println(max);

        max2(55,66);
    }

    //定义一个比较大小的方法
    //a,b均属与形式参数，可不写。
    //不用static修饰方法的话，要调用方法需要实例化MaxDemo类，通过对象调用方法
    public static int max1(int a,int b){
        //定义一个变量result，用于存放比较结果。
        int result = 0;
        if(a>b){
            result = a;
        }else{
            result = b;
        }
        return result;
    }
    
    public static void max2(int a,int b){
        int result = 0;
        if(a>b){
            result = a;
        }else{
            result = b;
        }
        System.out.println(result);
    }
}

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。

方法的重载的规则：

• 方法名必须相同。
• 参数列表（参数类型，参数个数，参数的排列顺序）必须不同。
• 方法的返回类型可以相同也可以不同。
• 返回类型不同不足以成为方法的重载。

实现的原理：方法名称相同时，编译器会根据调用方法的参数个数，参数类型等取逐个匹配，选择对应的方法，如果匹配失败，则编译器会报错。

示例（求两个整数的均值和求两个小数的均值）：

public class MethodOverload {
    //方法的重载
    public static void main(String[] args) {
        //整数
        int resultInt = avg(15,20);
        System.out.println(resultInt);
        //小数
        double resultDouble = avg(1.11,3.33);
        System.out.println(resultDouble);
    }
    //求两个整数的平均数
    public static int avg(int a,int b){
        return (a+b)/2;
    }
    //求两个小数的平均数
    public static double avg(double a,double b){
        return (a+b)/2;
    }
}

---

可变参数

• 从JDK5开始，java支持传递同类型的可变参数给一个方法。
• 可变参数：在指定参数类型后面加一个省略号（…）表明这个类型是个可变参数。如int…a
• 一个方法中只能指定一个类型的参数为可变参数，且这个参数必须是方法中形式参数的最后一个参数，任何普通参数必须在它之前声明。

示例（判断一串整数中最大的值）：传入一串整数，不知道要传入多少个，就可以用可变参数。

public class VariableParameter {
    public static void main(String[] args) {
        //max用于输出result
        int max = test(10,21,35,11,56);
        System.out.println(max);

    }
    //判断一串整数中最大的值。
    //int...a为可变参数
    public static int test(int...a){
        //如果没有整数传入，控制台输出“没有整数传入”
        if (a.length == 0){
            System.out.println("No integer passed！！");
            return 0;//终止方法
        }
        //传入的整数实际上是存放在数组里面的，数组的第一个元素下标为0。
        //返回的最大值为result
        int result = 0;
        for (int i = 0;i < a.length;i++){
            if (result <a[i]){
                result = a[i];
            }
        }
        return  result;
    }
}

---

命令行传参

有时候希望运行一个程序的时候再给它传递参数，这时候需要靠传递命令行参数给main函数实现。
示例：在运行主方法之后往主方法传入“I am Iron Man”，可是主方法运行之后我们却不知道该怎么传。（主方法的形式参数是一个String类型的数组，名称为args）

public class CommandLine {
    public static void main(String[] args) {
        for (int i = 0;i < args.length;i++){
            System.out.println("args["+i+"]="+args[i]);
        }
    }
}

我们在终端给main函数传递参数。



用cd…返回到src文件夹下然后用java命令运行试试

发现找不到主类，这是因为没有把包名也加进去！！

这个时候就实现简单的命令行传参了。

---

递归

递归：方法调用自己，按我自己的理解，递归其实可以看成一个循环，也需要设定一个条件（递归头），让递归停下来，如果一直递归，也会造成严重后果。利用递归，可以用简单的程序解决一个复杂的问题。递归就是把一个运算过程有很多重复的步骤简化成一个不重复的步骤，然后重复运行多次，直到最后一次的运算过程无法在分解（递归结束的条件），返回结果。如果需要递归的次数过多，则不建议使用递归。
递归头：运行到什么时候不再调用自己的方法，如果没有头，就会陷入死循环。
递归体：什么时候需要调用自己的方法。
示例（阶乘）：阶乘的计算用递归就能很好的解决。

public class RecursionDemo {
    //计算6的阶乘（6!）
    public static void main(String[] args) {
    int result = recursion(6);
        System.out.println(result);
    }

    public static int recursion(int a) {
    	//递归头，放传入的参数为1的时候，递归结束。
        if (a == 1) {
            return a = 1;
        } else {
        //如果参数不为一，则递归，调用自己再次计算
            return a * recursion(a-1);
        }
    }
}

调用完到头时，值会一个一个return回上一级，直到最开始。