Class Loading

Question 1

Binary class format

Answer 1

Format:

• init header `cafebabe’ to identify actual classes vs other binaries
• major/minor version numbers
• count of entries in constant pool
• actual constant pool data
• Superclass/interfaces - these reference constant pool entries for the class itself
• Information about fields/methods (themselves complex structures)
• Executable code for methods; code attributes contained within method definitions

Question 2

Constant pool data

Answer 2

Stores all constants used by the class definition

• class and method names, signatures, strings
• Items of variable length: first byte=>type/how to decode
• References to other methods and classes used by this class + declarations for this class and its method

Question 3

Attributes

Answer 3

Some container for data

e. g. method bytecode, constants, value of a constant field
- JVM ignores attributes of unknown type - flexibility for extending use of attributes to serve other purposes [metadata for frameworks that work with user classes - C#]

Question 4

JVM

Answer 4

• stack architecture

- operands: immediate or from constant pool

Question 5

JVM implementation

Answer 5

• Interpreted: slower than executive native code
• JIT translation: compile before executing the first time: better performance for repeated executions
• Adaptive techniques to monitor program execution, selectively optimise heavily used code

Question 6

Linking process in C

Answer 6

C => machine code

linking merges code from separately compiled source files + shared library code to form an executable

Question 7

Linking in Java

Answer 7

• no change to bytecode until loaded into JVM
• linking performed by JVM when class is loaded into memory
• some overhead as classes are initially loaded
• flexibility: e.g.applications can be written to use interfaces with the actual implementations left unspecified until run time [late binding]

Question 8

Loading classes in Java - when

Answer 8

• only load when needed (but JVM has some flexibility, but must maintain a fixed sequence of class initialisation
• dependencies between classes => recursive loading
• Initial core classes used by even empty Java programs
• Load dependencies only when an instance of the class is about to be created by code / static initialisers

Question 9

Loading classes in Java - what happens

Answer 9

• Decode binary class format
• Check compatibility with other classes
• Verify sequence of bytecode operations
• Construct java.lang.Class instance to represent new class
• Class instance becomes basis for all instances of the new class created by the JVM
• Class object is the identifier for the loaded class itself – can have multiple copies of the same binary class loaded into the JVM each with its own Class instance - they share the same class name but will be separate classes to the JVM.

Question 10

Bootstrap class loader

Answer 10

- built into JVM, responsible for loading basic Java class libraries 
special features:
- only load classes found on the boot class path
- less validation since these are trusted system classes

Question 11

Extension class loader

Answer 11

CL for loading classes from standard Java extension APIs

Question 12

System class loader

Answer 12

for loading classes from the general class path including your application classes

Question 13

Application defined class loaders - why

Answer 13

Runtime reloading of classes 
Derived from java.lang.ClassLoader provides core support for building an internal class representation from an array of bytes
Each constructed class is owned by the class loader that loaded it ... they keep a map from name => Class instance, for all loaded classes,  to be able to find one by name if it's requested again

Question 14

Class loader tree

Answer 14

1- class loader keeps reference to a parent class loader, defining a tree of class loaders with the bootstrap loader at the root.
2- When an instance of a particular class (identified by name)
is needed, whichever class loader initially handles the request normally checks with its parent class loader first before trying to load the class directly. 
3- This applies recursively if there are multiple layers of class loaders, so it means that a class will normally be visible not only within the class loader that loaded it, but also to all descendant class loaders. 
4- It also means that if a class can be loaded by more than one class loader in a chain, the one furthest up the tree will be the one that actually loads it.

Question 15

Example: utility of multiple class loaders, J2EE framework

Answer 15

• each J2EE application loaded by the framework needs to have a separate class loader to prevent classes in one application from interfering with other applications
• framework’s code itself will also use one or more other class loaders, to prevent interference to or from applications
• complete set of classloaders make upa