@Exported public interface ClassType extends ReferenceType
ReferenceType that applies to true classes in the JLS
 sense of the definition (not an interface, not an array type). Any
 ObjectReference that mirrors an instance of such a class
 will have a ClassType as its type.ObjectReference| Modifier and Type | Field and Description | 
|---|---|
| static int | INVOKE_SINGLE_THREADEDPerform method invocation with only the invoking thread resumed | 
| Modifier and Type | Method and Description | 
|---|---|
| List<InterfaceType> | allInterfaces()Gets the interfaces directly and indirectly implemented
 by this class. | 
| Method | concreteMethodByName(String name,
                    String signature)Returns a the single non-abstract  Methodvisible from
 this class that has the given name and signature. | 
| List<InterfaceType> | interfaces()Gets the interfaces directly implemented by this class. | 
| Value | invokeMethod(ThreadReference thread,
            Method method,
            List<? extends Value> arguments,
            int options)Invokes the specified static  Methodin the
 target VM. | 
| boolean | isEnum()Determine if this class was declared as an enum. | 
| ObjectReference | newInstance(ThreadReference thread,
           Method method,
           List<? extends Value> arguments,
           int options)Constructs a new instance of this type, using
 the given constructor  Methodin the
 target VM. | 
| void | setValue(Field field,
        Value value)Assigns a value to a static field. | 
| List<ClassType> | subclasses()Gets the currently loaded, direct subclasses of this class. | 
| ClassType | superclass()Gets the superclass of this class. | 
allFields, allLineLocations, allLineLocations, allMethods, availableStrata, classLoader, classObject, constantPool, constantPoolCount, defaultStratum, equals, failedToInitialize, fieldByName, fields, genericSignature, getValue, getValues, hashCode, instances, isAbstract, isFinal, isInitialized, isPrepared, isStatic, isVerified, locationsOfLine, locationsOfLine, majorVersion, methods, methodsByName, methodsByName, minorVersion, name, nestedTypes, sourceDebugExtension, sourceName, sourceNames, sourcePaths, visibleFields, visibleMethodstoString, virtualMachinecompareToisPackagePrivate, isPrivate, isProtected, isPublic, modifiersstatic final int INVOKE_SINGLE_THREADED
ClassType superclass()
ClassType that mirrors the superclass
 of this class in the target VM. If no such class exists,
 returns nullList<InterfaceType> interfaces()
InterfaceType objects each mirroring
 a direct interface this ClassType in the target VM.
 If none exist, returns a zero length List.ClassNotPreparedException - if this class not yet been
 prepared.List<InterfaceType> allInterfaces()
interfaces()
 are returned as well all superinterfaces.InterfaceType objects each mirroring
 an interface of this ClassType in the target VM.
 If none exist, returns a zero length List.ClassNotPreparedException - if this class not yet been
 prepared.List<ClassType> subclasses()
ClassType objects each mirroring a loaded
 subclass of this class in the target VM. If no such classes
 exist, this method returns a zero-length list.boolean isEnum()
true if this class was declared as an enum; false
 otherwise.void setValue(Field field, Value value) throws InvalidTypeException, ClassNotLoadedException
Field must be valid for this ClassType; that is,
 it must be from the mirrored object's class or a superclass of that class.
 The field must not be final.
 Object values must be assignment compatible with the field type (This implies that the field type must be loaded through the enclosing class' class loader). Primitive values must be either assignment compatible with the field type or must be convertible to the field type without loss of information. See JLS section 5.2 for more information on assignment compatibility.
field - the field to set.value - the value to be assigned.IllegalArgumentException - if the field is
 not static, the field is final, or the field does not exist
 in this class.ClassNotLoadedException - if the field type has not yet been loaded
 through the appropriate class loader.InvalidTypeException - if the value's type does not match
 the field's declared type.VMCannotBeModifiedException - if the VirtualMachine is read-only - see VirtualMachine.canBeModified().Value invokeMethod(ThreadReference thread, Method method, List<? extends Value> arguments, int options) throws InvalidTypeException, ClassNotLoadedException, IncompatibleThreadStateException, InvocationException
Method in the
 target VM. The
 specified method can be defined in this class,
 or in a superclass.
 The method must be a static method
 but not a static initializer.
 Use newInstance(com.sun.jdi.ThreadReference, com.sun.jdi.Method, java.util.List<? extends com.sun.jdi.Value>, int) to create a new object and
 run its constructor.
 
 The method invocation will occur in the specified thread.
 Method invocation can occur only if the specified thread
 has been suspended by an event which occurred in that thread.
 Method invocation is not supported
 when the target VM has been suspended through
 VirtualMachine.suspend() or when the specified thread
 is suspended through ThreadReference.suspend().
 
 The specified method is invoked with the arguments in the specified
 argument list.  The method invocation is synchronous; this method
 does not return until the invoked method returns in the target VM.
 If the invoked method throws an exception, this method will throw
 an InvocationException which contains a mirror to the exception
 object thrown.
 
Object arguments must be assignment compatible with the argument type (This implies that the argument type must be loaded through the enclosing class' class loader). Primitive arguments must be either assignment compatible with the argument type or must be convertible to the argument type without loss of information. If the method being called accepts a variable number of arguments, then the last argument type is an array of some component type. The argument in the matching position can be omitted, or can be null, an array of the same component type, or an argument of the component type followed by any number of other arguments of the same type. If the argument is omitted, then a 0 length array of the component type is passed. The component type can be a primitive type. Autoboxing is not supported. See Section 5.2 of The Java™ Language Specification for more information on assignment compatibility.
 By default, all threads in the target VM are resumed while
 the method is being invoked if they were previously
 suspended by an event or by VirtualMachine.suspend() or
 ThreadReference.suspend(). This is done to prevent the deadlocks
 that will occur if any of the threads own monitors
 that will be needed by the invoked method.
 Note, however, that this implicit resume acts exactly like
 ThreadReference.resume(), so if the thread's suspend
 count is greater than 1, it will remain in a suspended state
 during the invocation and thus a deadlock could still occur.
 By default, when the invocation completes,
 all threads in the target VM are suspended, regardless their state
 before the invocation.
 It is possible that
 breakpoints or other events might occur during the invocation.
 This can cause deadlocks as described above. It can also cause a deadlock
 if invokeMethod is called from the client's event handler thread.  In this
 case, this thread will be waiting for the invokeMethod to complete and
 won't read the EventSet that comes in for the new event.  If this
 new EventSet is SUSPEND_ALL, then a deadlock will occur because no
 one will resume the EventSet.  To avoid this, all EventRequests should
 be disabled before doing the invokeMethod, or the invokeMethod should
 not be done from the client's event handler thread.
 
 The resumption of other threads during the invocation can be prevented
 by specifying the INVOKE_SINGLE_THREADED
 bit flag in the options argument; however,
 there is no protection against or recovery from the deadlocks
 described above, so this option should be used with great caution.
 Only the specified thread will be resumed (as described for all
 threads above). Upon completion of a single threaded invoke, the invoking thread
 will be suspended once again. Note that any threads started during
 the single threaded invocation will not be suspended when the
 invocation completes.
 
 If the target VM is disconnected during the invoke (for example, through
 VirtualMachine.dispose()) the method invocation continues.
thread - the thread in which to invoke.method - the Method to invoke.arguments - the list of Value arguments bound to the
 invoked method. Values from the list are assigned to arguments
 in the order they appear in the method signature.options - the integer bit flag options.Value mirror of the invoked method's return value.IllegalArgumentException - if the method is not
 a member of this class or a superclass, if the size of the argument list
 does not match the number of declared arguments for the method, or
 if the method is an initializer, constructor or static intializer.{@link - InvalidTypeException} if any argument in the
 argument list is not assignable to the corresponding method argument
 type.ClassNotLoadedException - if any argument type has not yet been loaded
 through the appropriate class loader.IncompatibleThreadStateException - if the specified thread has not
 been suspended by an event.InvocationException - if the method invocation resulted in
 an exception in the target VM.InvalidTypeException - If the arguments do not meet this requirement --
         Object arguments must be assignment compatible with the argument
         type.  This implies that the argument type must be
         loaded through the enclosing class' class loader.
         Primitive arguments must be either assignment compatible with the
         argument type or must be convertible to the argument type without loss
         of information. See JLS section 5.2 for more information on assignment
         compatibility.VMCannotBeModifiedException - if the VirtualMachine is read-only - see VirtualMachine.canBeModified().ObjectReference newInstance(ThreadReference thread, Method method, List<? extends Value> arguments, int options) throws InvalidTypeException, ClassNotLoadedException, IncompatibleThreadStateException, InvocationException
Method in the
 target VM. The
 specified constructor must be defined in this class.
 
 Instance creation will occur in the specified thread.
 Instance creation can occur only if the specified thread
 has been suspended by an event which occurred in that thread.
 Instance creation is not supported
 when the target VM has been suspended through
 VirtualMachine.suspend() or when the specified thread
 is suspended through ThreadReference.suspend().
 
 The specified constructor is invoked with the arguments in the specified
 argument list.  The invocation is synchronous; this method
 does not return until the constructor returns in the target VM.
 If the invoked method throws an
 exception, this method will throw an InvocationException
 which contains a mirror to the exception object thrown.
 
Object arguments must be assignment compatible with the argument type (This implies that the argument type must be loaded through the enclosing class' class loader). Primitive arguments must be either assignment compatible with the argument type or must be convertible to the argument type without loss of information. If the method being called accepts a variable number of arguments, then the last argument type is an array of some component type. The argument in the matching position can be omitted, or can be null, an array of the same component type, or an argument of the component type, followed by any number of other arguments of the same type. If the argument is omitted, then a 0 length array of the component type is passed. The component type can be a primitive type. Autoboxing is not supported. See section 5.2 of The Java™ Language Specification for more information on assignment compatibility.
 By default, all threads in the target VM are resumed while
 the method is being invoked if they were previously
 suspended by an event or by VirtualMachine.suspend() or
 ThreadReference.suspend(). This is done to prevent the deadlocks
 that will occur if any of the threads own monitors
 that will be needed by the invoked method. It is possible that
 breakpoints or other events might occur during the invocation.
 Note, however, that this implicit resume acts exactly like
 ThreadReference.resume(), so if the thread's suspend
 count is greater than 1, it will remain in a suspended state
 during the invocation. By default, when the invocation completes,
 all threads in the target VM are suspended, regardless their state
 before the invocation.
 
 The resumption of other threads during the invocation can be prevented
 by specifying the INVOKE_SINGLE_THREADED
 bit flag in the options argument; however,
 there is no protection against or recovery from the deadlocks
 described above, so this option should be used with great caution.
 Only the specified thread will be resumed (as described for all
 threads above). Upon completion of a single threaded invoke, the invoking thread
 will be suspended once again. Note that any threads started during
 the single threaded invocation will not be suspended when the
 invocation completes.
 
 If the target VM is disconnected during the invoke (for example, through
 VirtualMachine.dispose()) the method invocation continues.
thread - the thread in which to invoke.method - the constructor Method to invoke.arguments - the list of Value arguments bound to the
 invoked constructor. Values from the list are assigned to arguments
 in the order they appear in the constructor signature.options - the integer bit flag options.ObjectReference mirror of the newly created
 object.IllegalArgumentException - if the method is not
 a member of this class, if the size of the argument list
 does not match the number of declared arguments for the constructor,
 or if the method is not a constructor.{@link - InvalidTypeException} if any argument in the
 argument list is not assignable to the corresponding method argument
 type.ClassNotLoadedException - if any argument type has not yet been loaded
 through the appropriate class loader.IncompatibleThreadStateException - if the specified thread has not
 been suspended by an event.InvocationException - if the method invocation resulted in
 an exception in the target VM.InvalidTypeException - If the arguments do not meet this requirement --
         Object arguments must be assignment compatible with the argument
         type.  This implies that the argument type must be
         loaded through the enclosing class' class loader.
         Primitive arguments must be either assignment compatible with the
         argument type or must be convertible to the argument type without loss
         of information. See JLS section 5.2 for more information on assignment
         compatibility.VMCannotBeModifiedException - if the VirtualMachine is read-only
 - see VirtualMachine.canBeModified().Method concreteMethodByName(String name, String signature)
Method visible from
 this class that has the given name and signature.
 See ReferenceType.methodsByName(java.lang.String, java.lang.String)
 for information on signature format.
 
 The returned method (if non-null) is a component of
 ClassType.
name - the name of the method to find.signature - the signature of the method to findMethod that matches the given
 name and signature or null if there is no match.ClassNotPreparedException - if methods are not yet available
 because the class has not yet been prepared.ReferenceType.visibleMethods(), 
ReferenceType.methodsByName(java.lang.String name), 
ReferenceType.methodsByName(java.lang.String name, java.lang.String signature)
 Copyright © 1999, 2025, Oracle and/or its affiliates.  All rights reserved.