public ObjectStreamField(String name,
    Class type) 
{
                                                
        this(name, type, false);
}

Create a Serializable field with the specified type. This field should be documented with a serialField tag.

Parameters:

name - the name of the serializable field

type - the Class object of the serializable field

 public ObjectStreamField(String name,
    Class type,
    boolean unshared) 
{
        if (name == null) {
            throw new NullPointerException();
        }
        this.name = name;
        this.type = type;
        this.unshared = unshared;
        signature = ObjectStreamClass.getClassSignature(type).intern();
        field = null;
}

Creates an ObjectStreamField representing a serializable field with the given name and type. If unshared is false, values of the represented field are serialized and deserialized in the default manner--if the field is non-primitive, object values are serialized and deserialized as if they had been written and read by calls to writeObject and readObject. If unshared is true, values of the represented field are serialized and deserialized as if they had been written and read by calls to writeUnshared and readUnshared.

Parameters:

name - field name

type - field type

unshared - if false, write/read field values in the same manner as writeObject/readObject; if true, write/read in the same manner as writeUnshared/readUnshared

since: 1.4 -

 ObjectStreamField(String name,
    String signature,
    boolean unshared) 
{
        if (name == null) {
            throw new NullPointerException();
        }
        this.name = name;
        this.signature = signature.intern();
        this.unshared = unshared;
        field = null;
        switch (signature.charAt(0)) {
            case 'Z": type = Boolean.TYPE; break;
            case 'B": type = Byte.TYPE; break;
            case 'C": type = Character.TYPE; break;
            case 'S": type = Short.TYPE; break;
            case 'I": type = Integer.TYPE; break;
            case 'J": type = Long.TYPE; break;
            case 'F": type = Float.TYPE; break;
            case 'D": type = Double.TYPE; break;
            case 'L":
            case '[": type = Object.class; break;
            default: throw new IllegalArgumentException("illegal signature");
        }
}

Creates an ObjectStreamField representing a field with the given name, signature and unshared setting.

 ObjectStreamField(Field field,
    boolean unshared,
    boolean showType) 
{
        this.field = field;
        this.unshared = unshared;
        name = field.getName();
        Class ftype = field.getType();
        type = (showType || ftype.isPrimitive()) ? ftype : Object.class;
        signature = ObjectStreamClass.getClassSignature(ftype).intern();
}

Creates an ObjectStreamField representing the given field with the specified unshared setting. For compatibility with the behavior of earlier serialization implementations, a "showType" parameter is necessary to govern whether or not a getType() call on this ObjectStreamField (if non-primitive) will return Object.class (as opposed to a more specific reference type).

 public int compareTo(Object obj) 
{
        ObjectStreamField other = (ObjectStreamField) obj;
        boolean isPrim = isPrimitive();
        if (isPrim != other.isPrimitive()) {
            return isPrim ? -1 : 1;
        }
        return name.compareTo(other.name);
}

Compare this field with another ObjectStreamField. Return -1 if this is smaller, 0 if equal, 1 if greater. Types that are primitives are "smaller" than object types. If equal, the field names are compared.

 Field getField() 
{
        return field;
}

Returns field represented by this ObjectStreamField, or null if ObjectStreamField is not associated with an actual field.

 public String getName() 
{
        return name;
}

Get the name of this field.

 public int getOffset() 
{
        return offset;
}

Offset of field within instance data.

 String getSignature() 
{
        return signature;
}

Returns JVM type signature of field (similar to getTypeString, except that signature strings are returned for primitive fields as well).

 public Class getType() 
{
        return type;
}

Get the type of the field. If the type is non-primitive and this ObjectStreamField was obtained from a deserialized ObjectStreamClass instance, then Object.class is returned. Otherwise, the Class object for the type of the field is returned.

 public char getTypeCode() 
{
        return signature.charAt(0);
}

Returns character encoding of field type. The encoding is as follows:

B byte
C char
D double
F float
I int
J long
L class or interface
S short
Z boolean
[ array

 public String getTypeString() 
{
        return isPrimitive() ? null : signature;
}

Return the JVM type signature.

 public boolean isPrimitive() 
{
        char tcode = signature.charAt(0);
        return ((tcode != 'L") && (tcode != '["));
}

Return true if this field has a primitive type.

 public boolean isUnshared() 
{
        return unshared;
}

Returns boolean value indicating whether or not the serializable field represented by this ObjectStreamField instance is unshared.

 protected  void setOffset(int offset) 
{
        this.offset = offset;
}

Offset within instance data.

 public String toString() 
{
        return signature + ' " + name;
}

Return a string that describes this field.