Loading Java Classes

From Ian Utting, I.A. Utting@kent.ac.uk

Before main can be called a number of steps must be followed:

--The class must be loaded
--The class must be linked, which includes:
   --Verification
   --Preparation
   --Resolution
--The class (including any superclasses) must be initialised

Class Loading

n       A class is retrieved by name from a class file (or elsewhere) by a Class Loader

n       A class loader may cache or pre-fetch class definitions, but any errors must occur only when the class is used in the program

n       ClassFormatError , UnsupportedClassVersionError , NoClassDefFoundError or ClassCircularityError are possible

{

java.lang.ClassLoader

n       {Each class has an associated class loader which was used to load it, and will be used to load any class loaded by it. It can be retrieved by calling: getClass().getClassLoader()

n       The system has a bootstrap class loader. ClassLoader.getSystemClassLoader() will return it.

n       When a class needs to be loaded, the system calls the loadClass(String name) method on the class loader.

n       So a class is defined by the pair of its name and its class loader.

Defining you own class loader

n       Create a new ClassLoader sub-class to get classes from another source, or in another format by overriding findClass(String name) or loadClass(String name)

n       Use this.getParent() to retrieve your parent’s class loader and delegate class loading to it.

n       Use defineClass(String name, byte [] b) to turn a byte array containing a class file into a Class object

n       Use resolveClass(Class c) to link the resulting Class object

}

 

Class Linking: verification

n       Verification ensures that the class file which is a candidate for loading is structurally correct, i.e.:

n       Every opcode is valid, and all the operands referred to have the correct type for the opcode

n       Every branch instruction must refer to the start of another instruction in the same method

n       All indexes (of methods, invocations etc.) must refer to valid areas of the constant pool

n       The depth of the operand stack must never exceed the value given in the method information in the class file

n       Etc

 

Class Linking: preparation and resolution

 

n       Preparation creates the static fields for the class in the runtime constant pool, and sets them to their default initial values.

n       Resolution resolves symbolic references to classes (etc.) from this class to other (already loaded) classes known to this class loader, or loads them recursively.

n       Access privileges are checked (e.g. private is enforced)

 

Class Initialisation

 

n       Class initialisation is triggered by creating a new instance of the class, or by referencing a static field or method

n       Initialisation causes static fields of the class to be set to their declared values, and static intitialiser blocks to be invoked in the order in which they were declared.

  class A {

    static {

      /* initialisation code */

    }

  }

 

----------------------------------------------------------------------------------------------------------------------------------

Conclusion ：

1 ． Creating new instance of the class :

·         Static variables (initialization with default value, or execute related method for static variables)

·         Static fields

·         Constructor

·         Main method

2 ． Only reference a static field or method :

No other static variables initialization.

 

Example :

package JavaPuzzles.javaInitial;
 
/**
  * output :
 
Test1:t1
print:j
print:constructor
Test1:t2
print:j
print:constructor
print:i
print:static fields
This is static main field
 
initialization: 1)2)3) 4)
  */
 
 
public class Test2 {
      public static int k = 0;
      //1)
      public static Test2 t1 = new Test2( "t1" );
      //2)
      public static Test2 t2 = new Test2( "t2" );
      //3)
      public static int i = print ( "i" );
      public static int n = 99;
 
      public int j ;
 
      static {
            print ( "static fields " );
      }
 
      public Test2(String str ) {
            System. out .println( "Test1:" + str );
            j = print ( "j" );
            print ( "constructor" );         
      }
 
      public static int print(String str) {
            System. out .println( "print:" + str );
            return 0;
      }
      
      public static void main(String[] args){
            //4)
            System. out .println( "This is static main field" );
      }
}