如何编写可接收任意类型变量并判断类型的Java函数？

嘿，这个需求其实在日常开发里挺常见的，我拿Java和Python这俩主流语言给你举具体例子，看完你就能直接上手实现啦～

Java作为强类型语言，我们可以利用instanceof关键字判断类型，结合条件分支或者新版本的模式匹配来处理不同输入：

基础版本（兼容所有Java版本） #

public class TypeHandler {
    public static void handleInput(Object input) {
        // 处理整数类型
        if (input instanceof Integer) {
            int num = (Integer) input;
            System.out.println("处理整数：将数值翻倍 → " + num * 2);
        } 
        // 处理浮点数类型
        else if (input instanceof Double) {
            double num = (Double) input;
            System.out.println("处理浮点数：将数值乘1.5 → " + num * 1.5);
        } 
        // 处理字符串类型
        else if (input instanceof String) {
            String str = (String) input;
            System.out.println("处理字符串：转大写 → " + str.toUpperCase());
        } 
        // 处理自定义对象（比如User类）
        else if (input instanceof User) {
            User user = (User) input;
            System.out.println("处理用户对象：获取用户名 → " + user.getUsername());
        } 
        // 兜底处理未知类型
        else {
            System.out.println("未知类型，无法处理：" + input.getClass().getName());
        }
    }

    // 自定义User类示例
    static class User {
        private String username;
        public User(String username) { this.username = username; }
        public String getUsername() { return username; }
    }

    // 测试函数
    public static void main(String[] args) {
        handleInput(10);
        handleInput(3.14);
        handleInput("hello world");
        handleInput(new User("genisome"));
        handleInput(true); // 布尔类型会走兜底分支
    }
}

简化版本（Java 14+，模式匹配） #

如果你的项目用的是Java 14及以上版本，推荐用模式匹配switch，不用手动强转，代码更简洁：

public static void handleInputWithPattern(Object input) {
    switch (input) {
        case Integer num -> System.out.println("整数翻倍 → " + num * 2);
        case Double num -> System.out.println("浮点数乘1.5 → " + num * 1.5);
        case String str -> System.out.println("字符串转大写 → " + str.toUpperCase());
        case User user -> System.out.println("用户名称 → " + user.getUsername());
        default -> System.out.println("未处理类型：" + input.getClass().getSimpleName());
    }
}

Python是动态类型语言，处理起来更灵活，用isinstance()函数判断类型（比type()更友好，支持继承关系）：

def handle_input(input_data):
    # 处理整数
    if isinstance(input_data, int):
        print(f"处理整数：数值翻倍 → {input_data * 2}")
    # 处理浮点数
    elif isinstance(input_data, float):
        print(f"处理浮点数：数值乘1.5 → {input_data * 1.5}")
    # 处理字符串
    elif isinstance(input_data, str):
        print(f"处理字符串：转大写 → {input_data.upper()}")
    # 处理列表
    elif isinstance(input_data, list):
        print(f"处理列表：元素翻倍 → {[x * 2 for x in input_data]}")
    # 处理自定义对象
    elif isinstance(input_data, User):
        print(f"处理用户对象：获取用户名 → {input_data.get_username()}")
    # 兜底处理
    else:
        print(f"未知类型，无法处理：{type(input_data).__name__}")

# 自定义User类示例
class User:
    def __init__(self, username):
        self.username = username
    def get_username(self):
        return self.username

# 测试
handle_input(10)
handle_input(3.14)
handle_input("hello world")
handle_input([1, 2, 3])
handle_input(User("genisome"))
handle_input(True)

如果需要处理的类型特别多，别一直加if-else或者switch分支，那样代码会变得臃肿难维护：

• 强类型语言（如Java）可以用策略模式，给每个类型对应一个处理策略类，通过工厂模式动态获取策略
• 动态类型语言（如Python）可以用字典映射，把类型和对应的处理函数绑定，直接通过字典查找执行
• 优先利用多态特性：让不同类型的对象自己实现处理逻辑，而不是在一个通用函数里做所有判断

内容的提问来源于stack exchange，提问作者genisome