java.lang.reflect.Constructor

package java.lang.reflect;

import sun.reflect.ConstructorAccessor;
import sun.reflect.Reflection;

/**
 * 表示构造函数的对象
 * 
 * comment by liqiang
 *
 * @author Kenneth Russell
 * @author Nakul Saraiya
 */
public final
class Constructor extends AccessibleObject implements Member {

 //声明此构造函数的类对象
    private Class  clazz;
    private int   slot;
    //参数列表数组
    private Class[]  parameterTypes;
    //异常数组
    private Class[]  exceptionTypes;
    //修饰符
    private int   modifiers;
    //真正实现功能的类,当前类只是它的代理
    private volatile ConstructorAccessor constructorAccessor;
    //由coyp的来的对象,回保留原对象的引用
    private Constructor         root;

    //包内的构造函数
    Constructor(Class declaringClass,
                Class[] parameterTypes,
                Class[] checkedExceptions,
                int modifiers,
                int slot)
    {
        this.clazz = declaringClass;
        this.parameterTypes = parameterTypes;
        this.exceptionTypes = checkedExceptions;
        this.modifiers = modifiers;
        this.slot = slot;
    }

    /**
     * 返回当前构造函数对象的一个拷贝
     */
    Constructor copy() {
     //用此对象的数据生成新的构造函数对象
        Constructor res = new Constructor(clazz, parameterTypes,
                                          exceptionTypes, modifiers, slot);
        //新构造函数的root指向自己
        res.root = this;
        //与新的构造函数对象共享ConstructorAccessor
        res.constructorAccessor = constructorAccessor;
        return res;
    }

    //返回定义此构造函数的类
    public Class getDeclaringClass() {
 return clazz;
    }

    //取得构造函数的名,它与类名一致
    public String getName() {
 return getDeclaringClass().getName();
    }

    //取得修饰符
    public int getModifiers() {
 return modifiers;
    }

    //取得此对象的参数列表
    public Class[] getParameterTypes() {
 return Method.copy(parameterTypes);
    }

    //返回此构造函数定义的异常列表,如果没有定义异常,则返回0长度数组
    public Class[] getExceptionTypes() {
 return Method.copy(exceptionTypes);
    }

    /**
     * 判断指定对象obj是否与当前构造函数对象相等
     */
    public boolean equals(Object obj) {
 if (obj != null && obj instanceof Constructor) {//对象不为null,且为构造函数对象
  //转型
     Constructor other = (Constructor)obj;
     if (getDeclaringClass() == other.getDeclaringClass()) {
     //两对象的定义类相等,这是他们的名称也一定相等
      
  Class[] params1 = parameterTypes;
  Class[] params2 = other.parameterTypes;
  
  //比较参数列表
  if (params1.length == params2.length) {
      for (int i = 0; i < params1.length; i++) {
   if (params1[i] != params2[i])
       return false;
      }
      return true;
  }
  
     }
 }
 
 //两个对象不等
 return false;
    }

    //返回hashCode
    public int hashCode() {
 return getDeclaringClass().getName().hashCode();
    }

    /**
     * 返回构造函数的字符串描述
     */
    public String toString() {
 try {
     StringBuffer sb = new StringBuffer();
     int mod = getModifiers();
     
     if (mod != 0) {
  //标志符
     sb.append(Modifier.toString(mod) + " ");
     }
     
     //注意它这里用的是Field方法中显示类的名字,这个方法显示数组类型跟Class.getName()不同
     //类名
     sb.append(Field.getTypeName(getDeclaringClass()));
     sb.append("(");
     
     //显示参数列表用","分隔
     Class[] params = parameterTypes; // avoid clone
     for (int j = 0; j < params.length; j++) {
  sb.append(Field.getTypeName(params[j]));
  if (j < (params.length - 1))
      sb.append(",");
     }
     sb.append(")");
     
     //显示异常列表用","分隔
     Class[] exceptions = exceptionTypes; // avoid clone
     if (exceptions.length > 0) {
  sb.append(" throws ");  
  for (int k = 0; k < exceptions.length; k++) {
      sb.append(exceptions[k].getName());
      if (k < (exceptions.length - 1))
   sb.append(",");
  }
  
     }
     return sb.toString();
 } catch (Exception e) {
     return "<" + e + ">";
 }
    }

    /**
     * 此类最重要的方法
     * 构造一个类的实例,如果构造函数是无参的,传入的数组为null或长度为0,
     * 原始类型的参数需要封装成其包装类
     * 
     */
    public Object newInstance(Object[] initargs)
 throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {//做检查
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class caller = Reflection.getCallerClass(2);
                if (securityCheckCache != caller) {
                 //上一个通过的调用者的Class对象被缓存,如果与上次通过的不同,则进行安全检查
                    Reflection.ensureMemberAccess(caller, clazz, null, modifiers);
                    securityCheckCache = caller;
                }
            }
        }
        
        //检查acquireConstructorAccessor
        if (constructorAccessor == null) acquireConstructorAccessor();
        
        //Constructor只是代理类,实现创建对象的操作是在ConstructorAccessor中
        return constructorAccessor.newInstance(initargs);
    }

    private void acquireConstructorAccessor() {
        ConstructorAccessor tmp = null;
        //取得上层的ConstructorAccessor
        if (root != null) tmp = root.getConstructorAccessor();
        if (tmp != null) {
         //如果上层的ConstructorAccessor不为空,则将上层的
         //ConstructorAccessor付给当前的ConstructorAccessor,并返回
            constructorAccessor = tmp;
            return;
        }
        
        //上层没有则创建一个
        tmp = reflectionFactory.newConstructorAccessor(this);
        setConstructorAccessor(tmp);
    }

    //直接返回onstructorAccessor
    ConstructorAccessor getConstructorAccessor() {
        return constructorAccessor;
    }

    //设置当前的constructorAccessor对象,会是上次的constructorAccessor对象都改变
    void setConstructorAccessor(ConstructorAccessor accessor) {
        //将当前的constructorAccessor对象置为新的ConstructorAccessor对象
     constructorAccessor = accessor;
        
     //递归调用上层的设置ConstructorAccessor对象的方法
        if (root != null) {
            root.setConstructorAccessor(accessor);
        }
    }

    int getSlot() {
        return slot;
    }
}