请教下invoke方法，至今没怎么明白

如果我没记错的话,很多类都有invoke方法

这个我当然知道了，我给个例子吧
public static void main(String[] args) {
                // TODO Auto-generated method stub
                Class arrayProxy = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
                Collection array = (Collection) Proxy.newProxyInstance(
                                arrayProxy.getClassLoader(),
                                new Class[] {Collection.class},
                                new InvocationHandler() {
                                        ArrayList target = new ArrayList();
                                        @Override
                                        public Object invoke(Object proxy, Method method, Object[] args)
                                                        throws Throwable {
                                                // TODO Auto-generated method stub
                                                long beginTime = System.currentTimeMillis();
                                                Object retVal = method.invoke(target, args);
                                                long endTime = System.currentTimeMillis();
                                                System.out.println(method.getName()+"running time of"+(endTime-beginTime));
                                                return retVal;
                                        }
                                }
                );

在这里invoke干什么用？？？请解释下，然后呢，别的地方有用到此方法的也给说一下，谢谢了

1. package again.reflect;
   
2. 
   
3. 
   
4. import java.lang.reflect.Method;
   
5. 
   
6. public class Test {
   
7. 
   
8.         public static void main(String[] args) throws Exception{
   
9.                 String testClassName=args[0];//这个类要传入的参数是要测试的那个类名：again.reflect.TestArgument
   
10.                 Method method=TestArgument.class.getMethod("main", String[].class);
    
11.                 method.invoke(null, (Object)new String[]{"111","222","333"});
    
12.                 //或者下面这种写法
    
13.                 method.invoke(null, new Object[]{new String[]{"111","222","333"}});       
    
14.         }
    
15. }
    
16. 
    
17. class TestArgument{
    
18.         public static void main(String []args){
    
19.                 for(String str:args)
    
20.                         System.out.println(str);
    
21.         }
    
22. }
    

复制代码

invoke（）方法就是执行你获得的那个方法，本例中就是：执行TestArgument.main(new Sting[]{"111","222","333"});

在多线程编程中，我们经常要在工作线程中去更新界面显示，而在多线程中直接调用界面控件的方法是错误的做法，Invoke 和 BeginInvoke 就是为了解决这个问题而出现的，使你在多线程中安全的更新界面显示。
正确的做法是将工作线程中涉及更新界面的代码封装为一个方法，通过 Invoke 或者 BeginInvoke 去调用，两者的区别就是一个导致工作线程等待，而另外一个则不会。
而所谓的“一面响应操作，一面添加节点”永远只能是相对的，使 UI 线程的负担不至于太大而已，因为界面的正确更新始终要通过 UI 线程去做，我们要做的事情是在工作线程中包揽大部分的运算，而将对纯粹的界面更新放到 UI 线程中去做，这样也就达到了减轻 UI 线程负担的目的了。
再举个简单例子说明下使用方法,比如你在启动一个线程,在线程的方法中想更新窗体中的一个TextBox..

类似:

using System.Threading;

//启动一个线程
Thread thread=new Thread(new ThreadStart(DoWork));
thread.Start();

//线程方法
private void DoWork()
{
//其他操作
//比如将界面的TextBox设置一下
this.TextBox1.Text="我是一个文本框";
}

如果你像上面操作,在VS2005或2008里是会有异常的...

正确的做法是用Invoke..

改为如下:
//定义一个委托
public delegate void MyInvoke(string str);
//更新界面的方法
private void UpdateTextBox(string str);
{
//更新
this.TextBox1.Text=str;
}

//启动一个线程
Thread thread=new Thread(new ThreadStart(DoWork));
thread.Start();

//线程方法
private void DoWork()
{
//其他操作
//比如将界面的TextBox内容设置一下
MyInvoke mi=new MyInvoke(UpdateTextBox);
this.BeginInvoke(mi,new object[]{"我是一个文本框"});
}  

invoke方法的签名是：
Object invoke(Object obj,Object...args)
...
对于静态方法，第一个参数可以被忽略，即可以将它设置为null
例如,假设用mI代表Employee类的getName方法，下面这条语句显示了调用这个方法的格式：
String n=(String)m1.invoke(harry);
...
例如,假设m2代表Employee类的getSalary方法，那么返回的实际类型是Double，因此必须相应的进行类型转换。
double s=(Double)m2.invoke(harry);

以下代码简单地介绍了java反射中invoke方法，

package org.curry.tool;
import java.lang.reflect.Method;

public class InvokeMethods {
public static void main(String[] args) {
  Employee emp = new Employee();
  Class cl = emp.getClass();//是Class，而不是class
  // /getClass获得emp对象所属的类型的对象，Class就是类的类　　　　　　　　　　
  // /Class是专门用来描述类的类，比如描述某个类有那些字段，　　　　　　　　　　
  // /方法，构造器等等！
  try {
   // /getMethod方法第一个参数指定一个需要调用的方法名称
   // /这里是Employee类的setAge方法，第二个参数是需要调用　
   // 方法的参数类型列表，是参数类型！如无参数可以指定null　
   // /该方法返回一个方法对象　
   Method sAge = cl.getMethod("setAge", new Class[] { int.class });//参数必须和方法中一样int和Integer，double和Double被视为不同的类型
   Method gAge = cl.getMethod("getAge", null);
   Method pName = cl.getMethod("printName",
     new Class[] { String.class });
   
   Object[] args1 = { new Integer(25) };
   // 参数列表
   // emp为隐式参数该方法不是静态方法必须指定
   sAge.invoke(emp, args1);
   Integer AGE = (Integer) gAge.invoke(emp, null);
   int age = AGE.intValue();
   System.out.println("The Employee Age is: " + age);
   Object[] args3 = { new String("Jack") };
   pName.invoke(emp, args3);
  } catch (Exception e) {
   e.printStackTrace();
  }
  System.exit(0);
}
}

class Employee {
// 定义一个员工类　　
public Employee() {
  age = 0;
  name = null;
}
// 将要被调用的方法　　
public void setAge(int a) {
  age = a;
}
// 将要被调用的方法　　
public int getAge() {
  return age;
}
// 将要被调用的方法
public void printName(String n) {
  name = n;
  System.out.println("The Employee Name is: " + name);
}
private int age;
private String name;
}

好的，似乎有些理解了