JavaDay6

可变参数

• JDK1.5开始，Java支持传递同类型的可变参数给一个方法
• 在方法声明中，在指定参数类型后加一个省略号(...)。
• 一个方法只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

package method;

public class Demo04 {
    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();

        demo04.printMax(10,20,30);

    }

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

}
输出：
30

递归

• A方法调用B方法，我们很容易理解!
• 递归就是:A方法调用A方法!就是自己调用自己。
• 利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
• 递归结构包括两个部分:
  • 递归头:什么时候不调用自身方法。如果没有头，将陷入死循环。
  • 递归体:什么时候需要调用自身方法。

package method;

public class Demo06 {
    public static void main(String[] args) {
        //递归思想
        System.out.println(fn(5));

    }
    public static int fn(int n){
        if(n == 1){
            return 1;
        }else {
            return n * fn(n-1);
        }
    }
}
输出：
120

Test

package method;
import java.util.Scanner;
public class Test {
    // 加法：支持任意数量的数字相加
    public static double add(double... nums) {
        double sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        return sum;
    }

    // 乘法：支持任意数量的数字相乘
    public static double multiply(double... nums) {
        if (nums.length == 0) {
            System.out.println("错误：至少需要一个数字");
            return Double.NaN;
        }

        double product = 1;
        for (int i = 0; i < nums.length; i++) {
            product *= nums[i];
        }
        return product;
    }

    // 减法：第一个数字减去后续所有数字
    public static double subtract(double firstNum, double... otherNums) {
        double result = firstNum;
        for (int i = 0; i < otherNums.length; i++) {
            result -= otherNums[i];
        }
        return result;
    }

    // 除法：第一个数字除以后续所有数字
    public static double divide(double firstNum, double... otherNums) {
        double result = firstNum;
        for (int i = 0; i < otherNums.length; i++) {
            if (otherNums[i] == 0) {
                System.out.println("错误：除数不能为0");
                return Double.NaN;
            }
            result /= otherNums[i];
        }
        return result;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        char continueChoice = 0;

        do {
            System.out.println("请选择操作符（+、-、*、/）：");
            char operator = scanner.next().charAt(0);

            System.out.println("请输入要计算的数字个数：");
            int count = scanner.nextInt();

            if (count < 1) {
                System.out.println("错误：数字个数不能小于1");
                continue;
            }

            // 在这里明确定义nums数组，确保在整个循环块中可见
            double[] nums = new double[count];
            System.out.println("请输入" + count + "个数字：");
            for (int i = 0; i < count; i++) {
                nums[i] = scanner.nextDouble();
            }

            double result = 0;
            boolean isValid = true;

            switch (operator) {
                case '+':
                    // 此处的nums就是上面定义的数组，作用域有效
                    result = add(nums);
                    break;
                case '-':
                    if (count == 1) {
                        result = nums[0];
                    } else {
                        result = subtract(nums[0], getSubArray(nums, 1));
                    }
                    break;
                case '*':
                    result = multiply(nums);
                    if (Double.isNaN(result)) {
                        isValid = false;
                    }
                    break;
                case '/':
                    if (count == 1) {
                        result = nums[0];
                    } else {
                        result = divide(nums[0], getSubArray(nums, 1));
                        if (Double.isNaN(result)) {
                            isValid = false;
                        }
                    }
                    break;
                default:
                    System.out.println("错误：无效的操作符");
                    isValid = false;
            }

            if (isValid) {
                System.out.print("计算结果：");
                for (int i = 0; i < count; i++) {
                    System.out.print(nums[i]);
                    if (i < count - 1) {
                        System.out.print(" " + operator + " ");
                    }
                }
                System.out.println(" = " + result);
            }

            System.out.println("是否继续计算？（y/n）");
            continueChoice = scanner.next().charAt(0);
        } while (continueChoice == 'y' || continueChoice == 'Y');

        System.out.println("计算器程序已退出。");
        scanner.close();
    }

    // 辅助方法：获取数组的子数组（从指定索引开始）
    private static double[] getSubArray(double[] array, int startIndex) {
        if (startIndex >= array.length) {
            return new double[0];
        }
        double[] subArray = new double[array.length - startIndex];
        System.arraycopy(array, startIndex, subArray, 0, subArray.length);
        return subArray;
    }
}