Java可变参数的使用规范与限制指南

// 可变参数求和方法
public static int sum(int... nums) {
    int total = 0;
    // 遍历可变参数，本质就是遍历数组
    for (int num : nums) {
        total += num;
    }
    return total;
}

public static void main(String[] args) {
    // 1. 不传任何参数（合法，底层是空数组）
    sum(); 
    // 2. 传1个参数
    sum(10); 
    // 3. 传多个零散参数（任意个数，同类型即可）
    sum(10, 20, 30); 
    // 4. 直接传对应类型的数组（底层本身就是数组，直接复用）
    sum(new int[]{10, 20, 30, 40}); 
}

// 正确示例（可变参数在最后）
public static void test(String name, int... nums) {}
public static void log(String prefix, Object... args) {}
// 错误示例（可变参数后面有普通参数，编译报错）
public static void test(int... nums, String name) {} // 编译报错
public static void log(Object... args, String suffix) {} // 编译报错

// 错误示例（多个可变参数，编译报错）
public static void test(int... a, String... b) {} // 编译报错
public static void print(Object... args1, Object... args2) {} // 编译报错

// 错误示例（两者冲突，编译报错）
public static void fun(int... arr) {} // 可变参数
public static void fun(int[] arr) {}  // 同类型数组，与上面冲突

public static void print(String... args) {}
// 正确调用
print("a", "b", "c");
print(new String[]{"a", "b", "c"});
// 错误调用（类型不匹配，编译报错）
print(10, 20); // 传入int类型，与String类型不匹配
print("a", 10); // 混合类型，编译报错

// 正确示例（构造方法使用可变参数）
public class User {
    private String name;
    private int[] ids;
    // 可变参数放在最后
    public User(String name, int... ids) {
        this.name = name;
        this.ids = ids; // 直接赋值，本质是数组
    }
}
// 错误示例（构造方法可变参数位置错误）
public User(int... ids, String name) {} // 编译报错

// 父类方法（可变参数）
class Parent {
    public void show(int... args) {}
}
// 子类重写（正确：保持可变参数写法一致）
class Son extends Parent {
    @Override
    public void show(int... args) {}
}
// 子类重写（允许：父类可变参数，子类可改为数组）
class Son extends Parent {
    @Override
    public void show(int[] args) {} // 合法，不报错
}
// 子类重写（错误：父类是数组，子类不能改为可变参数）
class Son extends Parent {
    // 编译报错，这不是重写，而是重载（方法签名不匹配）
    @Override
    public void show(int... args) {} 
}

// 泛型可变参数，会产生 unchecked 警告
public static <T> void print(T... args) {
    for (T arg : args) {
        System.out.println(arg);
    }
}

// 可变参数方法
public static void hello(String... args) {
    System.out.println("可变参数方法");
}
// 固定参数重载方法（两个String参数）
public static void hello(String a, String b) {
    System.out.println("固定参数方法");
}
// 调用时，编译报错（歧义）
public static void main(String[] args) {
    hello("a", "b"); // 编译器不知道匹配哪个方法
}

public static void show(int... nums) {
    // 这里取length，两种情况结果完全不同
    System.out.println(nums.length);
}
public static void main(String[] args) {
    // 1. 不传参数：nums是「空数组」（length=0），不会空指针
    show(); 
    // 2. 传null：nums是「空引用」，取length直接空指针
    show(null); 
}

public static void show(int... nums) {
    // 判空，避免NPE
    if (nums == null) {
        System.out.println("参数不能为null");
        return;
    }
    for (int num : nums) {
        System.out.println(num);
    }
}

// 错误示例（枚举构造器使用可变参数，编译报错）
enum Color {
    RED("红色", 1, 2),
    BLUE("蓝色", 3, 4);
    private String name;
    private int[] codes;
    // 错误：枚举构造器不能用可变参数
    Color(String name, int... codes) {
        this.name = name;
        this.codes = codes;
    }
}

// 错误：可变参数在中间，编译报错
public static void test(int... nums, String name) {}
// 正确：可变参数放在最后
public static void test(String name, int... nums) {}

public static void sum(int... nums) {
    // 未判空，传null时会报NPE
    int total = 0;
    for (int num : nums) { // 当nums为null时，这里报错
        total += num;
    }
}
// 调用
sum(null); // 空指针异常

// 可变参数方法
public static void print(Object... args) {}
// 固定参数重载方法
public static void print(String a, Object b) {}
// 调用时歧义，编译报错
print("a", 10); // 编译器无法判断匹配哪个方法