Question

In the parent delegation model for loading classes, I know that loadclass() is invoked on the parent, all the way to the top of the class-loader hierarchy (assuming the class is not loaded). At which point the topmost parent classloader’s findClass is invoked.
If this class is not found, how is the control transferred to the next classloader’s findClass method ?

Answer 1

The findClass(String) will be invoked by the loadClass(String) method of the classloader. It’s default
implementation throws a ClassNotFoundException and is intended to be overridden by classloaders.

The loadClass(String) method will call the following methods in that order

• First it tries to find if the class already loaded: findLoadedClass(String)
• Then if not found it calls the parent’ classloaders loadClass(String) method.
• If not found, it will call the findClass(String) method (custom loading)

So all a custom classloader has to do is override the findClass(String) method to load classes in a custom way. This will ensure the proper delegation in classloading. Check the links (javadoc), it explains what steps are taken and how the findClass(String) is called from loadClass(String)

So the classloading takes place in following order (example)
ClassLoader A with parent B (only explaining the findClass and loadClass)

               A.loadClass()
                    |
                (not-found?) (by findLoadedClass)
                    |
               B.loadClass()
                    |
                (not found?) (by findLoadedClass)
                    |
         systemclassloader.loadClass()  (Bs parent, also can be 
                    |                    called classpath classloader)
                    |
                (not found?) (by findLoadedClass)
                    |
        bootstrap classloader.loadClass() (the bootstrap classloader, 
                    |                      this has no parent)
                    |
                (not found?)
                    |
         systemclassloader.findClass()  (on system classloader, 
                    |                    will try to "find" class in "classpath")
                    |
                (not found?)
                    |
                B.findClass()
                    |
                (not found?)
                    |
                A.findClass()
                    |
                 (not found?)
                    |
            ClassNotFoundException

At any given time if the class is found (eigther by findClass or findLoadedClass), that class is returned.