方法基础知识——方法重载，可变参数与递归调用

23.什么是方法？

• System.out.print()，是什么？

• System —> 类

• out -----> 对象

• print() ----->方法

• 方法是实现某一功能的代码块集合。

• 方法包含与类或对象中

• 方法再程序中被创建，在其他地方被引用

• 方法设计原则

  • 方法是实现功能的代码块
  • 遵循原子性原则，一个方法只实现一个功能，这样利于我们后期扩展

• 方法的命名规则？

  • lowerCamelCase 风格 例子：addItem(), updateScore()

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

其中修饰符为可选项 public， static， private，protected等
*/

package com.demo.method;

public class Demo1 {
    //    main 方法
    public static void main(String[] args) {
        boolean ret = isPrimeNumbers(7); // 调用方法
        System.out.println(ret);
    }
//    定义一个判断数字是否是质数的类方法
  public static boolean isPrimeNumbers(int num) {
//    static 静态 提升作用域
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }
}

方法的重载

• 当类中有相同名称的方法名，但方法的形参不同，这就是方法重载
• 方法重载原则：
  1. 方法名必须相同
  2. 参数列表必须不同（个数不同，或类型不同，参数排列顺序不同等）
  3. 方法的返回值可以相同也可以不同
  4. 仅返回值不同不足以成为方法重载
• 编译器会根据参数的个数和类型去逐个匹配，以选择对应的方法，如果匹配失败，则编译器会报错

package com.demo.method;

public class Demo2 {
    public static void main(String[] args) {

        int max1 = max(5, 6);
        int max2 = max(3, 6, 9);
        double max3 = max(1.5, 9.5, 10.24);

        System.out.println(max1 + " " + max2 + " " + max3);

    }
    public static int max(int x, int y) {
        System.out.println("两个整数比较大小方法被调用");
        return x > y ? x : y;
    }
    public static int max(int x, int y, int z) {
        System.out.println("三个整数比较大小方法被调用");
        int max = 0;
        if (x > y) {
            max = x;
        } else {
            max = y;
        }
        if (z > max) {
            max = z;
        }
        return max;
    }
    public static double max(double x, double y, double z) {
        System.out.println("三个浮点数比较大小方法被调用");
        double max = 0;
        if (x > y) {
            max = x;
        } else {
            max = y;
        }
        if (z > max) {
            max = z;
        }
        return max;

    }
}

命令行传参

• 通过命令行的形式来传递参数给程序

package com.demo.method;

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

    }
}

• 在IDEA中传参

  1. 

  2. 

3. 

可变参数（不定项）

• 当我们需要给方法传递不确定长度的参数时可以用可变参数
• 可变参数只能有一个，且只能是最后一个
• 其本质是一个类数组对象

package com.demo.method;

public class Demo4 {
    public static void main(String[] args) {
        pprint(1, 2, 5, 6, 3, 2, 59, 5, 63, 2);
    }

    public static void pprint(int... nums) {  // 通过 变量类型... 方式创建的参数就是可变参数
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }
    }
}

• 求最大的值

package com.demo.method;

public class Demo5 {
    public static void main(String[] args) {

        double max;
        max = getMax(95, 65, 36.5, 69.2, 888, 77, 88, 9953, 651);
        System.out.println(max);
    }

    public static double getMax(double... numbers) {
        double max = numbers[0];
        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i] > max) {
                max = numbers[i];
            }
        }
        return max;
    }
}

递归

• 递归就是方法自己调用自己
• 递归有栈溢出风险

package com.demo.method;

public class Demo7 {
    public static void main(String[] args) {
        Demo7 demo7 = new Demo7();
        demo7.demoTest();
    }
    public void demoTest() {
        demoTest();
    }
}

• 构成递归需具备的条件：
  
  1. 子问题须与原始问题为同样的事，且更为简单；
  2. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。

package com.demo.method;

public class Demo8 {
    public static void main(String[] args) {
        Demo8 demo8 = new Demo8();
        int i = demo8.addNums(4);
        System.out.println(i);
    }

    public int addNums(int nums) {
//        这是一个累加方法
        if (nums == 1) {
            return 1;
        } else {
            return nums + addNums(nums - 1);
        }
    }
}

• 学习递归的思想，能不用递归则不用递归