CSC 150 Chapter 8: High Level Languages: Java
primary information resource: An Invitation to Computer Science (Java), Third Edition, G. Michael Schneider and Judith L. Gersting, Course Technology, 2007.

[ previous | schedule | next ]

High Level Languages (HLLs)

Motivate need for HLLs – disadvantages of assembler language:

• assembly programs not portable
• poor correspondence between problem domain and assembly language (cannot, for instance, translate a complex arithmetic expression directly into one instruction)
• much programmer time spent explicitly micromanaging data (e.g. load, store)
• focus on primitive operations makes it difficult to see the larger picture

HLLs designed to address these shortcomings

• Written for an abstract virtual machine and consequently more portable
• Close(r) correspondence to problem domain terminology (e,g. C, Fortran for math, Cobol for business apps)
• Many data operations done automatically
• A given statement may correspond to several-to-many assembly instructions

HLL is more abstract from machine structure

• Program must be in machine language to execute
• Therefore the translation process HLL -> machine code is more complex
• Compiler translates HLL program into object code and file for later execution
• Interpreter recognizes and immediately executes each HLL instruction.

Java combines these two:

• Java compiler translates program into bytecode, which is low-level but not machine code.
• Bytecode is, however, "machine code" for the Java Virtual Machine (JVM).
• The generated bytecode is stored in a file named with the extension ".class"
• A JVM interpreter then reads the bytecode instructions and immediately executes each one.
• Alternatively, a JVM compiler would translate bytecode to machine code (JIT, just-in-time compilers)
• If you are interested in more details about the bytecode instruction set, here are some resources
• Sun's JVM specification: http://java.sun.com/docs/books/vmspec/2nd-edition/html/VMSpecTOC.doc.html
• Sun's specification of JVM instruction set: http://java.sun.com/docs/books/vmspec/2nd-edition/html/Instructions.doc.html
• Yet another alternative is to design and build a machine for which bytecode is the machine code!  This has been done.

General remarks on Java program structure

application/applet/JavaScript

• application executes stand-alone when invoked with JVM interpreter
• applet executes within a web browser or applet viewer (which have built-in JVM interpreter).
• applets have security restrictions because they are downloaded from a server and run by client's web browser.
• program can be written to be run only as application, only as applet, or as either (subject to security restrictions).
• See simple (though old) 'Java in a Nutshell' applet examples
• Java applets, although run from withint a browser, are different than JavaScript.
• JavaScript is a restricted language in which the program source code is embedded in the HTML page
• JavaScript requires browser to have JavaScript interpreter, applets require JVM interpreter
• JavaScript is used to perform client-side (browser) processing of web forms
• textbook has JavaScript example on p. 443-444.

main

• every application begins execution with method called main.
• standard format: public static void main(String[] args) { ... }
• application may involve multiple files and classes, but only one that includes main can be executed.
• applets ignore main if present, and start with init method instead

packages

• a package is a group of related Java classes
• the Java API consists of many packages
• the upper-left frame of http://math.otterbein.edu/home/java/j2sdk1.5/docs/api/ lists the API packages
• click on one and the lower-left frame lists its classes (by default it lists all classes regardless of what package they are in)
• you warn the compiler that you are going to use a package or class by giving its name in an import statement.
• you can create your own packages

program files

• in general, each class is defined in a file of the same name.
• program that uses more than one class thus requires more than one file
• in order to run your program, all required Java files must be compiled and JVM must be able to find them
• the Java programs you worked with in CSC 120 all required at least two classes/files:
• one to produce and manage the GUI
• another to provide the underlying functionality (e.g. converting between F and C, finding roots, etc).

Data in Java programs

Java variable identifiers implement same concept as labeled .DATA in our assembly language: names that refer to memory locations containing data.

AKA variables, data storage whose contains can be changed.

There are other kinds of identifiers in Java:

• constant identifiers,
• class names,
• method names,
• formal parameters,
• keywords,
• labeled statements (rarely used)

public class Worker  {
  public float grossWages(int hours, float rate) {
    final int fulltime = 40;
    float gross;
    gross = hours * rate;
    if (hours > fulltime) {
       gross = gross + (hours-fulltime) *
               rate * 0.5;
    }
    done: return gross;
  }
}
 

In machine/assembly language, data were defined in a cluster at the end of instructions, to keep them out of the instruction flow.  In Java and most other HLLs, this is not necessary or even allowed.  Variable and constant identifiers (e.g. labels for data) must be declared before being used.

Textbook says that Java variable declarations are usually collected together at the top of the code (the C language requires this, but C++ and Java do not).  Other guidelines recommend declaring a variable “just in time”, just before its first usage.

Variable declaration has form: type variable;
where type is the name of its data type, and variable is the identifier you’ve chosen.

You can specify an initial value using the form: type variable = value;
where type and variable are as above, and value is a valid constant value of the same type.

There are a number of primitive types:

• For integer values: int, short, long, byte
• For real values: float, double
• For Boolean values: boolean
• For single characters: char

All others are object types (classes):

• String, for character sequences, is commonly used
• Other classes are defined in Java API (see http://math.otterbein.edu/home/java/j2sdk1.5/docs/api/)
• Other classes are programmer-defined
• each primitive type has a corresponding wrapper class (first letter is upper case, e.g. Boolean)

String is the most frequently used object type. It is not part of the Java language, but is a class provided in the java.lang package.

You may also declare and use arrays.  An array is:

• a collection of typed data items
• all items are of the same time,
• the collection is given one name
• individual items are referred to by integer position in array, starting at 0.

Instructions in Java programs

Java statements fall into one of three categories: sequential, conditional, iterative

• sequential statements include assignments, input and output
• conditional statements include if and switch statements
• conditional statements include for loops, while loops and do-while loops

input and output instructions

There are various classes of I/O devices:

• Console devices: keyboard and monitor
• File storage devices: normally disk
• Network interfaces
• Other I/O devices (mouse, speaker, etc)

The Java API includes packages for GUI interfaces (e.g. AWT or Swing) which can be used to interact via keyboard/mouse/monitor using WIMP techniques.

Java 1.5 update: Java 1.5 (aka 5.0) includes a new class in the java.util package called Scanner that you can use for easy input from the keyboard (or just about any other input source). Example:
  Scanner scan = new Scanner(System.in); // select keyboard as input source
  int i = scan.nextInt(); // transfer integer input into variable

Programming text-based console output in Java is not so bad, but still fairly primitive.
- Use statement System.out.print(stringExpression); to output a character string.
- Use statement System.out.println(stringExpression); to output a character string followed by newline character.
- In both cases, stringExpression is either a String or something that can be converted into a String (any primitive type, or object type that has a “toString” method).

The Java API includes a variety of classes for file I/O (e.g. FileInputStream, FileOutputStream) and network I/O (e.g. Socket).

The Object-oriented paradigm

Graphics programming and the textbook/Lab 14 examples

We covered the basics of computer graphics hardware in CSC 100.  See my notes on this subject at
http://faculty.otterbein.edu/PSanderson/csc100/notes/lecture07.html

Graphics are drawn within a rectangular window called a frame

• frame height and width are measured in pixels
• pixel is short for picture element, a dot on the screen
• Pixel position is given by its horizontal (x) and vertical (y) displacement from the frame origin.
• frame origin is upper left corner.
• horizontal values start at 0 and increase rightward
• vertical values start at 0 and increase downward

Example: given frame which is 100 pixels high and 200 pixels wide,

• the upper left corner is position (0, 0)
• the upper right corner is (199, 0)
• the lower right corner is (199, 99)
• the lower left corner is (0, 99).

Graphic2.java exemplifies the structure of the Lab 14 graphics programs.
Here it is, annotated with line numbers for each reference.

1   // Graphic2.java

2   import java.awt.*;

3   public class Graphic2 extends LabFrame{

4      int left = 100;
5      int top = 100;

6      public void paint(Graphics g){
7         setBackground(Color.black);
8         g.setColor(Color.white);
9         g.drawString("Click anywhere to draw a rectangle", 10, 40);
10        g.drawRect(left, top, 30, 30);
11     }

12     public void mousePressed(int x, int y){
13        left = x;
14        top = y;
15        repaint();
16     }

17     public static void main(String[] args){
18        LabFrame f = new Graphic2();
19        f.setSize(300, 300);
20        f.setVisible(true);
21     }

22  }

This is the program that draws a small rectangle with its upper-left corner based on the position of the mouse each time you click.

Comments on this code:
 

Line(s)	Comment
3	This application is an extension of LabFrame (see LabFrame.java), which itself extends Frame, one of Java's AWT classes.
6, 12, 17	These are the typical methods found in the Lab 14 programs.  The Graphic2 class inherits quite a few methods.  The mousePressed method is "automatically" called when a mouse button is pressed over the window.  The paint method is called anytime the window is changed and needs to be drawn again.
17-21	main kicks things off by creating and showing a frame (window).
12-16	mousePressed records the mouse position at the time of the button press (lines 13 and 14), and forces the frame to be repainted with a rectangle at the new mouse position.
15	repaint is inherited.  It is a method which in turn calls the paint method.
6-11	When a frame is changed, only its data structure is affected.  This occurs in lines 13 and 14.  In order to make the change visible, the Graphics object associated with the frame needs to be completely painted (drawn) again.  This method specifies how to paint it.  The Graphics object is parameter g.
10	This draws the rectangle itself.  There are four parameters: x-coordinate of upper left corner, y-coordinate of upper left corner, width in pixels, and height in pixels.  Note that rectangle size is constant but position depends on mouse position at the time of the click (at the time mousePressed was called).