1. 判断类型：你需要判断这个 Object 的实际运行时类型是什么。
2. 类型转换：如果它是一个可以转换为 int 的类型（如 Integer）,那么你就可以进行转换。
3. 处理错误：如果类型不匹配（它是一个 String 或者 List），或者它虽然是 Integer 但值为 null，那么程序可能会抛出异常,你需要妥善处理这些异常情况。

下面我将分几种最常见的情况来详细说明,并提供最佳实践。

Object 是 Integer 类型（最常见）

这是最直接的情况。Integer 是 int 的包装类,它们之间可以方便地转换。

方法 1：使用强制类型转换（需要先检查类型）

这是最基础的方法，但必须先使用 instanceof 操作符进行类型检查，否则如果类型不匹配会抛出 ClassCastException。

Object obj = 100; // 这里的 100 会被自动装箱为 Integer
if (obj instanceof Integer) {
    // 安全地转换为 Integer
    Integer integerObj = (Integer) obj;
    // 然后通过自动拆箱转换为 int
    int intValue = integerObj;
    System.out.println("转换成功: " + intValue); // 输出: 转换成功: 100
} else {
    System.out.println("对象不是 Integer 类型，无法转换。");
}

简化写法（自动拆箱）： Java 5 引入了自动拆箱（Autounboxing）,所以上面的代码可以简化为：

Object obj = 100;
if (obj instanceof Integer) {
    // (Integer) obj 得到一个 Integer 对象，然后自动拆箱为 int
    int intValue = (Integer) obj;
    System.out.println("转换成功: " + intValue); // 输出: 转换成功: 100
} else {
    System.out.println("对象不是 Integer 类型，无法转换。");
}

方法 2：使用 Object.intValue()（更安全）

Object 是 Integer 的实例，你可以直接调用它的 intValue() 方法，这个方法的好处是，obj 是 null，它会直接抛出 NullPointerException，而不是 ClassCastException,这有时更容易定位问题。

Object obj = 100; // 或者 new Integer(100)
if (obj != null) {
    // 假设我们知道或者检查过它是 Integer，直接调用方法
    // 在实际代码中，最好还是加上 instanceof 检查
    int intValue = ((Integer) obj).intValue();
    System.out.println("转换成功: " + intValue);
} else {
    System.out.println("对象是 null，无法转换。");
}

Object 是 String 类型

当 Object 是一个表示数字的字符串时，你需要先将其解析为 int，这通常使用 Integer.parseInt() 方法。

Object obj = "123";
if (obj instanceof String) {
    try {
        // Integer.parseInt() 会将字符串解析为 int
        int intValue = Integer.parseInt((String) obj);
        System.out.println("转换成功: " + intValue); // 输出: 转换成功: 123
    } catch (NumberFormatException e) {
        System.out.println("字符串格式不正确，无法转换为数字。");
    }
} else {
    System.out.println("对象不是 String 类型，无法解析。");
}

重要提示：

• Integer.parseInt() 要求字符串内容必须是一个有效的整数格式（"123", "-456"）。
• 如果字符串包含非数字字符（如 "12a3"）或者为空字符串 ，它会抛出 NumberFormatException。
• 如果字符串是小数（如 "12.3"），它也会抛出 NumberFormatException，这种情况下，你应该使用 Double.parseDouble() 然后强制转换为 int（注意会丢失精度）。

Object 是 null

处理 null 是一个非常重要的环节，否则很容易导致 NullPointerException。

Object obj = null;
// 在进行任何转换之前，一定要检查是否为 null
if (obj == null) {
    System.out.println("对象是 null，转换失败。");
    // 可以在这里设置一个默认值，或者抛出一个更明确的异常
    // int defaultValue = 0;
} else if (obj instanceof Integer) {
    int intValue = (Integer) obj;
    System.out.println("转换成功: " + intValue);
} else if (obj instanceof String) {
    try {
        int intValue = Integer.parseInt((String) obj);
        System.out.println("转换成功: " + intValue);
    } catch (NumberFormatException e) {
        System.out.println("字符串格式不正确，无法转换为数字。");
    }
} else {
    System.out.println("对象类型不支持转换为 int。");
}

Object 是其他数字类型（如 Double, Long, Float）

Object 是一个浮点数类型（Double, Float）或者长整型（Long），你可以通过强制类型转换将其转换为 int。注意：这会进行截断，而不是四舍五入，并且可能会丢失精度或溢出。

// 从 Double 转换
Object doubleObj = 99.9;
if (doubleObj instanceof Double) {
    // 强制转换会截断小数部分
    int intValue = ((Double) doubleObj).intValue(); // 或者 (int) doubleObj
    System.out.println("Double 转换为 int (截断): " + intValue); // 输出: Double 转换为 int (截断): 99
}
// 从 Long 转换
Object longObj = 2147483648L; // 这个值已经超过了 int 的最大值 (2147483647)
if (longObj instanceof Long) {
    // 强制转换会导致溢出，结果是一个不正确的负数
    int intValue = ((Long) longObj).intValue();
    System.out.println("Long 转换为 int (溢出): " + intValue); // 输出: Long 转换为 int (溢出): -2147483648
}

最佳实践：创建一个通用的转换工具方法

在实际项目中，你可能会需要频繁地执行这种转换,创建一个健壮的工具方法是一个非常好的实践。

public class IntConverter {
    /**
     * 将 Object 安全地转换为 int。
     *
     * @param obj 要转换的对象
     * @return 如果转换成功，返回对应的 int 值；如果转换失败（类型不匹配、格式错误或为 null），返回默认值 0。
     */
    public static toInt(Object obj) {
        return toInt(obj, 0);
    }
    /**
     * 将 Object 安全地转换为 int，并提供自定义的默认值。
     *
     * @param obj 要转换的对象
     * @param defaultValue 转换失败时返回的默认值
     * @return 如果转换成功，返回对应的 int 值；否则返回 defaultValue。
     */
    public static int toInt(Object obj, int defaultValue) {
        if (obj == null) {
            return defaultValue;
        }
        if (obj instanceof Integer) {
            return (Integer) obj;
        }
        if (obj instanceof String) {
            try {
                return Integer.parseInt((String) obj);
            } catch (NumberFormatException e) {
                return defaultValue;
            }
        }
        if (obj instanceof Long) {
            // 检查 Long 是否在 int 的范围内，防止溢出
            long longValue = (Long) obj;
            if (longValue >= Integer.MIN_VALUE && longValue <= Integer.MAX_VALUE) {
                return (int) longValue;
            }
        }
        if (obj instanceof Double) {
            // 同样检查范围
            double doubleValue = (Double) obj;
            if (doubleValue >= Integer.MIN_VALUE && doubleValue <= Integer.MAX_VALUE) {
                return (int) doubleValue;
            }
        }
        // 其他不支持的类型
        return defaultValue;
    }
    public static void main(String[] args) {
        System.out.println(toInt(100));           // 100
        System.out.println(toInt("200"));         // 200
        System.out.println(toInt("3.14"));        // 0 (默认值)
        System.out.println(toInt("abc"));         // 0 (默认值)
        System.out.println(toInt(null));          // 0 (默认值)
        System.out.println(toInt(new Double(99.9))); // 99 (截断)
        System.out.println(toInt(2147483648L));   // 0 (溢出，返回默认值)
        System.out.println(toInt("123", -1));      // 123
        System.out.println(toInt("abc", -1));      // -1
    }
}

核心原则：永远不要直接对 Object 进行强制类型转换，始终先进行 instanceof 检查或 null 检查,并妥善处理可能发生的异常。