Java 作为实例方法调用

下面是什么功能

Class c = Class.forName(handler);
Class partypes[] = new Class[1];
partypes[0] = new String().getClass();
Constructor ct = c.getConstructor(partypes);
Object arglist1[] = new Object[1];
arglist1[0] = address;
Method meth[] = c.getMethods();
Object arglist[] = new Object[7]; 
arglist[0] = new Integer(transid);
arglist[1] = transobj;            
arglist[2] = data_vec;            
arglist[3] = company_name;        
arglist[4] = new Boolean(flag_final_level_approval); 
flag_final_level_approval=true else false
arglist[5] = con;                
arglist[6] = scon;              
boolean found = false;
for(int i=0;i<meth.length;i++) {
    Method m = meth[i];
    if(m.getName().equals(functionName)) {
        result_vec = (Vector)m.invoke(ct.newInstance(arglist1),arglist);
    }
}

Class c=Class.forName（处理程序）；
类partypes[]=新类[1]；
partypes[0]=新字符串（）.getClass（）；
构造函数ct=c.getConstructor（partypes）；
对象arglist1[]=新对象[1]；
arglist1[0]=地址；
方法meth[]=c.getMethods（）；
对象arglist[]=新对象[7]；
arglist[0]=新整数（transid）；
arglist[1]=transobj；
arglist[2]=数据向量；
arglist[3]=公司名称；
arglist[4]=新布尔值（标志最终级别批准）；
标志\最终\级别\批准=真，否则为假
arglist[5]=con；
arglist[6]=scon；
布尔值=false；
对于（inti=0；i基本上，它检查类中的所有方法，并且在任何时候找到匹配项，它都会创建一个新实例（即
ct.newInstance（arglist1）
bit），然后调用该方法（即
m.invoke（…，arglist）
bit）

您可能会发现以下内容更容易理解：

Object instance = ct.newInstance(arglist1);
result_vec = (Vector) m.invoke(instance, arglist);

（总的来说，这是一段非常难看的代码…
基本上，它会检查类中的所有方法，只要找到匹配项，它就会创建一个新实例（即
ct.newInstance（arglist1）
bit），然后调用该方法（即
m.invoke（…，arglist）
bit）

您可能会发现以下内容更容易理解：

Object instance = ct.newInstance(arglist1);
result_vec = (Vector) m.invoke(instance, arglist);

（总的来说，这是非常难看的代码…
有人在使用一些令人发指的反射来调用
处理程序
类上的方法

我很想知道为什么把所有的参数费力地放入参数数组中，却不能传递给处理程序实例并简单地调用它们

似乎有人决定使用复杂的实现来满足（真实的或想象的）终极灵活性需求。
有人正在使用一些令人发指的反射来调用
处理程序
类上的方法

我很想知道为什么把所有的参数费力地放入参数数组中，却不能传递给处理程序实例并简单地调用它们

看起来有人决定使用复杂的实现来满足（真实的或想象的）需求对终极灵活性的要求。
这看起来像是滥用反射来掩盖未能为两个交互Java组件创建正确接口的错误。如果您在代码片段中为变量提供具体值，则可能会进一步猜测…
这看起来像是滥用反射来掩盖错误未能为两个交互Java组件创建正确的接口。如果您在代码段中为变量提供具体值，则可能会进一步猜测…
Class c=Class.forName（handler）；//为具有名称的类获取类对象
Class c = Class.forName(handler);       // get class object for class with name <handler>
Class partypes[] = new Class[1];    
partypes[0] = new String().getClass();      // get class object for string
Constructor ct = c.getConstructor(partypes);    // get constructor of <handler> with signature <handler>(String)
Object arglist1[] = new Object[1]; 
arglist1[0] = address; 
Method meth[] = c.getMethods();         // get method objects from <handler>
Object arglist[] = new Object[7];       // collect a few params
arglist[0] = new Integer(transid);      // collect a few params
arglist[1] = transobj;              // collect a few params
arglist[2] = data_vec;              // collect a few params
arglist[3] = company_name;          // collect a few params
arglist[4] = new Boolean(flag_final_level_approval); // collect a few params
flag_final_level_approval=true else false   // this won't compile
arglist[5] = con;               // collect a few params
arglist[6] = scon;              // collect a few params
boolean found = false; 
for(int i=0;i<meth.length;i++) {
    Method m = meth[i];
    if(m.getName().equals(functionName)) {  // if method with name <functionName> found
        result_vec = (Vector)m.invoke(ct.newInstance(arglist1),arglist);  // invokes method on ct.NewInstance with arglist as param 
    }

类partypes[]=新类[1]；
PartTypes[0]=新字符串（）.getClass（）；//获取字符串的类对象
构造函数ct=c.getConstructor（partypes）；//使用签名（字符串）获取的构造函数
对象arglist1[]=新对象[1]；
arglist1[0]=地址；
方法meth[]=c.getMethods（）；//从中获取方法对象
对象arglist[]=新对象[7]；//收集几个参数
arglist[0]=新整数（transid）；//收集几个参数
arglist[1]=transobj；//收集几个参数
arglist[2]=data\u vec；//收集几个参数
arglist[3]=公司名称；//收集几个参数
arglist[4]=new Boolean（flag_final_level_approval）；//收集一些参数
flag_final_level_approval=true，否则为false//这不会编译
arglist[5]=con；//收集几个参数
arglist[6]=scon；//收集几个参数
布尔值=false；
for（int i=0；i
Class c=Class.forName（handler）；//为具有名称的类获取类对象
类partypes[]=新类[1]；
PartTypes[0]=新字符串（）.getClass（）；//获取字符串的类对象
构造函数ct=c.getConstructor（partypes）；//使用签名（字符串）获取的构造函数
对象arglist1[]=新对象[1]；
arglist1[0]=地址；
方法meth[]=c.getMethods（）；//从中获取方法对象
对象arglist[]=新对象[7]；//收集几个参数
arglist[0]=新整数（transid）；//收集几个参数
arglist[1]=transobj；//收集几个参数
arglist[2]=data\u vec；//收集几个参数
arglist[3]=公司名称；//收集几个参数
arglist[4]=new Boolean（flag_final_level_approval）；//收集一些参数
flag_final_level_approval=true，否则为false//这不会编译
arglist[5]=con；//收集几个参数
arglist[6]=scon；//收集几个参数
布尔值=false；
对于（int i=0；i，将创建一个名为
handler
的对象表示类：

Class c = Class.forName(handler);

然后，我们用一个字符串参数搜索其构造函数：

Class partypes[] = new Class[1];
partypes[0] = new String().getClass();
Constructor ct = c.getConstructor(partypes);

并在for循环中使用

最后，迭代这些方法，寻找一个名为
functionName
的方法，该方法在新创建的实例上调用：

result_vec = (Vector)m.invoke(ct.newInstance(arglist1),arglist);

所有这些都相当于写作（使用诸如

正如我所有的同事所说，这显然是一种内省的滥用，因为通过迭代方法，一个人可能会遇到多个名称正确的方法，并尝试调用所有方法，收集各种执行异常和奇怪的结果。
创建了一个名为
handler
的对象表示类：

Class c = Class.forName(handler);

然后，我们用一个字符串参数搜索其构造函数：

Class partypes[] = new Class[1];
partypes[0] = new String().getClass();
Constructor ct = c.getConstructor(partypes);

并在for循环中使用

最后，迭代这些方法，寻找一个名为
functionName
的方法，该方法在新创建的实例上调用：

result_vec = (Vector)m.invoke(ct.newInstance(arglist1),arglist);

所有这些都相当于写作（使用诸如

正如我所有的同事所说，这显然是一种内省的滥用，因为通过迭代方法，一个人可能会遇到多个名称正确的方法，并且