public class A {
　　public void foo(String name) {
　　　　System.out.println("Hello, " + name);
　　}
}

import java.lang.reflect.Method;
public class TestClassLoad {
　　public static void main(String[] args) throws Exception {
　　　　Class<?> clz = Class.forName("A");
　　　　Object o = clz.newInstance();
　　　　Method m = clz.getMethod("foo", String.class);
　　　　for (int i = 0; i < 16; i++) {
　　　　　　m.invoke(o, Integer.toString(i));
　　　　}
　　}
}

[Loaded TestClassLoad from file:/D:/temp_code/test_java_classload/]
[Loaded A from file:/D:/temp_code/test_java_classload/]
[Loaded sun.reflect.NativeMethodAccessorImpl from shared objects file]
[Loaded sun.reflect.DelegatingMethodAccessorImpl from shared objects file]
Hello, 0
Hello, 1
Hello, 2
Hello, 3
Hello, 4
Hello, 5
Hello, 6
Hello, 7
Hello, 8
Hello, 9
Hello, 10
Hello, 11
Hello, 12
Hello, 13
Hello, 14
[Loaded sun.reflect.ClassFileConstants from shared objects file]
[Loaded sun.reflect.AccessorGenerator from shared objects file]
[Loaded sun.reflect.MethodAccessorGenerator from shared objects file]
[Loaded sun.reflect.ByteVectorFactory from shared objects file]
[Loaded sun.reflect.ByteVector from shared objects file]
[Loaded sun.reflect.ByteVectorImpl from shared objects file]
[Loaded sun.reflect.ClassFileAssembler from shared objects file]
[Loaded sun.reflect.UTF8 from shared objects file]
[Loaded java.lang.Void from shared objects file]
[Loaded sun.reflect.Label from shared objects file]
[Loaded sun.reflect.Label$PatchInfo from shared objects file]
[Loaded java.util.AbstractList$Itr from shared objects file]
[Loaded sun.reflect.MethodAccessorGenerator$1 from shared objects file]
[Loaded sun.reflect.ClassDefiner from shared objects file]
[Loaded sun.reflect.ClassDefiner$1 from shared objects file]
[Loaded sun.reflect.GeneratedMethodAccessor1 from __JVM_DefineClass__]
Hello, 15

java.lang.reflect.Method： 
public final
  class Method extends AccessibleObject implements GenericDeclaration, 
               Member {
  // ...
  private volatile MethodAccessor methodAccessor;
  // For sharing of MethodAccessors. This branching structure is
  // currently only two levels deep (i.e., one root Method and
  // potentially many Method objects pointing to it.)
  private Method       root;
  // ...
  public Object invoke(Object obj, Object... args)
      throws IllegalAccessException, IllegalArgumentException,
      InvocationTargetException
  {
    if (!override) {
      if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
        Class caller = Reflection.getCallerClass(1);
        Class targetClass = ((obj == null || !Modifier.isProtected(modifiers))
                   ? clazz
                   : obj.getClass());
        boolean cached;
        synchronized (this) {
          cached = (securityCheckCache == caller)
            && (securityCheckTargetClassCache == targetClass);
        }
        if (!cached) {
          Reflection.ensureMemberAccess(caller, clazz, obj, modifiers);
          synchronized (this) {
          securityCheckCache = caller;
          securityCheckTargetClassCache = targetClass;
          }
        }
      }
    }
    if (methodAccessor == null) acquireMethodAccessor();
    return methodAccessor.invoke(obj, args);
  }
  // NOTE that there is no synchronization used here. It is correct
  // (though not efficient) to generate more than one MethodAccessor
  // for a given Method. However, avoiding synchronization will
  // probably make the implementation more scalable.
  private void acquireMethodAccessor() {
    // First check to see if one has been created yet, and take it
    // if so
    MethodAccessor tmp = null;
    if (root != null) tmp = root.getMethodAccessor();
    if (tmp != null) {
      methodAccessor = tmp;
      return;
    }
    // Otherwise fabricate one and propagate it up to the root
    tmp = reflectionFactory.newMethodAccessor(this);
    setMethodAccessor(tmp);
  }
  // ...
}

sun.reflect.MethodAccessor：
public interface MethodAccessor {
  /** Matches specification in {@link java.lang.reflect.Method} */
  public Object invoke(Object obj, Object[] args)
    throws IllegalArgumentException, InvocationTargetException;
}

sun.reflect.ReflectionFactory：
public class ReflectionFactory {
  private static boolean initted = false;
  // ...
  //
  // "Inflation" mechanism. Loading bytecodes to implement
  // Method.invoke() and Constructor.newInstance() currently costs
  // 3-4x more than an invocation via native code for the first
  // invocation (though subsequent invocations have been benchmarked
  // to be over 20x faster). Unfortunately this cost increases
  // startup time for certain applications that use reflection
  // intensively (but only once per class) to bootstrap themselves.
  // To avoid this penalty we reuse the existing JVM entry points
  // for the first few invocations of Methods and Constructors and
  // then switch to the bytecode-based implementations.
  //
  // Package-private to be accessible to NativeMethodAccessorImpl
  // and NativeConstructorAccessorImpl
  private static boolean noInflation    = false;
  private static int   inflationThreshold = 15;
  // ...
  /** We have to defer full initialization of this class until after
    the static initializer is run since java.lang.reflect.Method's
    static initializer (more properly, that for
    java.lang.reflect.AccessibleObject) causes this class's to be
    run, before the system properties are set up. */
  private static void checkInitted() {
    if (initted) return;
    AccessController.doPrivileged(new PrivilegedAction() {
        public Object run() {
          // Tests to ensure the system properties table is fully
          // initialized. This is needed because reflection code is
          // called very early in the initialization process (before
          // command-line arguments have been parsed and therefore
          // these user-settable properties installed.) We assume that
          // if System.out is non-null then the System class has been
          // fully initialized and that the bulk of the startup code
          // has been run.
          if (System.out == null) {
            // java.lang.System not yet fully initialized
            return null;
          }
          String val = System.getProperty("sun.reflect.noInflation");
          if (val != null && val.equals("true")) {
            noInflation = true;
          }
          val = System.getProperty("sun.reflect.inflationThreshold");
          if (val != null) {
            try {
              inflationThreshold = Integer.parseInt(val);
            } catch (NumberFormatException e) {
              throw (RuntimeException) 
                new RuntimeException("Unable to parse property sun.reflect.inflationThreshold").
                  initCause(e);
            }
          }
          initted = true;
          return null;
        }
      });
  }
  // ...
  public MethodAccessor newMethodAccessor(Method method) {
    checkInitted();
    if (noInflation) {
      return new MethodAccessorGenerator().
        generateMethod(method.getDeclaringClass(),
                method.getName(),
                method.getParameterTypes(),
                method.getReturnType(),
                method.getExceptionTypes(),
                method.getModifiers());
    } else {
      NativeMethodAccessorImpl acc =
        new NativeMethodAccessorImpl(method);
      DelegatingMethodAccessorImpl res =
        new DelegatingMethodAccessorImpl(acc);
      acc.setParent(res);
      return res;
    }
  }
}

sun.reflect.DelegatingMethodAccessorImpl：
/** Delegates its invocation to another MethodAccessorImpl and can
  change its delegate at run time. */
class DelegatingMethodAccessorImpl extends MethodAccessorImpl {
  private MethodAccessorImpl delegate;
  DelegatingMethodAccessorImpl(MethodAccessorImpl delegate) {
    setDelegate(delegate);
  }  
  public Object invoke(Object obj, Object[] args)
    throws IllegalArgumentException, InvocationTargetException
  {
    return delegate.invoke(obj, args);
  }
  void setDelegate(MethodAccessorImpl delegate) {
    this.delegate = delegate;
  }
}

sun.reflect.NativeMethodAccessorImpl：
/** Used only for the first few invocations of a Method; afterward,
  switches to bytecode-based implementation */
class NativeMethodAccessorImpl extends MethodAccessorImpl {
  private Method method;
  private DelegatingMethodAccessorImpl parent;
  private int numInvocations;
  NativeMethodAccessorImpl(Method method) {
    this.method = method;
  }  
  public Object invoke(Object obj, Object[] args)
    throws IllegalArgumentException, InvocationTargetException
  {
    if (++numInvocations > ReflectionFactory.inflationThreshold()) {
      MethodAccessorImpl acc = (MethodAccessorImpl)
        new MethodAccessorGenerator().
          generateMethod(method.getDeclaringClass(),
                  method.getName(),
                  method.getParameterTypes(),
                  method.getReturnType(),
                  method.getExceptionTypes(),
                  method.getModifiers());
      parent.setDelegate(acc);
    }
    return invoke0(method, obj, args);
  }
  void setParent(DelegatingMethodAccessorImpl parent) {
    this.parent = parent;
  }
  private static native Object invoke0(Method m, Object obj, Object[] args);
}

JNIEXPORT jobject JNICALL Java_sun_reflect_NativeMethodAccessorImpl_invoke0
(JNIEnv *env, jclass unused, jobject m, jobject obj, jobjectArray args)
{
  return JVM_InvokeMethod(env, m, obj, args);
}
JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
 JVMWrapper("JVM_InvokeMethod");
 Handle method_handle;
 if (thread->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
  method_handle = Handle(THREAD, JNIHandles::resolve(method));
  Handle receiver(THREAD, JNIHandles::resolve(obj));
  objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
  oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
  jobject res = JNIHandles::make_local(env, result);
  if (JvmtiExport::should_post_vm_object_alloc()) {
   oop ret_type = java_lang_reflect_Method::return_type(method_handle());
   assert(ret_type != NULL, "sanity check: ret_type oop must not be NULL!");
   if (java_lang_Class::is_primitive(ret_type)) {
    // Only for primitive type vm allocates memory for java object.
    // See box() method.
    JvmtiExport::post_vm_object_alloc(JavaThread::current(), result);
   }
  }
  return res;
 } else {
  THROW_0(vmSymbols::java_lang_StackOverflowError());
 }

// This would be nicer if, say, java.lang.reflect.Method was a subclass
// of java.lang.reflect.Constructor
oop Reflection::invoke_method(oop method_mirror, Handle receiver, objArrayHandle args, TRAPS) {
 oop mirror       = java_lang_reflect_Method::clazz(method_mirror);
 int slot        = java_lang_reflect_Method::slot(method_mirror);
 bool override     = java_lang_reflect_Method::override(method_mirror) != 0;
 objArrayHandle ptypes(THREAD, objArrayOop(java_lang_reflect_Method::parameter_types(method_mirror)));
 oop return_type_mirror = java_lang_reflect_Method::return_type(method_mirror);
 BasicType rtype;
 if (java_lang_Class::is_primitive(return_type_mirror)) {
  rtype = basic_type_mirror_to_basic_type(return_type_mirror, CHECK_NULL);
 } else {
  rtype = T_OBJECT;
 }
 instanceKlassHandle klass(THREAD, java_lang_Class::as_klassOop(mirror));
 methodOop m = klass->method_with_idnum(slot);
 if (m == NULL) {
  THROW_MSG_0(vmSymbols::java_lang_InternalError(), "invoke");
 }
 methodHandle method(THREAD, m);
 return invoke(klass, method, receiver, override, ptypes, rtype, args, true, THREAD);
}

private static synchronized String generateName(boolean isConstructor,
                        boolean forSerialization)
{
  if (isConstructor) {
    if (forSerialization) {
      int num = ++serializationConstructorSymnum;
      return "sun/reflect/GeneratedSerializationConstructorAccessor" + num;
    } else {
      int num = ++constructorSymnum;
      return "sun/reflect/GeneratedConstructorAccessor" + num;
    }
  } else {
    int num = ++methodSymnum;
    return "sun/reflect/GeneratedMethodAccessor" + num;
  }
}

package sun.reflect;
public class GeneratedMethodAccessor1 extends MethodAccessorImpl {  
  public GeneratedMethodAccessor1() {
    super();
  }
  public Object invoke(Object obj, Object[] args)  
    throws IllegalArgumentException, InvocationTargetException {
    // prepare the target and parameters
    if (obj == null) throw new NullPointerException();
    try {
      A target = (A) obj;
      if (args.length != 1) throw new IllegalArgumentException();
      String arg0 = (String) args[0];
    } catch (ClassCastException e) {
      throw new IllegalArgumentException(e.toString());
    } catch (NullPointerException e) {
      throw new IllegalArgumentException(e.toString());
    }
    // make the invocation
    try {
      target.foo(arg0);
    } catch (Throwable t) {
      throw new InvocationTargetException(t);
    }
  }
}

/** 
 MagicAccessorImpl (named for parity with FieldAccessorImpl and
  others, not because it actually implements an interface) is a
  marker class in the hierarchy. All subclasses of this class are
  "magically" granted access by the VM to otherwise inaccessible
  fields and methods of other classes. It is used to hold the code
  for dynamically-generated FieldAccessorImpl and MethodAccessorImpl
  subclasses. (Use of the word "unsafe" was avoided in this class's
  name to avoid confusion with {@link sun.misc.Unsafe}.) 
  
 The bug fix for 4486457 also necessitated disabling
  verification for this class and all subclasses, as opposed to just
  SerializationConstructorAccessorImpl and subclasses, to avoid
  having to indicate to the VM which of these dynamically-generated
  stub classes were known to be able to pass the verifier. 
  
 Do not change the name of this class without also changing the
  VM's code. 
 */
class MagicAccessorImpl {
}

src/share/vm/prims/jvm.cpp 
// common code for JVM_DefineClass() and JVM_DefineClassWithSource()
// and JVM_DefineClassWithSourceCond()
static jclass jvm_define_class_common(JNIEnv *env, const char *name,
                   jobject loader, const jbyte *buf,
                   jsize len, jobject pd, const char *source,
                   jboolean verify, TRAPS) {
 if (source == NULL) source = "__JVM_DefineClass__";