/**@class java.lang.ClassLoader
@extends java.lang.Object

 Loads classes and resources from a repository. One or more class loaders are
 installed at runtime. These are consulted whenever the runtime system needs a
 specific class that is not yet available in-memory. Typically, class loaders
 are grouped into a tree where child class loaders delegate all requests to
 parent class loaders. Only if the parent class loader cannot satisfy the
 request, the child class loader itself tries to handle it.
 <p>
 {@code ClassLoader} is an abstract class that implements the common
 infrastructure required by all class loaders. Android provides several
 concrete implementations of the class, with
 {@link dalvik.system.PathClassLoader} being the one typically used. Other
 applications may implement subclasses of {@code ClassLoader} to provide
 special ways for loading classes.
 </p>
 @see Class
*/
var ClassLoader = {

/** To avoid unloading individual classes, {@link java.lang.reflect.Proxy}
 only generates one class for each set of interfaces. This maps sets of
 interfaces to the proxy class that implements all of them. It is declared
 here so that these generated classes can be unloaded with their class
 loader.

 @hide
*/
proxyCache : "null",
/**Returns the system class loader. This is the parent for new
 {@code ClassLoader} instances and is typically the class loader used to
 start the application.
*/
getSystemClassLoader : function(  ) {},

/**Finds the URL of the resource with the specified name. The system class
 loader's resource lookup algorithm is used to find the resource.
@param {String} resName
            the name of the resource to find.
@param resName
            the name of the resource to find.
@see Class#getResource
*/
getSystemResource : function(  ) {},

/**Returns an enumeration of URLs for the resource with the specified name.
 The system class loader's resource lookup algorithm is used to find the
 resource.
@param {String} resName
            the name of the resource to find.
@param resName
            the name of the resource to find.
@throws IOException
             if an I/O error occurs.
*/
getSystemResources : function(  ) {},

/**Returns a stream for the resource with the specified name. The system
 class loader's resource lookup algorithm is used to find the resource.
 Basically, the contents of the java.class.path are searched in order,
 looking for a path which matches the specified resource.
@param {String} resName
            the name of the resource to find.
@param resName
            the name of the resource to find.
@see Class#getResourceAsStream
*/
getSystemResourceAsStream : function(  ) {},

/**Returns this class loader's parent.
@return {Object {java.lang.ClassLoader}} this class loader's parent or {@code null}.
*/
getParent : function(  ) {},

/**Returns the URL of the resource with the specified name. This
 implementation first tries to use the parent class loader to find the
 resource; if this fails then {@link #findResource}(String) is called to
 find the requested resource.
@param {String} resName
            the name of the resource to find.
@return {Object {java.net.URL}} the {@code URL} object for the requested resource or {@code null}
         if the resource can not be found
@see Class#getResource
*/
getResource : function(  ) {},

/**Returns an enumeration of URLs for the resource with the specified name.
 This implementation first uses this class loader's parent to find the
 resource, then it calls {@link #findResources}(String) to get additional
 URLs. The returned enumeration contains the {@code URL} objects of both
 find operations.
@param {String} resName
            the name of the resource to find.
@param resName
            the name of the resource to find.
@throws IOException
             if an I/O error occurs.
*/
getResources : function(  ) {},

/**Returns a stream for the resource with the specified name. See
 {@link #getResource}(String) for a description of the lookup algorithm
 used to find the resource.
@param {String} resName
            the name of the resource to find.
@param resName
            the name of the resource to find.
@see Class#getResourceAsStream
*/
getResourceAsStream : function(  ) {},

/**Loads the class with the specified name. Invoking this method is
 equivalent to calling {@code loadClass(className, false)}.
 <p>
 <strong>Note:</strong> In the Android reference implementation, the
 second parameter of {@link #loadClass(String, boolean)} is ignored
 anyway.
 </p>
@param {String} className
            the name of the class to look for.
@param className
            the name of the class to look for.
@throws ClassNotFoundException
             if the class can not be found.
*/
loadClass : function(  ) {},

/**Sets the assertion status of the class with the specified name.
 <p>
 <strong>Note: </strong>This method does nothing in the Android reference
 implementation.
 </p>
@param {String} cname
            the name of the class for which to set the assertion status.
@param {Boolean} enable
            the new assertion status.
*/
setClassAssertionStatus : function(  ) {},

/**Sets the assertion status of the package with the specified name.
 <p>
 <strong>Note: </strong>This method does nothing in the Android reference
 implementation.
 </p>
@param {String} pname
            the name of the package for which to set the assertion status.
@param {Boolean} enable
            the new assertion status.
*/
setPackageAssertionStatus : function(  ) {},

/**Sets the default assertion status for this class loader.
 <p>
 <strong>Note: </strong>This method does nothing in the Android reference
 implementation.
 </p>
@param {Boolean} enable
            the new assertion status.
*/
setDefaultAssertionStatus : function(  ) {},

/**Sets the default assertion status for this class loader to {@code false}
 and removes any package default and class assertion status settings.
 <p>
 <strong>Note:</strong> This method does nothing in the Android reference
 implementation.
 </p>
*/
clearAssertionStatus : function(  ) {},


};