Source walk/Spring clean/Parameterize/Enhance et.al.

The following were applied during multiple itterations through the source.
 * Parameterize raw types.
 * Mark unused members.
 * Annotate override and deprecated methods.
 * Convert loops to enhance for loop.
 * Remove redundant else statements.
 * Widening collection type references.
 * Optimize code for improved readability.
 * Squash compiler warnings.
 * Identify smells.

1 files changed, 187 insertions, 153 deletions

diff --git a/src/main/javassist/CtClassType.java b/src/main/javassist/CtClassType.java
index b0a8819d..eaff92e0 100644
--- a/src/main/javassist/CtClassType.java
+++ b/src/main/javassist/CtClassType.java
@@ -16,6 +16,7 @@
 
 package javassist;
 
+import java.lang.ref.Reference;
 import java.lang.ref.WeakReference;
 import java.io.BufferedInputStream;
 import java.io.ByteArrayOutputStream;
@@ -29,6 +30,7 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Hashtable;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import javassist.bytecode.AccessFlag;
@@ -55,7 +57,7 @@ import javassist.compiler.Javac;
 import javassist.expr.ExprEditor;
 
 /**
- * Class types.
+ * Class<?> types.
  */
 class CtClassType extends CtClass {
     ClassPool classPool;
@@ -66,11 +68,11 @@ class CtClassType extends CtClass {
     ClassFile classfile;
     byte[] rawClassfile;    // backup storage
 
-    private WeakReference memberCache;
+    private Reference<CtMember.Cache> memberCache;
     private AccessorMaker accessors;
 
     private FieldInitLink fieldInitializers;
-    private Hashtable hiddenMethods;    // must be synchronous
+    private Map<CtMethod,String> hiddenMethods;    // must be synchronous
     private int uniqueNumberSeed;
 
     private boolean doPruning = ClassPool.doPruning;
@@ -103,6 +105,7 @@ class CtClassType extends CtClass {
         qualifiedName = classfile.getName();
     }
 
+    @Override
     protected void extendToString(StringBuffer buffer) {
         if (wasChanged)
             buffer.append("changed ");
@@ -162,6 +165,7 @@ class CtClassType extends CtClass {
         }
     }
 
+    @Override
     public AccessorMaker getAccessorMaker() {
         if (accessors == null)
             accessors = new AccessorMaker(this);
@@ -169,6 +173,7 @@ class CtClassType extends CtClass {
         return accessors;
     }
 
+    @Override
     public ClassFile getClassFile2() {
         return getClassFile3(true);
     }
@@ -229,6 +234,7 @@ class CtClassType extends CtClass {
     * @see javassist.CtClass#incGetCounter()
     * @see #toBytecode(DataOutputStream)
     */
+    @Override
    final void incGetCounter() { ++getCount; }
 
    /**
@@ -236,6 +242,7 @@ class CtClassType extends CtClass {
     * It releases the class files that have not been recently used
     * if they are unmodified. 
     */
+    @Override
    void compress() {
        if (getCount < GET_THRESHOLD)
            if (!isModified() && ClassPool.releaseUnmodifiedClassFile)
@@ -282,24 +289,29 @@ class CtClassType extends CtClass {
         return classfile;
     }
 
+    @Override
     public ClassPool getClassPool() { return classPool; }
 
     void setClassPool(ClassPool cp) { classPool = cp; }
 
+    @Override
     public URL getURL() throws NotFoundException {
         URL url = classPool.find(getName());
         if (url == null)
             throw new NotFoundException(getName());
-        else
-            return url;
+        return url;
     }
 
+    @Override
     public boolean isModified() { return wasChanged; }
 
+    @Override
     public boolean isFrozen() { return wasFrozen; }
 
+    @Override
     public void freeze() { wasFrozen = true; }
 
+    @Override
     void checkModify() throws RuntimeException {
         if (isFrozen()) {
             String msg = getName() + " class is frozen";
@@ -312,11 +324,13 @@ class CtClassType extends CtClass {
         wasChanged = true;
     }
 
+    @Override
     public void defrost() {
         checkPruned("defrost");
         wasFrozen = false;
     }
 
+    @Override
     public boolean subtypeOf(CtClass clazz) throws NotFoundException {
         int i;
         String cname = clazz.getName();
@@ -344,6 +358,7 @@ class CtClassType extends CtClass {
         return false;
     }
 
+    @Override
     public void setName(String name) throws RuntimeException {
         String oldname = getName();
         if (name.equals(oldname))
@@ -358,24 +373,27 @@ class CtClassType extends CtClass {
         classPool.classNameChanged(oldname, this);
     }
 
+    @Override
     public String getGenericSignature() {
         SignatureAttribute sa
             = (SignatureAttribute)getClassFile2().getAttribute(SignatureAttribute.tag);
         return sa == null ? null : sa.getSignature();
     }
 
+    @Override
     public void setGenericSignature(String sig) {
         ClassFile cf = getClassFile();
         SignatureAttribute sa = new SignatureAttribute(cf.getConstPool(), sig);
         cf.addAttribute(sa);
     }
 
+    @Override
     public void replaceClassName(ClassMap classnames)
         throws RuntimeException
     {
         String oldClassName = getName();
         String newClassName
-            = (String)classnames.get(Descriptor.toJvmName(oldClassName));
+            = classnames.get(Descriptor.toJvmName(oldClassName));
         if (newClassName != null) {
             newClassName = Descriptor.toJavaName(newClassName);
             // check this in advance although classNameChanged() below does.
@@ -393,6 +411,7 @@ class CtClassType extends CtClass {
         }
     }
 
+    @Override
     public void replaceClassName(String oldname, String newname)
         throws RuntimeException
     {
@@ -406,18 +425,22 @@ class CtClassType extends CtClass {
         }
     }
 
+    @Override
     public boolean isInterface() {
         return Modifier.isInterface(getModifiers());
     }
 
+    @Override
     public boolean isAnnotation() {
         return Modifier.isAnnotation(getModifiers());
     }
 
+    @Override
     public boolean isEnum() {
        return Modifier.isEnum(getModifiers());
     }
 
+    @Override
     public int getModifiers() {
         ClassFile cf = getClassFile2();
         int acc = cf.getAccessFlags();
@@ -429,6 +452,7 @@ class CtClassType extends CtClass {
         return AccessFlag.toModifier(acc);
     }
 
+    @Override
     public CtClass[] getNestedClasses() throws NotFoundException {
         ClassFile cf = getClassFile2();
         InnerClassesAttribute ica
@@ -438,7 +462,7 @@ class CtClassType extends CtClass {
 
         String thisName = cf.getName() + "$";
         int n = ica.tableLength();
-        ArrayList list = new ArrayList(n);
+        List<CtClass> list = new ArrayList<CtClass>(n);
         for (int i = 0; i < n; i++) {
             String name = ica.innerClass(i);
             if (name != null)
@@ -449,9 +473,10 @@ class CtClassType extends CtClass {
                 }
         }
 
-        return (CtClass[])list.toArray(new CtClass[list.size()]);
+        return list.toArray(new CtClass[list.size()]);
     }
 
+    @Override
     public void setModifiers(int mod) {
         checkModify();
         updateInnerEntry(mod, getName(), this, true);
@@ -495,7 +520,7 @@ class CtClassType extends CtClass {
                                        + " into a static class");
     }
 
-    //@Override
+    @Override
     public boolean hasAnnotation(String annotationName) {
         ClassFile cf = getClassFile2();
         AnnotationsAttribute ainfo = (AnnotationsAttribute)
@@ -508,7 +533,8 @@ class CtClassType extends CtClass {
     /**
      * @deprecated
      */
-    static boolean hasAnnotationType(Class clz, ClassPool cp,
+    @Deprecated
+    static boolean hasAnnotationType(Class<?> clz, ClassPool cp,
                                      AnnotationsAttribute a1,
                                      AnnotationsAttribute a2)
     {
@@ -544,7 +570,8 @@ class CtClassType extends CtClass {
         return false;
     }
 
-    public Object getAnnotation(Class clz) throws ClassNotFoundException {
+    @Override
+    public Object getAnnotation(Class<?> clz) throws ClassNotFoundException {
         ClassFile cf = getClassFile2();
         AnnotationsAttribute ainfo = (AnnotationsAttribute)
                 cf.getAttribute(AnnotationsAttribute.invisibleTag);  
@@ -553,7 +580,7 @@ class CtClassType extends CtClass {
         return getAnnotationType(clz, getClassPool(), ainfo, ainfo2);
     }
 
-    static Object getAnnotationType(Class clz, ClassPool cp,
+    static Object getAnnotationType(Class<?> clz, ClassPool cp,
                                     AnnotationsAttribute a1, AnnotationsAttribute a2)
         throws ClassNotFoundException
     {
@@ -583,10 +610,12 @@ class CtClassType extends CtClass {
         return null;
     }
 
+    @Override
     public Object[] getAnnotations() throws ClassNotFoundException {
        return getAnnotations(false);
     }
 
+    @Override
     public Object[] getAvailableAnnotations(){
        try {
            return getAnnotations(true);
@@ -642,23 +671,19 @@ class CtClassType extends CtClass {
    
            return result;
         }
-        else{
-           ArrayList annotations = new ArrayList();
-           for (int i = 0 ; i < size1 ; i++){
-              try{
-                 annotations.add(toAnnoType(anno1[i], cp));
-              }
-              catch(ClassNotFoundException e){}
-           }
-           for (int j = 0; j < size2; j++) {
-              try{
-                 annotations.add(toAnnoType(anno2[j], cp));
-              }
-              catch(ClassNotFoundException e){}
-           }
+       List<Object> annotations = new ArrayList<Object>();
+       for (int i = 0 ; i < size1 ; i++)
+          try{
+             annotations.add(toAnnoType(anno1[i], cp));
+          }
+          catch(ClassNotFoundException e){}
+       for (int j = 0; j < size2; j++)
+          try{
+             annotations.add(toAnnoType(anno2[j], cp));
+          }
+          catch(ClassNotFoundException e){}
 
-           return annotations.toArray();
-        }
+       return annotations.toArray();
     }
 
     static Object[][] toAnnotationType(boolean ignoreNotFound, ClassPool cp,
@@ -707,7 +732,7 @@ class CtClassType extends CtClass {
                     result[i][j + size1] = toAnnoType(anno2[j], cp);
             }
             else{
-                ArrayList annotations = new ArrayList();
+                List<Object> annotations = new ArrayList<Object>();
                 for (int j = 0 ; j < size1 ; j++){
                     try{
                         annotations.add(toAnnoType(anno1[j], cp));
@@ -742,7 +767,7 @@ class CtClassType extends CtClass {
             }
             catch (ClassNotFoundException e2){
                 try {
-                    Class clazz = cp.get(anno.getTypeName()).toClass();
+                    Class<?> clazz = cp.get(anno.getTypeName()).toClass();
                     return javassist.bytecode.annotation.AnnotationImpl.make(
                                             clazz.getClassLoader(),
                                             clazz, cp, anno);
@@ -754,6 +779,7 @@ class CtClassType extends CtClass {
         }
     }
 
+    @Override
     public boolean subclassOf(CtClass superclass) {
         if (superclass == null)
             return false;
@@ -772,14 +798,15 @@ class CtClassType extends CtClass {
         return false;
     }
 
+    @Override
     public CtClass getSuperclass() throws NotFoundException {
         String supername = getClassFile2().getSuperclass();
         if (supername == null)
             return null;
-        else
-            return classPool.get(supername);
+        return classPool.get(supername);
     }
 
+    @Override
     public void setSuperclass(CtClass clazz) throws CannotCompileException {
         checkModify();
         if (isInterface())
@@ -788,6 +815,7 @@ class CtClassType extends CtClass {
             getClassFile2().setSuperclass(clazz.getName());
     }
 
+    @Override
     public CtClass[] getInterfaces() throws NotFoundException {
         String[] ifs = getClassFile2().getInterfaces();
         int num = ifs.length;
@@ -798,6 +826,7 @@ class CtClassType extends CtClass {
         return ifc;
     }
 
+    @Override
     public void setInterfaces(CtClass[] list) {
         checkModify();
         String[] ifs;
@@ -813,12 +842,14 @@ class CtClassType extends CtClass {
         getClassFile2().setInterfaces(ifs);
     }
 
+    @Override
     public void addInterface(CtClass anInterface) {
         checkModify();
         if (anInterface != null)
             getClassFile2().addInterface(anInterface.getName());
     }
 
+    @Override
     public CtClass getDeclaringClass() throws NotFoundException {
         ClassFile cf = getClassFile2();
         InnerClassesAttribute ica = (InnerClassesAttribute)cf.getAttribute(
@@ -833,39 +864,41 @@ class CtClassType extends CtClass {
                 String outName = ica.outerClass(i);
                 if (outName != null)
                     return classPool.get(outName);
-                else {
-                    // maybe anonymous or local class.
-                    EnclosingMethodAttribute ema
-                        = (EnclosingMethodAttribute)cf.getAttribute(
-                                                    EnclosingMethodAttribute.tag);
-                    if (ema != null)
-                        return classPool.get(ema.className());
-                }
+                
+                // maybe anonymous or local class.
+                EnclosingMethodAttribute ema
+                    = (EnclosingMethodAttribute)cf.getAttribute(
+                                                EnclosingMethodAttribute.tag);
+                if (ema != null)
+                    return classPool.get(ema.className());
+                
             }
 
         return null;
     }
 
-    public CtBehavior getEnclosingBehavior() throws NotFoundException {
+    @Override
+    public CtBehavior getEnclosingBehavior() throws NotFoundException
+    {
         ClassFile cf = getClassFile2();
         EnclosingMethodAttribute ema
                 = (EnclosingMethodAttribute)cf.getAttribute(
                                                 EnclosingMethodAttribute.tag);
         if (ema == null)
             return null;
-        else {
-            CtClass enc = classPool.get(ema.className());
-            String name = ema.methodName();
-            if (MethodInfo.nameInit.equals(name))
-                return enc.getConstructor(ema.methodDescriptor());
-            else if(MethodInfo.nameClinit.equals(name))
-                return enc.getClassInitializer();
-            else
-                return enc.getMethod(name, ema.methodDescriptor());
-        }
+        CtClass enc = classPool.get(ema.className());
+        String name = ema.methodName();
+        if (MethodInfo.nameInit.equals(name))
+            return enc.getConstructor(ema.methodDescriptor());
+        else if(MethodInfo.nameClinit.equals(name))
+            return enc.getClassInitializer();
+        else
+            return enc.getMethod(name, ema.methodDescriptor());
     }
 
-    public CtClass makeNestedClass(String name, boolean isStatic) {
+    @Override
+    public CtClass makeNestedClass(String name, boolean isStatic)
+    {
         if (!isStatic)
             throw new RuntimeException(
                         "sorry, only nested static class is supported");
@@ -905,60 +938,47 @@ class CtClassType extends CtClass {
      * Returns null if members are not cached.
      */
     protected CtMember.Cache hasMemberCache() {
-        WeakReference cache = memberCache;
-        if (cache != null)
-            return (CtMember.Cache)cache.get();
-        else
-            return null;
+        if (memberCache != null)
+            return memberCache.get();
+        return null;
     }
 
     protected synchronized CtMember.Cache getMembers() {
         CtMember.Cache cache = null;
         if (memberCache == null
-            || (cache = (CtMember.Cache)memberCache.get()) == null) {
+            || (cache = memberCache.get()) == null) {
             cache = new CtMember.Cache(this);
             makeFieldCache(cache);
             makeBehaviorCache(cache);
-            memberCache = new WeakReference(cache);
+            memberCache = new WeakReference<CtMember.Cache>(cache);
         }
 
         return cache;
     }
 
     private void makeFieldCache(CtMember.Cache cache) {
-        List list = getClassFile3(false).getFields();
-        int n = list.size();
-        for (int i = 0; i < n; ++i) {
-            FieldInfo finfo = (FieldInfo)list.get(i);
-            CtField newField = new CtField(finfo, this);
-            cache.addField(newField);
-        }
+        List<FieldInfo> fields = getClassFile3(false).getFields();
+        for (FieldInfo finfo:fields)
+            cache.addField(new CtField(finfo, this));
     }
 
     private void makeBehaviorCache(CtMember.Cache cache) {
-        List list = getClassFile3(false).getMethods();
-        int n = list.size();
-        for (int i = 0; i < n; ++i) {
-            MethodInfo minfo = (MethodInfo)list.get(i);
-            if (minfo.isMethod()) {
-                CtMethod newMethod = new CtMethod(minfo, this);
-                cache.addMethod(newMethod);
-            }
-            else {
-                CtConstructor newCons = new CtConstructor(minfo, this);
-                cache.addConstructor(newCons);
-            }
-        }
+        List<MethodInfo> methods = getClassFile3(false).getMethods();
+        for (MethodInfo minfo:methods)
+            if (minfo.isMethod())
+                cache.addMethod(new CtMethod(minfo, this));
+            else
+                cache.addConstructor(new CtConstructor(minfo, this));
     }
 
+    @Override
     public CtField[] getFields() {
-        ArrayList alist = new ArrayList();
+        List<CtMember> alist = new ArrayList<CtMember>();
         getFields(alist, this);
-        return (CtField[])alist.toArray(new CtField[alist.size()]);
+        return alist.toArray(new CtField[alist.size()]);
     }
 
-    private static void getFields(ArrayList alist, CtClass cc) {
-        int i, num;
+    private static void getFields(List<CtMember> alist, CtClass cc) {
         if (cc == null)
             return;
 
@@ -969,9 +989,8 @@ class CtClassType extends CtClass {
 
         try {
             CtClass[] ifs = cc.getInterfaces();
-            num = ifs.length;
-            for (i = 0; i < num; ++i)
-                getFields(alist, ifs[i]);
+            for (CtClass ctc : ifs)
+                getFields(alist, ctc);
         }
         catch (NotFoundException e) {}
 
@@ -985,6 +1004,7 @@ class CtClassType extends CtClass {
         }
     }
 
+    @Override
     public CtField getField(String name, String desc) throws NotFoundException {
         CtField f = getField2(name, desc);
         return checkGetField(f, name, desc);
@@ -1000,10 +1020,10 @@ class CtClassType extends CtClass {
 
             throw new NotFoundException(msg + " in " + getName());
         }
-        else
-            return f;
+        return f;
     }
 
+    @Override
     CtField getField2(String name, String desc) {
         CtField df = getDeclaredField2(name, desc);
         if (df != null)
@@ -1011,9 +1031,8 @@ class CtClassType extends CtClass {
 
         try {
             CtClass[] ifs = getInterfaces();
-            int num = ifs.length;
-            for (int i = 0; i < num; ++i) {
-                CtField f = ifs[i].getField2(name, desc);
+            for (CtClass ctc : ifs) {
+                CtField f = ctc.getField2(name, desc);
                 if (f != null)
                     return f;
             }
@@ -1026,6 +1045,7 @@ class CtClassType extends CtClass {
         return null;
     }
 
+    @Override
     public CtField[] getDeclaredFields() {
         CtMember.Cache memCache = getMembers();
         CtMember field = memCache.fieldHead();
@@ -1041,10 +1061,12 @@ class CtClassType extends CtClass {
         return cfs;
     }
 
+    @Override
     public CtField getDeclaredField(String name) throws NotFoundException {
         return getDeclaredField(name, null);
     }
 
+    @Override
     public CtField getDeclaredField(String name, String desc) throws NotFoundException {
         CtField f = getDeclaredField2(name, desc);
         return checkGetField(f, name, desc);
@@ -1064,6 +1086,7 @@ class CtClassType extends CtClass {
         return null;
     }
 
+    @Override
     public CtBehavior[] getDeclaredBehaviors() {
         CtMember.Cache memCache = getMembers();
         CtMember cons = memCache.consHead();
@@ -1088,6 +1111,7 @@ class CtClassType extends CtClass {
         return cb;
     }
 
+    @Override
     public CtConstructor[] getConstructors() {
         CtMember.Cache memCache = getMembers();
         CtMember cons = memCache.consHead();
@@ -1119,6 +1143,7 @@ class CtClassType extends CtClass {
                 && cons.isConstructor();
     }
 
+    @Override
     public CtConstructor getConstructor(String desc)
         throws NotFoundException
     {
@@ -1137,6 +1162,7 @@ class CtClassType extends CtClass {
         return super.getConstructor(desc);
     }
 
+    @Override
     public CtConstructor[] getDeclaredConstructors() {
         CtMember.Cache memCache = getMembers();
         CtMember cons = memCache.consHead();
@@ -1164,6 +1190,7 @@ class CtClassType extends CtClass {
         return result;
     }
 
+    @Override
     public CtConstructor getClassInitializer() {
         CtMember.Cache memCache = getMembers();
         CtMember cons = memCache.consHead();
@@ -1179,18 +1206,18 @@ class CtClassType extends CtClass {
         return null;
     }
 
+    @Override
     public CtMethod[] getMethods() {
-        HashMap h = new HashMap();
+        Map<String,CtMember> h = new HashMap<String,CtMember>();
         getMethods0(h, this);
-        return (CtMethod[])h.values().toArray(new CtMethod[h.size()]);
+        return h.values().toArray(new CtMethod[h.size()]);
     }
 
-    private static void getMethods0(HashMap h, CtClass cc) {
+    private static void getMethods0(Map<String,CtMember> h, CtClass cc) {
         try {
             CtClass[] ifs = cc.getInterfaces();
-            int size = ifs.length;
-            for (int i = 0; i < size; ++i)
-                getMethods0(h, ifs[i]);
+            for (CtClass ctc : ifs)
+                getMethods0(h, ctc);
         }
         catch (NotFoundException e) {}
 
@@ -1214,15 +1241,15 @@ class CtClassType extends CtClass {
         }
     }
 
+    @Override
     public CtMethod getMethod(String name, String desc)
         throws NotFoundException
     {
         CtMethod m = getMethod0(this, name, desc);
         if (m != null)
             return m;
-        else
-            throw new NotFoundException(name + "(..) is not found in "
-                                        + getName());
+        throw new NotFoundException(name + "(..) is not found in "
+                                    + getName());
     }
 
     private static CtMethod getMethod0(CtClass cc,
@@ -1252,9 +1279,8 @@ class CtClassType extends CtClass {
 
         try {
             CtClass[] ifs = cc.getInterfaces();
-            int size = ifs.length;
-            for (int i = 0; i < size; ++i) {
-                CtMethod m = getMethod0(ifs[i], name, desc);
+            for (CtClass ctc : ifs) {
+                CtMethod m = getMethod0(ctc, name, desc);
                 if (m != null)
                     return m;
             }
@@ -1263,35 +1289,36 @@ class CtClassType extends CtClass {
         return null;
     }
 
+    @Override
     public CtMethod[] getDeclaredMethods() {
         CtMember.Cache memCache = getMembers();
         CtMember mth = memCache.methodHead();
         CtMember mthTail = memCache.lastMethod();
-        int num = CtMember.Cache.count(mth, mthTail);
-        CtMethod[] cms = new CtMethod[num];
-        int i = 0;
+        List<CtMember> methods = new ArrayList<CtMember>();
         while (mth != mthTail) {
             mth = mth.next();
-            cms[i++] = (CtMethod)mth;
+            methods.add(mth);
         }
 
-        return cms;
+        return methods.toArray(new CtMethod[methods.size()]);
     }
 
+    @Override
     public CtMethod[] getDeclaredMethods(String name) throws NotFoundException {
         CtMember.Cache memCache = getMembers();
         CtMember mth = memCache.methodHead();
         CtMember mthTail = memCache.lastMethod();
-        ArrayList methods = new ArrayList();
+        List<CtMember> methods = new ArrayList<CtMember>();
         while (mth != mthTail) {
             mth = mth.next();
             if (mth.getName().equals(name))
-                methods.add((CtMethod)mth);
+                methods.add(mth);
         }
 
-        return (CtMethod[]) methods.toArray(new CtMethod[methods.size()]);
+        return methods.toArray(new CtMethod[methods.size()]);
     }
 
+    @Override
     public CtMethod getDeclaredMethod(String name) throws NotFoundException {
         CtMember.Cache memCache = getMembers();
         CtMember mth = memCache.methodHead();
@@ -1306,6 +1333,7 @@ class CtClassType extends CtClass {
                                     + getName());
     }
 
+    @Override
     public CtMethod getDeclaredMethod(String name, CtClass[] params)
         throws NotFoundException
     {
@@ -1325,12 +1353,14 @@ class CtClassType extends CtClass {
                                     + getName());
     }
 
+    @Override
     public void addField(CtField f, String init)
         throws CannotCompileException
     {
         addField(f, CtField.Initializer.byExpr(init));
     }
 
+    @Override
     public void addField(CtField f, CtField.Initializer init)
         throws CannotCompileException
     {
@@ -1373,6 +1403,7 @@ class CtClassType extends CtClass {
         }
     }
 
+    @Override
     public void removeField(CtField f) throws NotFoundException {
         checkModify();
         FieldInfo fi = f.getFieldInfo2();
@@ -1385,6 +1416,7 @@ class CtClassType extends CtClass {
             throw new NotFoundException(f.toString());
     }
 
+    @Override
     public CtConstructor makeClassInitializer()
         throws CannotCompileException
     {
@@ -1399,6 +1431,7 @@ class CtClassType extends CtClass {
         return getClassInitializer();
     }
 
+    @Override
     public void addConstructor(CtConstructor c)
         throws CannotCompileException
     {
@@ -1410,6 +1443,7 @@ class CtClassType extends CtClass {
         getClassFile2().addMethod(c.getMethodInfo2());
     }
 
+    @Override
     public void removeConstructor(CtConstructor m) throws NotFoundException {
         checkModify();
         MethodInfo mi = m.getMethodInfo2();
@@ -1422,6 +1456,7 @@ class CtClassType extends CtClass {
             throw new NotFoundException(m.toString());
     }
 
+    @Override
     public void addMethod(CtMethod m) throws CannotCompileException {
         checkModify();
         if (m.getDeclaringClass() != this)
@@ -1442,7 +1477,9 @@ class CtClassType extends CtClass {
             setModifiers(getModifiers() | Modifier.ABSTRACT);
     }
 
-    public void removeMethod(CtMethod m) throws NotFoundException {
+    @Override
+    public void removeMethod(CtMethod m) throws NotFoundException
+    {
         checkModify();
         MethodInfo mi = m.getMethodInfo2();
         ClassFile cf = getClassFile2();
@@ -1454,52 +1491,53 @@ class CtClassType extends CtClass {
             throw new NotFoundException(m.toString());
     }
 
-    public byte[] getAttribute(String name) {
+    @Override
+    public byte[] getAttribute(String name)
+    {
         AttributeInfo ai = getClassFile2().getAttribute(name);
         if (ai == null)
             return null;
-        else
-            return ai.get();
+        return ai.get();
     }
 
-    public void setAttribute(String name, byte[] data) {
+    @Override
+    public void setAttribute(String name, byte[] data)
+    {
         checkModify();
         ClassFile cf = getClassFile2();
         cf.addAttribute(new AttributeInfo(cf.getConstPool(), name, data));
     }
 
+    @Override
     public void instrument(CodeConverter converter)
         throws CannotCompileException
     {
         checkModify();
         ClassFile cf = getClassFile2();
         ConstPool cp = cf.getConstPool();
-        List list = cf.getMethods();
-        int n = list.size();
-        for (int i = 0; i < n; ++i) {
-            MethodInfo minfo = (MethodInfo)list.get(i);
+        List<MethodInfo> methods = cf.getMethods();
+        for (MethodInfo minfo:methods)
             converter.doit(this, minfo, cp);
-        }
     }
 
+    @Override
     public void instrument(ExprEditor editor)
         throws CannotCompileException
     {
         checkModify();
         ClassFile cf = getClassFile2();
-        List list = cf.getMethods();
-        int n = list.size();
-        for (int i = 0; i < n; ++i) {
-            MethodInfo minfo = (MethodInfo)list.get(i);
+        List<MethodInfo> methods = cf.getMethods();
+        for (MethodInfo minfo:methods)
             editor.doit(this, minfo);
-        }
     }
 
     /**
      * @see javassist.CtClass#prune()
      * @see javassist.CtClass#stopPruning(boolean)
      */
-    public void prune() {
+    @Override
+    public void prune()
+    {
         if (wasPruned)
             return;
 
@@ -1507,8 +1545,10 @@ class CtClassType extends CtClass {
         getClassFile2().prune();
     }
 
+    @Override
     public void rebuildClassFile() { gcConstPool = true; }
 
+    @Override
     public void toBytecode(DataOutputStream out)
         throws CannotCompileException, IOException
     {
@@ -1552,7 +1592,8 @@ class CtClassType extends CtClass {
         }
     }
 
-    private void dumpClassFile(ClassFile cf) throws IOException {
+    private void dumpClassFile(ClassFile cf) throws IOException
+    {
         DataOutputStream dump = makeFileOutput(debugDump);
         try {
             cf.write(dump);
@@ -1564,13 +1605,16 @@ class CtClassType extends CtClass {
 
     /* See also checkModified()
      */
-    private void checkPruned(String method) {
+    private void checkPruned(String method)
+    {
         if (wasPruned)
             throw new RuntimeException(method + "(): " + getName()
                                        + " was pruned.");
     }
 
-    public boolean stopPruning(boolean stop) {
+    @Override
+    public boolean stopPruning(boolean stop)
+    {
         boolean prev = !doPruning;
         doPruning = !stop;
         return prev;
@@ -1655,10 +1699,8 @@ class CtClassType extends CtClass {
             return;
 
         ConstPool cp = cf.getConstPool();
-        List list = cf.getMethods();
-        int n = list.size();
-        for (int i = 0; i < n; ++i) {
-            MethodInfo minfo = (MethodInfo)list.get(i);
+        List<MethodInfo> methods = cf.getMethods();
+        for (MethodInfo minfo:methods) {
             if (minfo.isConstructor()) {
                 CodeAttribute codeAttr = minfo.getCodeAttribute();
                 if (codeAttr != null)
@@ -1729,19 +1771,20 @@ class CtClassType extends CtClass {
 
     // Methods used by CtNewWrappedMethod
 
-    Hashtable getHiddenMethods() {
+    Map<CtMethod,String> getHiddenMethods() {
         if (hiddenMethods == null)
-            hiddenMethods = new Hashtable();
+            hiddenMethods = new Hashtable<CtMethod,String>();
 
         return hiddenMethods;
     }
 
     int getUniqueNumber() { return uniqueNumberSeed++; }
 
+    @Override
     public String makeUniqueName(String prefix) {
-        HashMap table = new HashMap();
+        Map<Object,CtClassType> table = new HashMap<Object,CtClassType>();
         makeMemberList(table);
-        Set keys = table.keySet();
+        Set<Object> keys = table.keySet();
         String[] methods = new String[keys.size()];
         keys.toArray(methods);
 
@@ -1768,17 +1811,14 @@ class CtClassType extends CtClass {
         return true;
     }
 
-    private void makeMemberList(HashMap table) {
+    private void makeMemberList(Map<Object,CtClassType> table) {
         int mod = getModifiers();
         if (Modifier.isAbstract(mod) || Modifier.isInterface(mod))
             try {
                 CtClass[] ifs = getInterfaces();
-                int size = ifs.length;
-                for (int i = 0; i < size; i++) {
-                    CtClass ic =ifs[i];
+                for (CtClass ic : ifs)
                     if (ic != null && ic instanceof CtClassType)
                         ((CtClassType)ic).makeMemberList(table);
-                }
             }
             catch (NotFoundException e) {}
 
@@ -1789,19 +1829,13 @@ class CtClassType extends CtClass {
         }
         catch (NotFoundException e) {}
 
-        List list = getClassFile2().getMethods();
-        int n = list.size();
-        for (int i = 0; i < n; i++) {
-            MethodInfo minfo = (MethodInfo)list.get(i);
+        List<MethodInfo> methods = getClassFile2().getMethods();
+        for (MethodInfo minfo:methods)
             table.put(minfo.getName(), this);
-        }
 
-        list = getClassFile2().getFields();
-        n = list.size();
-        for (int i = 0; i < n; i++) {
-            FieldInfo finfo = (FieldInfo)list.get(i);
+        List<FieldInfo> fields = getClassFile2().getFields();
+        for (FieldInfo finfo:fields) 
             table.put(finfo.getName(), this);
-        }
     }
 }