protected ClassLoader() 
{
        this(getSystemClassLoader());
}

 protected ClassLoader(ClassLoader parent) 
{
        SecurityManager sc = System.getSecurityManager();
        if (sc != null) {
            sc.checkCreateClassLoader();
        }
        parentClassLoader = parent;
        // this field is used to determine whether class loader was initialized
        // properly.
        definedPackages = new HashMap< String, Package >();
}

 public  void clearAssertionStatus() 
{
        clearAssertionStatus = true;
        defaultAssertionStatus = -1;
        packageAssertionStatus = null;
        classAssertionStatus = null;
}

 protected final Class<?> defineClass(byte[] data,
    int offset,
    int len) throws ClassFormatError 
{
        return defineClass(null, data, offset, len);
}

 protected final Class<?> defineClass(String name,
    ByteBuffer b,
    ProtectionDomain protectionDomain) throws ClassFormatError 
{
		byte[] data = b.array();
        return defineClass(name, data, 0, data.length, protectionDomain);
}

 protected final Class<?> defineClass(String name,
    byte[] data,
    int offset,
    int len) throws ClassFormatError 
{
        return defineClass(name, data, offset, len, null);
}

 protected final synchronized Class<?> defineClass(String name,
    byte[] data,
    int offset,
    int len,
    ProtectionDomain domain) throws ClassFormatError 
{
        checkInitialized();
        if (name != null && name.indexOf('/') != -1) {
            throw new NoClassDefFoundError(
                    "The name is expected in binary (canonical) form,"
                    + " therefore '/' symbols are not allowed: " + name);
        }
        if (offset <  0 || len <  0 || offset + len  > data.length) {
            throw new IndexOutOfBoundsException(
                "Either offset or len is outside of the data array");
        }
        if (domain == null) {
            if (defaultDomain == null) {
                defaultDomain = new ProtectionDomain(
                        new CodeSource(null, (Certificate[])null), null, this, null);            
            }        
            domain = defaultDomain;
        }
        Certificate[] certs = null;
        String packageName = null;
        if (name != null) {
            if (name.startsWith("java.")) {
                throw new SecurityException(
                    "It is not allowed to define classes inside the java.* package: " + name);
            }
            int lastDot = name.lastIndexOf('.');
            packageName = lastDot == -1 ? "" : name.substring(0, lastDot);
            certs = getCertificates(packageName, domain.getCodeSource());
        }
        Class< ? > clazz = defineClass0(name, data, offset, len);
        clazz.setProtectionDomain(domain);
        if (certs != null) {
            packageCertificates.put(packageName, certs);
        }
        return clazz;
}

 protected Package definePackage(String name,
    String specTitle,
    String specVersion,
    String specVendor,
    String implTitle,
    String implVersion,
    String implVendor,
    URL sealBase) throws IllegalArgumentException 
{
        synchronized (definedPackages) {
            if (getPackage(name) != null) {
                throw new IllegalArgumentException("Package " + name
                    + "has been already defined.");
            }
            Package pkg = new Package(this, name, specTitle, specVersion, specVendor,
                implTitle, implVersion, implVendor, sealBase);
            definedPackages.put(name, pkg);
            return pkg;
        }
}

 protected Class<?> findClass(String name) throws ClassNotFoundException 
{
        throw new ClassNotFoundException("Can not find class " + name);
}

 protected String findLibrary(String name) 
{
        return null;
}

 protected final native Class<?> findLoadedClass(String name)

 protected URL findResource(String name) 
{
        return null;
}

 protected Enumeration<URL> findResources(String name) throws IOException 
{
        return EmptyEnum.getInstance();
}

 protected final Class<?> findSystemClass(String name) throws ClassNotFoundException 
{
        return getSystemClassLoader().loadClass(name, false);
}

 protected Package getPackage(String name) 
{
        checkInitialized();
        Package pkg = null;
        if (name == null) {
            throw new NullPointerException();
        }
        synchronized (definedPackages) {
            pkg = definedPackages.get(name);
        }
        if (pkg == null) {
            if (parentClassLoader == null) {
                pkg = BootstrapLoader.getPackage(name);
            } else {
                pkg = parentClassLoader.getPackage(name);
            }
        }
        return pkg;
}

 protected Package[] getPackages() 
{
        checkInitialized();
        ArrayList< Package > packages = new ArrayList< Package >();
        fillPackages(packages);
        return packages.toArray(new Package[packages.size()]);
}

 public final ClassLoader getParent() 
{
        SecurityManager sc = System.getSecurityManager();
        if (sc != null) {
            ClassLoader callerLoader = VMClassRegistry.getClassLoader(VMStack
                .getCallerClass(0));
            if (callerLoader != null && !callerLoader.isSameOrAncestor(this)) {
                sc.checkPermission(RuntimePermissionCollection.GET_CLASS_LOADER_PERMISSION);
            }
        }
        return parentClassLoader;
}

 public URL getResource(String name) 
{
        String nm = name.toString();
        checkInitialized();
        URL foundResource = (parentClassLoader == null)
            ? BootstrapLoader.findResource(nm)
            : parentClassLoader.getResource(nm);
        return foundResource == null ? findResource(nm) : foundResource;
}

 public InputStream getResourceAsStream(String name) 
{
        URL foundResource = getResource(name);
        if (foundResource != null) {
            try {
                return foundResource.openStream();
            } catch (IOException e) {
            }
        }
        return null;
}

 public Enumeration<URL> getResources(String name) throws IOException 
{
        checkInitialized();
        ClassLoader cl = this;
        final ArrayList< Enumeration< URL > > foundResources = 
            new ArrayList< Enumeration< URL > >();
        Enumeration< URL > resourcesEnum;
        do {
            resourcesEnum = cl.findResources(name);
            if (resourcesEnum != null && resourcesEnum.hasMoreElements()) {
                foundResources.add(resourcesEnum);
            }            
        } while ((cl = cl.parentClassLoader) != null);
        resourcesEnum = BootstrapLoader.findResources(name);
        if (resourcesEnum != null && resourcesEnum.hasMoreElements()) {
            foundResources.add(resourcesEnum);
        }
        return new Enumeration< URL >() {
                private int position = foundResources.size() - 1;
                public boolean hasMoreElements() {
                    while (position  >= 0) {
                        if (foundResources.get(position).hasMoreElements()) {
                            return true;
                        }
                        position--;
                    }
                    return false;
                }
                public URL nextElement() {
                    while (position  >= 0) {
                        try {
                            return (foundResources.get(position)).nextElement();
                        } catch (NoSuchElementException e) {}
                        position--;
                    }
                    throw new NoSuchElementException();
                }
            };
}

 static final ClassLoader getStackClassLoader(int depth) 
{
        Class< ? > clazz = VMStack.getCallerClass(depth);
        return clazz != null ? clazz.getClassLoaderImpl() : null;
}

 public static ClassLoader getSystemClassLoader() 
{
        if (!initialized) {
            // we assume only one thread will initialize system class loader. So
            // we don't synchronize initSystemClassLoader() method.
            initSystemClassLoader();
            // system class loader is initialized properly.
            initialized = true;
            // setContextClassLoader(...) method throws SecurityException if
            // current thread isn't allowed to set systemClassLoader as a
            // context class loader. Actually, it is abnormal situation if
            // thread can not change his own context class loader.
            // Thread.currentThread().setContextClassLoader(systemClassLoader);
        }
        //assert initialized;
        SecurityManager sc = System.getSecurityManager();
        if (sc != null) {
            // we use VMClassRegistry.getClassLoader(...) method instead of
            // Class.getClassLoader() due to avoid redundant security
            // checking
            ClassLoader callerLoader = VMClassRegistry.getClassLoader(VMStack
                .getCallerClass(0));
            if (callerLoader != null && callerLoader != systemClassLoader) {
                sc.checkPermission(RuntimePermissionCollection.GET_CLASS_LOADER_PERMISSION);
            }
        }
        return systemClassLoader;
}

 public static URL getSystemResource(String name) 
{
        return getSystemClassLoader().getResource(name);
}

 public static InputStream getSystemResourceAsStream(String name) 
{
        return getSystemClassLoader().getResourceAsStream(name);
}

 public static Enumeration<URL> getSystemResources(String name) throws IOException 
{
       return getSystemClassLoader().getResources(name);
}

 final boolean isSameOrAncestor(ClassLoader loader) 
{
        while (loader != null) {
            if (this == loader) {
                return true;
            }
            loader = loader.parentClassLoader;
        }
        return false;
}

 final boolean isSystemClassLoader() 
{
        return ClassLoaderInfo.isSystemClassLoader(this);
}

 public Class<?> loadClass(String name) throws ClassNotFoundException 
{
        return loadClass(name, false);
}

 protected synchronized Class<?> loadClass(String name,
    boolean resolve) throws ClassNotFoundException 
{
        checkInitialized();
        if (name == null) {
            throw new NullPointerException();
        }
        if(name.indexOf("/") != -1) {
            throw new ClassNotFoundException(name);
        }
        Class< ? > clazz = findLoadedClass(name);
        if (clazz == null) {
            if (parentClassLoader == null) {
                clazz = VMClassRegistry.loadBootstrapClass(name);
            } else {
                try {
                    clazz = parentClassLoader.loadClass(name);
                    if(clazz != null) {
                        try {
                            VMStack.getCallerClass(0)
                                    .asSubclass(ClassLoader.class);
                        } catch(ClassCastException ex) {
                            // caller class is not a subclass of
                            // java/lang/ClassLoader so register as
                            // initiating loader as we are called from
                            // outside of ClassLoader delegation chain
                            registerInitiatedClass(clazz);
                        }
                    }
                } catch (ClassNotFoundException e) {
                }
            }
            if (clazz == null) {
                clazz = findClass(name);
                if (clazz == null) {
                    throw new ClassNotFoundException(name);
                }
            }
        }
        if (resolve) {
            resolveClass(clazz);
        }
        return clazz;
}

 static final  void loadLibrary(String libName,
    ClassLoader loader,
    String libraryPath) 
{
        SecurityManager sc = System.getSecurityManager();
        if (sc != null) {
                sc.checkLink(libName);
        }
        String pathSeparator = System.getProperty("path.separator");
        String fileSeparator = System.getProperty("file.separator");
        String st[] = fracture(libraryPath, pathSeparator);
        int l = st.length;
        for (int i = 0; i <  l; i++) {
            try {
                VMClassRegistry.loadLibrary(st[i] + fileSeparator + libName, loader);
                return;
            } catch (UnsatisfiedLinkError e) {
            }
        }
        throw new UnsatisfiedLinkError(libName);
}

 static final  void loadLibraryWithClassLoader(String libName,
    ClassLoader loader) 
{
        SecurityManager sc = System.getSecurityManager();
        if (sc != null) {
                sc.checkLink(libName);
        }
        if (loader != null) {
                String fullLibName = loader.findLibrary(libName);
                if (fullLibName != null) {
                        loadLibrary(fullLibName, loader, null);
                        return;
                }
        }       
                String path = System.getProperty("java.library.path", "");
                path += System.getProperty("vm.boot.library.path", "");
        loadLibrary(libName, loader, path);
}

 native  void registerInitiatedClass(Class<?> clazz)
Registers this class loader as initiating for a class
Declared as package private to use it from java.lang.Class.forName

 protected final  void resolveClass(Class<?> clazz) 
{
        if (clazz == null) {
            throw new NullPointerException();
        }
        VMClassRegistry.linkClass(clazz);
}

 public  void setClassAssertionStatus(String name,
    boolean flag) 
{
        if (name != null) {
            Class.disableAssertions = false;
            synchronized (definedPackages) {
                if (classAssertionStatus == null) {
                    classAssertionStatus = new Hashtable< String, Boolean >();
                }
            }
            classAssertionStatus.put(name, Boolean.valueOf(flag));
        }
}

 public  void setDefaultAssertionStatus(boolean flag) 
{
        if (flag) {
            Class.disableAssertions = false;
        }
        defaultAssertionStatus = flag ? 1 : -1;
}

 public  void setPackageAssertionStatus(String name,
    boolean flag) 
{
        if (name == null) {
            name = "";
        }
        Class.disableAssertions = false;
        synchronized (definedPackages) {
            if (packageAssertionStatus == null) {
                packageAssertionStatus = new Hashtable< String, Boolean >();
            }
        }
        packageAssertionStatus.put(name, Boolean.valueOf(flag));
}

Empty string is used to denote default package.

 protected final  void setSigners(Class<?> clazz,
    Object[] signers) 
{
        checkInitialized();
        String name = clazz.getName();
        ClassLoader classLoader = clazz.getClassLoaderImpl();
        if (classLoader != null) {
            if (classLoader.classSigners == null) {
                classLoader.classSigners = new Hashtable< String, Object[] >();
            }
            classLoader.classSigners.put(name, signers);
        }
}