Java Tutorial, July 1, 1996
	Using Java in Scientific Computing 
	Part II:  Java Language and 
	Object-Oriented Concepts 
	http://www.npac.syr.edu/projects/tutorials/Java/ 
		Instructors: Geoffrey Fox ,
		Nancy McCracken
		Syracuse University
		111 College Place
		Syracuse
		New York 13244-4100
	Java Language Basics 
		 
	Java Language -- Lexical Issues I
		Lexical structure inherits a lot from C/C++. There are however some notable differences which are listed below.
		Java characters are based on 16--bit wide Unicode Worldwide Character Encoding rather than the usual 8--bit wide ASCII.
		This allows full support of all alphabets and hence all languages
		Three types of comments are supported: 
			// ignore all till the end of this line 
			/* ignore all between starts */
			 /** an insert into an  automatically generated software documentation */
		 for /** */ one inserts HTML documentation with some simple macros such as @see (to designate see also) BEFORE the method or class being documented
	Java Language -- Lexical Issues II
		Java reserves the following keywords:
		      abstract boolean break byte case catch
		      char class const continue default do double
		      else extends final finally float for
		      goto if implements import instanceof int
		      interface long native new
		      package private protected public return
		      short static super switch synchronized this
		      throw throws transient try void volatile while 
		Note goto is not allowed in Java but its still reserved!
		null true and false are literals with special meaning but not keywords
	Java Language -- Program Structure
		Source code of a Java program consists of one or more compilation units, implemented as files with .java extension.
		Each compilation unit can contain: 
			a package statement 
			import statements 
			class declarations 
			interface declarations
		Java compiler (called javac) reads java source and produces a set of binary bytecode files with .class extensions, one for each class declared in the source file. For example, if Foo.java implements Foo and Fred classes, then "javac Foo.java" will generate Foo.class and Fred.class files.
		Suppose that Foo implements an applet and Fred is an auxiliary class used by Foo. If Netscape/Internet Explorer encounters a tag <APPLET  code="Foo.class">, it will download Foo.class and Fred.class files and it will start interpreting bytecodes in Foo.class.
	Java Language -- Variable/Expression Types
		Each Java variable or expression has a definite type, given by a  declaration such as"int i;". There are three "types" of types!
			There are Primitive or Simple types such as integers or booleans which are built-in. 
			New composite types (objects) can be constructed in terms of classes and interfaces. The type of an object is its class or interface
			Arrays we will see are a sort of "almost" object!
		First we discuss the Primitive Types
			There are 4 integer types: byte, short, int, long of size 8, 16, 32 and 64 bits, respectively. 
			float is 32 bits, double is 64 bits. Floating point arithmetic and data formats are defined by IEEE754 standard.
			characters are given by 16bit Unicode charset and represented as short integers.
		One can use casts for conversion such as longint = (long) i; // which can be explicit as here and sometimes implied (see later)
		Note booleans are either TRUE or FALSE -- they are not 0, 1 ,-1 ...
	Java Language -- Types: Array
		Arrays are "true" or "first class" objects in Java and no pointer arithmetic is supported. 
		An Array is declared as:
		          int vec[]; 
		alternative syntax:   int[] vec;
		and created by:
		           vec = new int[128]; 
		or concisely:
		           int vec[] = new int[128];
		Arrays of arbitrary objects can be constructed,
			e.g.   Thread myThreadList[] = new Thread[1024];
			The only difference is that in the case of primitive types, the array elements are actually allocated.  In the case of arbitrary objects, an array of object references is created;  before you use array elements, you must call the constructor of that type for each element.
	Java Language -- More on Arrays
		An array of length 128 is subscripted by integers from 0 to 127.
		Subscripts are range checked in runtime and so vec[-1] and vec[128] will generate exceptions.
		Array length can be extracted via the length instance variable, e.g.
		           int len = vec.length will assign len = 128.
		Arrays can have dynamic sizing (a fixed size determined at runtime)
		        int sizeofarray = 67;
		        int vec[] = new int[sizeofarray];
		Multidimensional arrays are arrays of arrays
			char icon[][] = new char[16][16]
			These arrays can be "ragged":
				int graph[][] = new int[2][];
				graph[0][] = new int[4];
				graph[1][] = new int[7];
	Java Language -- Expressions
		Java's expressions are very similar to C and the following are valid:
		 2+3
		(2+3)*i
		i++   /* equivalent to i = i +1  */
		(i > 0 ) && (j>0)  /* Boolean */
		i <<1  /*  Left shift by 1 binary digit */
		(i>0) ? true:false  /* conditional expression */
		i >>> 2  /* Signed right shift by 2 binary digits */
		"fred" + "jim" is "fredjim" 
		 /*  + Equivalent to . in Perl */
		(a instanceof B) /* True iff object a is of class B */
	Java Language -- Control Flow I
		if(some boolean expression)  {   .. }
		else if(another boolean)  { .. }
		else {   ...   } 
		while(any boolean) {  /* Do Stuff */  }
		do { /* What to do */ } while(another boolean);
		for(expression1; booleanexpression ; expression2) { ...}
		    naturally starts with expression1, applies expression2 at end of each loop, and continues as long as booleanexpression true
		switch (expression)  {  /* Just as in C */
		case Constant1: /* Do following if expression=Constant1 */
		 /* Bunch of Stuff */
		 break;
		case Constant2: /* Do following if expression=Constant2 */
		 /* Bunch of Stuff */
		 break;  /* ....... */
		default:
		/* Bunch of Stuff */
		 break;
		}
	Java Language -- Control Flow II -- continue
		One can break out of an iteration of a (nested) for loops in fashion offered by Perl but with a different syntax
		outer: // label
		for( int j=0; j<10; j++) { /* Note j only defined in for loop */
		/* select course j */
		     for( int i=0; i<15; i++)   {
		        if(studentgrade[j][i] == 4.0)  {
		            /* Celebrate  */
		            continue outer; // go to next iteration of outer loop
		        }
		     }
		/* Continue jumps to here  to next iteration of loop labelled with outer */
		}
	Java Language -- Control Flow III -- break and for loop
		One can break out of (nested) for loops in fashion offered by Perl with different syntax
		outer: // label
		for( int j=0; j<10; j++) { /* Note j only defined in for loop */
		/* select course j */
		     for( int i=0; i<15; i++)   {
		        if(studentgrade[j][i] == 4.0)  {
		            /* Celebrate  */
		            break outer; // go to end of outer loop
		        }
		     }
		}
		/* break jumps to here out of loop labelled by outer  */
	Java Language -- Control Flow IV -- break and switch
		loopstart: // label
		for( int j=0; j <10; j++)  {
		 switch(j)  {
		  case 3:
		  break;
		  default:
		  if( studentgrade[j] == 2.5)
		      break loopstart;  /* go to end of loop */
		  /* do some stuff */
		  break;
		 }
		}
		/* break loopstart goes to here out of loopstart loop */
	Java Language -- Control Flow V -- continue and switch
		loopstart: // label of following for loop
		for( int j=0; j <10; j++)  {
		 switch(j)  {
		  case 3:
		  break;
		  default:
		  if( studentgrade[j] == 2.5)
		      continue loopstart;  /* go to next iteration of loop */
		  /* do some stuff */
		  break;
		 } // End Switch Block
		/* continue loopstart goes to here for next iteration of loopstart loop */
		} // End loopstart for loop
	Method Definitions
		Subprograms in Java are called methods.  The definition format is
		
			Returntype Methodname ( Parameterlist )
			{
				declarations and statements
			}

		The parameter list contains the types and names of all the parameters.
		The declarations and statements are called the body of the method.  Parameter names and variables declared in the body are local to it.
		Control returns from the methods either when the body is finished execution or a return statement is encountered.  Return statements may also return a result.
	The Java Object Model:  Classes, Instances and Methods
		 
	The Java Object Model Overview
		Programs are composed of a set of modules called classes.   Each class is a template 
		specifying a set of behaviors on 
		the data of the class.
		Each class has class variables 
		(sometimes called instance vars) 
		to hold the data and methods (called 
		functions or procedures in other 
		languages) to define the behaviors.
		Each object in a program is created 
		as an instance of a class.  Each class
		instance has its own copy of the class
		variables.
		Classes can be used for data encapsulation, hiding the details of the data representation from the user of the class (by marking variables as private).
	Defining a Class
		The class definition consists of 
			a header line giving the class name, modifiers, possible subclass and interface structure
			declarations (and possibly initializations) of class variables (aka instance variables)
			declaration of a constructor method.  This method has the same name as the class and does any initialization whenever an instance is created.
			declarations of other methods.
	API of a Class
		Each class has an API (Application Programming Interface) consisting of all the variables and methods that other programmers (i.e. in other classes) are allowed to use.  These are designated by the "public" keyword.
		Example showing part of the Java Date class:
		      public class Date 
		       {  // Constructor methods to create instances of class
		            public Date();
		            public Date(int year, int month, int day);
		          // Accessor and Mutator methods to access and change data
		            public int getHours();
		            public int getYear();
		            . . .
		            public void setHours();
		            public void setYear();
		            . . .
		          // Other public methods
		            public boolean after(Date when);
		            . . .    }
		The on-line Java Hierarchy and Index shows the API's of all Java classes.
	Using a Class
		This declares object today to have type class
		            Date today
		Date() is Constructor of Date class which constructs an instance of Date class and sets default value  to be the current date
		            new Date()
		An example application using a method of the Date class:
		     import java.util.Date;
		     class DateApplication
		     { public static void main ()
		         { Date today = new Date();
		           Date medieval = new Date(1400, 12, 25);
		           if (today.after (medieval))
		               System.out.println( "Today is not medieval!");
		            }}
	A Computational Class
		A class (such as a "main routine") may also be implemented to have just one computational instance.
		This application reads from standard input and counts number of characters which are then printed
		class Count	{
		public static void main (String args[])
		  throws java.io.IOException
		  {  int count = 0;
		     while (System.in.read() != -1)
		        count++;
		      System.out.println("Input has " + count + " chars.");
		}}
	Header of Class Definition
		Class declaration in Java shares common aspects with C++ but there are also some syntactic and semantic differences.
		ClassModifiers class className [extends superClass] [implements interfaces] { <body of class>}
		e.g. public class Test extends Applet implements Runnable { . . . }
		defines an applet that can use threads which have methods defined by Runnable interface
		Only single inheritance is supported but aspects of multiple inheritance can be achieved in terms of the interface construct. Interface is similar to an abstract class with all methods being abstract and with all variables being static (independent of instance). Unlike classes, interfaces can be multiply-inherited.
	Java Language -- Types of Classes - I
		Possible ClassModifiers are:
		abstract -- Contains abstract methods without implementation -- typically such abstract classes have several subclasses that define implementation of methods
		public -- May be used by code outside the class package and (unix) file must be called ClassName.java where ClassName is unique public class in file
		private -- this class can only be used within current file -- i.e current class
		friendly(i.e. empty ClassModifier) -- class can be used only within current package
		protected -- Only accessible to subclasses
	Java Language -- Types of Classes - II
		threadsafe: Instance or static variables will never change asynchronously and so can use compiler optimizations such as assigning to registers. Next modifier -- final -- is also valuable to compilers
		final -- Cannot have a subclass for classes 
			cannot be overridden for methods
			final variables have a constant value e.g.
				final int ageatdeath = 101;
		transient -- specifies that objects are not persistent
		Note most of these modifiers can be used either for a class or an object -- a particular instance of a class
			abstract only makes sense for a class and transient is perhaps more useful on an object basis
	Java Language -- Types of Methods
		MethodModifier ReturnType Name(argType1 arg1, ......)
		Returntypes are either simple types (int, byte etc.), arrays or class names
		Possible MethodModifiers are:
			public -- This method is accessible by all methods inside and outside class 
			protected -- This method is only accessible by a subclass
			private -- This method is only accessible to other methods in this class
			friendly(i.e. empty) -- This method is accessible by methods in classes that are in same package
			final -- a method that cannot be overriden
			static -- This method is shared by ALL instances of this class and can be invoked with <Class>.method syntax as well as <Instance>.method
			synchronized -- This method locks object on entry and unlocks it on exit. If the object is already locked, the method waits until the lock is released before executing -- can be used on methods or statement blocks
			native -- to declare methods implemented in a platform -- dependent language, e.g. C. 
	The Java Object Model:  Inheritance and the Class Hierarchy
		 
	Relationships between Classes
		use
			A uses B:  A calls a method (sends a message to) an object of class B or creates, receives, or returns an object of class B.
		containment
			A has a B:  special case of use - an object of class A contains an object of B
		inheritance
			B is a A:  specialization - B extends A (is a subclass of A) if B has all the variables and methods of A (and more).
			In the class definition of B, the child class, there is no need to repeat declarations of variables and methods of A, they are assumed to be there.  The definition of B has the additional variables and methods of B.
	Use of Methods Defined in Parent
		Call to method in Object2 (message) from object1 is passed up the class hierarchy until a definition is found
	Use of Methods Defined in Parent but overridden in child class
		Call to method in Object2 (message) from object1 is passed up the class hierarchy until a definition is found
	Comments on Casting
		Casting (type conversion) is supported between types and class types. Syntax:
			(classname)reference
		Two forms of casting are possible: widening and narrowing
		Widening, where the subclass is used as an instance of the superclass, is performed implicitly
		Narrowing, where the superclass is used as an instance of the subclass, must be performed explicitly
		Given Parent: Dot -> DrawableDot (Child):
			Widening: An instance of DrawableDot is used as an instance of Dot
			Narrowing: An instance of Dot is used as an instance of DrawableDot
		Casting between sibling classes is a compile-time error
	Array - A Pseudo Class!
		Not in any package
		One final instance variable: length
		For each primitive type (and all classes), there's an implicit Array subclass
		Cannot be extended (subclassed)
		Superclass is Object
		Inherits methods from Object
		(new int[5]).getClass().getSuperclass()  
		will return Java.lang.Object
	By value and By reference 
		Many languages are confusing as they differ in often unstated distinction between the value and "handle" -- Java is no exception! (reference,address,pointer) of an entity
		Consider assignment:       a = b;     // sets value of a to value of b
		If a and b are primitive types, then they hold "actual literals" and so if b=66, then a is set to 66
			In this case if you change b, then a is left unchanged
		However if a or b is an object, b is in fact a reference and so one sets a to refer to same object as b (i.e. same "location" in memory)
			if you change b in some way, then a will be changed accordingly
			Note null is value of an object which has not been assigned (constructed) and so does not point anywhere
		Arguments to Methods are always passed by value BUT if an object is an argument, then that value is ALWAYS a reference and so in practice
			Primitive types are passed by value
			Objects are passed by reference
		Arrays reflect properties of what they are arrays of!
	Comments on Overloading and Overriding in Classes
		Overriding Methods (where child class provides method with same signature as method in parent)
			To override a method, a subclass of the class that originally declared the method must declare a method with the same name, return type (or a subclass of that return type), and same parameter list.
			When the method is invoked on an instance of the subclass, the new method is called rather than the original method.
			The overridden method can be invoked using the super variable.
			Super can be used to refer to instance variables in the superclass as well.
		Overloading (where a class can provide a set of methods all with the same name, but with different signatures):  The signature is defined (as in Arnold-Gosling book) by
			Lowest conversion cost of parameter list, based on type and number of parameters.  Return type and declaration order not important.
			Java will declare an error if method is invoked where there is not one with a unique signature which matches call after removing less specific methods (use of objects in hierarchy can cause lots of confusing matches!)
	Abstract Methods
	 and Classes
	Interfaces
	(classes without implementation)
		 
	Abstract Methods and Classes
		An abstract method has no body - it is provided in a class to define the signature of the method for program structuring purposes.  It must be defined in some subclass of the class in which it is declared.
			Constructors, static methods, private methods cannot be abstract
			A method that overrides a superclass method cannot be abstract
		Classes that contain abstract methods and classes that inherit abstract methods without overriding them are considered abstract classes
			It is compile-time error to instantiate an abstract class or attempt to call an abstract method directly.
	Java Language -- Interfaces - Overview
		An interface specifies a collection of methods (behaviors) without implementing their bodies (akin to giving the API).
			public interface Storable {
			     public abstract void store(Stream s);
			     public abstract void retrieve(Stream s);
			    }
		Any other class which implements the interface is guaranteeing that it will have the set of behaviors, and will give concrete bodies to the methods of the interface.
		Interfaces solve some of the same problems as multiple inheritance, without as much overhead at runtime. 
			There is a small performance penalty because interfaces involve dynamic method binding.
		Interfaces can be implemented by classes on unrelated inheritance trees, making it unnecessary to add methods to common superclass.
	Cars as an Examples of Interfaces/ Multiple Inheritance
		We could imagine a Ford Mustang as inheriting from two major sources 
		Firstly a set of manufacturing companies -- make these interfaces as "qualitative"
		Secondly from a set of Vehicle types which we will make real classes as there are non trivial methods involved in constructing cars
	Picture of Interfaces and Classes for Cars and their Manufacture
		
		Cars MyFordMustang = new Cars(Lots of Options)
		is a particluar instance of  class Cars
	Java Language -- Interface Example -- Implementing Storable 
		A class may implement an interface, in which case it provides the body for the methods specified in the interface.
		interface storable has store and retrieve methods
			public class Picture implements Storable {
			     public void store(Stream s) {
			          // JPEG compress image before storing
			        }
			     public void retrieve(Stream s) {
			          // JPEG decompress image before retrieving
			        }
			   }
			public class StudentRecord implements Storable {
			      . . .
			   }
	Interfaces can be used as Classes in type specification
		Interfaces behave exactly as classes when used as a type.
		The normal type declaration syntax "interfaceName variableName" declares a variable or parameter to be an instance of some class that implements interfaceName.
			public class StudentBody {
			     Stream s;
			     Picture id_photo; // of interface storable
			     StudentRecord id_card; // of interface storable
			     . . .
			     public void register() {
			          save(id_photo);
			          save(id_card);
			       }
			     public void save(Storable o) {
			          o.store(s);
			       }
			   }
	Further Features of Interfaces
		Interfaces are either public or have the default friendly access (public for the package and private elsewhere)
		Methods in an interface are always abstract and have the same access as the interface. No other modifiers may be applied
		Variables in an interface are public, static, and final. They must be initialized.
		When a class implements an interface:
			it implements all the methods described in the interface
			or it is an abstract class, which leaves the implementation of some or all of the interface methods to its subclasses
		Interfaces can incorporate one or more other interfaces, using the extends keyword:
			public interface DoesItAll extends Storable, Paintable {
			     public abstract void doesSomethingElse();
			  }
		A class can implement more than one interface:
			public class Picture implements Storable, Paintable {
			     public void store(Stream s) {...}
			     public void retrieve(Stream s) {...}
			     public void refresh() {...}
			  }
	More on Interfaces -- Why use them 
		Note that Interfaces often play a software engineering as opposed to required functional role
		Note that Interfaces are not significantly used in current Java release where perhaps there are 15 times as many class definitions as interface definitions
		Two examples are Runnable and Cloneable both of which extend Object class -- note interfaces like classes can extend existing classes. 
		The Runnable Interface has one method run() which must always be overwritten and is used to indicate that class with this interface can use threads without being a subclass of Thread. Applets must use Runnable if they need explicit threads because they explicitly are a subclass of panel and as no multiple inheritance, one cannot be a subclass of two classes
	Packages in Java
		 
	Overview of Packages and Directory Structure
		One file can contain several related classes, but only one of them can be public.  If the public class is called wheat.java, then the file must be called wheat.
		A set of classes in different files can be grouped together in a package.  Each of the files must be in the same directory and contain the command 
			package mill;
		The name of the directory must also be mill.
	Using Java packages
		One conveniently uses files in a package by inserting
			import mill.* 
		at the beginning of a file that needs classes from the mill package
			Then classes in the mill package can be refered to by just using their Classname
			Without the import command, one must explicitly say mill.Classname
		Packages can be grouped hierarchically, with the corresponding directory tree.  For example, the mill package could be a subpackage of agriculture.  Then a class is referred to as agriculture.mill.Classname.
		Except for classes provided with the Java language, all of which have the form java.X, a class that is imported or used must either be in the current directory or be accessible to the compiler through the CLASSPATH environment variable.
	Java 1.0 System Packages
		java.lang  Contains essential Java classes and is by default imported into every Java file and so import java.lang.* is unnecessary. Thread, Math, Object and Type Wrappers are here
		java.io contains classes to do I/O. This is not necessary (or even allowed!) for applets which can't do much I/O in Netscape!
		java.util contains various utility classes that didn't make it to java.lang. Date is here as are hashtables 
		java.net contains classes to do network applications. This will be important for any distributed applications
		java.applet has the classes needed to support applets 
		java.awt has the classes to support windowing -- The Abstract Windows Toolkit
		java.awt.image has image processing classes
		java.awt.peer is a secret set of classes with platform dependent details
	More on the Java Language:  Exceptions
		 
	Java Language -- Handling Runtime Errors Using Exceptions
		The language itself supports concept of an exception
		Java supports a hierarchical model of exceptions which allow and indeed require user to supply suitable handlers for any exception that can occur in a Java program
		Note exceptions that can occur in a method must either be caught (i.e. handled inside method) or thrown (i.e. returned to callee)
		Thrown exceptions are like returned arguments and are for instance part of interface to a method
		Exceptions are all (at some level in hierarchy) subclasses of Throwable class
	User Created Exceptions
		Exception class has two constructors, one of which allows a message to be included in each instance.
		The user can either throw an exception of type Exception with a unique message, or create own subclass of Exception:
		
		   public static void MyMethod() throws MyException
		     { . . . 
		       throw new MyException;
		       . . . }
		   class MyException extends Exception
		     { public MyException ()
		          { super ("This is my exception message."); }
		     }
		Methods which call "MyMethod" should use a try and catch block which catches an exception e of type MyException.  Methods e.getMessage and e.printStackTrace can be used on Exceptions.
	Basic Structure of Exception Handling in Nested Calls
		method1 {
		    try {
		           call method2;
		        }  catch (Exception3 e) {
		          doErrorProcessing(e);
		        }
		  }
		method2 throws Exception3  {
		     call method3; // method2 just passes exception through
		  }
		method3 throws Exception3 {
		     call dividebyzeroorreadfileorsomething; // create exception
		  }
	Examples of Exception Hierarchy
		As Examples of hierarchy:
		catch(FileNotFoundException e) { .. } would catch particular exception whereas
		catch(IOException e) { .. } would catch all IOexceptions
	Example of Handling Exceptions
		File file; /* defines file to be object of class File */
		try{
		     file = new File("filenameyouwant");
		     . . . . .
		     file.write("stuff put out");
		  } catch (IOException e)  {
		         /* This catches ALL I/O errors including 
		                        read and write stuff */
		         /* Handle Exception somehow */
		  return;
		  }
		  /* but the optional finally clause will be executed 
		            whether or not code terminates normally */
		  finally {
		        file.close();
		  }
	Classes of Exceptions 
		There are two subclasses of Throwable
			Error such as OutOfMemoryError which do NOT have to be caught as they are serious but unpredictable and could typically occur anywhere!
			Exception which we have discussed 
		Exception has a subclass RuntimeException that need NOT be caught
		Typical RuntimeException subclasses are
		ArithmeticException,  ClassCastException, IndexOutofBoundException
	Exceptions in Applets
		When writing a Java applet, your code is overriding one of the standard applet methods, and you are not allowed to throw any exceptions that it would not.  So, in general, you must handle exceptions.
		What to do:  The standard trick of writing a message to System.out works fine for debugging when running with the applet viewer.  It also works fine with the Netscape browser for errors that you don't really expect to happen in working code (like your code had a null pointer) because Netscape provides a "Java console" under the Options menu that displays all messages.
		However, for errors that you really want to bring to the attention of the user, such as they typed in their URL incorrectly and the network methods returned a "malformedURLException", you can put up a pop-up window in the style of professional GUI programs.
		Note that you don't have to micromanage exceptions - you don't have to put a "try-catch" construct around every statement that can throw an exception.  You can put the "try-catch" around the entire code with the same catch action or even put different catches for different actions of the errors.