Question

How can we identify that our program is ready for the final execution in computer science in Java.

Answer 1

$\huge\tt\red{Answer}$

Java, being a platform independent programming language, doesn’t work on one-step-compilation. Instead, it involves a two-step execution, first through an OS independent compiler; and second, in a virtual machine (JVM) which is custom-built for every operating system. The two principle stages are explained below:

Compilation

First, the source ‘.java’ file is passed through the compiler, which then encodes the source code into a machine independent encoding, known as Bytecode. The content of each class contained in the source file is stored in a separate ‘.class’ file. While converting the source code into the bytecode, the compiler follows the following steps:

Parse: Reads a set of *.java source files and maps the resulting token sequence into AST (Abstract Syntax Tree)-Nodes.

Enter: Enters symbols for the definitions into the symbol table.

Process annotations: If Requested, processes annotations found in the specified compilation units.

Attribute: Attributes the Syntax trees. This step includes name resolution, type checking and constant folding.

Flow: Performs dataflow analysis on the trees from the previous step. This includes checks for assignments and reachability.

Desugar: Rewrites the AST and translates away some syntactic sugar.

Generate: Generates ‘.Class’ files.

Execution

The class files generated by the compiler are independent of the machine or the OS, which allows them to be run on any system. To run, the main class file (the class that contains the method main) is passed to the JVM, and then goes through three main stages before the final machine code is executed. These stages are:

Class LoaderThe main class is loaded into the memory by passing its ‘.class’ file to the JVM, through invoking the latter. All the other classes referenced in the program are loaded through the class loader.

A class loader, itself an object, creates a flat name space of class bodies that are referenced by a string name. The method definition is:

// loadClass function prototype

  

Class r = loadClass(String className, boolean resolveIt);

  

// className: name of the class to be loaded

// resolveIt: flag to decide whether any referenced class should be loaded or not.

There are two types of class loaders: primordial, and non-primordial. Primordial class loader is embedded into all the JVMs, and is the default class loader. A non-primordial class loader is a user-defined class loader, which can be coded in order to customize class-loading process. Non-primordial class loader, if defined, is preferred over the default one, to load classes.

Bytecode VerifierAfter the bytecode of a class is loaded by the class loader, it has to be inspected by the bytecode verifier, whose job is to check that the instructions don’t perform damaging actions. The following are some of the checks carried out:

Variables are initialized before they are used.

Method calls match the types of object references.

Rules for accessing private data and methods are not violated.

Local variable accesses fall within the runtime stack.

The run time stack does not overflow.

If any of the above checks fails, the verifier doesn’t allow the class to be loaded.

$\huge\tt\red{thnks}$