Java运行时类型转换编译性检测指南

<dependency>
    <groupId>org.codehaus.janino</groupId>
    <artifactId>janino</artifactId>
    <version>3.1.9</version> <!-- 使用最新稳定版本 -->
</dependency>

import org.codehaus.janino.SimpleCompiler;

/**
 * 提供了在运行时检测Java类型转换是否可编译的功能。
 */
public class CastabilityChecker {

    /**
     * 检测从源类型（src）到目标类型（dst）的强制类型转换是否能在Java编译器中通过。
     * 例如，如果dst是List.class，src是ArrayList.class，则返回true。
     * 如果dst是Boolean.TYPE，src是String.class，则返回false。
     *
     * @param dst 目标类型（例如：java.util.List.class）
     * @param src 源类型（例如：java.util.ArrayList.class）
     * @return 如果类型转换可编译，则返回true；否则返回false。
     */
    public boolean isCastCompilable(Class<?> dst, Class<?> src) {
        // 获取类型的完全限定名
        String targetTypeName = dst.getName();
        String sourceTypeName = src.getName();

        // 构造一个包含目标类型转换的最小Java代码片段
        // 我们创建一个公共类TestCast，其中包含一个公共方法convert，
        // 该方法接收sourceTypeName类型的参数x，并尝试将其转换为targetTypeName类型。
        String sampleCode = "public class TestCast {"
            + "    public " + targetTypeName + " convert(" + sourceTypeName + " x) {"
            + "        return (" + targetTypeName + ")x;"
            + "    }"
            + "}";

        // 使用Janino编译器尝试编译这段代码
        SimpleCompiler compiler = new SimpleCompiler();
        try {
            compiler.cook(sampleCode); // 尝试编译
            return true; // 编译成功，说明类型转换是合法的
        } catch (Exception e) {
            // 编译失败，说明类型转换是非法的
            // 在实际应用中，可以考虑记录e以便调试
            // System.err.println("Cast compilation failed for " + src.getName() + " to " + dst.getName() + ": " + e.getMessage());
            return false;
        }
    }

    // 示例用法
    public static void main(String[] args) {
        CastabilityChecker checker = new CastabilityChecker();

        // 示例1：合法的类型转换
        // ArrayList x; List y = ((List)x);
        System.out.println("List <- ArrayList: " + checker.isCastCompilable(java.util.List.class, java.util.ArrayList.class)); // 预期: true

        // 示例2：合法的类型转换 (基本类型自动装箱/拆箱不直接涉及强制转换编译性，这里是引用类型)
        // Integer x; Number y = ((Number)x);
        System.out.println("Number <- Integer: " + checker.isCastCompilable(Number.class, Integer.class)); // 预期: true

        // 示例3：非法的类型转换
        // String x; boolean y = (boolean)x;
        System.out.println("boolean <- String: " + checker.isCastCompilable(Boolean.TYPE, String.class)); // 预期: false

        // 示例4：非法的类型转换 (不相关的引用类型)
        // String x; Integer y = ((Integer)x);
        System.out.println("Integer <- String: " + checker.isCastCompilable(Integer.class, String.class)); // 预期: false

        // 示例5：原始类型到包装类型的转换 (编译时合法，运行时可能ClassCastException)
        // int x; Integer y = (Integer)x; // 编译器会拒绝此直接转换，因为int不是引用类型，不能直接强转为Integer引用
        // 但如果考虑的是自动装箱，那是另一回事。这里测试的是显式强制类型转换。
        System.out.println("Integer <- int: " + checker.isCastCompilable(Integer.class, int.class)); // 预期: false

        // 示例6：原始类型之间的转换
        // int x; long y = (long)x; // 原始类型之间是隐式或显式数值转换，不是引用类型强制转换
        System.out.println("long <- int: " + checker.isCastCompilable(long.class, int.class)); // 预期: true (因为Java允许原始类型之间的隐式/显式数值转换，Janino会接受)
        System.out.println("char <- int: " + checker.isCastCompilable(char.class, int.class)); // 预期: true
        System.out.println("boolean <- int: " + checker.isCastCompilable(boolean.class, int.class)); // 预期: false
    }
}