Java OO and Compilation

Modules and Information Hiding

A class in OOP is a module.

Module - a generalization of a function: a collection of functions, data types, constants and variables packaged together into separately compiled units.

• E.g. trigonometric functions, logarithmic functions, string functions, date/time functions.  Some of these functions are part of a class others may be static and available not associated with a class.
• Most production languages: C, C++, Ada, FORTRAN, COBOL languages were designed with separate compilation of modules.
• Java separately compiles each class; each class definition is a separate file (.java). There is an exception with inner classes (later).

Views

int F1();
// Function F1 behaves
// as follows:
//..pre/post..
int F2();
// Function F2 behaves
// as follows:
//..pre/post..

int F1()
//comments repeated
{
...
}

int F2()
//comments repeated
{
...
}

In Java: standard documentation file (JavaDoc) can be generated from a standard form of commenting in the class definition.  You then supply the .class file and the Javadoc information for the user.

Encapsulation - the grouping of related items for a module and hiding of the private components from the public view.

Advantages of separate compilation:

1. One module may be used by many clients
2. Individual modules may be modified and recompiled without recompiling the entire program
3. Clients of a module may be modified and recompiled without recompiling that module.
4. After a module's object file is generated, the source may be removed to hide the details

Separate Compilation and Linking example for C++. 

Linking - the final step in combining all the modules together for a complete program

Java does the linking dynamically (at run time) with a "class loading" process.  

Compiling Java

Each class definition is in its own file.  The class name MUST be used as the file name and the extension is .java.  Capitalization counts!

Applications must have a main method (just like C/C++).  The JVM will look to the main method as the starting point.

Compiling is a command in the DOS or telnet window such as

javac myclass.java

Running the program from the DOS or Unix command window is

java myclass

Output to console uses methods

System.out.print(string)
System.out.println(string)

The strings may contain the standard escape sequences \n, \t, \\, \"

The Java Language Environment

How is the Java runtime environment different from compiled languages? and also from interpreted languages?

• compile source to bytecodes: "machine independence" (.class file)
• bytecodes are interpreted; performance worse than native code
• every different platform must have a Java Virtual Machine (JVM) program; these are usually built into web browsers as plug-ins.
• appletviewer or the java command in the DOS command window invokes the JVM
• java command in Unix invokes the JVM

What are the three phases to execute Java code?

1. class loader -- load the class file containing the compiled bytecodes; reviews other referred class files and retrieves them, even from the Internet
2. bytecode verifier -- enforce the security model that no illegal byte codes are found and that the codes and operations are also legal in the context of the environment.  E.g., a downloaded applet that accesses a database can only access the database that is on the same host that served the applet
3. interpreter -- execute the bytecodes

What is a "Just-in-time" compiler?

• Part of the interpreter (most JVM's)
• in the first encounter of a sequence of bytecodes, the segment is converted to native code to eliminate the interpretation step for future execution of that segment.
• result is a faster executing java program; slow startup

Off -the-shelf components

Advantages

• object brokerage
• programmers do not have to reinvent algorithms that already exist
• money saving
• improved reliability
• more efficient

Locality

Locality refers to the development of off-the-shelf components

• division of labor
• comprehensibility
• implementation independence

Java Packages

Class files can be put into

• the source directory -- typically a general collection of [possibly unrelated] class files
• package -- this is a directory reference

Packages

Java lets us group related classes together into a unit called a package.

Packages provide several advantages:

• let us organize our files.
• can be compiled separately and imported into our programs.
• make it easier for programs to use common class files.
• help us avoid naming conflicts (two classes can have the same name if they are in different packages).

Using Packages

A Java compilation unit can consist of a file with

• the keyword package followed by an identifier indicating the name of the package:
  • package someName;
• import declarations, to make the contents of other packages available:
  • import java.util.Scanner;
• one or more declarations of classes; exactly one of these classes must be public

The classes defined in the file are members of the package. The name of the file containing the compilation unit must match the name of the public class within the unit. Each Java compilation unit is stored in its own file.

The Java system identifies the file using a combination of the package name and the name of the public class in the compilation unit. Java restricts us to having a single public class in a file so that it can use file names to locate all public classes. Thus, a package with multiple public classes must be implemented with multiple compilation units, each in a separate file.

In order to access the contents of a package from within a program, you must import it into your program:

• import packagename.*;
• import packagename.Classname;

The Java package rules are defined to work seamlessly with hierarchical file systems:

import ch03.stacks.*;

Information Hiding

1. The user is provided with only the information needed to use a module.
2. The implementer is provided with only the information needed to implement a module.

Imports and exports

• Every module has a "wall" around it called the abstraction barrier.
• The module interface allows a module to share certain items with clients of the module.
• These items are exported.
• The client imports the items.
• Module interface diagrams are called Booch Diagrams.

General Booch Diagram

What's shown is what the user needs.  The details of implementation are hidden.

String class in Java

Strings are sequences of characters, but you don't really know how it is stored (info hiding); strings are objects.

Characters are represented internally as Unicode rather than ASCII (2 bytes).

Concatenation operation is +

Strings are immutable-- you cannot change a string.  If you want to change a string you must create a new one.

Garbage collection is part of the JVM to recover the memory from old, discarded objects or strings.