Java方法重载案例如何实操

wen java案例 2026-07-02 248

本文目录导读：

Java方法重载案例如何实操

基础重载案例 - 计算器
实战案例 - 用户管理系统
进阶案例 - 数据处理工具类
实际业务场景 - 订单系统
标准库中的重载
重载的注意事项
最佳实践建议

我来给你展示一个完整的Java方法重载实操案例,从基础到进阶。

基础重载案例 - 计算器

public class Calculator {
    // 1. 参数数量不同
    public int add(int a, int b) {
        System.out.println("两个整数相加");
        return a + b;
    }
    public int add(int a, int b, int c) {
        System.out.println("三个整数相加");
        return a + b + c;
    }
    // 2. 参数类型不同
    public double add(double a, double b) {
        System.out.println("两个小数相加");
        return a + b;
    }
    // 3. 参数顺序不同
    public String add(String str, int num) {
        System.out.println("字符串+整数");
        return str + num;
    }
    public String add(int num, String str) {
        System.out.println("整数+字符串");
        return num + str;
    }
}
// 测试类
public class TestCalculator {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        // 调用不同版本的重载方法
        System.out.println(calc.add(5, 3));           // 调用int,int版本
        System.out.println(calc.add(5, 3, 2));        // 调用int,int,int版本
        System.out.println(calc.add(5.5, 3.3));       // 调用double,double版本
        System.out.println(calc.add("Hello", 123));   // 调用String,int版本
        System.out.println(calc.add(456, "World"));   // 调用int,String版本
    }
}

实战案例 - 用户管理系统

public class UserManager {
    // 创建用户的不同方式
    // 1. 只传用户名
    public void createUser(String username) {
        User user = new User();
        user.setUsername(username);
        user.setRole("普通用户");
        user.setCreateTime(new Date());
        System.out.println("创建基础用户: " + username);
    }
    // 2. 用户名+密码
    public void createUser(String username, String password) {
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);
        user.setRole("普通用户");
        System.out.println("创建带密码用户: " + username);
    }
    // 3. 用户名+密码+角色
    public void createUser(String username, String password, String role) {
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);
        user.setRole(role);
        System.out.println("创建" + role + ": " + username);
    }
    // 4. 从其他对象创建用户（参数类型不同）
    public void createUser(Map<String, String> userMap) {
        User user = new User();
        user.setUsername(userMap.get("username"));
        user.setPassword(userMap.get("password"));
        user.setRole(userMap.getOrDefault("role", "普通用户"));
        System.out.println("从Map创建用户: " + user.getUsername());
    }
}
// 用户实体类
class User {
    private String username;
    private String password;
    private String role;
    private Date createTime;
    // getter和setter方法
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    public String getRole() { return role; }
    public void setRole(String role) { this.role = role; }
    public Date getCreateTime() { return createTime; }
    public void setCreateTime(Date createTime) { this.createTime = createTime; }
}

进阶案例 - 数据处理工具类

import java.util.List;
import java.util.Arrays;
public class DataUtils {
    // 数组转字符串的不同方式
    // 1. 整数数组转字符串
    public String arrayToString(int[] arr) {
        return Arrays.toString(arr);
    }
    // 2. 字符串数组转字符串
    public String arrayToString(String[] arr) {
        return String.join(", ", arr);
    }
    // 3. 对象数组转字符串（带分隔符）
    public String arrayToString(Object[] arr, String delimiter) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if (i > 0) sb.append(delimiter);
            sb.append(arr[i].toString());
        }
        return sb.toString();
    }
    // 4. 集合转字符串（参数类型不同）
    public String arrayToString(List<?> list) {
        return list.toString();
    }
    // 打印数据的不同方式
    public void print(int value) {
        System.out.println("整数: " + value);
    }
    public void print(double value) {
        System.out.println("小数: " + value);
    }
    public void print(String value) {
        System.out.println("字符串: " + value);
    }
    public void print(String format, Object... args) {
        System.out.println(String.format(format, args));
    }
}

实际业务场景 - 订单系统

public class OrderService {
    // 查询订单的不同方式
    // 1. 按订单ID查询
    public Order findOrder(Long orderId) {
        System.out.println("按ID查询订单: " + orderId);
        return new Order(); // 模拟返回
    }
    // 2. 按用户ID查询
    public List<Order> findOrders(Long userId, boolean isUser) {
        System.out.println("按用户ID查询订单列表");
        return new ArrayList<>();
    }
    // 3. 按时间范围查询
    public List<Order> findOrders(Date startDate, Date endDate) {
        System.out.println("按时间范围查询订单");
        return new ArrayList<>();
    }
    // 4. 按状态查询
    public List<Order> findOrders(String status) {
        System.out.println("按状态查询订单: " + status);
        return new ArrayList<>();
    }
    // 5. 综合查询（带分页）
    public PageResult<Order> findOrders(String keyword, int page, int size) {
        System.out.println("综合查询订单，关键词: " + keyword);
        return new PageResult<>();
    }
}
// 订单实体和分页结果
class Order {
    private Long id;
    private Long userId;
    private String status;
    private Date createTime;
    private double totalAmount;
    // 省略getter/setter
}
class PageResult<T> {
    private List<T> data;
    private int totalCount;
    private int page;
    private int size;
}

标准库中的重载

public class StandardLibraryOverloadDemo {
    public static void main(String[] args) {
        // 1. String.valueOf() 的重载
        String s1 = String.valueOf(123);        // int版本
        String s2 = String.valueOf(45.67);      // double版本
        String s3 = String.valueOf(true);       // boolean版本
        String s4 = String.valueOf(new Object());// Object版本
        // 2. System.out.println() 的重载
        System.out.println(123);                // int版本
        System.out.println(45.67);              // double版本
        System.out.println("Hello");            // String版本
        System.out.println(true);               // boolean版本
        // 3. Math 类的重载方法
        int maxInt = Math.max(5, 10);           // int版本
        double maxDouble = Math.max(5.5, 10.5); // double版本
        long maxLong = Math.max(5L, 10L);       // long版本
    }
}

重载的注意事项

public class OverloadWarningDemo {
    // 错误示例 - 只有返回值不同不能构成重载
    // public int calculate(int a, int b) { return a + b; }
    // public double calculate(int a, int b) { return a * b; } // 编译错误！
    // 正确示例 - 必须参数不同
    public int calculate(int a, int b) {
        return a + b;
    }
    public double calculate(double a, double b) {
        return a * b;
    }
    // 方法重载 vs 方法重写
    // 重载：同一个类中，方法名相同，参数列表不同
    // 重写：子类中，方法签名与父类完全相同
    // 自动类型转换的问题
    public void test(int num) {
        System.out.println("int版本: " + num);
    }
    public void test(long num) {
        System.out.println("long版本: " + num);
    }
    // 调用测试
    public void testOverload() {
        test(10);    // 调用int版本
        test(10L);   // 调用long版本
        test(10.5);  // 编译错误，没有匹配的double版本
    }
}

最佳实践建议

参数含义要清晰：重载的方法应该做相同或相似的事情
参数数量适中：一般不超过3-4个参数
使用构建者模式：参数过多时考虑使用Builder模式
文档要完善：清楚说明每个重载版本的用途
避免歧义：确保编译器能明确区分不同的重载版本

// 好的重载设计
public class GoodPracticeExample {
    // 建议：使用参数对象代替过多重载
    public void search(SearchCriteria criteria) {
        // 统一处理方法
    }
}
class SearchCriteria {
    private String keyword;
    private Long userId;
    private Date startDate;
    private Date endDate;
    private String status;
    private int page = 1;
    private int size = 20;
    // 使用Builder模式创建
}

通过以上案例,你可以看到方法重载在实际开发中的广泛应用，掌握好方法重载，能让你的代码更加灵活、易用。

本文地址： https://www.bmjup.com/post/13902.html