Class ClassLoader

java.lang.Object
java.lang.ClassLoader
Direct Known Subclasses:
SecureClassLoader
public abstract classClassLoaderextendsObject
A class loader is an object that is responsible for loading classes. TheclassClassLoader is an abstract class. Given thebinary name of a class, a class loader should attempt tolocate or generate data that constitutes a definition for the class. Atypical strategy is to transform the name into a file name and then read a"class file" of that name from a file system.

EveryClass object contains areference to theClassLoader that definedit.

Class objects for array classes are not created by classloaders, but are created automatically as required by the Java runtime.The class loader for an array class, as returned byClass.getClassLoader() is the same as the class loader for its elementtype; if the element type is a primitive type, then the array class has noclass loader.

Applications implement subclasses ofClassLoader in order toextend the manner in which the Java virtual machine dynamically loadsclasses.

In addition to loading classes, a class loader is also responsible forlocating resources. A resource is some data (a ".class" file,configuration data, or an image for example) that is identified with anabstract '/'-separated path name. Resources are typically packaged with anapplication or library so that they can be located by code in theapplication or library. In some cases, the resources are included so thatthey can be located by other libraries.

TheClassLoader class uses a delegation model to search forclasses and resources. Each instance ofClassLoader has anassociated parent class loader. When requested to find a class orresource, aClassLoader instance will usually delegate the searchfor the class or resource to its parent class loader before attempting tofind the class or resource itself.

Class loaders that support concurrent loading of classes are known asparallel capable classloaders and are required to register themselves at their class initializationtime by invoking theClassLoader.registerAsParallelCapablemethod. Note that theClassLoader class is registered as parallelcapable by default. However, its subclasses still need to register themselvesif they are parallel capable.In environments in which the delegation model is not strictlyhierarchical, class loaders need to be parallel capable, otherwise classloading can lead to deadlocks because the loader lock is held for theduration of the class loading process (seeloadClass methods).

Run-time Built-in Class Loaders

The Java run-time has the following built-in class loaders:

  • Bootstrap class loader. It is the virtual machine's built-in class loader, typically represented asnull, and does not have a parent.

  • Platform class loader. The platform class loader is responsible for loading theplatform classes. 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. The platform class loader can be used as the parent of aClassLoader instance.

    To allow for upgrading/overriding of modules defined to the platform class loader, and where upgraded modules read modules defined to class loaders other than the platform class loader and its ancestors, then the platform class loader may have to delegate to other class loaders, the application class loader for example. In other words, classes in named modules defined to class loaders other than the platform class loader and its ancestors may be visible to the platform class loader.

  • System class loader. It is also known asapplication class loader and is distinct from the platform class loader. The system class loader is typically used to define classes on the application class path, module path, and JDK-specific tools. The platform class loader is the parent or an ancestor of the system class loader, so the system class loader can load platform classes by delegating to its parent.

Normally, the Java virtual machine loads classes from the local filesystem in a platform-dependent manner.However, some classes may not originate from a file; they may originatefrom other sources, such as the network, or they could be constructed by anapplication. The methoddefineClass converts an array of bytes into an instance of classClass. Instances of this newly defined class can be created usingClass.newInstance.

The methods and constructors of objects created by a class loader mayreference other classes. To determine the class(es) referred to, the Javavirtual machine invokes theloadClass method ofthe class loader that originally created the class.

For example, an application could create a network class loader todownload 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 methodsfindClass andloadClassData to load a classfrom the network. Once it has downloaded the bytes that make up the class,it should use the methoddefineClass tocreate 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             . . .        }    }

Binary names

Any class name provided as aString parameter to methods inClassLoader must be a binary name as defined byThe 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 aString parameter to methods inClassLoader must be either the empty string (denoting an unnamed package)or a fully qualified name as defined byThe Java Language Specification.

SeeJava Language Specification:
6.7 Fully Qualified Names and Canonical Names
13.1 The Form of a Binary
Since:
1.0
See Also:

  • Constructor Details

    • ClassLoader

      protected ClassLoader(String name,ClassLoader parent)
      Creates a new class loader of the specified name and using thespecified parent class loader for delegation.
      API Note:
      If the parent is specified asnull (for thebootstrap class loader) then there is no guarantee that all platformclasses are visible.
      Parameters:
      name - class loader name; ornull if not named
      parent - the parent class loader
      Throws:
      IllegalArgumentException - if the given name is empty.
      Since:
      9

    • ClassLoader

      protected ClassLoader(ClassLoader parent)
      Creates a new class loader using the specified parent class loader fordelegation.
      API Note:
      If the parent is specified asnull (for thebootstrap class loader) then there is no guarantee that all platformclasses are visible.
      Parameters:
      parent - The parent class loader
      Since:
      1.2

    • ClassLoader

      protected ClassLoader()
      Creates a new class loader using theClassLoader returned bythe methodgetSystemClassLoader() as the parent class loader.

  • Method Details

    • getName

      public String getName()
      Returns the name of this class loader ornull ifthis class loader is not named.
      API Note:
      This method is non-final for compatibility. If thismethod is overridden, this method must return the same nameas specified when this class loader was instantiated.
      Returns:
      name of this class loader; ornull ifthis class loader is not named.
      Since:
      9

    • loadClass

      public Class<?> loadClass(String name) throwsClassNotFoundException
      Loads the class with the specifiedbinary name.This method searches for classes in the same manner as theloadClass(String, boolean) method. It is invoked by the Java virtualmachine to resolve class references. Invoking this method is equivalentto invokingloadClass(name,false).
      Parameters:
      name - Thebinary name of the class
      Returns:
      The resultingClass object
      Throws:
      ClassNotFoundException - If the class was not found

    • loadClass

      protected Class<?> loadClass(String name, boolean resolve) throwsClassNotFoundException
      Loads the class with the specifiedbinary name. Thedefault implementation of this method searches for classes in thefollowing order:

      1. InvokefindLoadedClass(String) to check if the class has already been loaded.

      2. Invoke theloadClass method on the parent class loader. If the parent isnull the class loader built into the virtual machine is used, instead.

      3. Invoke thefindClass(String) method to find the class.

      If the class was found using the above steps, and theresolve flag is true, this method will then invoke theresolveClass(Class) method on the resultingClass object.

      Subclasses ofClassLoader are encouraged to overridefindClass(String), rather than this method.

      Unless overridden, this method synchronizes on the result ofgetClassLoadingLock methodduring the entire class loading process.

      Parameters:
      name - Thebinary name of the class
      resolve - Iftrue then resolve the class
      Returns:
      The resultingClass object
      Throws:
      ClassNotFoundException - If the class could not be found

    • getClassLoadingLock

      protected Object getClassLoadingLock(String className)
      Returns the lock object for class loading operations.
      API Note:
      This method allows parallel capable class loaders to implementfiner-grained locking schemes such that multiple threads may load classesconcurrently without deadlocks. For non-parallel-capable class loaders,theClassLoader object is synchronized on during the class loadingoperations. Class loaders with non-hierarchical delegation should beregistered as parallel capableto prevent deadlocks.
      Implementation Requirements:
      If thisClassLoader object is registered as parallel capable,this method returns a dedicated object associated with the specifiedclass name. Otherwise, this method returns thisClassLoader object.
      Parameters:
      className - The name of the to-be-loaded class
      Returns:
      the lock for class loading operations
      Throws:
      NullPointerException - If registered as parallel capable andclassName isnull
      Since:
      1.7
      See Also:

    • findClass

      protected Class<?> findClass(String name) throwsClassNotFoundException
      Finds the class with the specifiedbinary name.This method should be overridden by class loader implementations thatfollow the delegation model for loading classes, and will be invoked bytheloadClass method after checking theparent class loader for the requested class.
      Implementation Requirements:
      The default implementation throwsClassNotFoundException.
      Parameters:
      name - Thebinary name of the class
      Returns:
      The resultingClass object
      Throws:
      ClassNotFoundException - If the class could not be found
      Since:
      1.2

    • findClass

      protected Class<?> findClass(String moduleName,String name)
      Finds the class with the givenbinary namein a module defined to this class loader.Class loader implementations that support loading from modulesshould override this method.
      API Note:
      This method returnsnull rather than throwingClassNotFoundException if the class could not be found.
      Implementation Requirements:
      The default implementation attempts to find the class byinvokingfindClass(String) when themoduleName isnull. It otherwise returnsnull.
      Parameters:
      moduleName - The module name; ornull to find the class in theunnamed module for this class loader
      name - Thebinary name of the class
      Returns:
      The resultingClass object, ornull if the class could not be found.
      Since:
      9

    • defineClass

      @Deprecated(since="1.1")protected final Class<?> defineClass(byte[] b, int off, int len) throwsClassFormatError
      Converts an array of bytes into an instance of classClass.Before theClass can be used it must be resolved. This methodis deprecated in favor of the version that takes abinary name as its first argument, and is more secure.
      Parameters:
      b - The bytes that make up the class data. The bytes in positionsoff throughoff+len-1 should have the format of a valid class file as defined byThe Java Virtual Machine Specification.
      off - The start offset inb of the class data
      len - The length of the class data
      Returns:
      TheClass object that was created from the specified class data
      Throws:
      ClassFormatError - If the data did not contain a valid class
      IndexOutOfBoundsException - If eitheroff orlen is negative, or ifoff+len is greater thanb.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.".
      See Also:

    • defineClass

      protected final Class<?> defineClass(String name, byte[] b, int off, int len) throwsClassFormatError
      Converts an array of bytes into an instance of classClass.Before theClass can be used it must be resolved.

      This method assigns a defaultProtectionDomain to the newly defined class. ThegetPermissions method of theProtectionDomain alwaysreturnsnull.The default protection domain is created on the first invocationofdefineClass,and re-used on subsequent invocations.

      To assign a specificProtectionDomain to the class, usethedefineClass method that takes aProtectionDomain as one of its arguments.

      This method defines a package in this class loader corresponding to thepackage of theClass (if such a package has not already been definedin this class loader). The name of the defined package is derived fromthebinary name of the class specified bythe byte arrayb.Other properties of the defined package are as specified byPackage.

      Parameters:
      name - The expectedbinary name of the class, ornull if not known
      b - The bytes that make up the class data. The bytes in positionsoff throughoff+len-1 should have the format of a valid class file as defined byThe Java Virtual Machine Specification.
      off - The start offset inb of the class data
      len - The length of the class data
      Returns:
      TheClass object that was created from the specified class data.
      Throws:
      ClassFormatError - If the data did not contain a valid class
      IndexOutOfBoundsException - If eitheroff orlen is negative, or ifoff+len is greater thanb.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 ifname begins with "java.".
      Since:
      1.1
      See Also:

    • defineClass

      protected final Class<?> defineClass(String name, byte[] b, int off, int len,ProtectionDomain protectionDomain) throwsClassFormatError
      Converts an array of bytes into an instance of classClass,with a givenProtectionDomain.

      If the givenProtectionDomain isnull,then a default protection domain will be assigned to the class as specifiedin the documentation fordefineClass(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 ofcertificates that all subsequent classes defined in that package mustcontain. The set of certificates for a class is obtained from theCodeSource within theProtectionDomain of the class. Any classes added to thatpackage must contain the same set of certificates or aSecurityException will be thrown. Note that ifname isnull, this check is not performed.You should always pass in thebinary name of theclass you are defining as well as the bytes. This ensures that theclass you are defining is indeed the class you think it is.

      If the specifiedname begins with "java.", it canonly be defined by theplatform class loader or its ancestors; otherwiseSecurityExceptionwill be thrown. Ifname is notnull, it must be equal tothebinary name of the classspecified by the byte arrayb, otherwise aNoClassDefFoundError will be thrown.

      This method defines a package in this class loader corresponding to thepackage of theClass (if such a package has not already been definedin this class loader). The name of the defined package is derived fromthebinary name of the class specified bythe byte arrayb.Other properties of the defined package are as specified byPackage.

      Parameters:
      name - The expectedbinary name of the class, ornull if not known
      b - The bytes that make up the class data. The bytes in positionsoff throughoff+len-1 should have the format of a valid class file as defined byThe Java Virtual Machine Specification.
      off - The start offset inb of the class data
      len - The length of the class data
      protectionDomain - TheProtectionDomain of the class
      Returns:
      TheClass object created from the data, andProtectionDomain.
      Throws:
      ClassFormatError - If the data did not contain a valid class
      NoClassDefFoundError - Ifname is notnull and not equal to thebinary name of the class specified byb
      IndexOutOfBoundsException - If eitheroff orlen is negative, or ifoff+len is greater thanb.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 ifname begins with "java." and this class loader is not the platform class loader or its ancestor.

    • defineClass

      protected final Class<?> defineClass(String name,ByteBuffer b,ProtectionDomain protectionDomain) throwsClassFormatError
      Converts aByteBuffer into an instance of classClass, with the givenProtectionDomain. If the givenProtectionDomain isnull, then a default protection domain will be assigned to the class as specified in the documentation fordefineClass(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 fordefineClass(String, byte[], int, int, ProtectionDomain).

      An invocation of this method of the formcl.defineClass(name,bBuffer,pd) yields exactly the same result as the statements

      ...
      byte[] temp = new byte[bBuffer.remaining()];
      bBuffer.get(temp);
      returncl.defineClass(name, temp, 0, temp.length, pd);

      Parameters:
      name - The expectedbinary name. of the class, ornull if not known
      b - The bytes that make up the class data. The bytes from positionsb.position() throughb.position() + b.limit() -1 should have the format of a valid class file as defined byThe Java Virtual Machine Specification.
      protectionDomain - TheProtectionDomain of the class, ornull.
      Returns:
      TheClass object created from the data, andProtectionDomain.
      Throws:
      ClassFormatError - If the data did not contain a valid class.
      NoClassDefFoundError - Ifname is notnull and not equal to thebinary name of the class specified byb
      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 ifname begins with "java.".
      Since:
      1.5
      See Also:

    • resolveClass

      protected final void resolveClass(Class<?> c)
      Links the specified class. This (misleadingly named) method may beused by a class loader to link a class. If the classc hasalready been linked, then this method simply returns. Otherwise, theclass is linked as described in the "Execution" chapter ofThe Java Language Specification.
      Parameters:
      c - The class to link
      Throws:
      NullPointerException - Ifc isnull.
      See Also:

    • findSystemClass

      protected final Class<?> findSystemClass(String name) throwsClassNotFoundException
      Finds a class with the specifiedbinary name,loading it if necessary.

      This method loads the class through the system class loader (seegetSystemClassLoader()). TheClass object returnedmight have more than oneClassLoader associated with it.Subclasses ofClassLoader need not usually invoke this method,because most class loaders need to override justfindClass(String).

      Parameters:
      name - Thebinary name of the class
      Returns:
      TheClass object for the specifiedname
      Throws:
      ClassNotFoundException - If the class could not be found
      See Also:

    • findLoadedClass

      protected final Class<?> findLoadedClass(String name)
      Returns the class with the givenbinary name if thisloader has been recorded by the Java virtual machine as an initiatingloader of a class with thatbinary name. Otherwisenull is returned.
      Parameters:
      name - Thebinary name of the class
      Returns:
      TheClass object, ornull if the class has not been loaded
      Since:
      1.1

    • setSigners

      protected final void setSigners(Class<?> c,Object[] signers)
      Sets the signers of a class. This should be invoked after defining aclass.
      Parameters:
      c - TheClass object
      signers - The signers for the class
      Since:
      1.1

    • findResource

      protected URL findResource(String moduleName,String name) throwsIOException
      Returns a URL to a resource in a module defined to this class loader.Class loader implementations that support loading from modulesshould override this method.
      API Note:
      This method is the basis for theClass.getResource,Class.getResourceAsStream, andModule.getResourceAsStream methods. It is not subject to the rules forencapsulation specified byModule.getResourceAsStream.
      Implementation Requirements:
      The default implementation attempts to find the resource byinvokingfindResource(String) when themoduleName isnull. It otherwise returnsnull.
      Parameters:
      moduleName - The module name; ornull to find a resource in theunnamed module for this class loader
      name - The resource name
      Returns:
      A URL to the resource;null if the resource could not be found, a URL could not be constructed to locate the resource, or there isn't a module of the given name defined to the class loader.
      Throws:
      IOException - If I/O errors occur
      Since:
      9
      See Also:

    • getResource

      public URL getResource(String name)
      Finds the resource with the given name. A resource is some data(images, audio, text, etc) that can be accessed by class code in a waythat is independent of the location of the code.

      The name of a resource is a '/'-separated path name thatidentifies the resource.

      Resources in named modules are subject to the encapsulation rulesspecified byModule.getResourceAsStream.Additionally, and except for the special case where the resource has aname ending with ".class", this method will only find resources inpackages of named modules when the package isopened unconditionally (even if the caller of this method is in thesame module as the resource).

      API Note:
      Where several modules are defined to the same class loader,and where more than one module contains a resource with the given name,then the ordering that modules are searched is not specified and may bevery unpredictable.When overriding this method it is recommended that an implementationensures that any delegation is consistent with thegetResources(String) method.
      Implementation Requirements:
      The default implementation will first search the parent classloader for the resource; if the parent isnull the path of theclass loader built into the virtual machine is searched. If not found,this method will invokefindResource(String) to find the resource.
      Parameters:
      name - The resource name
      Returns:
      URL object for reading the resource;null if the resource could not be found, aURL could not be constructed to locate the resource, or the resource is in a package that is not opened unconditionally.
      Throws:
      NullPointerException - Ifname isnull
      Since:
      1.1

    • getResources

      public Enumeration<URL> getResources(String name) throwsIOException
      Finds all the resources with the given name. A resource is some data(images, audio, text, etc) that can be accessed by class code in a waythat is independent of the location of the code.

      The name of a resource is a/-separated path name thatidentifies the resource.

      Resources in named modules are subject to the encapsulation rulesspecified byModule.getResourceAsStream.Additionally, and except for the special case where the resource has aname ending with ".class", this method will only find resources inpackages of named modules when the package isopened unconditionally (even if the caller of this method is in thesame module as the resource).

      API Note:
      Where several modules are defined to the same class loader,and where more than one module contains a resource with the given name,then the ordering is not specified and may be very unpredictable.When overriding this method it is recommended that animplementation ensures that any delegation is consistent with thegetResource(String) method. This shouldensure that the first element returned by the Enumeration'snextElement method is the same resource that thegetResource(String) method would return.
      Implementation Requirements:
      The default implementation will first search the parent classloader for the resource; if the parent isnull the path of theclass loader built into the virtual machine is searched. It theninvokesfindResources(String) to find the resources with thename in this class loader. It returns an enumeration whose elementsare the URLs found by searching the parent class loader followed bythe elements found withfindResources.
      Parameters:
      name - The resource name
      Returns:
      An enumeration ofURL objects for the resource. If no resources could be found, the enumeration will be empty. Resources for which aURL cannot be constructed, or are in a package that is not opened unconditionally, are not returned in the enumeration.
      Throws:
      IOException - If I/O errors occur
      NullPointerException - Ifname isnull
      Since:
      1.2

    • resources

      public Stream<URL> resources(String name)
      Returns a stream whose elements are the URLs of all the resources withthe given name. A resource is some data (images, audio, text, etc) thatcan be accessed by class code in a way that is independent of thelocation of the code.

      The name of a resource is a/-separated path name thatidentifies the resource.

      The resources will be located when the returned stream is evaluated.If the evaluation results in anIOException then the I/Oexception is wrapped in anUncheckedIOException that is thenthrown.

      Resources in named modules are subject to the encapsulation rulesspecified byModule.getResourceAsStream.Additionally, and except for the special case where the resource has aname ending with ".class", this method will only find resources inpackages of named modules when the package isopened unconditionally (even if the caller of this method is in thesame module as the resource).

      API Note:
      When overriding this method it is recommended that animplementation ensures that any delegation is consistent with thegetResource(String) method. This shouldensure that the first element returned by the stream is the sameresource that thegetResource(String) method would return.
      Implementation Requirements:
      The default implementation invokesgetResources to find all the resources with the given name and returnsa stream with the elements in the enumeration as the source.
      Parameters:
      name - The resource name
      Returns:
      A stream of resourceURL objects. If no resources could be found, the stream will be empty. Resources for which aURL cannot be constructed, or are in a package that is not opened unconditionally, will not be in the stream.
      Throws:
      NullPointerException - Ifname isnull
      Since:
      9

    • findResource

      protected URL findResource(String name)
      Finds the resource with the given name. Class loader implementationsshould override this method.

      For resources in named modules then the method must implement therules for encapsulation specified in theModulegetResourceAsStream method. Additionally,it must not find non-".class" resources in packages of namedmodules unless the package isopenedunconditionally.

      Implementation Requirements:
      The default implementation returnsnull.
      Parameters:
      name - The resource name
      Returns:
      URL object for reading the resource;null if the resource could not be found, aURL could not be constructed to locate the resource, or the resource is in a package that is not opened unconditionally.
      Since:
      1.2

    • findResources

      protected Enumeration<URL> findResources(String name) throwsIOException
      Returns an enumeration ofURL objectsrepresenting all the resources with the given name. Class loaderimplementations should override this method.

      For resources in named modules then the method must implement therules for encapsulation specified in theModulegetResourceAsStream method. Additionally,it must not find non-".class" resources in packages of namedmodules unless the package isopenedunconditionally.

      Implementation Requirements:
      The default implementation returns an enumeration thatcontains no elements.
      Parameters:
      name - The resource name
      Returns:
      An enumeration ofURL objects for the resource. If no resources could be found, the enumeration will be empty. Resources for which aURL cannot be constructed, or are in a package that is not opened unconditionally, are not returned in the enumeration.
      Throws:
      IOException - If I/O errors occur
      Since:
      1.2

    • registerAsParallelCapable

      protected static boolean registerAsParallelCapable()
      Registers the caller asparallel capable.The registration succeeds if and only if all of the followingconditions are met:
      1. no instance of the caller has been created
      2. all of the super classes (except class Object) of the caller areregistered as parallel capable

      Note that once a class loader is registered as parallel capable, thereis no way to change it back.

      In cases where this method is called from a context where the caller isnot a subclass ofClassLoader or there is no caller frame on thestack (e.g. when called directly from a JNI attached thread),IllegalCallerException is thrown.

      Returns:
      true if the caller is successfully registered as parallel capable andfalse if otherwise.
      Throws:
      IllegalCallerException - if the caller is not a subclass ofClassLoader
      Since:
      1.7
      See Also:

    • isRegisteredAsParallelCapable

      public final boolean isRegisteredAsParallelCapable()
      Returnstrue if this class loader is registered asparallel capable, otherwisefalse.
      Returns:
      true if this class loader is parallel capable, otherwisefalse.
      Since:
      9
      See Also:

    • getSystemResource

      public static URL getSystemResource(String name)
      Find a resource of the specified name from the search path used to loadclasses. This method locates the resource through the system classloader (seegetSystemClassLoader()).

      Resources in named modules are subject to the encapsulation rulesspecified byModule.getResourceAsStream.Additionally, and except for the special case where the resource has aname ending with ".class", this method will only find resources inpackages of named modules when the package isopened unconditionally.

      Parameters:
      name - The resource name
      Returns:
      AURL to the resource; null if the resource could not be found, a URL could not be constructed to locate the resource, or the resource is in a package that is not opened unconditionally.
      Since:
      1.1

    • getSystemResources

      public static Enumeration<URL> getSystemResources(String name) throwsIOException
      Finds all resources of the specified name from the search path used toload classes. The resources thus found are returned as anEnumeration ofURL objects.

      The search order is described in the documentation forgetSystemResource(String).

      Resources in named modules are subject to the encapsulation rulesspecified byModule.getResourceAsStream.Additionally, and except for the special case where the resource has aname ending with ".class", this method will only find resources inpackages of named modules when the package isopened unconditionally.

      Parameters:
      name - The resource name
      Returns:
      An enumeration ofURL objects for the resource. If no resources could be found, the enumeration will be empty. Resources for which aURL cannot be constructed, or are in a package that is not opened unconditionally, are not returned in the enumeration.
      Throws:
      IOException - If I/O errors occur
      Since:
      1.2

    • getResourceAsStream

      public InputStream getResourceAsStream(String name)
      Returns an input stream for reading the specified resource.

      The search order is described in the documentation forgetResource(String).

      Resources in named modules are subject to the encapsulation rulesspecified byModule.getResourceAsStream.Additionally, and except for the special case where the resource has aname ending with ".class", this method will only find resources inpackages of named modules when the package isopened unconditionally.

      Parameters:
      name - The resource name
      Returns:
      An input stream for reading the resource;null if the resource could not be found, or the resource is in a package that is not opened unconditionally.
      Throws:
      NullPointerException - Ifname isnull
      Since:
      1.1

    • getSystemResourceAsStream

      public static InputStream getSystemResourceAsStream(String name)
      Open for reading, a resource of the specified name from the search pathused to load classes. This method locates the resource through thesystem class loader (seegetSystemClassLoader()).

      Resources in named modules are subject to the encapsulation rulesspecified byModule.getResourceAsStream.Additionally, and except for the special case where the resource has aname ending with ".class", this method will only find resources inpackages of named modules when the package isopened unconditionally.

      Parameters:
      name - The resource name
      Returns:
      An input stream for reading the resource;null if the resource could not be found, or the resource is in a package that is not opened unconditionally.
      Since:
      1.1

    • getParent

      public final ClassLoader getParent()
      Returns the parent class loader for delegation. Some implementations mayusenull to represent the bootstrap class loader. This methodwill returnnull in such implementations if this class loader'sparent is the bootstrap class loader.
      Returns:
      The parentClassLoader
      Since:
      1.2

    • getUnnamedModule

      public final Module getUnnamedModule()
      Returns the unnamedModule for this class loader.
      Returns:
      The unnamed Module for this class loader
      Since:
      9
      See Also:

    • getPlatformClassLoader

      public static ClassLoader getPlatformClassLoader()
      Returns the platform class loader. Allplatform classes are visible tothe platform class loader.
      Implementation Note:
      The name of the builtin platform class loader is"platform".
      Returns:
      The platformClassLoader.
      Since:
      9

    • getSystemClassLoader

      public static ClassLoader getSystemClassLoader()
      Returns the system class loader. This is the defaultdelegation parent for newClassLoader instances, and istypically the class loader used to start the application.

      This method is first invoked early in the runtime's startupsequence, at which point it creates the system class loader. Thisclass loader will be the context class loader for the main applicationthread (for example, the thread that invokes themain method ofthe main class).

      The default system class loader is an implementation-dependentinstance of this class.

      If the system property "java.system.class.loader"is defined when this method is first invoked then the value of thatproperty is taken to be the name of a class that will be returned as thesystem class loader. The class is loaded using the default system classloader and must define a public constructor that takes a single parameterof typeClassLoader which is used as the delegation parent. Aninstance is then created using this constructor with the default systemclass loader as the parameter. The resulting class loader is definedto be the system class loader. During construction, the class loadershould take great care to avoid callinggetSystemClassLoader().If circular initialization of the system class loader is detected thenanIllegalStateException is thrown.

      Implementation Note:
      The system property to override the system class loader is notexamined until the VM is almost fully initialized. Code that executesthis method during startup should take care not to cache the returnvalue until the system is fully initialized.

      The name of the built-in system class loader is"app".The system property "java.class.path" is read during earlyinitialization of the VM to determine the class path.An empty value of "java.class.path" property is interpreteddifferently depending on whether the initial module (the modulecontaining the main class) is named or unnamed:If named, the built-in system class loader will have no class path andwill search for classes and resources using the application module path;otherwise, if unnamed, it will set the class path to the currentworking directory.

      JAR files on the class path may contain aClass-Path manifestattribute to specify dependent JAR files to be included in the class path.Class-Path entries must meet certain conditions for validity (seetheJAR File Specification for details). InvalidClass-Pathentries are ignored. For debugging purposes, ignored entries can beprinted to the console if thejdk.net.URLClassPath.showIgnoredClassPathEntries systemproperty is set totrue.

      Returns:
      The systemClassLoader
      Throws:
      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 theThrowable.getCause() method.

    • definePackage

      protected Package definePackage(String name,String specTitle,String specVersion,String specVendor,String implTitle,String implVersion,String implVendor,URL sealBase)
      Defines a package byname in thisClassLoader.

      Package names must be unique within a class loader andcannot 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 thisdefinePackage method before callingdefineClass.Otherwise, thedefineClassmethod will define a package in this class loader corresponding to the packageof the newly defined class; the properties of this defined package arespecified byPackage.

      API Note:
      A class loader that wishes to define a package for classes in a JARtypically uses the specification and implementation titles, versions, andvendors from the JAR's manifest. If the package is specified assealed in the JAR's manifest,theURL of the JAR file is typically used as thesealBase.If classes of package'p' defined by this class loaderare loaded from multiple JARs, thePackage object may containdifferent information depending on the first class of package'p'defined and which JAR's manifest is read first to explicitly definepackage'p'.

      It is strongly recommended that a class loader does not call thismethod to explicitly define packages innamed modules; instead,the package will be automatically defined when a class isbeing defined.If it is desirable to definePackage explicitly, it should ensurethat all packages in a named module are defined with the propertiesspecified byPackage. Otherwise, somePackage objectsin a named module may be for example sealed with different seal base.

      Parameters:
      name - Thepackage name
      specTitle - The specification title
      specVersion - The specification version
      specVendor - The specification vendor
      implTitle - The implementation title
      implVersion - The implementation version
      implVendor - The implementation vendor
      sealBase - If notnull, then this package is sealed with respect to the given code sourceURL object. Otherwise, the package is not sealed.
      Returns:
      The newly definedPackage object
      Throws:
      NullPointerException - ifname isnull.
      IllegalArgumentException - if a package of the givenname is already defined by this class loader
      SeeJava Virtual Machine Specification:
      5.3 Creation and Loading
      Since:
      1.2
      See Also:

    • getDefinedPackage

      public final Package getDefinedPackage(String name)
      Returns aPackage of the givenname thathas been defined by this class loader.
      Parameters:
      name - Thepackage name
      Returns:
      ThePackage of the given name that has been defined by this class loader, ornull if not found
      Throws:
      NullPointerException - ifname isnull.
      SeeJava Virtual Machine Specification:
      5.3 Creation and Loading
      Since:
      9

    • getDefinedPackages

      public final Package[] getDefinedPackages()
      Returns all of thePackages that have been defined bythis class loader. The returned array has no duplicatedPackagesof the same name.
      API Note:
      This method returns an array rather than aSet orStream for consistency with the existinggetPackages() method.
      Returns:
      The array ofPackage objects that have been defined by this class loader; or a zero length array if no package has been defined by this class loader.
      SeeJava Virtual Machine Specification:
      5.3 Creation and Loading
      Since:
      9

    • getPackage

      @Deprecated(since="9")protected Package getPackage(String name)
      Deprecated.
      If multiple class loaders delegate to each other and define classeswith the same package name, and one such loader relies on the lookupbehavior ofgetPackage to return aPackage froma parent loader, then the properties exposed by thePackagemay not be as expected in the rest of the program.For example, thePackage will only expose annotations from thepackage-info.class file defined by the parent loader, even ifannotations exist in apackage-info.class file defined bya child loader. A more robust approach is to use thegetDefinedPackage(String) method which returnsaPackage for the specified class loader.
      Finds a package byname in this class loader and its ancestors.

      If this class loader defines aPackage of the given name,thePackage is returned. Otherwise, the ancestors ofthis class loader are searched recursively (parent by parent)for aPackage of the given name.

      API Note:
      Theplatform class loadermay delegate to the application class loader but the application classloader is not its ancestor. When invoked on the platform class loader,this method will not find packages defined to the applicationclass loader.
      Parameters:
      name - Thepackage name
      Returns:
      ThePackage of the given name that has been defined by this class loader or its ancestors, ornull if not found.
      Throws:
      NullPointerException - ifname isnull.
      Since:
      1.2
      See Also:

    • getPackages

      protected Package[] getPackages()
      Returns all of thePackages that have been defined bythis class loader and its ancestors. The returned array may containmore than onePackage object of the same package name, eachdefined by a different class loader in the class loader hierarchy.
      API Note:
      Theplatform class loadermay delegate to the application class loader. In other words,packages in modules defined to the application class loader may bevisible to the platform class loader. On the other hand,the application class loader is not its ancestor and hencewhen invoked on the platform class loader, this method will notreturn any packages defined to the application class loader.
      Returns:
      The array ofPackage objects that have been defined by this class loader and its ancestors
      Since:
      1.2
      See Also:

    • findLibrary

      protected String findLibrary(String libname)
      Returns the absolute path name of a native library. The VM invokes thismethod to locate the native libraries that belong to classes loaded withthis class loader. If this method returnsnull, the VMsearches the library along the path specified as the"java.library.path" property.
      Parameters:
      libname - The library name
      Returns:
      The absolute path of the native library
      Since:
      1.2
      See Also:

    • setDefaultAssertionStatus

      public void setDefaultAssertionStatus(boolean enabled)
      Sets the default assertion status for this class loader. This settingdetermines whether classes loaded by this class loader and initializedin the future will have assertions enabled or disabled by default.This setting may be overridden on a per-package or per-class basis byinvokingsetPackageAssertionStatus(String, boolean) orsetClassAssertionStatus(String, boolean).
      Parameters:
      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.
      Since:
      1.4

    • setPackageAssertionStatus

      public void setPackageAssertionStatus(String packageName, boolean enabled)
      Sets the package default assertion status for the named package. Thepackage default assertion status determines the assertion status forclasses initialized in the future that belong to the named package orany of its "subpackages".

      A subpackage of a package named p is any package whose name beginswith "p.". For example,javax.swing.text is asubpackage ofjavax.swing, and bothjava.util andjava.lang.reflect are subpackages ofjava.

      In the event that multiple package defaults apply to a given class,the package default pertaining to the most specific package takesprecedence over the others. For example, ifjavax.lang andjavax.lang.reflect both have package defaults associated withthem, the latter package default applies to classes injavax.lang.reflect.

      Package defaults take precedence over the class loader's defaultassertion status, and may be overridden on a per-class basis by invokingsetClassAssertionStatus(String, boolean).

      Parameters:
      packageName - The name of the package whose package default assertion status is to be set. Anull value indicates the unnamed package that is "current" (see section7.4.2 ofThe 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.
      Since:
      1.4

    • setClassAssertionStatus

      public void setClassAssertionStatus(String className, boolean enabled)
      Sets the desired assertion status for the named top-level class in thisclass loader and any nested classes contained therein. This settingtakes precedence over the class loader's default assertion status, andover any applicable per-package default. This method has no effect ifthe named class has already been initialized. (Once a class isinitialized, its assertion status cannot change.)

      If the named class is not a top-level class, this invocation willhave no effect on the actual assertion status of any class.

      Parameters:
      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.
      Since:
      1.4

    • clearAssertionStatus

      public void clearAssertionStatus()
      Sets the default assertion status for this class loader tofalse and discards any package defaults or class assertionstatus settings associated with the class loader. This method isprovided so that class loaders can be made to ignore any command line orpersistent assertion status settings and "start with a clean slate."
      Since:
      1.4