Field(Class<?> declaringClass,
    String name,
    Class<?> type,
    int modifiers,
    int slot,
    String signature,
    byte[] annotations) 
{
        this.clazz = declaringClass;
        this.name = name;
        this.type = type;
        this.modifiers = modifiers;
        this.slot = slot;
        this.signature = signature;
        this.annotations = annotations;
}

Package-private constructor used by ReflectAccess to enable instantiation of these objects in Java code from the java.lang package via sun.reflect.LangReflectAccess.

 Field copy() 
{
        // This routine enables sharing of FieldAccessor objects
        // among Field objects which refer to the same underlying
        // method in the VM. (All of this contortion is only necessary
        // because of the "accessibility" bit in AccessibleObject,
        // which implicitly requires that new java.lang.reflect
        // objects be fabricated for each reflective call on Class
        // objects.)
        Field res = new Field(clazz, name, type, modifiers, slot, signature, annotations);
        res.root = this;
        // Might as well eagerly propagate this if already present
        res.fieldAccessor = fieldAccessor;
        res.overrideFieldAccessor = overrideFieldAccessor;
        return res;
}

Package-private routine (exposed to java.lang.Class via ReflectAccess) which returns a copy of this Field. The copy's "root" field points to this Field.

 public boolean equals(Object obj) 
{
        if (obj != null && obj instanceof Field) {
            Field other = (Field)obj;
            return (getDeclaringClass() == other.getDeclaringClass())
                && (getName() == other.getName())
                && (getType() == other.getType());
        }
        return false;
}

Compares this {@code Field} against the specified object. Returns true if the objects are the same. Two {@code Field} objects are the same if they were declared by the same class and have the same name and type.

 public Object get(Object obj) throws IllegalArgumentException, IllegalAccessException 
{
        return getFieldAccessor(obj).get(obj);
}

Returns the value of the field represented by this {@code Field}, on the specified object. The value is automatically wrapped in an object if it has a primitive type.

The underlying field's value is obtained as follows:

If the underlying field is a static field, the {@code obj} argument is ignored; it may be null.

Otherwise, the underlying field is an instance field. If the specified {@code obj} argument is null, the method throws a {@code NullPointerException}. If the specified object is not an instance of the class or interface declaring the underlying field, the method throws an {@code IllegalArgumentException}.

If this {@code Field} object is enforcing Java language access control, and the underlying field is inaccessible, the method throws an {@code IllegalAccessException}. If the underlying field is static, the class that declared the field is initialized if it has not already been initialized.

Otherwise, the value is retrieved from the underlying instance or static field. If the field has a primitive type, the value is wrapped in an object before being returned, otherwise it is returned as is.

If the field is hidden in the type of {@code obj}, the field's value is obtained according to the preceding rules.

 public T getAnnotation(Class<T> annotationClass) 
{
        if (annotationClass == null)
            throw new NullPointerException();
        return (T) declaredAnnotations().get(annotationClass);
}

 public boolean getBoolean(Object obj) throws IllegalArgumentException, IllegalAccessException 
{
        return getFieldAccessor(obj).getBoolean(obj);
}

Gets the value of a static or instance {@code boolean} field.

 public byte getByte(Object obj) throws IllegalArgumentException, IllegalAccessException 
{
        return getFieldAccessor(obj).getByte(obj);
}

Gets the value of a static or instance {@code byte} field.

 public char getChar(Object obj) throws IllegalArgumentException, IllegalAccessException 
{
        return getFieldAccessor(obj).getChar(obj);
}

Gets the value of a static or instance field of type {@code char} or of another primitive type convertible to type {@code char} via a widening conversion.

 public Annotation[] getDeclaredAnnotations() 
{
        return AnnotationParser.toArray(declaredAnnotations());
}

 public Class<?> getDeclaringClass() 
{
        return clazz;
}

Returns the {@code Class} object representing the class or interface that declares the field represented by this {@code Field} object.

 public double getDouble(Object obj) throws IllegalArgumentException, IllegalAccessException 
{
        return getFieldAccessor(obj).getDouble(obj);
}

Gets the value of a static or instance field of type {@code double} or of another primitive type convertible to type {@code double} via a widening conversion.

 public float getFloat(Object obj) throws IllegalArgumentException, IllegalAccessException 
{
        return getFieldAccessor(obj).getFloat(obj);
}

Gets the value of a static or instance field of type {@code float} or of another primitive type convertible to type {@code float} via a widening conversion.

 public Type getGenericType() 
{
        if (getGenericSignature() != null)
            return getGenericInfo().getGenericType();
        else
            return getType();
}

Returns a {@code Type} object that represents the declared type for the field represented by this {@code Field} object.

If the {@code Type} is a parameterized type, the {@code Type} object returned must accurately reflect the actual type parameters used in the source code.

If the type of the underlying field is a type variable or a parameterized type, it is created. Otherwise, it is resolved.

 public int getInt(Object obj) throws IllegalArgumentException, IllegalAccessException 
{
        return getFieldAccessor(obj).getInt(obj);
}

Gets the value of a static or instance field of type {@code int} or of another primitive type convertible to type {@code int} via a widening conversion.

 public long getLong(Object obj) throws IllegalArgumentException, IllegalAccessException 
{
        return getFieldAccessor(obj).getLong(obj);
}

Gets the value of a static or instance field of type {@code long} or of another primitive type convertible to type {@code long} via a widening conversion.

 public int getModifiers() 
{
        return modifiers;
}

Returns the Java language modifiers for the field represented by this {@code Field} object, as an integer. The {@code Modifier} class should be used to decode the modifiers.

 public String getName() 
{
        return name;
}

Returns the name of the field represented by this {@code Field} object.

 public short getShort(Object obj) throws IllegalArgumentException, IllegalAccessException 
{
        return getFieldAccessor(obj).getShort(obj);
}

Gets the value of a static or instance field of type {@code short} or of another primitive type convertible to type {@code short} via a widening conversion.

 public Class<?> getType() 
{
        return type;
}

Returns a {@code Class} object that identifies the declared type for the field represented by this {@code Field} object.

 static String getTypeName(Class<?> type) 
{
        if (type.isArray()) {
            try {
                Class< ? > cl = type;
                int dimensions = 0;
                while (cl.isArray()) {
                    dimensions++;
                    cl = cl.getComponentType();
                }
                StringBuffer sb = new StringBuffer();
                sb.append(cl.getName());
                for (int i = 0; i <  dimensions; i++) {
                    sb.append("[]");
                }
                return sb.toString();
            } catch (Throwable e) { /*FALLTHRU*/ }
        }
        return type.getName();
}

 public int hashCode() 
{
        return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
}

Returns a hashcode for this {@code Field}. This is computed as the exclusive-or of the hashcodes for the underlying field's declaring class name and its name.

 public boolean isEnumConstant() 
{
        return (getModifiers() & Modifier.ENUM) != 0;
}

Returns {@code true} if this field represents an element of an enumerated type; returns {@code false} otherwise.

 public boolean isSynthetic() 
{
        return Modifier.isSynthetic(getModifiers());
}

Returns {@code true} if this field is a synthetic field; returns {@code false} otherwise.

 public  void set(Object obj,
    Object value) throws IllegalArgumentException, IllegalAccessException 
{
        getFieldAccessor(obj).set(obj, value);
}

Sets the field represented by this {@code Field} object on the specified object argument to the specified new value. The new value is automatically unwrapped if the underlying field has a primitive type.

The operation proceeds as follows:

If the underlying field is static, the {@code obj} argument is ignored; it may be null.

Otherwise the underlying field is an instance field. If the specified object argument is null, the method throws a {@code NullPointerException}. If the specified object argument is not an instance of the class or interface declaring the underlying field, the method throws an {@code IllegalArgumentException}.

If this {@code Field} object is enforcing Java language access control, and the underlying field is inaccessible, the method throws an {@code IllegalAccessException}.

If the underlying field is final, the method throws an {@code IllegalAccessException} unless {@code setAccessible(true)} has succeeded for this {@code Field} object and the field is non-static. Setting a final field in this way is meaningful only during deserialization or reconstruction of instances of classes with blank final fields, before they are made available for access by other parts of a program. Use in any other context may have unpredictable effects, including cases in which other parts of a program continue to use the original value of this field.

If the underlying field is of a primitive type, an unwrapping conversion is attempted to convert the new value to a value of a primitive type. If this attempt fails, the method throws an {@code IllegalArgumentException}.

If, after possible unwrapping, the new value cannot be converted to the type of the underlying field by an identity or widening conversion, the method throws an {@code IllegalArgumentException}.

If the underlying field is static, the class that declared the field is initialized if it has not already been initialized.

The field is set to the possibly unwrapped and widened new value.

If the field is hidden in the type of {@code obj}, the field's value is set according to the preceding rules.

 public  void setBoolean(Object obj,
    boolean z) throws IllegalArgumentException, IllegalAccessException 
{
        getFieldAccessor(obj).setBoolean(obj, z);
}

Sets the value of a field as a {@code boolean} on the specified object. This method is equivalent to {@code set(obj, zObj)}, where {@code zObj} is a {@code Boolean} object and {@code zObj.booleanValue() == z}.

 public  void setByte(Object obj,
    byte b) throws IllegalArgumentException, IllegalAccessException 
{
        getFieldAccessor(obj).setByte(obj, b);
}

Sets the value of a field as a {@code byte} on the specified object. This method is equivalent to {@code set(obj, bObj)}, where {@code bObj} is a {@code Byte} object and {@code bObj.byteValue() == b}.

 public  void setChar(Object obj,
    char c) throws IllegalArgumentException, IllegalAccessException 
{
        getFieldAccessor(obj).setChar(obj, c);
}

Sets the value of a field as a {@code char} on the specified object. This method is equivalent to {@code set(obj, cObj)}, where {@code cObj} is a {@code Character} object and {@code cObj.charValue() == c}.

 public  void setDouble(Object obj,
    double d) throws IllegalArgumentException, IllegalAccessException 
{
        getFieldAccessor(obj).setDouble(obj, d);
}

Sets the value of a field as a {@code double} on the specified object. This method is equivalent to {@code set(obj, dObj)}, where {@code dObj} is a {@code Double} object and {@code dObj.doubleValue() == d}.

 public  void setFloat(Object obj,
    float f) throws IllegalArgumentException, IllegalAccessException 
{
        getFieldAccessor(obj).setFloat(obj, f);
}

Sets the value of a field as a {@code float} on the specified object. This method is equivalent to {@code set(obj, fObj)}, where {@code fObj} is a {@code Float} object and {@code fObj.floatValue() == f}.

 public  void setInt(Object obj,
    int i) throws IllegalArgumentException, IllegalAccessException 
{
        getFieldAccessor(obj).setInt(obj, i);
}

Sets the value of a field as an {@code int} on the specified object. This method is equivalent to {@code set(obj, iObj)}, where {@code iObj} is a {@code Integer} object and {@code iObj.intValue() == i}.

 public  void setLong(Object obj,
    long l) throws IllegalArgumentException, IllegalAccessException 
{
        getFieldAccessor(obj).setLong(obj, l);
}

Sets the value of a field as a {@code long} on the specified object. This method is equivalent to {@code set(obj, lObj)}, where {@code lObj} is a {@code Long} object and {@code lObj.longValue() == l}.

 public  void setShort(Object obj,
    short s) throws IllegalArgumentException, IllegalAccessException 
{
        getFieldAccessor(obj).setShort(obj, s);
}

Sets the value of a field as a {@code short} on the specified object. This method is equivalent to {@code set(obj, sObj)}, where {@code sObj} is a {@code Short} object and {@code sObj.shortValue() == s}.

 public String toGenericString() 
{
        int mod = getModifiers();
        Type fieldType = getGenericType();
        return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
            +  ((fieldType instanceof Class) ?
                getTypeName((Class)fieldType): fieldType.toString())+ " "
            + getTypeName(getDeclaringClass()) + "."
            + getName());
}

Returns a string describing this {@code Field}, including its generic type. The format is the access modifiers for the field, if any, followed by the generic field type, followed by a space, followed by the fully-qualified name of the class declaring the field, followed by a period, followed by the name of the field.

The modifiers are placed in canonical order as specified by "The Java Language Specification". This is {@code public}, {@code protected} or {@code private} first, and then other modifiers in the following order: {@code static}, {@code final}, {@code transient}, {@code volatile}.

 public String toString() 
{
        int mod = getModifiers();
        return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
            + getTypeName(getType()) + " "
            + getTypeName(getDeclaringClass()) + "."
            + getName());
}

Returns a string describing this {@code Field}. The format is the access modifiers for the field, if any, followed by the field type, followed by a space, followed by the fully-qualified name of the class declaring the field, followed by a period, followed by the name of the field. For example:

   public static final int java.lang.Thread.MIN_PRIORITY
   private int java.io.FileDescriptor.fd

The modifiers are placed in canonical order as specified by "The Java Language Specification". This is {@code public}, {@code protected} or {@code private} first, and then other modifiers in the following order: {@code static}, {@code final}, {@code transient}, {@code volatile}.