JVM Class Loader
What
is ClassLoader in Java
In short here is the location from which Bootstrap, Extension and
Application ClassLoader load Class files.
1) Bootstrap ClassLoader - JRE/lib/rt.jar
2) Extension ClassLoader - JRE/lib/ext or any directory denoted by java.ext.dirs
3) Application ClassLoader - CLASSPATH environment variable, -classpath
or -cp option, Class-Path attribute of Manifest inside JAR
file.
How ClassLoader works in Java
As I explained earlier Java ClassLoader works in three principles :
delegation, visibility and uniqueness.
Delegation
principles
As discussed on when
a class is loaded and initialized in Java, a class is loaded in Java, when
its needed. Suppose you have an application specific class called Abc.class, first
request of loading this class will come to Application ClassLoader which will
delegate to its parent Extension ClassLoader which further delegates to
Primordial or Bootstrap class loader. Primordial will look for
that class in rt.jar and since that class is not
there, request comes to Extension class loader which looks on jre/lib/ext
directory and tries to locate this class there, if class is found there
than Extension class loader will load that class and Application class loader
will never load that class but if its not loaded by extension class-loader than
Application class loader loads it from Classpath
in Java. Remember Classpath is used to load class files while
PATH
is used to locate executable like javac or java command.
Visibility
Principle
According to visibility principle, Child ClassLoader can see class loaded
by Parent ClassLoader but vice-versa is not true. Which mean if class Abc is loaded
by Application class loader than trying to load class ABC explicitly using
extension ClassLoader will throw either java.lang.ClassNotFoundException.
as shown in below Example
package test;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Java program to demonstrate How ClassLoader works in Java,
* in particular about visibility
principle of ClassLoader.
*
* @author Javin Paul
*/
public class
ClassLoaderTest {
public static void
main(String args[]) {
try {
//printing
ClassLoader of this class
System.out.println("ClassLoaderTest.getClass().getClassLoader()
: "
+ ClassLoaderTest.class.getClassLoader());
//trying
to explicitly load this class again using Extension class loader
Class.forName("test.ClassLoaderTest",
true
, ClassLoaderTest.class.getClassLoader().getParent());
} catch (ClassNotFoundException
ex) {
Logger.getLogger(ClassLoaderTest.class.getName()).log(Level.SEVERE,
null, ex);
}
}
}
Output:
ClassLoaderTest.getClass().getClassLoader() : sun.misc.Launcher$AppClassLoader@601bb1
16/08/2012
2:43:48 AM test.ClassLoaderTest
main
SEVERE: null
java.lang.ClassNotFoundException:
test.ClassLoaderTest
at java.net.URLClassLoader$1.run(URLClassLoader.java:202)
at java.security.AccessController.doPrivileged(Native
Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:190)
at sun.misc.Launcher$ExtClassLoader.findClass(Launcher.java:229)
at java.lang.ClassLoader.loadClass(ClassLoader.java:306)
at java.lang.ClassLoader.loadClass(ClassLoader.java:247)
at java.lang.Class.forName0(Native
Method)
at java.lang.Class.forName(Class.java:247)
at test.ClassLoaderTest.main(ClassLoaderTest.java:29)
Uniqueness Principle
According to this principle a class loaded by Parent should not be loaded
by Child ClassLoader again. Though its completely possible to write class loader
which violates Delegation and Uniqueness principles and loads class by itself,
its not something which is beneficial. You should follow all class loader principle while writing your own
ClassLoader.
Class loading and Initialization
http://javarevisited.blogspot.sg/2012/07/when-class-loading-initialization-java-example.html
When a Class is initialized in Java
After class loading, initialization of class takes place which means initializing all static members of class. A Class is initialized in Java when :
1) an Instance of class is created using either new() keyword or using reflection using class.forName(), which may throw ClassNotFoundException in Java.
2) an static method of Class is invoked.
3) an static field of Class is assigned.
4) an static field of class is used which is not a constant variable.
5) if Class is a top level class and an assert statement lexically nested within class is executed.
How Class is initialized in Java
Here are some of the rules of class initialization in Java:
1) Classes are initialized from top to bottom so field declared on top initialized before field declared in bottom
2) Super Class is initialized before Sub Class or derived class in Java
3) If Class initialization is triggered due to access of static field, only Class which has declared static field is initialized and it doesn't trigger initialization of super class or sub class even if static field is referenced by Type of Sub Class, Sub Interface or by implementation class of interface.
4) interface initialization in Java doesn't cause super interfaces to be initialized.
5) static fields are initialized during static initialization of class while non static fields are initialized when instance of class is created. It means static fields are initialized before non static fields in Java.
6)non static fields are initialized by constructors in Java. sub class constructor implicitly call super class constructor before doing any initialization, which guarantees that non static or instance variables of super class is initialized before sub class.
