java如何动态修改一个对象的类型

Posted 2023-03-28

类test.Test内容如下

public class Testpublic String name="222";
public static void main(String[] args)
Class typ = Class.forName("test.Test");
Object obj = typ.newInstance();
Field field = typ.getField("name");
field.set(obj, 111);

现在又这样一个对象，就是通过反射创建一个Test对象
最后一行会执行失败，因为类型不符
目前希望实现一个功能，就是能够读取field的类型，并将111转换成指定的类型
想完成下面的方法如何写呢
public void changeType(Object obj, Class typ)
把对象obj转换成typ指定的类型

我的意思就是反射创建一个对象，然后从Xml中读取数据给对象初始化，读出来的都是String类型，可是不知道如何进行类型转换，比如读到true，也知道目标字段类型
我有一种想法：
Object obj = 5;
public Object changeType(Object s, Class type)
Method method = type.getMethod("valueOf", s.getClass());
return method.invoke(type, s);

我想这样，可是怎么就不行呢
changeType("asdg", obj.getClass());
这样调用怎么也不对，说没有valueOf方法，可是String类里面分明有valueOf方法
怎么回事呢

基本明白了楼组的意思， 这样不知道能否解决， 抽象出需要转型的类型的共同点，然后写成抽象类或者接口 ，是不是用泛型都木有关系，这样可以缓解一定的问题。

另外，假通过反射强制类型转换 怎么用类型变量去引用呢 还只能用Object 。 反射能动态获得对象类型及属性参数 行了追问

麻烦帮忙看下补充

追答

热，String里面却是有valueOf的静态方法，但是你要看清楚，你的参数是都是正确的，valueOf后面都是值类型，没有String类型，当然提示你找不到这个方法了，
method=demo.getMethod("valueOf", int.class);
method.invoke(demo.newInstance(),1);
这样就可以，

追问

我知道,valueOf都是值类型
而我要取的是int的啊
下面代码就会出错
Object str = "1";
Object int1 = 1;
Method method = str.getClass().getMethod("valueOf", int1.getClass());

追答

你知道valueOf都是值类型，为什么这里你要放一个Object进去？
Object int1 = 1; ("valueOf", int1.getClass()); ？？？
你打印一下int1.getClass()这个值是这个java.lang.Integer，
应用对象，如参不匹配，就对不上方法了。
method=demo.getMethod("valueOf", int.class); 写成这样就OK。

追问

关键是int都从filed中取得的，必然是一个object

追答

JAVA自动装拆箱，参数类型对了就OK，你懂的。

参考技术A

楼主可以换种思路来实现：对于不同的类型，设置不同的参数，如下：

String typeName = type.getName();
String value = "1";
if(typeName.indexOf("int") != -1) 
    field.set(obj, Integer.valueOf(value));
 else if(typeName.indexOf("String") != -1) 
    field.set(obj, value);
 else if(typeName.indexOf("其他类型") != -1) 
    field.set(obj, "类型转换");

追问

麻烦帮忙看下补充

参考技术B 直接类型强转就行了，没有继承关系的类是不可能互转的追问

强制转不行的

参考技术C typ是一个类对象，时test对应的类的类对象，你确定要把obj装换成类对象对应的类吗？追问

麻烦帮忙看下补充

Java核心技术类型信息(Class对象 反射 动态代理)

1 Class对象

理解RTTI在Java中的工作原理，首先需要知道类型信息在运行时是如何表示的，这是由Class对象来完成的，它包含了与类有关的信息。Class对象就是用来创建所有“常规”对象的，Java使用Class对象来执行RTTI，即使你正在执行的是类似类型转换这样的操作。

 

每个类都会产生一个对应的Class对象，也就是保存在.class文件。所有类都是在对其第一次使用时，动态加载到JVM的，当程序创建一个对类的静态成员的引用时，就会加载这个类。Class对象仅在需要的时候才会加载，static初始化是在类加载时进行的。类加载器首先会检查这个类的Class对象是否已被加载过，如果尚未加载，默认的类加载器就会根据类名查找对应的.class文件。

 

想在运行时使用类型信息，必须获取对象(比如类Base对象)的Class对象的引用，使用功能Class.forName(“Base”)可以实现该目的，或者使用base.class。注意，有一点很有趣，使用功能”.class”来创建Class对象的引用时，不会自动初始化该Class对象，使用forName()会自动初始化该Class对象。使用”.class”不会自动初始化是因为被延迟到了对静态方法（构造器隐私地是静态的）或者非常数静态域进行首次引用时才进行。

为了使用类而做的准备工作一般有以下3个步骤：

• 加载：由类加载器完成，找到对应的字节码，创建一个Class对象
• 链接：验证类中的字节码，为静态域分配空间
• 初始化：如果该类有超类，则对其初始化，执行静态初始化器和静态初始化块

public class Base {
    static int num = 1;
 
    static {
        System.out.println("Base " + num);
    }
}
public class Main {
    public static void main(String[] args) {
        // 不会初始化静态块
        Class clazz1 = Base.class;
        System.out.println("------");
        // 会初始化
        Class clazz2 = Class.forName("zzz.Base");
    }
}

 

类型转换前先做检查

编译器将检查类型向下转型是否合法，如果不合法将抛出异常。向下转换类型前，可以使用instanceof判断。

class Base { }
class Derived extends Base { }
 
public class Main {
    public static void main(String[] args) {
       Base base = new Derived();
       if (base instanceof Derived) {
           // 这里可以向下转换了
           System.out.println("ok");
       }
       else {
           System.out.println("not ok");
       }
    }
}

 

2 反射 运行时信息

如果不知道某个对象的确切类型，RTTI可以告诉你，但是有一个前提：这个类型在编译时必须已知，这样才能使用RTTI来识别它。Class类与java.lang.reflect类库一起对反射进行了支持，该类库包含Field、Method和Constructor类，这些类的对象由JVM在启动时创建，用以表示未知类里对应的成员。

 

反射机制并没有什么神奇之处，当通过反射与一个未知类型的对象打交道时，JVM只是简单地检查这个对象，看它属于哪个特定的类。因此，那个类的.class对于JVM来说必须是可获取的，要么在本地机器上，要么从网络获取。所以对于RTTI和反射之间的真正区别只在于：

● RTTI，编译器在编译时打开和检查.class文件

● 反射，运行时打开和检查.class文件

 

class Base { }
class Derived extends Base { }
 
public class Main {
    public static void main(String[] args) {
       Base base = new Derived();
       if (base instanceof Derived) {
           // 这里可以向下转换了
           System.out.println("ok");
       }
       else {
           System.out.println("not ok");
       }
    }
}

 

3 动态代理

代理模式是为了提供额外或不同的操作，而插入的用来替代”实际”对象的对象，这些操作涉及到与”实际”对象的通信，因此代理通常充当中间人角色。Java的动态代理比代理的思想更前进了一步，它可以动态地创建并代理并动态地处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器上，它的工作是揭示调用的类型并确定相应的策略。以下是一个动态代理示例：

public interface Hello {
    void doSomething();
}
 
public class HelloImpl implements Hello {
    @Override
    public void doSomething() {
        System.out.println("HelloImpl doSomething");
    }
}
 
/**
 * 代理类
 */
public class ProxyHandler implements InvocationHandler {
    private Object proxyed;
 
    public ProxyHandler(Object proxy) {
        proxyed = proxy;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        System.out.println("proxy working");
        return method.invoke(proxyed, args);
    }
}
 
public static void main(String[] args) {
    Hello hello = new HelloImpl();
    Hello proxy = (Hello) Proxy.newProxyInstance(Hello.class.getClassLoader(),
            new Class[]{Hello.class}, new ProxyHandler(hello));
 
    proxy.doSomething();
}

输出结果：

 

通过调用Proxy静态方法Proxy.newProxyInstance()可以创建动态代理，这个方法需要得到一个类加载器，一个你希望该代理实现的接口列表(不是类或抽象类)，以及InvocationHandler的一个实现类。动态代理可以将所有调用重定向到调用处理器，因此通常会调用处理器的构造器传递一个”实际”对象的引用，从而将调用处理器在执行中介任务时，将请求转发。

 

参考资料：

1. 《Java编程思想》动态代理章节

2. 深入理解Java反射