Download Java Concepts ()

Java Concepts and Tips (for C programmers)
N. Guydosh
2/28/02
The following is based some commentary on the concepts presented in Appendix A (Java Primer)
in “Applied Operating Systems Concepts”, by Silberschatz. These comments are not complete,
but hopefully should serve as a review or introduction. They relate or compare Java concepts to
corresponding ANSI C concepts.
If you need a “tutorial” review or would like to download the JDK package, see the “Useful Links”
link on the CS 350 web site. The tutorial given at:
http://java.sun.com/docs/books/tutorial/information/download.html
appears to be useful. Download the tutorial.zip package and expand it out on your hard drive for
the tutorial.
The following pertains to standalone java programs – not applets.

General Comments
The source code for a java Program is a collection of formal structures called classes. A class
in java is similar to a “structure” in C language. A C language structure contains only data
declarations/definitions, whereas a java class contains both data declarations and function
declarations. The function definitions are called “methods” in java. Java functions can only
exist as methods within a class. See code samples in this document for examples.
There are two important special methods: a constructor “method”, and the main method. The
constructor has a function name which is the same as the name of the class. The purpose of he
constructor is to initialize the data variables within the class containing the constructor. There
may be more than one constructor (with the same name) in a class. Multiple constructors are
distinguished by having different input parameter lists. Note that technically a constructor is
not a method since it does not return a value. It more closely resembles a pascal procedure.
Methods, on the other hand, are essentially C functions since they return a value. The main
method defines the logical “entry point” of he Java program. A Java program may consists of
multiple files containing the various classes; the name of the file containing main() must match
tha class name in which it appears. Every stand-alone program (run from the command line)
must contain a main() method.
One property of a Java method which distinguishes it from an ANSI C function is the way
parameters are passed to the function. In ANSI C when a variable is passed to a function, it is
passed by copy. A copy of the current value is passed to the function. If the variable is
modified on the inside of the function, it has no affect on the corresponding variable on the
outside. This is obviously a problem if the variable represents a large data structure. The only
way an outside variable could be modified is by passing a pointer (the address of the variable)
to it to the function. In Java, only primitive variables are passed by value. Objects, on the
other hand, are passed by reference to a method. Any modifications to the object are
immediately reflected in the original object on the outside. A “reference” to an object is
CS350
Spring 2002
Java Concepts
page 1
defined as the name of the object. A reference is logically similar to a pointer in C. When you
pass a reference to a method, you pass a copy of the reference (not the object being
referenced). As long as you do not change the value of the reference pased, then changing the
internals of the referenced object, will be reflected to the object outside of the method that was
passed. See below for more on objects.
How to instantiate or allocate an object from a class definition.
Objects are at the heart of java programming. An object is a particular instantiation or
allocation of a class in much the same way that when we define a variable against a
declaration of a C data structure, the declaration becomes allocated in memory (defined).
Each time a variable is defined against this C data structure, we have another instantiation or
allocation of the structure. Now in Java, a class is allocated or instantiated to an object by the
“new” operator. Taking an example from the sample Java code below, we have a class defined
called Manager. The constructor for Manager is also called Manager (…) with three
parameters. We may now instantiate manager to an object called boss using the new operator:
Manager boss = new Manager(“Pat”, “Supervisor”, 30000);
The left side of the assignment declares boss to be of type Manager (the class), and the right
hand side allocates this variable boss to be an instantiation of Manager. Now an important
event takes place (besides the allocation of memory). Whenever an object is instantiated with
new, the constructor is invoked using the parameters specified in the new statement, and the
resulting object is initialized by invoking the constructor. This initialization is the current state
of the object. Multiple instantiations of an object generally have different states.
How to access data variables and call methods in a class
Once an object has been instantiated, we can now refer to data variables and methods, in the
object in much the same way we reference data variables in a C structure – namely by using
the “dot” notation to get at stuff inside. In our example below, we may invoke the
computeRaise() method in Manager (object boss) as follows:
boss.computeRaise();
Data is referenced the same way as in C data structures. If you want to call a method from
within the object in which it is defined, there is no need to use the dotted qualifier. If you want
to make it explicit to refer to the local object the dotted qualifier “this” could be used:
this.computeRaise(); “this” is a reference to the object in which it is used.
Scope of methods and variables:
Variables and methods defined with the key word public can be referenced outside of the
defining class using the above dot notation. If they are defined with the private key word, the
can only be accessed inside the defining class.
.Summary and a few loose ends:
o A class consists of methods and data declarations. One of the “methods” which has the
same name as the name of the class is the constructor, which gets executed whenever an
object instantiation of the class is allocated using the new operator.
CS350
Spring 2002
Java Concepts
page 2
o A program consists of a number of classes compiled from *.java to *.class using the javac
compiler. One of the classes, say xyz.java must have a “main” method. When you
compile this one: javac xyz.java, all the other classes referenced by xyz will get compiled
also. It is xyz which gets run from the command line using the java command: java xyx .

Inherentance: The primer considers three aspects:
In all cases below, an abstract method is a method which is not defined, but only declared
(used in an interface or an abstract class – to be defined later). It essentially has the format of
a prototype statement in C language. We consider inheritance in three general categories:
o A general class: Extending some arbitrary “base” class to a derived class:
You can extend any class (to another class) by adding (augmenting) variables and methods
to the base class. The format is:
public class base-class {…}
public class derived-class extends base-class {…}
where base-class is the base class
The derived class “derived-class” will use the super statement it initialize base-class from
which it is derived.
You can have many different derived classes.
o An interface: Implementing an interface to a “implemented” class:
An interface is like a class that contains only abstract methods and no data definitions
except constants. You can create a class by “implementing” an interface. This is done by
defining all the abstract methods, and adding any required variable data definitions in the
resulting implemented class.
The format is:
public interface interface-name {…}
public class implemented-class implements interface-name {…}
where “interface-name” is the name of the interface and “implemented-class” is the
name of the class which got implemented.
The resulting class “implemented-class” will use NOT the super statement it initialize
interface from which it is derived because the latter has no implemented methods.
You can have many different implemented classes.
See page 775.
o An abstract class: Extending an abstract class to a derived class:
**** this is what is used in programming with threads ********
An abstract class is like an interface, but can contain both abstract methods and fully
defined methods including variable data definitions. You can “extend” an abstract class
(to a class). The derived class implements the abstract methods of the abstract class.
CS350
Spring 2002
Java Concepts
page 3
The format is:
public abstract abstract-class-name {…}
public class derived-class extends abstract-class-name {…}
where abstract-class-name is the name of the abstract class.
The derived class “derived-class” will use the super statement it initialize abstract class
from which it is derived.
You can have many different derived classes.
The importance of inheritance in our study of threads is that threads are created from an abstract
thread class by using inheritance.
An example will now be given from “Applied Operating Systems Concepts”, 1st ed., by
Silberschatz to illustrate these ideas.
public abstract class Employee
{
public Employee (String n, String t, double s) { // consructor
name = n;
title = t;
salary = s;
}
public void printInfo() {
System.out.println(“Name: “ + name);
System.out.println(“Title: “ + title);
System.out.println(“Salary: “ + salary);
}
public abstract void computeRaise();
private String name;
private String name;
private double salary;
}
// end of class Employee
public class Manager extends Employee
{
public Manager (String n, String t, double s) {
//constructor
super(n, t, s); // calls constructor on class Employee
}
public void computeRaise() {
salary += salary * .05 + BONUS;
}
private static final double BONUS = 2500;
}
// end of class Manager
CS350
Spring 2002
Java Concepts
page 4
public class Developer extends Employee
{
public Developer (String n, String t, double s, int np) {
//constructor
super(n, t, s); // calls constructor on class Employee
numOfPrograms = np;
}
public void computeRaise() {
salary += salary * .05 + numOfPrograms * 25;
}
private int numOfPrograms;
}
// end of class Developer
public class Test
// this is the class containing the main method
{
public static void main(String args[]) {
Employee[] worker = new Employee[3];
worker[0] = new Manager(“Pat”, “Supervisor”, 30000);
worker[1] = new Developer(“Tom”, “Programmer”, 28000, 20);
worker[2] = new Developer(“Jay”, “Intern”, 26000, 8);
for (i = 0; i <3; i++) {
worker[i].computeRaise();
worker[i].printInfo();
}
private int i;
}
}
// end of main
// end of class Test
CS350
Spring 2002
Java Concepts
page 5