diff --git a/src/class_linker.cc b/src/class_linker.cc
index 04f703b..6ee3af3 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -29,11 +29,6 @@
 
 void ClassLinker::Init(std::vector<DexFile*> boot_class_path) {
 
-  // setup boot_class_path_ so that object_array_class_ can be properly initialized
-  for (size_t i = 0; i != boot_class_path.size(); ++i) {
-    AppendToBootClassPath(boot_class_path[i]);
-  }
-
   // Allocate and partially initialize the Class, Object, Field, Method classes.
   // Initialization will be completed when the definitions are loaded.
   java_lang_Class_ = down_cast<Class*>(Heap::AllocObject(NULL, sizeof(Class)));
@@ -48,21 +43,13 @@
 
   java_lang_Class_->super_class_ = java_lang_Object_;
 
-  java_lang_ref_Field_ = AllocClass(NULL);
-  CHECK(java_lang_ref_Field_ != NULL);
-  java_lang_ref_Field_->descriptor_ = "Ljava/lang/ref/Field;";
+  java_lang_reflect_Field_ = AllocClass(NULL);
+  CHECK(java_lang_reflect_Field_ != NULL);
+  java_lang_reflect_Field_->descriptor_ = "Ljava/lang/reflect/Field;";
 
-  java_lang_ref_Method_ = AllocClass(NULL);
-  CHECK(java_lang_ref_Method_ != NULL);
-  java_lang_ref_Method_->descriptor_ = "Ljava/lang/Method;";
-
-  java_lang_Cloneable_ = AllocClass(NULL);
-  CHECK(java_lang_Cloneable_ != NULL);
-  java_lang_Cloneable_->descriptor_ = "Ljava/lang/Cloneable;";
-
-  java_io_Serializable_ = AllocClass(NULL);
-  CHECK(java_io_Serializable_ != NULL);
-  java_io_Serializable_->descriptor_ = "Ljava/io/Serializable;";
+  java_lang_reflect_Method_ = AllocClass(NULL);
+  CHECK(java_lang_reflect_Method_ != NULL);
+  java_lang_reflect_Method_->descriptor_ = "Ljava/lang/reflect/Method;";
 
   java_lang_String_ = AllocClass(NULL);
   CHECK(java_lang_String_ != NULL);
@@ -79,11 +66,50 @@
   primitive_boolean_ = CreatePrimitiveClass("Z");
   primitive_void_ = CreatePrimitiveClass("V");
 
+  // object_array_class_ is needed to heap alloc DexCache instances
+  // created by AppendToBootClassPath below
+  object_array_class_ = AllocClass(NULL);
+  CHECK(object_array_class_ != NULL);
+
+  // setup boot_class_path_ so that the below array classes can be
+  // initialized using the normal FindSystemClass API
+  for (size_t i = 0; i != boot_class_path.size(); ++i) {
+    AppendToBootClassPath(boot_class_path[i]);
+  }
+
+  // A single, global copy of "interfaces" and "iftable" for reuse across array classes
+  java_lang_Cloneable_ = AllocClass(NULL);
+  CHECK(java_lang_Cloneable_ != NULL);
+  java_lang_Cloneable_->descriptor_ = "Ljava/lang/Cloneable;";
+
+  java_io_Serializable_ = AllocClass(NULL);
+  CHECK(java_io_Serializable_ != NULL);
+  java_io_Serializable_->descriptor_ = "Ljava/io/Serializable;";
+
+  array_interfaces_ = AllocObjectArray(2);
+  CHECK(array_interfaces_ != NULL);
+  array_interfaces_->Set(0, java_lang_Cloneable_);
+  array_interfaces_->Set(1, java_io_Serializable_);
+
+  // We assume that Cloneable/Serializable don't have superinterfaces --
+  // normally we'd have to crawl up and explicitly list all of the
+  // supers as well.  These interfaces don't have any methods, so we
+  // don't have to worry about the ifviPool either.
+  array_iftable_ = new InterfaceEntry[2];
+  CHECK(array_iftable_ != NULL);
+  memset(array_iftable_, 0, sizeof(InterfaceEntry) * 2);
+  array_iftable_[0].SetClass(down_cast<Class*>(array_interfaces_->Get(0)));
+  array_iftable_[1].SetClass(down_cast<Class*>(array_interfaces_->Get(1)));
+
   char_array_class_ = FindSystemClass("[C");
   CHECK(char_array_class_ != NULL);
+  class_array_class_ = FindSystemClass("[Ljava/lang/Class;");
+  CHECK(class_array_class_ != NULL);
+  field_array_class_ = FindSystemClass("[Ljava/lang/reflect/Field;");
+  CHECK(field_array_class_ != NULL);
+  method_array_class_ = FindSystemClass("[Ljava/lang/reflect/Method;");
+  CHECK(method_array_class_ != NULL);
 
-  object_array_class_ = FindSystemClass("[Ljava/lang/Object;");
-  CHECK(object_array_class_ != NULL);
 }
 
 DexCache* ClassLinker::AllocDexCache() {
@@ -97,17 +123,17 @@
 }
 
 StaticField* ClassLinker::AllocStaticField() {
-  return down_cast<StaticField*>(Heap::AllocObject(java_lang_ref_Field_,
+  return down_cast<StaticField*>(Heap::AllocObject(java_lang_reflect_Field_,
                                                    sizeof(StaticField)));
 }
 
 InstanceField* ClassLinker::AllocInstanceField() {
-  return down_cast<InstanceField*>(Heap::AllocObject(java_lang_ref_Field_,
+  return down_cast<InstanceField*>(Heap::AllocObject(java_lang_reflect_Field_,
                                                      sizeof(InstanceField)));
 }
 
 Method* ClassLinker::AllocMethod() {
-  return down_cast<Method*>(Heap::AllocObject(java_lang_ref_Method_,
+  return down_cast<Method*>(Heap::AllocObject(java_lang_reflect_Method_,
                                               sizeof(Method)));
 }
 
@@ -143,6 +169,7 @@
     const DexFile::ClassDef* dex_class_def = pair.second;
     DexCache* dex_cache = FindDexCache(dex_file);
     // Load the class from the dex file.
+    // TODO add fast path to avoid all these comparisons once special cases are found
     if (descriptor == "Ljava/lang/Object;") {
       klass = java_lang_Object_;
       klass->dex_cache_ = dex_cache;
@@ -152,26 +179,31 @@
       klass = java_lang_Class_;
       klass->dex_cache_ = dex_cache;
       klass->object_size_ = sizeof(Class);
-    } else if (descriptor == "Ljava/lang/ref/Field;") {
-      klass = java_lang_ref_Field_;
+    } else if (descriptor == "Ljava/lang/reflect/Field;") {
+      klass = java_lang_reflect_Field_;
       klass->dex_cache_ = dex_cache;
       klass->object_size_ = sizeof(Field);
-    } else if (descriptor == "Ljava/lang/ref/Method;") {
-      klass = java_lang_ref_Method_;
+    } else if (descriptor == "Ljava/lang/reflect/Method;") {
+      klass = java_lang_reflect_Method_;
       klass->dex_cache_ = dex_cache;
       klass->object_size_ = sizeof(Method);
-    } else if (descriptor == "Ljava/lang/Cloneable;") {
-      klass = java_lang_Cloneable_;
-      klass->dex_cache_ = dex_cache;
-    } else if (descriptor == "Ljava/io/Serializable;") {
-      klass = java_io_Serializable_;
-      klass->dex_cache_ = dex_cache;
     } else if (descriptor == "Ljava/lang/String;") {
       klass = java_lang_String_;
       klass->dex_cache_ = dex_cache;
       klass->object_size_ = sizeof(String);
+    } else if (descriptor == "Ljava/lang/Cloneable;") {
+      klass = java_lang_Cloneable_;
+      klass->dex_cache_ = dex_cache;
+      klass->object_size_ = 0;
+    } else if (descriptor == "Ljava/io/Serializable;") {
+      klass = java_io_Serializable_;
+      klass->dex_cache_ = dex_cache;
+      klass->object_size_ = 0;
     } else {
       klass = AllocClass(dex_cache);
+      // LinkInstanceFields only will update object_size_ if it is 0
+      // to avoid overwriting the special initialized cases above.
+      klass->object_size_ = 0;
     }
     LoadClass(*dex_file, *dex_class_def, klass);
     // Check for a pending exception during load
@@ -245,10 +277,10 @@
   klass->super_class_ = NULL;
   klass->super_class_idx_ = dex_class_def.superclass_idx_;
 
-  klass->num_static_fields_ = header.static_fields_size_;
-  klass->num_instance_fields_ = header.instance_fields_size_;
-  klass->num_direct_methods_ = header.direct_methods_size_;
-  klass->num_virtual_methods_ = header.virtual_methods_size_;
+  size_t num_static_fields = header.static_fields_size_;
+  size_t num_instance_fields = header.instance_fields_size_;
+  size_t num_direct_methods = header.direct_methods_size_;
+  size_t num_virtual_methods = header.virtual_methods_size_;
 
   klass->source_file_ = dex_file.dexGetSourceFile(dex_class_def);
 
@@ -256,58 +288,61 @@
   LoadInterfaces(dex_file, dex_class_def, klass);
 
   // Load static fields.
-  if (klass->NumStaticFields() != 0) {
-    // TODO: allocate on the object heap.
-    klass->sfields_ = new StaticField*[klass->NumStaticFields()]();
+  DCHECK(klass->sfields_ == NULL);
+  if (num_static_fields != 0) {
+    klass->sfields_ = AllocObjectArray(num_static_fields);
     uint32_t last_idx = 0;
     for (size_t i = 0; i < klass->NumStaticFields(); ++i) {
       DexFile::Field dex_field;
       dex_file.dexReadClassDataField(&class_data, &dex_field, &last_idx);
       StaticField* sfield = AllocStaticField();
-      klass->sfields_[i] = sfield;
+      klass->SetStaticField(i, sfield);
       LoadField(dex_file, dex_field, klass, sfield);
     }
   }
 
   // Load instance fields.
-  if (klass->NumInstanceFields() != 0) {
+  DCHECK(klass->ifields_ == NULL);
+  if (num_instance_fields != 0) {
     // TODO: allocate on the object heap.
-    klass->ifields_ = new InstanceField*[klass->NumInstanceFields()]();
+    klass->ifields_ = AllocObjectArray(num_instance_fields);
     uint32_t last_idx = 0;
     for (size_t i = 0; i < klass->NumInstanceFields(); ++i) {
       DexFile::Field dex_field;
       dex_file.dexReadClassDataField(&class_data, &dex_field, &last_idx);
       InstanceField* ifield = AllocInstanceField();
-      klass->ifields_[i] = ifield;
+      klass->SetInstanceField(i, ifield);
       LoadField(dex_file, dex_field, klass, ifield);
     }
   }
 
   // Load direct methods.
-  if (klass->NumDirectMethods() != 0) {
+  DCHECK(klass->direct_methods_ == NULL);
+  if (num_direct_methods != 0) {
     // TODO: append direct methods to class object
-    klass->direct_methods_ = new Method*[klass->NumDirectMethods()]();
+    klass->direct_methods_ = AllocObjectArray(num_direct_methods);
     uint32_t last_idx = 0;
     for (size_t i = 0; i < klass->NumDirectMethods(); ++i) {
       DexFile::Method dex_method;
       dex_file.dexReadClassDataMethod(&class_data, &dex_method, &last_idx);
       Method* meth = AllocMethod();
-      klass->direct_methods_[i] = meth;
+      klass->SetDirectMethod(i, meth);
       LoadMethod(dex_file, dex_method, klass, meth);
       // TODO: register maps
     }
   }
 
   // Load virtual methods.
-  if (klass->NumVirtualMethods() != 0) {
+  DCHECK(klass->virtual_methods_ == NULL);
+  if (num_virtual_methods != 0) {
     // TODO: append virtual methods to class object
-    klass->virtual_methods_ = new Method*[klass->NumVirtualMethods()]();
+    klass->virtual_methods_ = AllocObjectArray(num_virtual_methods);
     uint32_t last_idx = 0;
     for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
       DexFile::Method dex_method;
       dex_file.dexReadClassDataMethod(&class_data, &dex_method, &last_idx);
       Method* meth = AllocMethod();
-      klass->virtual_methods_[i] = meth;
+      klass->SetVirtualMethod(i, meth);
       LoadMethod(dex_file, dex_method, klass, meth);
       // TODO: register maps
     }
@@ -319,12 +354,13 @@
                                  Class* klass) {
   const DexFile::TypeList* list = dex_file.GetInterfacesList(dex_class_def);
   if (list != NULL) {
-    klass->interface_count_ = list->Size();
-    // TODO: allocate the interfaces array on the object heap.
-    klass->interfaces_ = new Class*[list->Size()]();
+    DCHECK(klass->interfaces_ == NULL);
+    klass->interfaces_ = AllocObjectArray(list->Size());
+    DCHECK(klass->interfaces_idx_ == NULL);
+    klass->interfaces_idx_ = new uint32_t[list->Size()];
     for (size_t i = 0; i < list->Size(); ++i) {
       const DexFile::TypeItem& type_item = list->GetTypeItem(i);
-      klass->interfaces_[i] = reinterpret_cast<Class*>(type_item.type_idx_);
+      klass->interfaces_idx_[i] = type_item.type_idx_;
     }
   }
 }
@@ -515,9 +551,16 @@
     //
     // Array classes are simple enough that we don't need to do a full
     // link step.
-    Class* new_class = AllocClass(NULL);
-    if (new_class == NULL) {
-      return NULL;
+
+    Class* new_class;
+    if (descriptor == "[Ljava/lang/Object;") {
+      CHECK(object_array_class_);
+      new_class = object_array_class_;
+    } else {
+      new_class = AllocClass(NULL);
+      if (new_class == NULL) {
+        return NULL;
+      }
     }
     new_class->descriptor_alloc_ = new std::string(descriptor.data(),
                                                    descriptor.size());
@@ -542,26 +585,15 @@
     // so we need to make sure the class object is GC-valid while we're in
     // there.  Do this by clearing the interface list so the GC will just
     // think that the entries are null.
-    //
-    // TODO?
-    // We may want to create a single, global copy of "interfaces" and
-    // "iftable" somewhere near the start and just point to those (and
-    // remember not to free them for arrays).
-    new_class->interface_count_ = 2;
-    new_class->interfaces_ = new Class*[2];
-    memset(new_class->interfaces_, 0, sizeof(Class*) * 2);
-    new_class->interfaces_[0] = java_lang_Cloneable_;
-    new_class->interfaces_[1] = java_io_Serializable_;
 
-    // We assume that Cloneable/Serializable don't have superinterfaces --
-    // normally we'd have to crawl up and explicitly list all of the
-    // supers as well.  These interfaces don't have any methods, so we
-    // don't have to worry about the ifviPool either.
+
+    // Use the single, global copies of "interfaces" and "iftable"
+    // (remember not to free them for arrays).
+    DCHECK(array_interfaces_ != NULL);
+    new_class->interfaces_ = array_interfaces_;
     new_class->iftable_count_ = 2;
-    new_class->iftable_ = new InterfaceEntry[2];
-    memset(new_class->iftable_, 0, sizeof(InterfaceEntry) * 2);
-    new_class->iftable_[0].SetClass(new_class->interfaces_[0]);
-    new_class->iftable_[1].SetClass(new_class->interfaces_[1]);
+    DCHECK(array_iftable_ != NULL);
+    new_class->iftable_ = array_iftable_;
 
     // Inherit access flags from the component type.  Arrays can't be
     // used as a superclass or interface, so we want to add "final"
@@ -992,15 +1024,6 @@
 }
 
 bool ClassLinker::LinkInterfaces(Class* klass, const DexFile* dex_file) {
-  scoped_array<uint32_t> interfaces_idx;
-  // TODO: store interfaces_idx in the Class object
-  // TODO: move this outside of link interfaces
-  if (klass->interface_count_ > 0) {
-    size_t length = klass->interface_count_ * sizeof(klass->interfaces_[0]);
-    interfaces_idx.reset(new uint32_t[klass->interface_count_]);
-    memcpy(interfaces_idx.get(), klass->interfaces_, length);
-    memset(klass->interfaces_, 0xFF, length);
-  }
   // Mark the class as loaded.
   klass->status_ = Class::kStatusLoaded;
   if (klass->super_class_idx_ != DexFile::kDexNoIndex) {
@@ -1011,16 +1034,16 @@
     }
     klass->super_class_ = super_class;  // TODO: write barrier
   }
-  if (klass->interface_count_ > 0) {
-    for (size_t i = 0; i < klass->interface_count_; ++i) {
-      uint32_t idx = interfaces_idx[i];
-      klass->interfaces_[i] = ResolveClass(klass, idx, dex_file);
-      if (klass->interfaces_[i] == NULL) {
+  if (klass->NumInterfaces() > 0) {
+    for (size_t i = 0; i < klass->NumInterfaces(); ++i) {
+      uint32_t idx = klass->interfaces_idx_[i];
+      klass->SetInterface(i, ResolveClass(klass, idx, dex_file));
+      if (klass->GetInterface(i) == NULL) {
         LG << "Failed to resolve interface";
         return false;
       }
       // Verify
-      if (!klass->CanAccess(klass->interfaces_[i])) {
+      if (!klass->CanAccess(klass->GetInterface(i))) {
         LG << "Inaccessible interface";
         return false;
       }
@@ -1165,26 +1188,26 @@
   } else {
     super_ifcount = 0;
   }
-  size_t ifCount = super_ifcount;
-  ifCount += klass->interface_count_;
-  for (size_t i = 0; i < klass->interface_count_; i++) {
-    ifCount += klass->interfaces_[i]->iftable_count_;
+  size_t ifcount = super_ifcount;
+  ifcount += klass->NumInterfaces();
+  for (size_t i = 0; i < klass->NumInterfaces(); i++) {
+    ifcount += klass->GetInterface(i)->iftable_count_;
   }
-  if (ifCount == 0) {
+  if (ifcount == 0) {
     DCHECK(klass->iftable_count_ == 0);
     DCHECK(klass->iftable_ == NULL);
     return true;
   }
-  klass->iftable_ = new InterfaceEntry[ifCount * sizeof(InterfaceEntry)];
-  memset(klass->iftable_, 0x00, sizeof(InterfaceEntry) * ifCount);
+  klass->iftable_ = new InterfaceEntry[ifcount * sizeof(InterfaceEntry)];
+  memset(klass->iftable_, 0x00, sizeof(InterfaceEntry) * ifcount);
   if (super_ifcount != 0) {
     memcpy(klass->iftable_, klass->GetSuperClass()->iftable_,
            sizeof(InterfaceEntry) * super_ifcount);
   }
   // Flatten the interface inheritance hierarchy.
   size_t idx = super_ifcount;
-  for (size_t i = 0; i < klass->interface_count_; i++) {
-    Class* interf = klass->interfaces_[i];
+  for (size_t i = 0; i < klass->NumInterfaces(); i++) {
+    Class* interf = klass->GetInterface(i);
     DCHECK(interf != NULL);
     if (!interf->IsInterface()) {
       LG << "Class implements non-interface class";  // TODO: IncompatibleClassChangeError
@@ -1195,12 +1218,12 @@
       klass->iftable_[idx++].SetClass(interf->iftable_[j].GetClass());
     }
   }
-  CHECK_EQ(idx, ifCount);
-  klass->iftable_count_ = ifCount;
-  if (klass->IsInterface() || super_ifcount == ifCount) {
+  CHECK_EQ(idx, ifcount);
+  klass->iftable_count_ = ifcount;
+  if (klass->IsInterface() || super_ifcount == ifcount) {
     return true;
   }
-  for (size_t i = super_ifcount; i < ifCount; i++) {
+  for (size_t i = super_ifcount; i < ifcount; i++) {
     pool_size += klass->iftable_[i].GetClass()->NumVirtualMethods();
   }
   if (pool_size == 0) {
@@ -1209,7 +1232,7 @@
   klass->ifvi_pool_count_ = pool_size;
   klass->ifvi_pool_ = new uint32_t[pool_size];
   std::vector<Method*> miranda_list;
-  for (size_t i = super_ifcount; i < ifCount; ++i) {
+  for (size_t i = super_ifcount; i < ifcount; ++i) {
     klass->iftable_[i].method_index_array_ = klass->ifvi_pool_ + pool_offset;
     Class* interface = klass->iftable_[i].GetClass();
     pool_offset += interface->NumVirtualMethods();    // end here
@@ -1250,19 +1273,18 @@
     }
   }
   if (miranda_count != 0) {
-    int oldMethodCount = klass->NumVirtualMethods();
-    int newMethodCount = oldMethodCount + miranda_count;
-    Method** newVirtualMethods = new Method*[newMethodCount];
+    int old_method_count = klass->NumVirtualMethods();
+    int new_method_count = old_method_count + miranda_count;
+    ObjectArray* new_virtual_methods = AllocObjectArray(new_method_count);
     if (klass->virtual_methods_ != NULL) {
-      memcpy(newVirtualMethods,
-             klass->virtual_methods_,
-             klass->NumVirtualMethods() * sizeof(Method*));
+      ObjectArray::Copy(klass->virtual_methods_, 0,
+                        new_virtual_methods, 0,
+                        old_method_count);
     }
-    klass->virtual_methods_ = newVirtualMethods;
-    klass->num_virtual_methods_ = newMethodCount;
+    klass->virtual_methods_ = new_virtual_methods;
 
     CHECK(klass->vtable_ != NULL);
-    int oldVtableCount = klass->vtable_count_;
+    int old_vtable_count = klass->vtable_count_;
     klass->vtable_count_ += miranda_count;
 
     for (int i = 0; i < miranda_count; i++) {
@@ -1270,9 +1292,9 @@
       memcpy(meth, miranda_list[i], sizeof(Method));
       meth->klass_ = klass;
       meth->access_flags_ |= kAccMiranda;
-      meth->method_index_ = 0xFFFF & (oldVtableCount + i);
-      klass->virtual_methods_[oldMethodCount+i] = meth;
-      klass->vtable_[oldVtableCount + i] = meth;
+      meth->method_index_ = 0xFFFF & (old_vtable_count + i);
+      klass->SetVirtualMethod(old_method_count + i, meth);
+      klass->vtable_[old_vtable_count + i] = meth;
     }
   }
   return true;
@@ -1415,7 +1437,10 @@
   }
 #endif
 
-  klass->object_size_ = field_offset;
+  if (klass->object_size_ == 0) {
+    // avoid overwriting object_size_ of special crafted classes such as java_lang_*_
+    klass->object_size_ = field_offset;
+  }
   return true;
 }
 
diff --git a/src/class_linker.h b/src/class_linker.h
index ee56595..622eaea 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -161,8 +161,8 @@
 
   Class* java_lang_Class_;
   Class* java_lang_Object_;
-  Class* java_lang_ref_Field_;
-  Class* java_lang_ref_Method_;
+  Class* java_lang_reflect_Field_;
+  Class* java_lang_reflect_Method_;
   Class* java_lang_Cloneable_;
   Class* java_io_Serializable_;
   Class* java_lang_String_;
@@ -177,8 +177,14 @@
   Class* primitive_long_;
   Class* primitive_void_;
 
-  Class* object_array_class_;
   Class* char_array_class_;
+  Class* class_array_class_;
+  Class* object_array_class_;
+  Class* field_array_class_;
+  Class* method_array_class_;
+
+  ObjectArray* array_interfaces_;
+  InterfaceEntry* array_iftable_;
 
   FRIEND_TEST(ClassLinkerTest, ProtoCompare);
   FRIEND_TEST(ClassLinkerTest, ProtoCompare2);
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index 54b13fe..2025b71 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -38,7 +38,7 @@
     EXPECT_EQ(0U, primitive->NumVirtualMethods());
     EXPECT_EQ(0U, primitive->NumInstanceFields());
     EXPECT_EQ(0U, primitive->NumStaticFields());
-    EXPECT_EQ(0U, primitive->interface_count_);
+    EXPECT_EQ(0U, primitive->NumInterfaces());
   }
 
   void AssertArrayClass(const StringPiece& array_descriptor,
@@ -70,7 +70,7 @@
     EXPECT_EQ(0U, array->NumVirtualMethods());
     EXPECT_EQ(0U, array->NumInstanceFields());
     EXPECT_EQ(0U, array->NumStaticFields());
-    EXPECT_EQ(2U, array->interface_count_);
+    EXPECT_EQ(2U, array->NumInterfaces());
   }
 };
 
@@ -132,7 +132,7 @@
   EXPECT_EQ(0U, JavaLangObject->NumVirtualMethods());
   EXPECT_EQ(0U, JavaLangObject->NumInstanceFields());
   EXPECT_EQ(0U, JavaLangObject->NumStaticFields());
-  EXPECT_EQ(0U, JavaLangObject->interface_count_);
+  EXPECT_EQ(0U, JavaLangObject->NumInterfaces());
 
 
   scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassDex));
@@ -161,7 +161,7 @@
   EXPECT_EQ(0U, MyClass->NumVirtualMethods());
   EXPECT_EQ(0U, MyClass->NumInstanceFields());
   EXPECT_EQ(0U, MyClass->NumStaticFields());
-  EXPECT_EQ(0U, MyClass->interface_count_);
+  EXPECT_EQ(0U, MyClass->NumInterfaces());
 
   EXPECT_EQ(JavaLangObject->GetClass()->GetClass(), MyClass->GetClass()->GetClass());
 
diff --git a/src/common_test.h b/src/common_test.h
index 96834b1..e7b4f30 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -12,6 +12,15 @@
 
 // package java.lang;
 // public class Object {}
+
+// package java.lang;
+// public class Class {}
+//
+// package java.lang.reflect;
+// public class Field {}
+//
+// package java.lang.reflect;
+// public class Method {}
 //
 // package java.lang;
 // public interface Cloneable {}
@@ -19,17 +28,23 @@
 // package java.io;
 // public interface Serializable {}
 static const char kJavaLangDex[] =
-  "ZGV4CjAzNQAdS5NB20pfz7Z3u9Jh2IVuB3Hxe6BzR9FAAgAAcAAAAHhWNBIAAAAAAAAAALgBAAAI"
-  "AAAAcAAAAAQAAACQAAAAAQAAAKAAAAAAAAAAAAAAAAEAAACsAAAAAwAAALQAAAAsAQAAFAEAACgB"
-  "AAAwAQAAQAEAAFgBAABvAQAAgwEAAJABAACjAQAAAgAAAAMAAAAEAAAABwAAAAcAAAADAAAAAAAA"
-  "AAIAAAAAAAAAAgAAAAEAAAD/////AAAAAAUAAAAAAAAAqwEAAAAAAAAAAAAAAQYAAAIAAAAAAAAA"
-  "BgAAAAAAAAAAAAAAAAAAAAEAAAABBgAAAgAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQABAAAAAACm"
-  "AQAAAQAAAA4AAAAGPGluaXQ+AA5DbG9uZWFibGUuamF2YQAWTGphdmEvaW8vU2VyaWFsaXphYmxl"
-  "OwAVTGphdmEvbGFuZy9DbG9uZWFibGU7ABJMamF2YS9sYW5nL09iamVjdDsAC09iamVjdC5qYXZh"
-  "ABFTZXJpYWxpemFibGUuamF2YQABVgADAAcOAAAAAQAAgYAElAIAAAALAAAAAAAAAAEAAAAAAAAA"
-  "AQAAAAgAAABwAAAAAgAAAAQAAACQAAAAAwAAAAEAAACgAAAABQAAAAEAAACsAAAABgAAAAMAAAC0"
-  "AAAAASAAAAEAAAAUAQAAAiAAAAgAAAAoAQAAAyAAAAEAAACmAQAAACAAAAEAAACrAQAAABAAAAEA"
-  "AAC4AQAA";
+  "ZGV4CjAzNQCgffHhLqornhe/ZtOPPH5jBex6xYfwloPAAwAAcAAAAHhWNBIAAAAAAAAAADgDAAAO"
+  "AAAAcAAAAAcAAACoAAAAAQAAAMQAAAAAAAAAAAAAAAQAAADQAAAABgAAAPAAAAAQAgAAsAEAAAwC"
+  "AAAUAgAAIAIAADACAAA8AgAAVAIAAGcCAAB+AgAAkgIAAK0CAADJAgAA1gIAAOMCAAD2AgAABAAA"
+  "AAUAAAAGAAAABwAAAAgAAAAJAAAADQAAAA0AAAAGAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAEAAAA"
+  "AAAAAAUAAAAAAAAAAwAAAAEAAAD/////AAAAAAsAAAAAAAAADQMAAAAAAAAAAAAAAQYAAAMAAAAA"
+  "AAAADAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAwAAAAAAAAABAAAAAAAAABcDAAAAAAAAAgAAAAEG"
+  "AAADAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAEAAAAAQAAAAMAAAAAAAAAAwAAAAAAAAAhAwAAAAAA"
+  "AAUAAAABAAAAAwAAAAAAAAAKAAAAAAAAACsDAAAAAAAAAQABAAAAAAD5AgAAAQAAAA4AAAABAAEA"
+  "AQAAAP4CAAAEAAAAcBABAAAADgABAAEAAQAAAAMDAAAEAAAAcBABAAAADgABAAEAAQAAAAgDAAAE"
+  "AAAAcBABAAAADgAGPGluaXQ+AApDbGFzcy5qYXZhAA5DbG9uZWFibGUuamF2YQAKRmllbGQuamF2"
+  "YQAWTGphdmEvaW8vU2VyaWFsaXphYmxlOwARTGphdmEvbGFuZy9DbGFzczsAFUxqYXZhL2xhbmcv"
+  "Q2xvbmVhYmxlOwASTGphdmEvbGFuZy9PYmplY3Q7ABlMamF2YS9sYW5nL3JlZmxlY3QvRmllbGQ7"
+  "ABpMamF2YS9sYW5nL3JlZmxlY3QvTWV0aG9kOwALTWV0aG9kLmphdmEAC09iamVjdC5qYXZhABFT"
+  "ZXJpYWxpemFibGUuamF2YQABVgADAAcOAAUABw4ABQAHDgAFAAcOAAAAAQABgYAEsAMAAAEAAIGA"
+  "BMQDAAABAAKBgATcAwAAAQADgYAE9AMAAAALAAAAAAAAAAEAAAAAAAAAAQAAAA4AAABwAAAAAgAA"
+  "AAcAAACoAAAAAwAAAAEAAADEAAAABQAAAAQAAADQAAAABgAAAAYAAADwAAAAASAAAAQAAACwAQAA"
+  "AiAAAA4AAAAMAgAAAyAAAAQAAAD5AgAAACAAAAQAAAANAwAAABAAAAEAAAA4AwAA";
 
 // package java.lang;
 // public class Object {}
diff --git a/src/object.h b/src/object.h
index 770e8bb..d0b2f13 100644
--- a/src/object.h
+++ b/src/object.h
@@ -561,6 +561,51 @@
   const void* native_method_;
 };
 
+class Array : public Object {
+ public:
+  uint32_t GetLength() const {
+    return length_;
+  }
+  void SetLength(uint32_t length) {
+    length_ = length;
+  }
+  const void* GetData() const {
+    return &elements_;
+  }
+  void* GetData() {
+    return &elements_;
+  }
+
+ private:
+  // The number of array elements.
+  uint32_t length_;
+  // Location of first element.
+  uint32_t elements_[0];
+  Array();
+};
+
+class ObjectArray : public Array {
+ public:
+  Object* Get(uint32_t i) const {
+    DCHECK_LT(i, GetLength());
+    Object* const * data = reinterpret_cast<Object* const *>(GetData());
+    return data[i];
+  }
+  void Set(uint32_t i, Object* object) {
+    DCHECK_LT(i, GetLength());
+    Object** data = reinterpret_cast<Object**>(GetData());
+    data[i] = object;
+  }
+  static void Copy(ObjectArray* src, int src_pos, ObjectArray* dst, int dst_pos, size_t length) {
+    for (size_t i = 0; i < length; i++) {
+      dst->Set(dst_pos + i, src->Get(src_pos + i));
+    }
+  }
+
+ private:
+  ObjectArray();
+};
+
 // Class objects.
 class Class : public Object {
  public:
@@ -692,24 +737,32 @@
 
   // Returns the number of static, private, and constructor methods.
   size_t NumDirectMethods() const {
-    return num_direct_methods_;
+    return (direct_methods_ != NULL) ? direct_methods_->GetLength() : 0;
   }
 
   Method* GetDirectMethod(uint32_t i) const {
-    return direct_methods_[i];
+    return down_cast<Method*>(direct_methods_->Get(i));
+  }
+
+  void SetDirectMethod(uint32_t i, Method* f) {  // TODO: uint16_t
+    direct_methods_->Set(i, f);
   }
 
   // Returns the number of non-inherited virtual methods.
   size_t NumVirtualMethods() const {
-    return num_virtual_methods_;
+    return (virtual_methods_ != NULL) ? virtual_methods_->GetLength() : 0;
   }
 
   Method* GetVirtualMethod(uint32_t i) const {
-    return virtual_methods_[i];
+    return down_cast<Method*>(virtual_methods_->Get(i));
+  }
+
+  void SetVirtualMethod(uint32_t i, Method* f) {  // TODO: uint16_t
+    virtual_methods_->Set(i, f);
   }
 
   size_t NumInstanceFields() const {
-    return num_instance_fields_;
+    return (ifields_ != NULL) ? ifields_->GetLength() : 0;
   }
 
   // Returns the number of instance fields containing reference types.
@@ -718,22 +771,23 @@
   }
 
   InstanceField* GetInstanceField(uint32_t i) {  // TODO: uint16_t
-    DCHECK_LT(i, num_instance_fields_);
-    return ifields_[i];
+    return down_cast<InstanceField*>(ifields_->Get(i));
   }
 
   void SetInstanceField(uint32_t i, InstanceField* f) {  // TODO: uint16_t
-    DCHECK_LT(i, num_instance_fields_);
-    ifields_[i] = f;
+    ifields_->Set(i, f);
   }
 
   size_t NumStaticFields() const {
-    return num_static_fields_;
+    return (sfields_ != NULL) ? sfields_->GetLength() : 0;
   }
 
   StaticField* GetStaticField(uint32_t i) const {  // TODO: uint16_t
-    DCHECK_LT(i, num_static_fields_);
-    return sfields_[i];
+    return down_cast<StaticField*>(sfields_->Get(i));
+  }
+
+  void SetStaticField(uint32_t i, StaticField* f) {  // TODO: uint16_t
+    sfields_->Set(i, f);
   }
 
   uint32_t GetReferenceOffsets() const {
@@ -749,12 +803,15 @@
   Method* FindVirtualMethod(const StringPiece& name) const;
 
   size_t NumInterfaces() const {
-    return interface_count_;
+    return (interfaces_ != NULL) ? interfaces_->GetLength() : 0;
   }
 
   Class* GetInterface(uint32_t i) const {
-    DCHECK_LT(i, interface_count_);
-    return interfaces_[i];
+    return down_cast<Class*>(interfaces_->Get(i));
+  }
+
+  void SetInterface(uint32_t i, Class* f) {  // TODO: uint16_t
+    interfaces_->Set(i, f);
   }
 
   Method* FindDirectMethodLocally(const StringPiece& name,
@@ -822,16 +879,14 @@
   // InitiatingLoaderList initiating_loader_list_;
 
   // array of interfaces this class implements directly
-  size_t interface_count_;
-  Class** interfaces_;
+  ObjectArray* interfaces_;
+  uint32_t* interfaces_idx_;
 
   // static, private, and <init> methods
-  size_t num_direct_methods_;
-  Method** direct_methods_;
+  ObjectArray* direct_methods_;
 
   // virtual methods defined in this class; invoked through vtable
-  size_t num_virtual_methods_;
-  Method** virtual_methods_;
+  ObjectArray* virtual_methods_;
 
   // Virtual method table (vtable), for use by "invoke-virtual".  The
   // vtable from the superclass is copied in, and virtual methods from
@@ -869,13 +924,12 @@
   // a superclass are listed in the superclass's Class.ifields.
   //
   // All instance fields that refer to objects are guaranteed to be at
-  // the beginning of the field list.  ifieldRefCount specifies the
-  // number of reference fields.
-  size_t num_instance_fields_;
+  // the beginning of the field list.  num_reference_instance_fields_
+  // specifies the number of reference fields.
+  ObjectArray* ifields_;
 
   // number of fields that are object refs
   size_t num_reference_instance_fields_;
-  InstanceField** ifields_;
 
   // Bitmap of offsets of ifields.
   uint32_t reference_offsets_;
@@ -884,8 +938,7 @@
   const char* source_file_;
 
   // Static fields
-  size_t num_static_fields_;
-  StaticField** sfields_;
+  ObjectArray* sfields_;
 
  private:
   Class();
@@ -899,50 +952,11 @@
   DataObject();
 };
 
-class Array : public Object {
- public:
-  uint32_t GetLength() const {
-    return length_;
-  }
-  void SetLength(uint32_t length) {
-    length_ = length;
-  }
-  const void* GetData() const {
-    return &elements_;
-  }
-  void* GetData() {
-    return &elements_;
-  }
-
- private:
-  // The number of array elements.
-  uint32_t length_;
-  // Location of first element.
-  uint32_t elements_[0];
-  Array();
-};
-
 class CharArray : public Array {
  private:
   CharArray();
 };
 
-class ObjectArray : public Array {
- public:
-  Object* Get(uint32_t i) const {
-    DCHECK_LT(i, GetLength());
-    Object* const * data = reinterpret_cast<Object* const *>(GetData());
-    return data[i];
-  }
-  void Set(uint32_t i, Object* object) {
-    DCHECK_LT(i, GetLength());
-    Object** data = reinterpret_cast<Object**>(GetData());
-    data[i] = object;
-  }
- private:
-  ObjectArray();
-};
-
 class String : public Object {
  public:
   CharArray* array_;