org.apache.bcel.classfile

## Class JavaClass

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

- All Implemented Interfaces:
    Cloneable, Comparable<JavaClass>, Node

      public class JavaClass
      extends AccessFlags
      implements Cloneable, Node, Comparable<JavaClass>

  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.
  See Also:
    `ClassGen`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static byte` | `FILE`
    `static byte` | `HEAP`
    `static byte` | `ZIP`

    - ### Fields inherited from class org.apache.bcel.classfile.AccessFlags

      `access_flags`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `JavaClass(int classNameIndex, int superclassNameIndex, String fileName, int major, int minor, int access_flags, ConstantPool constantPool, int[] interfaces, Field[] fields, Method[] methods, Attribute[] attributes)` Constructor gets all contents as arguments.
    `JavaClass(int classNameIndex, int superclassNameIndex, String fileName, int major, int minor, int access_flags, ConstantPool constantPool, int[] interfaces, Field[] fields, Method[] methods, Attribute[] attributes, byte source)` Constructor gets all contents as arguments.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `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(JavaClass 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 fileName.
    `boolean` | `equals(Object obj)` Return value as defined by given BCELComparator strategy.
    `JavaClass[]` | `getAllInterfaces()` Get all interfaces implemented by this JavaClass (transitively).
    `AnnotationEntry[]` | `getAnnotationEntries()`
    `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()` returns the super class name of this class.
    `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` | `isAnonymous()`
    `boolean` | `isClass()`
    `boolean` | `isNested()`
    `boolean` | `isSuper()`
    `void` | `setAttributes(Attribute[] attributes)`
    `void` | `setClassName(String className)`
    `void` | `setClassNameIndex(int classNameIndex)`
    `static void` | `setComparator(BCELComparator comparator)`
    `void` | `setConstantPool(ConstantPool constantPool)`
    `void` | `setFields(Field[] fields)`
    `void` | `setFileName(String fileName)` Set File name of class, aka SourceFile attribute value
    `void` | `setInterfaceNames(String[] interfaceNames)`
    `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 sourceFileName)` Set absolute path to file this class was read from.
    `void` | `setSuperclassName(String superclassName)`
    `void` | `setSuperclassNameIndex(int superclassNameIndex)`
    `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, isVarArgs, isVarArgs, 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 classNameIndex,
                           int superclassNameIndex,
                           String fileName,
                           int major,
                           int minor,
                           int access_flags,
                           ConstantPool constantPool,
                           int[] interfaces,
                           Field[] fields,
                           Method[] methods,
                           Attribute[] attributes,
                           byte source)

      Constructor gets all contents as arguments.
      Parameters:
        `classNameIndex` - Index into constant pool referencing a ConstantClass that represents this class.
        `superclassNameIndex` - Index into constant pool referencing a ConstantClass that represents this class's superclass.
        `fileName` - File name
        `major` - Major compiler version
        `minor` - Minor compiler version
        `access_flags` - Access rights defined by bit flags
        `constantPool` - 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 classNameIndex,
                           int superclassNameIndex,
                           String fileName,
                           int major,
                           int minor,
                           int access_flags,
                           ConstantPool constantPool,
                           int[] interfaces,
                           Field[] fields,
                           Method[] methods,
                           Attribute[] attributes)

      Constructor gets all contents as arguments.
      Parameters:
        `classNameIndex` - Class name
        `superclassNameIndex` - Superclass name
        `fileName` - File name
        `major` - Major compiler version
        `minor` - Minor compiler version
        `access_flags` - Access rights defined by bit flags
        `constantPool` - 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 fileName.
      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.

    - #### getAnnotationEntries

          public AnnotationEntry[] getAnnotationEntries()

      Returns:
        Annotations on the class
      Since:
        6.0

    - #### 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 `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 the super class name of this class. In the case that this class is java.lang.Object, it will return itself (java.lang.Object). This is probably incorrect but isn't fixed at this time to not break existing clients.
      Returns:
        Superclass name.

    - #### getSuperclassNameIndex

          public int getSuperclassNameIndex()

      Returns:
        Class name index.

    - #### setAttributes

          public void setAttributes(Attribute[] attributes)

      Parameters:
        `attributes` - .

    - #### setClassName

          public void setClassName(String className)

      Parameters:
        `className` - .

    - #### setClassNameIndex

          public void setClassNameIndex(int classNameIndex)

      Parameters:
        `classNameIndex` - .

    - #### setConstantPool

          public void setConstantPool(ConstantPool constantPool)

      Parameters:
        `constantPool` - .

    - #### setFields

          public void setFields(Field[] fields)

      Parameters:
        `fields` - .

    - #### setFileName

          public void setFileName(String fileName)

      Set File name of class, aka SourceFile attribute value

    - #### setInterfaceNames

          public void setInterfaceNames(String[] interfaceNames)

      Parameters:
        `interfaceNames` - .

    - #### 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 sourceFileName)

      Set absolute path to file this class was read from.

    - #### setSuperclassName

          public void setSuperclassName(String superclassName)

      Parameters:
        `superclassName` - .

    - #### setSuperclassNameIndex

          public void setSuperclassNameIndex(int superclassNameIndex)

      Parameters:
        `superclassNameIndex` - .

    - #### 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()

    - #### isAnonymous

          public final boolean isAnonymous()

      Since:
        6.0

    - #### isNested

          public final boolean isNested()

      Since:
        6.0

    - #### 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(JavaClass obj)

      Return the natural ordering of two JavaClasses. This ordering is based on the class name
      Specified by:
        `compareTo` in interface `Comparable<JavaClass>`
      Since:
        6.0

    - #### 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 © 2004–2020 The Apache Software Foundation. All rights reserved.