|
|
The Java compiler not only checks
that your syntax is correct in your source code
that was created in the Java language, but it
ensures that the code doesn't violate the
language's safety rules. The compiler ensures
that you have not made any errors, such as
casting objects that are incompatible or using
incorrect parameters.
The Java Compiler works
similarly to compilers in C-type languages in
that it takes intelligible source code and
converts it to code for a machine to interpret.
The difference is that the machine that the Java
compiler compiles for is the Java Virtual
Machine, and the code is not native machine code
for your CPU, it is bytecode for the JVM.
Additionally, the Java compiler does not convert
references to numbers and does not create a
memory layout for the program at compile time.
Although performance takes a hit since
references in Java must be looked up in an
object index at runtime instead of referring to
exact memory addresses with the code, these
changes were made for security reasons.
The compiler enforces sizes
for bytecode commands and symbolic address
references it creates. Each bytecode command
consists of an opcode and an operand.
The opcode is the command that the interpreter
recognizes. The operand is the data needed by
the opcode. Opcodes are executed sequentially
and stored in 8-bit numbers. Operands vary in
length, but are divided into bytes. Each opcode
has a 32-bit symbolic address reference, or
handle. The interpreter is able to locate pieces
of code in memory using the opcodes assigned by
the compiler. It is important that these sizes
remain constant for portability, and the
compiler ensures that they are.
|
|
