# Uses of Class
javassist.CtClass

Packages that use CtClass
Package
Description
javassist
The Javassist Core API.
javassist.bytecode
Bytecode-level API.
javassist.bytecode.analysis
Bytecode Analysis API.
javassist.bytecode.annotation
Bytecode-level Annotations API.
javassist.expr
This package contains the classes for modifying a method body.
javassist.tools.reflect
Runtime Behavioral Reflection.
javassist.util
Utility classes.

## Uses of CtClass in javassist

Subclasses of CtClass in javassist
Modifier and Type
Class
Description
`final class`
`CtPrimitiveType`
An instance of `CtPrimitiveType` represents a primitive type.
Fields in javassist declared as CtClass
Modifier and Type
Field
Description
`static CtClass`
CtClass.`booleanType`
The `CtClass` object representing the `boolean` type.
`static CtClass`
CtClass.`byteType`
The `CtClass` object representing the `byte` type.
`static CtClass`
CtClass.`charType`
The `CtClass` object representing the `char` type.
`static CtClass`
CtClass.`doubleType`
The `CtClass` object representing the `double` type.
`static CtClass`
CtClass.`floatType`
The `CtClass` object representing the `float` type.
`static CtClass`
CtClass.`intType`
The `CtClass` object representing the `int` type.
`static CtClass`
CtClass.`longType`
The `CtClass` object representing the `long` type.
`static CtClass`
CtClass.`shortType`
The `CtClass` object representing the `short` type.
`static CtClass`
CtClass.`voidType`
The `CtClass` object representing the `void` type.
Methods in javassist that return CtClass
Modifier and Type
Method
Description
`CtClass`
ClassPool.`get(String classname)`
Reads a class file from the source and returns a reference to the `CtClass` object representing that class file.
`CtClass[]`
ClassPool.`get(String[] classnames)`
Reads class files from the source and returns an array of `CtClass` objects representing those class files.
`CtClass`
ClassPool.`getAndRename(String orgName, String newName)`
Reads a class file and constructs a `CtClass` object with a new name.
`CtClass`
CtClass.`getComponentType()`
If this object represents an array, this method returns the component type of the array.
`CtClass`
ClassPool.`getCtClass(String classname)`
Returns a `CtClass` object with the given name.
`CtClass[]`
CtClass.`getDeclaredClasses()`
Returns an array of nested classes declared in the class.
`CtClass`
CtClass.`getDeclaringClass()`
If this class is a member class or interface of another class, then the class enclosing this class is returned.
`CtClass`
CtField.`getDeclaringClass()`
Returns the class declaring the field.
`CtClass`
CtMember.`getDeclaringClass()`
Returns the class that declares this member.
`CtClass[]`
CtBehavior.`getExceptionTypes()`
Obtains exceptions that this method/constructor may throw.
`CtClass[]`
CtClass.`getInterfaces()`
Obtains the class objects representing the interfaces implemented by the class or, if this object represents an interface, the interfaces extended by that interface.
`CtClass[]`
CtClass.`getNestedClasses()`
Returns an array of nested classes declared in the class.
`CtClass`
ClassPool.`getOrNull(String classname)`
Reads a class file from the source and returns a reference to the `CtClass` object representing that class file.
`CtClass[]`
CtBehavior.`getParameterTypes()`
Obtains parameter types of this method/constructor.
`CtClass`
CtMethod.`getReturnType()`
Obtains the type of the returned value.
`CtClass`
CtClass.`getSuperclass()`
Obtains the class object representing the superclass of the class.
`CtClass`
CtField.`getType()`
Returns the type of the field.
`CtClass`
ClassPool.`makeAnnotation(String name)`
Creates a new annotation.
`CtClass`
ClassPool.`makeClass(InputStream classfile)`
Creates a new class (or interface) from the given class file.
`CtClass`
ClassPool.`makeClass(InputStream classfile, boolean ifNotFrozen)`
Creates a new class (or interface) from the given class file.
`CtClass`
ClassPool.`makeClass(String classname)`
Creates a new public class.
`CtClass`
ClassPool.`makeClass(String classname, CtClass superclass)`
Creates a new public class.
`CtClass`
ClassPool.`makeClass(ClassFile classfile)`
Creates a new class (or interface) from the given class file.
`CtClass`
ClassPool.`makeClass(ClassFile classfile, boolean ifNotFrozen)`
Creates a new class (or interface) from the given class file.
`CtClass`
ClassPool.`makeClassIfNew(InputStream classfile)`
Creates a new class (or interface) from the given class file.
`CtClass`
ClassPool.`makeInterface(String name)`
Creates a new public interface.
`CtClass`
ClassPool.`makeInterface(String name, CtClass superclass)`
Creates a new public interface.
`CtClass`
CtClass.`makeNestedClass(String name, boolean isStatic)`
Makes a new public nested class.
Methods in javassist with parameters of type CtClass
Modifier and Type
Method
Description
`static CtMethod`
CtNewMethod.`abstractMethod(CtClass returnType, String mname, CtClass[] parameters, CtClass[] exceptions, CtClass declaring)`
Creates a public abstract method.
`void`
CtBehavior.`addCatch(String src, CtClass exceptionType)`
Adds a catch clause that handles an exception thrown in the body.
`void`
CtBehavior.`addCatch(String src, CtClass exceptionType, String exceptionName)`
Adds a catch clause that handles an exception thrown in the body.
`void`
CtClass.`addInterface(CtClass anInterface)`
Adds an interface.
`void`
CtBehavior.`addLocalVariable(String name, CtClass type)`
Declares a new local variable.
`void`
CtBehavior.`addParameter(CtClass type)`
Appends a new parameter, which becomes the last parameter.
`static CtField.Initializer`
CtField.Initializer.`byCall(CtClass methodClass, String methodName)`
Makes an initializer calling a static method.
`static CtField.Initializer`
CtField.Initializer.`byCall(CtClass methodClass, String methodName, String[] stringParams)`
Makes an initializer calling a static method.
`static CtField.Initializer`
CtField.Initializer.`byCallWithParams(CtClass methodClass, String methodName)`
Makes an initializer calling a static method.
`static CtField.Initializer`
CtField.Initializer.`byCallWithParams(CtClass methodClass, String methodName, String[] stringParams)`
Makes an initializer calling a static method.
`static CtField.Initializer`
CtField.Initializer.`byNew(CtClass objectType)`
Makes an initializer creating a new object.
`static CtField.Initializer`
CtField.Initializer.`byNew(CtClass objectType, String[] stringParams)`
Makes an initializer creating a new object.
`static CtField.Initializer`
CtField.Initializer.`byNewArray(CtClass type, int size)`
Makes an initializer creating a new array.
`static CtField.Initializer`
CtField.Initializer.`byNewArray(CtClass type, int[] sizes)`
Makes an initializer creating a new multi-dimensional array.
`static CtField.Initializer`
CtField.Initializer.`byNewWithParams(CtClass objectType)`
Makes an initializer creating a new object.
`static CtField.Initializer`
CtField.Initializer.`byNewWithParams(CtClass objectType, String[] stringParams)`
Makes an initializer creating a new object.
`static long`
SerialVersionUID.`calculateDefault(CtClass clazz)`
Calculate default value.
`static CtConstructor`
CtNewConstructor.`copy(CtConstructor c, CtClass declaring, ClassMap map)`
Creates a copy of a constructor.
`static CtMethod`
CtNewMethod.`copy(CtMethod src, String name, CtClass declaring, ClassMap map)`
Creates a copy of a method with a new name.
`static CtMethod`
CtNewMethod.`copy(CtMethod src, CtClass declaring, ClassMap map)`
Creates a copy of a method.
`static CtConstructor`
CtNewConstructor.`defaultConstructor(CtClass declaring)`
Creates a default (public) constructor.
`static CtMethod`
CtNewMethod.`delegator(CtMethod delegate, CtClass declaring)`
Creates a method forwarding to a delegate in a super class.
`void`
ClassMap.`fix(CtClass clazz)`
Prevents a mapping from the specified class name to another name.
`CtConstructor`
CtClass.`getDeclaredConstructor(CtClass[] params)`
Returns a constructor receiving the specified parameters.
`CtMethod`
CtClass.`getDeclaredMethod(String name, CtClass[] params)`
Retrieves the method with the specified name and parameter types among the methods declared in the class.
`void`
CtBehavior.`insertParameter(CtClass type)`
Inserts a new parameter, which becomes the first parameter.
`Class<?>`
Loader.Simple.`invokeDefineClass(CtClass cc)`
Invokes the protected `defineClass()` in `ClassLoader`.
`static CtField`
CtField.`make(String src, CtClass declaring)`
Compiles the given source code and creates a field.
`static CtMethod`
CtMethod.`make(String src, CtClass declaring)`
Compiles the given source code and creates a method.
`static CtMethod`
CtMethod.`make(MethodInfo minfo, CtClass declaring)`
Creates a method from a `MethodInfo` object.
`static CtConstructor`
CtNewConstructor.`make(String src, CtClass declaring)`
Compiles the given source code and creates a constructor.
`static CtConstructor`
CtNewConstructor.`make(CtClass[] parameters, CtClass[] exceptions, int howto, CtMethod body, CtMethod.ConstParameter cparam, CtClass declaring)`
Creates a public constructor.
`static CtConstructor`
CtNewConstructor.`make(CtClass[] parameters, CtClass[] exceptions, String body, CtClass declaring)`
Creates a public constructor.
`static CtConstructor`
CtNewConstructor.`make(CtClass[] parameters, CtClass[] exceptions, CtClass declaring)`
Creates a public constructor that only calls a constructor in the super class.
`static CtMethod`
CtNewMethod.`make(int modifiers, CtClass returnType, String mname, CtClass[] parameters, CtClass[] exceptions, String body, CtClass declaring)`
Creates a method.
`static CtMethod`
CtNewMethod.`make(String src, CtClass declaring)`
Compiles the given source code and creates a method.
`static CtMethod`
CtNewMethod.`make(String src, CtClass declaring, String delegateObj, String delegateMethod)`
Compiles the given source code and creates a method.
`static CtMethod`
CtNewMethod.`make(CtClass returnType, String mname, CtClass[] parameters, CtClass[] exceptions, String body, CtClass declaring)`
Creates a public (non-static) method.
`CtClass`
ClassPool.`makeClass(String classname, CtClass superclass)`
Creates a new public class.
`CtClass`
ClassPool.`makeInterface(String name, CtClass superclass)`
Creates a new public interface.
`void`
ClassMap.`put(CtClass oldname, CtClass newname)`
Maps a class name to another name in this hashtable.
`void`
CodeConverter.`redirectFieldAccess(CtField field, CtClass newClass, String newFieldname)`
Modify a method body so that field read/write expressions access a different field from the original one.
`void`
CodeConverter.`replaceArrayAccess(CtClass calledClass, CodeConverter.ArrayAccessReplacementMethodNames names)`
Modify a method body, so that ALL accesses to an array are replaced with calls to static methods within another class.
`void`
CodeConverter.`replaceFieldRead(CtField field, CtClass calledClass, String calledMethod)`
Modify a method body so that an expression reading the specified field is replaced with a call to the specified static method.
`void`
CodeConverter.`replaceFieldWrite(CtField field, CtClass calledClass, String calledMethod)`
Modify a method body so that an expression writing the specified field is replaced with a call to the specified static method.
`void`
CodeConverter.`replaceNew(CtClass oldClass, CtClass newClass)`
Modify a method body so that instantiation of the class specified by `oldClass` is replaced with instantiation of another class `newClass`.
`void`
CodeConverter.`replaceNew(CtClass newClass, CtClass calledClass, String calledMethod)`
Modify a method body so that instantiation of the specified class is replaced with a call to the specified static method.
`void`
CtBehavior.`setExceptionTypes(CtClass[] types)`
Sets exceptions that this method/constructor may throw.
`void`
CtClass.`setInterfaces(CtClass[] list)`
Sets implemented interfaces.
`static void`
SerialVersionUID.`setSerialVersionUID(CtClass clazz)`
Adds serialVersionUID if one does not already exist.
`void`
CtClass.`setSuperclass(CtClass clazz)`
Changes a super class unless this object represents an interface.
`void`
CtField.`setType(CtClass clazz)`
Sets the type of the field.
`static CtConstructor`
CtNewConstructor.`skeleton(CtClass[] parameters, CtClass[] exceptions, CtClass declaring)`
Creates a public constructor that only calls a constructor in the super class.
`boolean`
CtClass.`subclassOf(CtClass superclass)`
Determines whether the class directly or indirectly extends the given class.
`boolean`
CtClass.`subtypeOf(CtClass clazz)`
Returns `true` if this class extends or implements `clazz`.
`Class`
ClassPool.`toClass(CtClass clazz)`
Converts the given class to a `java.lang.Class` object.
`Class<?>`
ClassPool.`toClass(CtClass ct, Class<?> neighbor)`
Converts the class to a `java.lang.Class` object.
`Class`
ClassPool.`toClass(CtClass ct, Class<?> neighbor, ClassLoader loader, ProtectionDomain domain)`
Converts the class to a `java.lang.Class` object.
`Class`
ClassPool.`toClass(CtClass ct, ClassLoader loader)`
Deprecated.
Replaced by `ClassPool.toClass(CtClass,Class,ClassLoader,ProtectionDomain)`.
`Class`
ClassPool.`toClass(CtClass ct, ClassLoader loader, ProtectionDomain domain)`
Deprecated.
Replaced by `ClassPool.toClass(CtClass,Class,ClassLoader,ProtectionDomain)`.
`Class<?>`
ClassPool.`toClass(CtClass ct, MethodHandles.Lookup lookup)`
Converts the class to a `java.lang.Class` object.
`CtMethod`
CtConstructor.`toMethod(String name, CtClass declaring)`
Makes a copy of this constructor and converts it into a method.
`CtMethod`
CtConstructor.`toMethod(String name, CtClass declaring, ClassMap map)`
Makes a copy of this constructor and converts it into a method.
`boolean`
CtMember.`visibleFrom(CtClass clazz)`
Returns true if this member is accessible from the given class.
`static CtMethod`
CtNewMethod.`wrapped(CtClass returnType, String mname, CtClass[] parameterTypes, CtClass[] exceptionTypes, CtMethod body, CtMethod.ConstParameter constParam, CtClass declaring)`
Creates a wrapped method.
Constructors in javassist with parameters of type CtClass
Modifier
Constructor
Description
``
`CtConstructor(CtClass[] parameters, CtClass declaring)`
Creates a constructor with no constructor body.
``
`CtConstructor(CtConstructor src, CtClass declaring, ClassMap map)`
Creates a copy of a `CtConstructor` object.
``
`CtField(CtClass type, String name, CtClass declaring)`
Creates a `CtField` object.
``
`CtField(CtField src, CtClass declaring)`
Creates a copy of the given field.
``
`CtMethod(CtClass returnType, String mname, CtClass[] parameters, CtClass declaring)`
Creates a public abstract method.
``
`CtMethod(CtMethod src, CtClass declaring, ClassMap map)`
Creates a copy of a `CtMethod` object.

## Uses of CtClass in javassist.bytecode

Fields in javassist.bytecode declared as CtClass
Modifier and Type
Field
Description
`static final CtClass`
Bytecode.`THIS`
Represents the `CtClass` file using the constant pool table given to this `Bytecode` object.
`static final CtClass`
ConstPool.`THIS`
Represents the class using this constant pool table.
Methods in javassist.bytecode that return CtClass
Modifier and Type
Method
Description
`CtClass`
SignatureAttribute.BaseType.`getCtlass()`
Returns the `CtClass` representing this primitive type.
`static CtClass[]`
Descriptor.`getParameterTypes(String desc, ClassPool cp)`
Returns the `CtClass` objects representing the parameter types specified by the given descriptor.
`static CtClass`
Descriptor.`getReturnType(String desc, ClassPool cp)`
Returns the `CtClass` object representing the return type specified by the given descriptor.
`static CtClass`
Descriptor.`toCtClass(String desc, ClassPool cp)`
Returns a `CtClass` object representing the type specified by the given descriptor.
Methods in javassist.bytecode with parameters of type CtClass
Modifier and Type
Method
Description
`void`
Bytecode.`addAnewarray(CtClass clazz, int length)`
Appends ICONST and ANEWARRAY.
`void`
Bytecode.`addCheckcast(CtClass c)`
Appends CHECKCAST.
`int`
ConstPool.`addClassInfo(CtClass c)`
Adds a new `CONSTANT_Class_info` structure.
`void`
Bytecode.`addConstZero(CtClass type)`
Appends an instruction for pushing zero or null on the stack.
`void`
Bytecode.`addExceptionHandler(int start, int end, int handler, CtClass type)`
Adds a new entry of `exception_table`.
`void`
Bytecode.`addGetfield(CtClass c, String name, String type)`
Appends GETFIELD.
`void`
Bytecode.`addGetstatic(CtClass c, String name, String type)`
Appends GETSTATIC.
`void`
Bytecode.`addInvokeinterface(CtClass clazz, String name, String desc, int count)`
Appends INVOKEINTERFACE.
`void`
Bytecode.`addInvokeinterface(CtClass clazz, String name, CtClass returnType, CtClass[] paramTypes, int count)`
Appends INVOKEINTERFACE.
`void`
Bytecode.`addInvokespecial(CtClass clazz, String name, String desc)`
Appends INVOKESPECIAL.
`void`
Bytecode.`addInvokespecial(CtClass clazz, String name, CtClass returnType, CtClass[] paramTypes)`
Appends INVOKESPECIAL.
`void`
Bytecode.`addInvokestatic(CtClass clazz, String name, String desc)`
Appends INVOKESTATIC.
`void`
Bytecode.`addInvokestatic(CtClass clazz, String name, CtClass returnType, CtClass[] paramTypes)`
Appends INVOKESTATIC.
`void`
Bytecode.`addInvokevirtual(CtClass clazz, String name, String desc)`
Appends INVOKEVIRTUAL.
`void`
Bytecode.`addInvokevirtual(CtClass clazz, String name, CtClass returnType, CtClass[] paramTypes)`
Appends INVOKEVIRTUAL.
`int`
Bytecode.`addLoad(int n, CtClass type)`
Appends an instruction for loading a value from the local variable at the index `n`.
`int`
Bytecode.`addLoadParameters(CtClass[] params, int offset)`
Appends instructions for loading all the parameters onto the operand stack.
`int`
Bytecode.`addMultiNewarray(CtClass clazz, int dim)`
Appends MULTINEWARRAY.
`int`
Bytecode.`addMultiNewarray(CtClass clazz, int[] dimensions)`
Appends MULTINEWARRAY.
`void`
Bytecode.`addNew(CtClass clazz)`
Appends NEW.
`void`
Bytecode.`addPutfield(CtClass c, String name, String desc)`
Appends PUTFIELD.
`void`
Bytecode.`addPutstatic(CtClass c, String name, String desc)`
Appends PUTSTATIC.
`void`
Bytecode.`addReturn(CtClass type)`
Appends ARETURN, IRETURN, .., or RETURN.
`int`
Bytecode.`addStore(int n, CtClass type)`
Appends an instruction for storing a value into the local variable at the index `n`.
`static String`
Descriptor.`appendParameter(CtClass type, String descriptor)`
Appends a parameter type to the parameter list represented by the given descriptor.
`static String`
Descriptor.`insertParameter(CtClass type, String descriptor)`
Inserts a parameter type at the beginning of the parameter list represented by the given descriptor.
`static String`
Descriptor.`of(CtClass type)`
Returns the descriptor representing the given type.
`static String`
Descriptor.`ofConstructor(CtClass[] paramTypes)`
Returns the descriptor representing a constructor receiving the given parameter types.
`static String`
Descriptor.`ofMethod(CtClass returnType, CtClass[] paramTypes)`
Returns the descriptor representing a method that receives the given parameter types and returns the given type.
`static String`
Descriptor.`ofParameters(CtClass[] paramTypes)`
Returns the descriptor representing a list of parameter types.
`void`
Bytecode.`setMaxLocals(boolean isStatic, CtClass[] params, int locals)`
Sets `max_locals`.
`static String`
Descriptor.`toJvmName(CtClass clazz)`
Returns the internal representation of the class name in the JVM.

## Uses of CtClass in javassist.bytecode.analysis

Methods in javassist.bytecode.analysis that return CtClass
Modifier and Type
Method
Description
`CtClass`
MultiArrayType.`getCtClass()`
`CtClass`
MultiType.`getCtClass()`
Gets the class that corresponds with this type.
`CtClass`
Type.`getCtClass()`
Returns the class this type represents.
Methods in javassist.bytecode.analysis with parameters of type CtClass
Modifier and Type
Method
Description
`Frame[]`
Analyzer.`analyze(CtClass clazz, MethodInfo method)`
Performs data-flow analysis on a method and returns an array, indexed by instruction position, containing the starting frame state of all reachable instructions.
`static Type`
Type.`get(CtClass clazz)`
Obtain the Type for a given class.
`void`
FramePrinter.`print(CtClass clazz)`
Prints all the methods declared in the given class.
`static void`
FramePrinter.`print(CtClass clazz, PrintStream stream)`
Prints all the methods declared in the given class.
Constructors in javassist.bytecode.analysis with parameters of type CtClass
Modifier
Constructor
Description
``
`ControlFlow(CtClass ctclazz, MethodInfo minfo)`
Constructs a control-flow analyzer.
Constructor parameters in javassist.bytecode.analysis with type arguments of type CtClass
Modifier
Constructor
Description
``
`MultiType(Map<String,CtClass> interfaces)`
``
`MultiType(Map<String,CtClass> interfaces, Type potentialClass)`

## Uses of CtClass in javassist.bytecode.annotation

Methods in javassist.bytecode.annotation with parameters of type CtClass
Modifier and Type
Method
Description
`static MemberValue`
Annotation.`createMemberValue(ConstPool cp, CtClass type)`
Makes an instance of `MemberValue`.
Constructors in javassist.bytecode.annotation with parameters of type CtClass
Modifier
Constructor
Description
``
`Annotation(ConstPool cp, CtClass clazz)`
Constructs an annotation that can be accessed through the interface represented by `clazz`.

## Uses of CtClass in javassist.expr

Methods in javassist.expr that return CtClass
Modifier and Type
Method
Description
`CtClass`
NewArray.`getComponentType()`
Returns the type of array components.
`CtClass`
Expr.`getEnclosingClass()`
Returns the class that declares the method enclosing this expression.
`CtClass`
Cast.`getType()`
Returns the `CtClass` object representing the type specified by the cast.
`CtClass`
Handler.`getType()`
Returns the type handled by the catch clause.
`CtClass`
Instanceof.`getType()`
Returns the `CtClass` object representing the type name on the right hand side of the instanceof operator.
`CtClass[]`
Cast.`mayThrow()`
Returns the list of exceptions that the expression may throw.
`CtClass[]`
Expr.`mayThrow()`
Returns the list of exceptions that the expression may throw.
`CtClass[]`
FieldAccess.`mayThrow()`
Returns the list of exceptions that the expression may throw.
`CtClass[]`
Handler.`mayThrow()`
Returns the list of exceptions that the catch clause may throw.
`CtClass[]`
Instanceof.`mayThrow()`
Returns the list of exceptions that the expression may throw.
`CtClass[]`
MethodCall.`mayThrow()`
Returns the list of exceptions that the expression may throw.
`CtClass[]`
NewArray.`mayThrow()`
Returns the list of exceptions that the expression may throw.
`CtClass[]`
NewExpr.`mayThrow()`
Returns the list of exceptions that the expression may throw.
Methods in javassist.expr with parameters of type CtClass
Modifier and Type
Method
Description
`boolean`
ExprEditor.`doit(CtClass clazz, MethodInfo minfo)`
Undocumented method.

## Uses of CtClass in javassist.tools.reflect

Methods in javassist.tools.reflect with parameters of type CtClass
Modifier and Type
Method
Description
`boolean`
Reflection.`makeReflective(CtClass clazz, CtClass metaobject, CtClass metaclass)`
Produces a reflective class.

## Uses of CtClass in javassist.util

Methods in javassist.util with parameters of type CtClass
Modifier and Type
Method
Description
`static void`
HotSwapAgent.`redefine(Class<?>[] oldClasses, CtClass[] newClasses)`
Redefines classes.
`static void`
HotSwapAgent.`redefine(Class<?> oldClass, CtClass newClass)`
Redefines a class.