SecureClassLoader
public abstract class ClassLoader extends Object
Every Class
object contains a reference
to the ClassLoader that defined
it.
Class objects for array classes are not created by class
loaders, but are created automatically as required by the Java runtime.
The class loader for an array class, as returned by Class.getClassLoader()
is the same as the class loader for its element
type; if the element type is a primitive type, then the array class has no
class loader.
Applications implement subclasses of ClassLoader in order to extend the manner in which the Java virtual machine dynamically loads classes.
Class loaders may typically be used by security managers to indicate security domains.
The ClassLoader class uses a delegation model to search for classes and resources. Each instance of ClassLoader has an associated parent class loader. When requested to find a class or resource, a ClassLoader instance will delegate the search for the class or resource to its parent class loader before attempting to find the class or resource itself.
Class loaders that support concurrent loading of classes are known as
parallel capable class loaders and are required to register
themselves at their class initialization time by invoking the
ClassLoader.registerAsParallelCapable
method. Note that the ClassLoader class is registered as parallel
capable by default. However, its subclasses still need to register themselves
if they are parallel capable.
In environments in which the delegation model is not strictly
hierarchical, class loaders need to be parallel capable, otherwise class
loading can lead to deadlocks because the loader lock is held for the
duration of the class loading process (see loadClass
methods).
null
, and does not have a parent.ClassLoader
instance.
Platform classes include Java SE platform APIs, their implementation
classes and JDK-specific run-time classes that are defined by the
platform class loader or its ancestors. Normally, the Java virtual machine loads classes from the local file
system in a platform-dependent manner.
However, some classes may not originate from a file; they may originate
from other sources, such as the network, or they could be constructed by an
application. The method defineClass
converts an array of bytes into an instance of class
Class. Instances of this newly defined class can be created using
Class.newInstance
.
The methods and constructors of objects created by a class loader may
reference other classes. To determine the class(es) referred to, the Java
virtual machine invokes the loadClass
method of
the class loader that originally created the class.
For example, an application could create a network class loader to download class files from a server. Sample code might look like:
ClassLoader loader = new NetworkClassLoader(host, port); Object main = loader.loadClass("Main", true).newInstance(); . . .
The network class loader subclass must define the methods findClass
and loadClassData to load a class
from the network. Once it has downloaded the bytes that make up the class,
it should use the method defineClass
to
create a class instance. A sample implementation is:
class NetworkClassLoader extends ClassLoader { String host; int port; public Class findClass(String name) { byte[] b = loadClassData(name); return defineClass(name, b, 0, b.length); } private byte[] loadClassData(String name) { // load the class data from the connection . . . } }
Any class name provided as a String
parameter to methods in
ClassLoader
must be a binary name as defined by
The Java™ Language Specification.
Examples of valid class names include:
"java.lang.String" "javax.swing.JSpinner$DefaultEditor" "java.security.KeyStore$Builder$FileBuilder$1" "java.net.URLClassLoader$3$1"
Any package name provided as a String
parameter to methods in
ClassLoader
must be either the empty string (denoting an unnamed package)
or a fully qualified name as defined by
The Java™ Language Specification.
resolveClass(Class)
Modifier | Constructor | Description |
---|---|---|
protected |
ClassLoader() |
Creates a new class loader using the ClassLoader returned by
the method
getSystemClassLoader() as the parent class loader. |
protected |
ClassLoader(ClassLoader parent) |
Creates a new class loader using the specified parent class loader for
delegation.
|
Modifier and Type | Method | Description |
---|---|---|
void |
clearAssertionStatus() |
Sets the default assertion status for this class loader to
false and discards any package defaults or class assertion
status settings associated with the class loader.
|
protected Class<?> |
defineClass(byte[] b,
int off,
int len) |
Deprecated.
Replaced by
defineClass(String, byte[], int, int) |
protected Class<?> |
defineClass(String name,
byte[] b,
int off,
int len) |
Converts an array of bytes into an instance of class
Class . |
protected Class<?> |
defineClass(String name,
byte[] b,
int off,
int len,
ProtectionDomain protectionDomain) |
Converts an array of bytes into an instance of class
Class ,
with a given ProtectionDomain . |
protected Class<?> |
defineClass(String name,
ByteBuffer b,
ProtectionDomain protectionDomain) |
|
protected Package |
definePackage(String name,
String specTitle,
String specVersion,
String specVendor,
String implTitle,
String implVersion,
String implVendor,
URL sealBase) |
Defines a package by name in this
ClassLoader . |
protected Class<?> |
findClass(String name) |
Finds the class with the specified binary name.
|
protected Class<?> |
findClass(String moduleName,
String name) |
Finds the class with the given binary name
in a module defined to this class loader.
|
protected String |
findLibrary(String libname) |
Returns the absolute path name of a native library.
|
protected Class<?> |
findLoadedClass(String name) |
Returns the class with the given binary name if this
loader has been recorded by the Java virtual machine as an initiating
loader of a class with that binary name.
|
protected URL |
findResource(String name) |
Finds the resource with the given name.
|
protected URL |
findResource(String moduleName,
String name) |
Returns a URL to a resource in a module defined to this class loader.
|
protected Enumeration<URL> |
findResources(String name) |
Returns an enumeration of
URL objects
representing all the resources with the given name. |
protected Class<?> |
findSystemClass(String name) |
Finds a class with the specified binary name,
loading it if necessary.
|
protected Object |
getClassLoadingLock(String className) |
Returns the lock object for class loading operations.
|
Package |
getDefinedPackage(String name) |
Returns a
Package of the given name that has been
defined by this class loader. |
Package[] |
getDefinedPackages() |
Returns all of the
Package s defined by this class loader. |
protected Package |
getPackage(String name) |
Deprecated.
If multiple class loaders delegate to each other and define classes
with the same package name, and one such loader relies on the lookup
behavior of
getPackage to return a Package from
a parent loader, then the properties exposed by the Package
may not be as expected in the rest of the program.
For example, the Package will only expose annotations from the
package-info.class file defined by the parent loader, even if
annotations exist in a package-info.class file defined by
a child loader. A more robust approach is to use the
getDefinedPackage(java.lang.String) method which returns
a Package for the specified class loader. |
protected Package[] |
getPackages() |
Returns all of the
Package s defined by this class loader
and its ancestors. |
ClassLoader |
getParent() |
Returns the parent class loader for delegation.
|
static ClassLoader |
getPlatformClassLoader() |
Returns the platform class loader for delegation.
|
URL |
getResource(String name) |
Finds the resource with the given name.
|
InputStream |
getResourceAsStream(String name) |
Returns an input stream for reading the specified resource.
|
Enumeration<URL> |
getResources(String name) |
Finds all the resources with the given name.
|
static ClassLoader |
getSystemClassLoader() |
Returns the system class loader for delegation.
|
static URL |
getSystemResource(String name) |
Find a resource of the specified name from the search path used to load
classes.
|
static InputStream |
getSystemResourceAsStream(String name) |
Open for reading, a resource of the specified name from the search path
used to load classes.
|
static Enumeration<URL> |
getSystemResources(String name) |
Finds all resources of the specified name from the search path used to
load classes.
|
Module |
getUnnamedModule() |
Returns the unnamed
Module for this class loader. |
Class<?> |
loadClass(String name) |
Loads the class with the specified binary name.
|
protected Class<?> |
loadClass(String name,
boolean resolve) |
Loads the class with the specified binary name.
|
protected static boolean |
registerAsParallelCapable() |
Registers the caller as parallel capable.
|
protected void |
resolveClass(Class<?> c) |
Links the specified class.
|
Stream<URL> |
resources(String name) |
Returns a stream whose elements are the URLs of all the resources with
the given name.
|
void |
setClassAssertionStatus(String className,
boolean enabled) |
Sets the desired assertion status for the named top-level class in this
class loader and any nested classes contained therein.
|
void |
setDefaultAssertionStatus(boolean enabled) |
Sets the default assertion status for this class loader.
|
void |
setPackageAssertionStatus(String packageName,
boolean enabled) |
Sets the package default assertion status for the named package.
|
protected void |
setSigners(Class<?> c,
Object[] signers) |
Sets the signers of a class.
|
protected ClassLoader()
getSystemClassLoader()
as the parent class loader.
If there is a security manager, its checkCreateClassLoader
method is invoked. This may result in
a security exception.
SecurityException
- If a security manager exists and its
checkCreateClassLoader method doesn't allow creation
of a new class loader.protected ClassLoader(ClassLoader parent)
If there is a security manager, its checkCreateClassLoader
method is invoked. This may result in
a security exception.
parent
- The parent class loaderSecurityException
- If a security manager exists and its
checkCreateClassLoader method doesn't allow creation
of a new class loader.public Class<?> loadClass(String name) throws ClassNotFoundException
loadClass(String, boolean)
method. It is invoked by the Java virtual
machine to resolve class references. Invoking this method is equivalent
to invoking loadClass(name,
false)
.name
- The binary name of the classClassNotFoundException
- If the class was not foundprotected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException
Invoke findLoadedClass(String)
to check if the class
has already been loaded.
Invoke the loadClass
method
on the parent class loader. If the parent is null the class
loader built-in to the virtual machine is used, instead.
Invoke the findClass(String)
method to find the
class.
If the class was found using the above steps, and the
resolve flag is true, this method will then invoke the resolveClass(Class)
method on the resulting Class object.
Subclasses of ClassLoader are encouraged to override findClass(String)
, rather than this method.
Unless overridden, this method synchronizes on the result of
getClassLoadingLock
method
during the entire class loading process.
name
- The binary name of the classresolve
- If true then resolve the classClassNotFoundException
- If the class could not be foundprotected Object getClassLoadingLock(String className)
className
- The name of the to-be-loaded classNullPointerException
- If registered as parallel capable and className is nullloadClass(String, boolean)
protected Class<?> findClass(String name) throws ClassNotFoundException
loadClass
method after checking the
parent class loader for the requested class. The default implementation
throws a ClassNotFoundException.name
- The binary name of the classClassNotFoundException
- If the class could not be foundprotected Class<?> findClass(String moduleName, String name)
null
rather than throwing
ClassNotFoundException
if the class could not be foundnull
.moduleName
- The module namename
- The binary name of the classClass
object, or null
if the class could not be found.@Deprecated(since="1.1") protected final Class<?> defineClass(byte[] b, int off, int len) throws ClassFormatError
defineClass(String, byte[], int, int)
b
- The bytes that make up the class data. The bytes in positions
off through off+len-1 should have the format
of a valid class file as defined by
The Java™ Virtual Machine Specification.off
- The start offset in b of the class datalen
- The length of the class dataClassFormatError
- If the data did not contain a valid classIndexOutOfBoundsException
- If either off or len is negative, or if
off+len is greater than b.length.SecurityException
- If an attempt is made to add this class to a package that
contains classes that were signed by a different set of
certificates than this class, or if an attempt is made
to define a class in a package with a fully-qualified name
that starts with "java.
".loadClass(String, boolean)
,
resolveClass(Class)
protected final Class<?> defineClass(String name, byte[] b, int off, int len) throws ClassFormatError
Class
.
Before the Class
can be used it must be resolved.
This method assigns a default ProtectionDomain
to the newly defined class. The
ProtectionDomain
is effectively granted the same set of
permissions returned when Policy.getPolicy().getPermissions(new CodeSource(null, null))
is invoked. The default protection domain is created on the first invocation
of defineClass
,
and re-used on subsequent invocations.
To assign a specific ProtectionDomain
to the class, use
the defineClass
method that takes a
ProtectionDomain
as one of its arguments.
This method defines a package in this class loader corresponding to the
package of the Class
(if such a package has not already been defined
in this class loader). The name of the defined package is derived from
the binary name of the class specified by
the byte array b
.
Other properties of the defined package are as specified by Package
.
name
- The expected binary name of the class, or
null
if not knownb
- The bytes that make up the class data. The bytes in positions
off
through off+len-1
should have the format
of a valid class file as defined by
The Java™ Virtual Machine Specification.off
- The start offset in b
of the class datalen
- The length of the class dataClass
object that was created from the specified
class data.ClassFormatError
- If the data did not contain a valid classIndexOutOfBoundsException
- If either off
or len
is negative, or if
off+len
is greater than b.length
.SecurityException
- If an attempt is made to add this class to a package that
contains classes that were signed by a different set of
certificates than this class (which is unsigned), or if
name
begins with "java.
".loadClass(String, boolean)
,
resolveClass(Class)
,
CodeSource
,
SecureClassLoader
protected final Class<?> defineClass(String name, byte[] b, int off, int len, ProtectionDomain protectionDomain) throws ClassFormatError
Class
,
with a given ProtectionDomain
.
If the given ProtectionDomain
is null
,
then a default protection domain will be assigned to the class as specified
in the documentation for defineClass(String, byte[], int, int)
.
Before the class can be used it must be resolved.
The first class defined in a package determines the exact set of
certificates that all subsequent classes defined in that package must
contain. The set of certificates for a class is obtained from the
CodeSource
within the
ProtectionDomain
of the class. Any classes added to that
package must contain the same set of certificates or a
SecurityException
will be thrown. Note that if
name
is null
, this check is not performed.
You should always pass in the binary name of the
class you are defining as well as the bytes. This ensures that the
class you are defining is indeed the class you think it is.
If the specified name
begins with "java.
", it can
only be defined by the platform class loader or its ancestors; otherwise SecurityException
will be thrown. If name
is not null
, it must be equal to
the binary name of the class
specified by the byte array b
, otherwise a NoClassDefFoundError
will be thrown.
This method defines a package in this class loader corresponding to the
package of the Class
(if such a package has not already been defined
in this class loader). The name of the defined package is derived from
the binary name of the class specified by
the byte array b
.
Other properties of the defined package are as specified by Package
.
name
- The expected binary name of the class, or
null
if not knownb
- The bytes that make up the class data. The bytes in positions
off
through off+len-1
should have the format
of a valid class file as defined by
The Java™ Virtual Machine Specification.off
- The start offset in b
of the class datalen
- The length of the class dataprotectionDomain
- The ProtectionDomain
of the classClass
object created from the data,
and ProtectionDomain
.ClassFormatError
- If the data did not contain a valid classNoClassDefFoundError
- If name
is not null
and not equal to the
binary name of the class specified by b
IndexOutOfBoundsException
- If either off
or len
is negative, or if
off+len
is greater than b.length
.SecurityException
- If an attempt is made to add this class to a package that
contains classes that were signed by a different set of
certificates than this class, or if name
begins with
"java.
" and this class loader is not the platform
class loader or its ancestor.protected final Class<?> defineClass(String name, ByteBuffer b, ProtectionDomain protectionDomain) throws ClassFormatError
ByteBuffer
into an instance
of class Class
, with the given ProtectionDomain
.
If the given ProtectionDomain
is null
, then a default
protection domain will be assigned to the class as
specified in the documentation for defineClass(String, byte[],
int, int)
. Before the class can be used it must be resolved.
The rules about the first class defined in a package determining the
set of certificates for the package, the restrictions on class names,
and the defined package of the class
are identical to those specified in the documentation for defineClass(String, byte[], int, int, ProtectionDomain)
.
An invocation of this method of the form cl.defineClass(name, bBuffer, pd) yields exactly the same result as the statements
...
byte[] temp = new byte[bBuffer.remaining
()];
bBuffer.get
(temp);
return cl.defineClass
(name, temp, 0,
temp.length, pd);
name
- The expected binary name. of the class, or
null if not knownb
- The bytes that make up the class data. The bytes from positions
b.position() through b.position() + b.limit() -1
should have the format of a valid class file as defined by
The Java™ Virtual Machine Specification.protectionDomain
- The ProtectionDomain
of the class, or null
.Class
object created from the data,
and ProtectionDomain
.ClassFormatError
- If the data did not contain a valid class.NoClassDefFoundError
- If name
is not null
and not equal to the
binary name of the class specified by b
SecurityException
- If an attempt is made to add this class to a package that
contains classes that were signed by a different set of
certificates than this class, or if name
begins with
"java.
".defineClass(String, byte[], int, int, ProtectionDomain)
protected final void resolveClass(Class<?> c)
c
- The class to linkNullPointerException
- If c is null.defineClass(String, byte[], int, int)
protected final Class<?> findSystemClass(String name) throws ClassNotFoundException
This method loads the class through the system class loader (see
getSystemClassLoader()
). The Class object returned
might have more than one ClassLoader associated with it.
Subclasses of ClassLoader need not usually invoke this method,
because most class loaders need to override just findClass(String)
.
name
- The binary name of the classClassNotFoundException
- If the class could not be foundClassLoader(ClassLoader)
,
getParent()
protected final Class<?> findLoadedClass(String name)
name
- The binary name of the classprotected final void setSigners(Class<?> c, Object[] signers)
c
- The Class objectsigners
- The signers for the classprotected URL findResource(String moduleName, String name) throws IOException
null
.moduleName
- The module namename
- The resource namenull
if the resource could not be
found, a URL could not be constructed to locate the resource,
access to the resource is denied by the security manager, or
there isn't a module of the given name defined to the class
loader.IOException
- If I/O errors occurModuleReader.find(String)
public URL getResource(String name)
The name of a resource is a '/'-separated path name that identifies the resource.
This method will first search the parent class loader for the
resource; if the parent is null the path of the class loader
built-in to the virtual machine is searched. That failing, this method
will invoke findResource(String)
to find the resource.
getResources(String)
method.name
- The resource namepublic Enumeration<URL> getResources(String name) throws IOException
The name of a resource is a /-separated path name that identifies the resource.
The search order is described in the documentation for getResource(String)
.
getResource(String)
method. This should
ensure that the first element returned by the Enumeration's
nextElement
method is the same resource that the
getResource(String)
method would return.name
- The resource nameURL
objects for
the resource. If no resources could be found, the enumeration
will be empty. Resources that the class loader doesn't have
access to will not be in the enumeration.IOException
- If I/O errors occurfindResources(String)
public Stream<URL> resources(String name)
The name of a resource is a /
-separated path name that
identifies the resource.
The search order is described in the documentation for getResource(String)
.
The resources will be located when the returned stream is evaluated.
If the evaluation results in an IOException
then the I/O
exception is wrapped in an UncheckedIOException
that is then
thrown.
getResource(String)
method. This should
ensure that the first element returned by the stream is the same
resource that the getResource(String)
method would return.name
- The resource nameURL
objects. If no
resources could be found, the stream will be empty. Resources
that the class loader doesn't have access to will not be in the
stream.findResources(String)
protected URL findResource(String name)
name
- The resource nameprotected Enumeration<URL> findResources(String name) throws IOException
URL
objects
representing all the resources with the given name. Class loader
implementations should override this method to specify where to load
resources from.
Resources in a named module are private to that module. This method does
not find resources in named modules defined to this class loader.name
- The resource nameURL
objects for
the resourcesIOException
- If I/O errors occurprotected static boolean registerAsParallelCapable()
Note that once a class loader is registered as parallel capable, there is no way to change it back.
public static URL getSystemResource(String name)
getSystemClassLoader()
).
Resources in a named module are private to that module. This method does
not find resources in named modules.name
- The resource nameURL
object for reading the
resource, or null if the resource could not be foundpublic static Enumeration<URL> getSystemResources(String name) throws IOException
Enumeration
of URL
objects.
Resources in a named module are private to that module. This method does
not find resources in named modules.
The search order is described in the documentation for getSystemResource(String)
.
name
- The resource nameURL
objectsIOException
- If I/O errors occurpublic InputStream getResourceAsStream(String name)
The search order is described in the documentation for getResource(String)
.
name
- The resource namepublic static InputStream getSystemResourceAsStream(String name)
getSystemClassLoader()
).
Resources in a named module are private to that module. This method does
not find resources in named modules.name
- The resource namepublic final ClassLoader getParent()
SecurityException
- If a security manager is present, and the caller's class loader
is not null
and is not an ancestor of this class loader,
and the caller does not have the
RuntimePermission
("getClassLoader")
public final Module getUnnamedModule()
Module
for this class loader.Module.isNamed()
public static ClassLoader getPlatformClassLoader()
ClassLoader
.SecurityException
- If a security manager is present, and the caller's class loader is
not null
, and the caller's class loader is not the same
as or an ancestor of the platform class loader,
and the caller does not have the
RuntimePermission
("getClassLoader")
public static ClassLoader getSystemClassLoader()
This method is first invoked early in the runtime's startup
sequence, at which point it creates the system class loader. This
class loader will be the context class loader for the main application
thread (for example, the thread that invokes the main
method of
the main class).
The default system class loader is an implementation-dependent instance of this class.
If the system property "java.system.class.loader" is defined
when this method is first invoked then the value of that property is
taken to be the name of a class that will be returned as the system
class loader. The class is loaded using the default system class loader
and must define a public constructor that takes a single parameter of
type ClassLoader which is used as the delegation parent. An
instance is then created using this constructor with the default system
class loader as the parameter. The resulting class loader is defined
to be the system class loader. During construction, the class loader
should take great care to avoid calling getSystemClassLoader()
.
If circular initialization of the system class loader is detected then
an unspecified error or exception is thrown.
SecurityException
- If a security manager is present, and the caller's class loader
is not null
and is not the same as or an ancestor of the
system class loader, and the caller does not have the
RuntimePermission
("getClassLoader")
IllegalStateException
- If invoked recursively during the construction of the class
loader specified by the "java.system.class.loader"
property.Error
- If the system property "java.system.class.loader"
is defined but the named class could not be loaded, the
provider class does not define the required constructor, or an
exception is thrown by that constructor when it is invoked. The
underlying cause of the error can be retrieved via the
Throwable.getCause()
method.protected Package definePackage(String name, String specTitle, String specVersion, String specVendor, String implTitle, String implVersion, String implVendor, URL sealBase)
ClassLoader
.
Package names must be unique within a class loader and cannot be redefined or changed once created.
If a class loader wishes to define a package with specific properties,
such as version information, then the class loader should call this
definePackage
method before calling defineClass
.
Otherwise, the
defineClass
method will define a package in this class loader corresponding to the package
of the newly defined class; the properties of this defined package are
specified by Package
.
URL
of the JAR file is typically used as the sealBase
.
If classes of package 'p'
defined by this class loader
are loaded from multiple JARs, the Package
object may contain
different information depending on the first class of package 'p'
defined and which JAR's manifest is read first to explicitly define
package 'p'
.
It is strongly recommended that a class loader does not call this
method to explicitly define packages in named modules; instead,
the package will be automatically defined when a class is being defined.
If it is desirable to define Package
explicitly, it should ensure
that all packages in a named module are defined with the properties
specified by Package
. Otherwise, some Package
objects
in a named module may be for example sealed with different seal base.
name
- The package namespecTitle
- The specification titlespecVersion
- The specification versionspecVendor
- The specification vendorimplTitle
- The implementation titleimplVersion
- The implementation versionimplVendor
- The implementation vendorsealBase
- If not null
, then this package is sealed with
respect to the given code source URL
object. Otherwise, the package is not sealed.Package
objectNullPointerException
- if name
is null
.IllegalArgumentException
- if a package of the given name
is already
defined by this class loaderpublic final Package getDefinedPackage(String name)
Package
of the given name that has been
defined by this class loader.name
- The package namePackage
of the given name defined by this class loader,
or null
if not foundNullPointerException
- if name
is null
.public final Package[] getDefinedPackages()
Package
s defined by this class loader.
The returned array has no duplicated Package
s of the same name.Set
or Stream
for consistency with the existing getPackages()
method.Package
objects defined by this class loader;
or an zero length array if no package has been defined by this class loader.@Deprecated(since="9") protected Package getPackage(String name)
getPackage
to return a Package
from
a parent loader, then the properties exposed by the Package
may not be as expected in the rest of the program.
For example, the Package
will only expose annotations from the
package-info.class
file defined by the parent loader, even if
annotations exist in a package-info.class
file defined by
a child loader. A more robust approach is to use the
getDefinedPackage(java.lang.String)
method which returns
a Package
for the specified class loader.
If this class loader defines a Package
of the given name,
the Package
is returned. Otherwise, the ancestors of
this class loader are searched recursively (parent by parent)
for a Package
of the given name.
name
- The package namePackage
corresponding to the given name defined by
this class loader or its ancestors, or null
if not found.NullPointerException
- if name
is null
.protected Package[] getPackages()
Package
s defined by this class loader
and its ancestors. The returned array may contain more than one
Package
object of the same package name, each defined by
a different class loader in the class loader hierarchy.Package
objects defined by this
class loader and its ancestorsprotected String findLibrary(String libname)
libname
- The library nameSystem.loadLibrary(String)
,
System.mapLibraryName(String)
public void setDefaultAssertionStatus(boolean enabled)
setPackageAssertionStatus(String, boolean)
or setClassAssertionStatus(String, boolean)
.enabled
- true if classes loaded by this class loader will
henceforth have assertions enabled by default, false
if they will have assertions disabled by default.public void setPackageAssertionStatus(String packageName, boolean enabled)
A subpackage of a package named p is any package whose name begins with "p.". For example, javax.swing.text is a subpackage of javax.swing, and both java.util and java.lang.reflect are subpackages of java.
In the event that multiple package defaults apply to a given class, the package default pertaining to the most specific package takes precedence over the others. For example, if javax.lang and javax.lang.reflect both have package defaults associated with them, the latter package default applies to classes in javax.lang.reflect.
Package defaults take precedence over the class loader's default
assertion status, and may be overridden on a per-class basis by invoking
setClassAssertionStatus(String, boolean)
.
packageName
- The name of the package whose package default assertion status
is to be set. A null value indicates the unnamed
package that is "current"
(see section 7.4.2 of
The Java™ Language Specification.)enabled
- true if classes loaded by this classloader and
belonging to the named package or any of its subpackages will
have assertions enabled by default, false if they will
have assertions disabled by default.public void setClassAssertionStatus(String className, boolean enabled)
If the named class is not a top-level class, this invocation will have no effect on the actual assertion status of any class.
className
- The fully qualified class name of the top-level class whose
assertion status is to be set.enabled
- true if the named class is to have assertions
enabled when (and if) it is initialized, false if the
class is to have assertions disabled.public void clearAssertionStatus()
Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2016, Oracle and/or its affiliates. All rights reserved.
DRAFT 9-internal+0-2016-10-04-161205.jjg.dev.8159855.tools-spi