## org.apache.bcel.classfile
Class JavaClass

    java.lang.Object
      org.apache.bcel.classfile.AccessFlags
          org.apache.bcel.classfile.JavaClass

All Implemented Interfaces:
  Serializable, Cloneable, Comparable, Node

    public class JavaClass

extends AccessFlags
implements Cloneable, Node, Comparable

Represents a Java class, i.e., the data structures, constant pool, fields, methods and commands contained in a Java .class file. See JVM specification for details. The intent of this class is to represent a parsed or otherwise existing class file. Those interested in programatically generating classes should see the ClassGen class.

Version:
  $Id: JavaClass.java 386056 2006-03-15 11:31:56Z tcurdt $
See Also:
  `ClassGen`, Serialized Form

Field Summary
`static byte` `FILE`
`static byte` `HEAP`
`static byte` `ZIP`

Fields inherited from class org.apache.bcel.classfile.AccessFlags
`access_flags`

Constructor Summary
`JavaClass(int class_name_index, int superclass_name_index, String file_name, int major, int minor, int access_flags, ConstantPool constant_pool, int[] interfaces, Field[] fields, Method[] methods, Attribute[] attributes)` Constructor gets all contents as arguments.
`JavaClass(int class_name_index, int superclass_name_index, String file_name, int major, int minor, int access_flags, ConstantPool constant_pool, int[] interfaces, Field[] fields, Method[] methods, Attribute[] attributes, byte source)` Constructor gets all contents as arguments.

Method Summary
`void` `accept(Visitor v)` Called by objects that are traversing the nodes of the tree implicitely defined by the contents of a Java class.
`int` `compareTo(Object obj)` Return the natural ordering of two JavaClasses.
`JavaClass` `copy()`
`void` `dump(DataOutputStream file)` Dump Java class to output stream in binary format.
`void` `dump(File file)` Dump class to a file.
`void` `dump(OutputStream file)` Dump Java class to output stream in binary format.
`void` `dump(String _file_name)` Dump class to a file named file_name.
`boolean` `equals(Object obj)` Return value as defined by given BCELComparator strategy.
`JavaClass[]` `getAllInterfaces()` Get all interfaces implemented by this JavaClass (transitively).
`Attribute[]` `getAttributes()`
`byte[]` `getBytes()`
`String` `getClassName()`
`int` `getClassNameIndex()`
`static BCELComparator` `getComparator()`
`ConstantPool` `getConstantPool()`
`Field[]` `getFields()`
`String` `getFileName()`
`int[]` `getInterfaceIndices()`
`String[]` `getInterfaceNames()`
`JavaClass[]` `getInterfaces()` Get interfaces directly implemented by this JavaClass.
`int` `getMajor()`
`Method` `getMethod(Method m)`
`Method[]` `getMethods()`
`int` `getMinor()`
`String` `getPackageName()`
`Repository` `getRepository()` Gets the ClassRepository which holds its definition.
`byte` `getSource()`
`String` `getSourceFileName()`
`JavaClass` `getSuperClass()`
`JavaClass[]` `getSuperClasses()`
`String` `getSuperclassName()`
`int` `getSuperclassNameIndex()`
`int` `hashCode()` Return value as defined by given BCELComparator strategy.
`boolean` `implementationOf(JavaClass inter)`
`boolean` `instanceOf(JavaClass super_class)` Equivalent to runtime "instanceof" operator.
`boolean` `isClass()`
`boolean` `isSuper()`
`void` `setAttributes(Attribute[] attributes)`
`void` `setClassName(String class_name)`
`void` `setClassNameIndex(int class_name_index)`
`static void` `setComparator(BCELComparator comparator)`
`void` `setConstantPool(ConstantPool constant_pool)`
`void` `setFields(Field[] fields)`
`void` `setFileName(String file_name)` Set File name of class, aka SourceFile attribute value
`void` `setInterfaceNames(String[] interface_names)`
`void` `setInterfaces(int[] interfaces)`
`void` `setMajor(int major)`
`void` `setMethods(Method[] methods)`
`void` `setMinor(int minor)`
`void` `setRepository(Repository repository)` Sets the ClassRepository which loaded the JavaClass.
`void` `setSourceFileName(String source_file_name)` Set absolute path to file this class was read from.
`void` `setSuperclassName(String superclass_name)`
`void` `setSuperclassNameIndex(int superclass_name_index)`
`String` `toString()`

Methods inherited from class org.apache.bcel.classfile.AccessFlags

`getAccessFlags, getModifiers, isAbstract, isAbstract, isAnnotation, isAnnotation, isEnum, isEnum, isFinal, isFinal, isInterface, isInterface, isNative, isNative, isPrivate, isPrivate, isProtected, isProtected, isPublic, isPublic, isStatic, isStatic, isStrictfp, isStrictfp, isSynchronized, isSynchronized, isSynthetic, isSynthetic, isTransient, isTransient, isVolatile, isVolatile, setAccessFlags, setModifiers`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

### HEAP

    public static final byte HEAP

See Also:
  Constant Field Values

### FILE

    public static final byte FILE

See Also:
  Constant Field Values

### ZIP

    public static final byte ZIP

See Also:
  Constant Field Values

Constructor Detail

### JavaClass

    public JavaClass(int class_name_index,
                     int superclass_name_index,
                     String file_name,
                     int major,
                     int minor,
                     int access_flags,
                     ConstantPool constant_pool,
                     int[] interfaces,
                     Field[] fields,
                     Method[] methods,
                     Attribute[] attributes,
                     byte source)

  Constructor gets all contents as arguments.

  Parameters:
    `class_name_index` - Index into constant pool referencing a ConstantClass that represents this class.
    `superclass_name_index` - Index into constant pool referencing a ConstantClass that represents this class's superclass.
    `file_name` - File name
    `major` - Major compiler version
    `minor` - Minor compiler version
    `access_flags` - Access rights defined by bit flags
    `constant_pool` - Array of constants
    `interfaces` - Implemented interfaces
    `fields` - Class fields
    `methods` - Class methods
    `attributes` - Class attributes
    `source` - Read from file or generated in memory?

### JavaClass

    public JavaClass(int class_name_index,
                     int superclass_name_index,
                     String file_name,
                     int major,
                     int minor,
                     int access_flags,
                     ConstantPool constant_pool,
                     int[] interfaces,
                     Field[] fields,
                     Method[] methods,
                     Attribute[] attributes)

  Constructor gets all contents as arguments.

  Parameters:
    `class_name_index` - Class name
    `superclass_name_index` - Superclass name
    `file_name` - File name
    `major` - Major compiler version
    `minor` - Minor compiler version
    `access_flags` - Access rights defined by bit flags
    `constant_pool` - Array of constants
    `interfaces` - Implemented interfaces
    `fields` - Class fields
    `methods` - Class methods
    `attributes` - Class attributes

Method Detail

### accept

    public void accept(Visitor v)

  Called by objects that are traversing the nodes of the tree implicitely defined by the contents of a Java class. I.e., the hierarchy of methods, fields, attributes, etc. spawns a tree of objects.

  Specified by:
    `accept` in interface `Node`
  Parameters:
    `v` - Visitor object

### dump

    public void dump(File file)
              throws IOException

  Dump class to a file.

  Parameters:
    `file` - Output file
  Throws:
    `IOException`

### dump

    public void dump(String _file_name)
              throws IOException

  Dump class to a file named file_name.

  Parameters:
    `_file_name` - Output file name
  Throws:
    `IOException`

### getBytes

    public byte[] getBytes()

  Returns:
    class in binary format

### dump

    public void dump(OutputStream file)
              throws IOException

  Dump Java class to output stream in binary format.

  Parameters:
    `file` - Output stream
  Throws:
    `IOException`

### dump

    public void dump(DataOutputStream file)
              throws IOException

  Dump Java class to output stream in binary format.

  Parameters:
    `file` - Output stream
  Throws:
    `IOException`

### getAttributes

    public Attribute[] getAttributes()

  Returns:
    Attributes of the class.

### getClassName

    public String getClassName()

  Returns:
    Class name.

### getPackageName

    public String getPackageName()

  Returns:
    Package name.

### getClassNameIndex

    public int getClassNameIndex()

  Returns:
    Class name index.

### getConstantPool

    public ConstantPool getConstantPool()

  Returns:
    Constant pool.

### getFields

    public Field[] getFields()

  Returns:
    Fields, i.e., variables of the class. Like the JVM spec mandates for the classfile format, these fields are those specific to this class, and not those of the superclass or superinterfaces.

### getFileName

    public String getFileName()

  Returns:
    File name of class, aka SourceFile attribute value

### getInterfaceNames

    public String[] getInterfaceNames()

  Returns:
    Names of implemented interfaces.

### getInterfaceIndices

    public int[] getInterfaceIndices()

  Returns:
    Indices in constant pool of implemented interfaces.

### getMajor

    public int getMajor()

  Returns:
    Major number of class file version.

### getMethods

    public Method[] getMethods()

  Returns:
    Methods of the class.

### getMethod

    public Method getMethod(Method m)

  Returns:
    A org.apache.bcel.classfile.Method corresponding to java.lang.reflect.Method if any

### getMinor

    public int getMinor()

  Returns:
    Minor number of class file version.

### getSourceFileName

    public String getSourceFileName()

  Returns:
    sbsolute path to file where this class was read from

### getSuperclassName

    public String getSuperclassName()

  Returns:
    Superclass name.

### getSuperclassNameIndex

    public int getSuperclassNameIndex()

  Returns:
    Class name index.

### setAttributes

    public void setAttributes(Attribute[] attributes)

  Parameters:
    `attributes` - .

### setClassName

    public void setClassName(String class_name)

  Parameters:
    `class_name` - .

### setClassNameIndex

    public void setClassNameIndex(int class_name_index)

  Parameters:
    `class_name_index` - .

### setConstantPool

    public void setConstantPool(ConstantPool constant_pool)

  Parameters:
    `constant_pool` - .

### setFields

    public void setFields(Field[] fields)

  Parameters:
    `fields` - .

### setFileName

    public void setFileName(String file_name)

  Set File name of class, aka SourceFile attribute value

### setInterfaceNames

    public void setInterfaceNames(String[] interface_names)

  Parameters:
    `interface_names` - .

### setInterfaces

    public void setInterfaces(int[] interfaces)

  Parameters:
    `interfaces` - .

### setMajor

    public void setMajor(int major)

  Parameters:
    `major` - .

### setMethods

    public void setMethods(Method[] methods)

  Parameters:
    `methods` - .

### setMinor

    public void setMinor(int minor)

  Parameters:
    `minor` - .

### setSourceFileName

    public void setSourceFileName(String source_file_name)

  Set absolute path to file this class was read from.

### setSuperclassName

    public void setSuperclassName(String superclass_name)

  Parameters:
    `superclass_name` - .

### setSuperclassNameIndex

    public void setSuperclassNameIndex(int superclass_name_index)

  Parameters:
    `superclass_name_index` - .

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`
  Returns:
    String representing class contents.

### copy

    public JavaClass copy()

  Returns:
    deep copy of this class

### isSuper

    public final boolean isSuper()

### isClass

    public final boolean isClass()

### getSource

    public final byte getSource()

  Returns:
    returns either HEAP (generated), FILE, or ZIP

### getRepository

    public Repository getRepository()

  Gets the ClassRepository which holds its definition. By default this is the same as SyntheticRepository.getInstance();

### setRepository

    public void setRepository(Repository repository)

  Sets the ClassRepository which loaded the JavaClass. Should be called immediately after parsing is done.

### instanceOf

    public final boolean instanceOf(JavaClass super_class)
                             throws ClassNotFoundException

  Equivalent to runtime "instanceof" operator.

  Returns:
    true if this JavaClass is derived from the super class
  Throws:
    `ClassNotFoundException` - if superclasses or superinterfaces of this object can't be found

### implementationOf

    public boolean implementationOf(JavaClass inter)
                             throws ClassNotFoundException

  Returns:
    true, if this class is an implementation of interface inter
  Throws:
    `ClassNotFoundException` - if superclasses or superinterfaces of this class can't be found

### getSuperClass

    public JavaClass getSuperClass()
                            throws ClassNotFoundException

  Returns:
    the superclass for this JavaClass object, or null if this is java.lang.Object
  Throws:
    `ClassNotFoundException` - if the superclass can't be found

### getSuperClasses

    public JavaClass[] getSuperClasses()
                                throws ClassNotFoundException

  Returns:
    list of super classes of this class in ascending order, i.e., java.lang.Object is always the last element
  Throws:
    `ClassNotFoundException` - if any of the superclasses can't be found

### getInterfaces

    public JavaClass[] getInterfaces()
                              throws ClassNotFoundException

  Get interfaces directly implemented by this JavaClass.

  Throws:
    `ClassNotFoundException`

### getAllInterfaces

    public JavaClass[] getAllInterfaces()
                                 throws ClassNotFoundException

  Get all interfaces implemented by this JavaClass (transitively).

  Throws:
    `ClassNotFoundException`

### getComparator

    public static BCELComparator getComparator()

  Returns:
    Comparison strategy object

### setComparator

    public static void setComparator(BCELComparator comparator)

  Parameters:
    `comparator` - Comparison strategy object

### equals

    public boolean equals(Object obj)

  Return value as defined by given BCELComparator strategy. By default two JavaClass objects are said to be equal when their class names are equal.

  Overrides:
    `equals` in class `Object`
  See Also:
    `Object.equals(java.lang.Object)`

### compareTo

    public int compareTo(Object obj)

  Return the natural ordering of two JavaClasses. This ordering is based on the class name

  Specified by:
    `compareTo` in interface `Comparable`

### hashCode

    public int hashCode()

  Return value as defined by given BCELComparator strategy. By default return the hashcode of the class name.

  Overrides:
    `hashCode` in class `Object`
  See Also:
    `Object.hashCode()`

Copyright © 2002-2006 Apache Software Foundation. All Rights Reserved.