Java 方法重载Overload常见误区及注意事项

public class Calculator {
    // 两个整数相加
    public int add(int a, int b) {
        return a + b;
    }
    // 三个整数相加（参数数量不同）
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class Printer {
    // 打印整数
    public void print(int num) {
        System.out.println("整数：" + num);
    }
    // 打印字符串（参数类型不同）
    public void print(String text) {
        System.out.println("字符串：" + text);
    }
}

public class Converter {
    // int + String
    public void convert(int a, String b) {
        System.out.println(a + b);
    }
    // String + int（参数顺序不同）
    public void convert(String a, int b) {
        System.out.println(a + b);
    }
}

public class SumUtils {
    // 两个整数相加
    public int sum(int a, int b) {
        return a + b;
    }
    // 可变参数（本质是数组）
    public int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
}
// 调用示例
sum(1, 2);       // 调用第一个方法
sum(1, 2, 3);    // 调用可变参数方法
sum(5);          // 调用可变参数方法

public class Demo {
    // 基本类型 int
    public void process(int num) {
        System.out.println("基本类型: " + num);
    }
    // 包装类 Integer（参数类型不同）
    public void process(Integer num) {
        System.out.println("包装类: " + num);
    }
}
// 调用示例
demo.process(5);     // 调用基本类型方法（优先匹配）
demo.process(Integer.valueOf(5)); // 调用包装类方法

public class ErrorExample {
    // 编译错误：仅返回类型不同
    public int getValue() { return 1; }
    public String getValue() { return "1"; }
}

public class ErrorExample {
    // 编译错误：参数名称不同不构成重载
    public void test(int a) {}
    public void test(int b) {}
}

public class ErrorExample {
    // 编译错误：访问修饰符不同不构成重载
    public void log(String msg) {}
    private void log(String msg) {}
}

public class ErrorExample {
    // 编译错误：异常声明不同不构成重载
    public void read() throws IOException {}
    public void read() throws SQLException {}
}

public class OverloadDemo {
    public void process(int num) {
        System.out.println("int: " + num);
    }
    public void process(long num) {
        System.out.println("long: " + num);
    }
    public void process(Integer num) {
        System.out.println("Integer: " + num);
    }
}
// 调用示例
OverloadDemo demo = new OverloadDemo();
demo.process(5);    // 输出 "int: 5"（精确匹配）
demo.process(5L);   // 输出 "long: 5"（精确匹配）
demo.process(Integer.valueOf(5)); // 输出 "Integer: 5"（精确匹配）
// 若只有 process(long) 和 process(Integer)
demo.process(5);    // 优先匹配 process(long)（自动类型转换）

public class User {
    private String name;
    private int age;
    // 无参构造方法
    public User() {}
    // 带参构造方法（参数不同）
    public User(String name) {
        this.name = name;
    }
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class FileUtils {
    // 按路径读取文件
    public static String readFile(String path) { /* ... */ }
    // 按路径和编码读取文件
    public static String readFile(String path, String charset) { /* ... */ }
    // 按输入流读取文件
    public static String readFile(InputStream input) { /* ... */ }
}

public class Logger {
    // 记录字符串日志
    public void log(String message) { /* ... */ }
    // 记录异常日志
    public void log(Exception e) { /* ... */ }
    // 格式化日志
    public void log(String format, Object... args) { /* ... */ }
}