Java对象类型的转换和instanceof 用源码实现

在Java中，对象类型的转换通常分为隐式转换和显式转换，也称为自动装箱和手动装箱。这是为了适应不同类型之间的操作，比如将基本数据类型转换成其对应的包装类对象。

**1. 隐式转换（自动装箱）**:
当你从基本类型赋值给对应的包装类变量时，例如 `int i = 5; Integer boxI = i;`，这是由JVM自动完成的，无需开发者编写额外的代码。源码实际上不会直接展示这个过程，它发生在编译阶段。

**2. 显式转换（手动装箱）**:
如果你需要将包装类对象转换回基本类型，比如 `Integer boxI = 5; int primitiveI = (int) boxI;`，这就是显式转换。这需要明确地进行类型转换，源码会显示这种类型强制转换。

至于`instanceof`关键字，用于检查一个对象是否属于某个特定类或其子类。它的实现并不公开于Java的源码，但可以简单理解为它是在运行时检查引用的内存地址是否匹配指定类的类型信息。例如：

if (object instanceof MyClass) {
    // object是MyClass或其子类的对象
}

相关问题

java动态代理源码分析

Java动态代理是一种在运行时生成代理类的机制，用于代替手动编写代理类的过程。在Java中，动态代理通常使用JDK自带的Proxy和InvocationHandler接口来实现。

下面是一个简单的动态代理示例：

public interface UserService {
    void save();
}

public class UserServiceImpl implements UserService {
    public void save() {
        System.out.println("保存用户");
    }
}

public class UserInvocationHandler implements InvocationHandler {
    private Object target;

    public UserInvocationHandler(Object target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始操作");
        Object result = method.invoke(target, args);
        System.out.println("操作完成");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        UserService proxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(), new UserInvocationHandler(userService));
        proxy.save();
    }
}

在这个示例中，我们首先定义了一个UserService接口和一个UserServiceImpl实现类。然后我们定义了一个UserInvocationHandler类，它实现了InvocationHandler接口，该接口中只有一个invoke方法，该方法用于在代理对象上调用方法时执行的代码逻辑。在Main类中，我们通过Proxy.newProxyInstance方法创建了一个代理对象proxy，并将其强制转换为UserService类型。该方法需要三个参数：ClassLoader，该代理对象实现的接口列表和InvocationHandler实例。最后，我们通过代理对象调用了save方法。

下面是动态代理的源码分析：

在Proxy.newProxyInstance方法中，我们可以看到它调用了Proxy.getProxyClass方法，该方法用于获取代理类的Class对象。

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    Objects.requireNonNull(h);
    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    /*
     * Look up or generate the designated proxy class.
     */
    Class<?> cl = getProxyClass0(loader, intfs);

    /*
     * Invoke its constructor with the designated invocation handler.
     */
    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }

        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        return cons.newInstance(new Object[]{h});
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString());
    } catch (IllegalAccessException e) {
        throw new InternalError(e.toString());
    } catch (InstantiationException e) {
        throw new InternalError(e.toString());
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString());
        }
    }
}

在getProxyClass0方法中，它会先尝试从缓存中获取代理类，如果没有找到则调用ProxyClassFactory的apply方法生成代理类。

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // If the proxy class defined by the given loader implementing
    // the given interfaces exists, this will simply return the cached copy;
    // otherwise, it will create the proxy class via the ProxyClassFactory
    return proxyClassCache.get(loader, interfaces);
}

在ProxyClassFactory的apply方法中，它会使用ASM框架生成代理类的字节码。ASM是一个轻量级的Java字节码操作和分析框架，可以用于动态生成字节码。

public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
    Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
    for (Class<?> intf : interfaces) {
        /*
         * Verify that the class loader resolves the name of this
         * interface to the same Class object.
         */
        Class<?> interfaceClass = null;
        try {
            interfaceClass = Class.forName(intf.getName(), false, loader);
        } catch (ClassNotFoundException e) {
        }
        if (interfaceClass != intf) {
            throw new IllegalArgumentException(
                intf + " is not visible from class loader");
        }
        /*
         * Verify that the interface is a true interface
         */
        if (!interfaceClass.isInterface()) {
            throw new IllegalArgumentException(
                interfaceClass.getName() + " is not an interface");
        }
        /*
         * Verify that this interface is not a duplicate.
         */
        if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
            throw new IllegalArgumentException(
                "repeated interface: " + interfaceClass.getName());
        }
    }

    /*
     * Choose a name for the proxy class to generate.
     */
    String proxyName = generateProxyName(interfaces);

    /*
     * Generate the specified proxy class.
     */
    byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
        proxyName, interfaces, accessFlags);
    try {
        return defineClass0(loader, proxyName,
                            proxyClassFile, 0, proxyClassFile.length);
    } catch (ClassFormatError e) {
        /*
         * A ClassFormatError here means that (barring bugs in the
         * proxy class generation code) there was some other
         * invalid aspect of the arguments supplied to the proxy
         * class creation (such as virtual machine limitations
         * exceeded).
         */
        throw new IllegalArgumentException(e.toString());
    }
}

在ProxyGenerator.generateProxyClass方法中，它使用ASM框架生成代理类的字节码。

public static byte[] generateProxyClass(String var0, Class<?>[] var1, int var2) {
    return generateProxyClass(var0, var1, null, var2);
}

public static byte[] generateProxyClass(String var0, Class<?>[] var1, Class<?> var2, int var3) {
    ProxyGenerator var4 = new ProxyGenerator(var0, var1, var2, var3);
    byte[] var5 = var4.generateClassFile();
    if (DUMP_CLASS) {
        dumpClass(var0, var5);
    }

    return var5;
}

在ProxyGenerator的generateClassFile方法中，它使用ASM框架生成代理类的字节码。

public byte[] generateClassFile() {
    this.createClassInfo();
    this.createFieldInfo();
    this.createConstructorInfo();
    this.createMethodInfo();
    this.createAttributeInfo();
    return this.classWriter.toByteArray();
}

总体来说，Java动态代理实现的核心在于使用ASM框架生成代理类的字节码。ASM框架提供了一种轻量级的生成和修改Java字节码的方式，可以很方便地生成符合Java规范的字节码。通过动态生成代理类，我们可以省去手动编写代理类的繁琐过程，并且可以使代理类更加灵活和易于维护。

编写程序统计一个输入的Java源码中关键字（区分大小写）出现的次数。说明如下： 代码小于60行。使用正则表达式。Java中共有53个关键字（自行百度） 从键盘输入一段源码，统计这段源码中出现的关键字的数量 注释中出现的关键字不用统计 字符串中出现的关键字不用统计 统计出的关键字及数量按照关键字升序进行排序输出 未输入源码则认为输入非法 输入格式: 输入Java源码字符串，可以一行或多行，以exit行作为结束标志 输出格式: 当未输入源码时，程序输出Wrong Format 当没有统计数据时，输出为空 当有统计数据时，关键字按照升序排列，每行输出一个关键字及数量，格式为数量\t关键字

好的，我可以为您编写这个程序。以下是程序代码：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        StringBuilder code = new StringBuilder();
        String line;
        while (!(line = scanner.nextLine()).equals("exit")) {
            code.append(line).append("\n");
        }

        String[] keywords = {"abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue", "default", "do", "double", "else", "enum", "extends", "final", "finally", "float", "for", "if", "goto", "implements", "import", "instanceof", "int", "interface", "long", "native", "new", "package", "private", "protected", "public", "return", "short", "static", "strictfp", "super", "switch", "synchronized", "this", "throw", "throws", "transient", "try", "void", "volatile", "while"};

        Map<String, Integer> keywordCount = new TreeMap<>();
        for (String keyword : keywords) {
            keywordCount.put(keyword, 0);
        }

        String codeStr = code.toString();
        codeStr = codeStr.replaceAll("\".*?\"", ""); // 去除字符串中的内容
        codeStr = codeStr.replaceAll("//.*?\n", ""); // 去除单行注释
        codeStr = codeStr.replaceAll("/\\*.*?\\*/", ""); // 去除多行注释

        for (String keyword : keywords) {
            String regex = "\\b" + keyword + "\\b";
            int count = codeStr.split(regex, -1).length - 1;
            keywordCount.put(keyword, count);
        }

        boolean hasResult = false;
        for (Map.Entry<String, Integer> entry : keywordCount.entrySet()) {
            if (entry.getValue() > 0) {
                System.out.println(entry.getValue() + "\t" + entry.getKey());
                hasResult = true;
            }
        }

        if (!hasResult) {
            System.out.println();
        }
    }
}

程序的思路是先读入源码，并将其转换成一个字符串。然后使用正则表达式去除字符串和注释中的内容，只留下代码部分。接着，使用 Java 中的关键字数组和一个 TreeMap 统计每个关键字出现的次数。最后，按照升序排列关键字，输出每个关键字的出现次数。

注意，程序中使用了 Java 中的正则表达式，可以匹配各种形式的注释和字符串。如果您对正则表达式不熟悉，可以参考 Java 的正则表达式文档。