8|Page

II. Introduction to Java 
 
Objectives 
 
In  this  chapter,  a  little  bit  of  Java  history  and  what  is  Java  technology  will  be  discussed.  The 
phases that a Java program undergoes will also be tackled. 
 
At the end of this lesson, the student should be able to: 
 Knowledge on the history of Java 
 Describe the features of Java technology 
 Identify the different phases of a Java program 
 
Java Background 
 
  Java was started as a project called "Oak" by James Gosling et al. of Sun Microsystems in 
June  1991.  Its  name  was  changed  to  Java  because  there  was  already  a  language  called  Oak. 
Gosling's goals were to implement a virtual machine and a language that had a familiar C‐like 
notation but with greater uniformity and simplicity than C/C++. The first public implementation 
was Java 1.0 in 1995. It made the promise of "Write Once, Run Anywhere", with free runtimes 
on  popular  platforms.  It  was  fairly  secure  and  its  security  was  configurable,  allowing  for 
network and file access to be limited. The major web browsers soon incorporated it into their 
standard configurations in a secure "applet" configuration. 
 
Java Technology 
 
 A programming language 
As  a  programming  language,  Java  can  create  all  kinds  of  applications  that  you 
could create using any conventional programming language. 
 
 A development environment 
As a development environment, Java technology provides you with a large suite 
of  tools:  a  compiler,  an  interpreter,  a  documentation  generator,  a  class  file  packaging 
tool and so on. 
 
 An application environment 
Java technology applications are typically general‐purpose programs that run on 
any machine where the Java Runtime Environment (JRE) is installed. 
 
 A deployment environment 
Java technology has two main deployment environments: First, the JRE supplied 
by the Java 2 Software Development Kit (SDK) contains the complete set of classes for 
all the Java technology packages, which includes basic language classes, GUI component 

Training-workshop on Object-oriented Programming using Java

9|Page

classes, and so on. The other main deployment environment is the web browser. Most 
commercial browsers supply a Java Technology Interpreter and Runtime environment. 
 
Some Features of Java 
 The Java Virtual Machine 
The Java Virtual Machine (JVM) is an imaginary machine that is implemented by 
emulating  software  on  a  real  machine.  The  JVM  provides  the  hardware  platform 
specifications to which you compile all Java technology code. This specification enables 
the  Java  software  to  be  platform‐independent  because  the  compilation  is  done  for  a 
generic machine known as the JVM. 
A  bytecode  is  a  special  machine  language  that  can  be  understood  by  the  Java 
Virtual  Machine  (JVM).  The  bytecode  is  independent  of  any  particular  computer 
hardware,  so  any  computer  with  a  Java  interpreter  can  execute  the  compiled  Java 
program, no matter what type of computer the program was compiled on. 
 
 Garbage Collection 
Many  programming  languages  allow  a  programmer  to  allocate  memory  during 
runtime.  However,  after  using  that  allocated  memory,  there  should  be  a  way  to  de‐
allocate  that  memory  block  in  order  for  other  programs  to  use  it  again.  In  C,  C++  and 
other  languages  the  programmer  is  responsible  for  this.  This  can  be  difficult  at  times 
since  there  can  be  instances  wherein  the  programmers  forget  to  de‐allocate  memory 
and therefore result to what we call memory leaks. 
In Java, the programmer is freed from the burden of having to de‐allocate that 
memory themselves by having what we call the garbage collection thread. The garbage 
collection thread is responsible for freeing any memory that can be freed. This happens 
automatically during the lifetime of the Java program. 
 
 Code Security
Code security is attained in Java through the implementation of its Java Runtime 
Environment  (JRE).  The  JRE  runs  code  compiled  for  a  JVM  and  performs  class  loading 
(through the class loader), code verification (through the bytecode verifier) and finally 
code execution. 
The  Class  Loader  is  responsible  for  loading  all  classes  needed  for  the  Java 
program. It adds security by separating the namespaces for the classes of the local file 
system from those that are imported from network sources. This limits any Trojan horse 
applications since local classes are always loaded first. After loading all the classes, the 
memory  layout  of  the  executable  is  then  determined.  This  adds  protection  against 
unauthorized  access  to  restricted  areas  of  the  code  since  the  memory  layout  is 
determined during runtime. 
After loading the class and lay outing of memory, the bytecode verifier then tests 
the  format of  the  code  fragments and  checks  the  code  fragments  for  illegal code  that 
can violate access rights to objects. 
After all of these have been done, the code is then finally executed. 
 
Training-workshop on Object-oriented Programming using Java
10 | P a g e

Processing a Java Program 
The following figure describes the process of compiling and executing a Java program. 

   
Figure 2.1: Processing a Java Program 
 
 
Training-workshop on Object-oriented Programming using Java
11 | P a g e

Phase 1: Creating a Program 
 
Phase 1 consists of editing a file with an editor program (normally known simply as an 
editor). You type a Java program (typically referred to as source code) using the editor, make 
any necessary corrections and save the program on a secondary storage device, such as your 
hard  drive.  A  file  name  ending  with  the  .java  extension  indicates  that  the  file  contains  Java 
source code. We assume that the reader knows how to edit a file. Two editors widely used on 
Linux systems are vi and emacs. On Windows, a simple editing program like Windows Notepad 
will  suffice.  Many  freeware  and  shareware  editors  are  also  available  for  download  from  the 
Internet. 
For  organizations  that  develop  substantial  information  systems,  integrated 
development environments (IDEs) are available from many major software suppliers, including 
Sun  Microsystems.  IDEs  provide  tools  that  support  the  software  development  process, 
including editors for writing and editing programs and debuggers for locating logic errors. 
 
Phase 2: Compiling a Java Program into Bytecodes 
 
In Phase 2, the programmer uses the command javac (the Java compiler) to compile a 
program.  For  example,  to  compile  a  program  called  Welcome.java,  you  would  type  javac 
Welcome.java in the command window of your system (i.e., the MS‐DOS prompt in Windows 
95/98/ ME,  the Command Prompt in Windows  NT/2000/XP, the shell prompt in Linux or the 
Terminal application in Mac OS X). If the program compiles, the compiler produces a .class file 
called Welcome.class that contains the compiled version of the program. 
The Java compiler translates Java source code into bytecodes that represent the tasks to 
execute in the execution phase (Phase 5). Bytecodes are executed by the Java Virtual Machine 
(JVM)—a part of the JDK and the foundation of the Java platform. A virtual machine (VM) is a 
software application that simulates a computer, but hides the underlying operating system and 
hardware from the programs that interact with the VM. 
 
Phase 3: Loading a Program into Memory 
 
In  Phase  3,  the  program  must  be  placed  in  memory  before  it  can  execute—known  as 
loading. The class loader takes the .class files containing the program’s bytecodes and transfers 
them  to  primary  memory.  The  class  loader  also  loads  any  of  the  .class  files  provided  by  Java 
that  your  program  uses.  The  .class  files  can  be  loaded  from  a  disk  on  your  system  or  over  a 
network (e.g., your local college or company network, or the Internet). 
 
Phase 4: Bytecode Verification 
 
In Phase 4, as the classes are loaded, the bytecode verifier examines their bytecodes to 
ensure that they are valid and do not violate Java’s security restrictions. Java enforces strong 
security, to make sure that Java programs arriving over the network do not damage your files or 
your system (as computer viruses and worms might). 
 
Training-workshop on Object-oriented Programming using Java
12 | P a g e

Phase 5: Execution 
 
In  Phase  5,  the  JVM  executes  the  program’s  bytecodes,  thus  performing  the  actions 
specified  by  the  program.  In  early  Java  versions,  the  JVM  was  simply  an  interpreter  for  Java 
bytecodes. This caused most Java programs to execute slowly because the JVM would interpret 
and  execute  one  bytecode  at  a  time.  Today’s  JVMs  typically  execute  bytecodes  using  a 
combination of interpretation and so‐called just‐in‐time (JIT) compilation. In this process, The 
JVM  analyzes  the  bytecodes  as  they  are  interpreted,  searching  for  hot  spots—  parts  of  the 
bytecodes that execute frequently. For these parts, a just‐in‐time (JIT) compiler— known as the 
Java  HotSpot  compiler—translates  the  bytecodes  into  the  underlying  computer’s  machine 
language. When the JVM encounters these compiled parts again, the faster machine‐language 
code executes. Thus Java programs actually go through two compilation phases—one in which 
source  code  is  translated  into  bytecodes  (for  portability  across  JVMs  on  different  computer 
platforms) and a second in which, during execution, the bytecodes are translated into machine 
language for the actual computer on which the program executes. 
 
Task  Tool to use  Output 
Write the program  Any text editor  File with .java extension 
File with .class extension (Java 
Compile the program  Java compiler 
bytecode) 
Run the program  Java interpreter  Program Output 
Table 2.1: Summary of Processing of a Java Program 
 
 
 

Training-workshop on Object-oriented Programming using Java