Full HTML for Basic Java Tutorial 98- 2: Java Language and Object Oriented Techniques

Full HTML for

Basic foilset Java Tutorial 98- 2: Java Language and Object Oriented Techniques

Given by Geoffrey C. Fox, Nancy McCracken at NAVO Tutorial on Sept 23 1998. Foils prepared Sept 21 1998
Outside Index Summary of Material

In Part 1 of the Tutorial We Covered:

Overview including History and alpha versus production issues
Comparison of Java and Javascript
Overall Java Philosophy and Features including security etc.

This Part(2) of Tutorial Covers

Java Programming Language

Introduction to Applications,Applets and their Invocation from HTML
"Hello World" and Basic Graphics Applets

Object Oriented and Class Structure

Methods, Constructors etc.
Interfaces

Exceptions

And in the Remaining Parts of the Java Tutorial We Cover:

Applet Programming and Threads
Abstract Windowing Toolkit
Networking and I/O
Futures and HPCC Implications

Table of Contents for full HTML of Java Tutorial 98- 2: Java Language and Object Oriented Techniques

Denote Foils where Image Critical

Denote Foils where Image has important information

Denote Foils where HTML is sufficient

denotes presence of Additional linked information which is greyed out if missing

1

Java Tutorial - 1998
2

Java Language Basics
3

Java Language -- Lexical Issues I
4

Java Language -- Lexical Issues II
5

Java Language -- Program Structure
6

Java Variable/Expression Types
7

Primitive Types
8

Java Language -- Types: Array
9

Java Language -- More on Arrays
10

Java Language -- Expressions
11

Java Language -- Control Flow I
12

Java Language -- Control Flow II
13

Method Definitions
14

The Java Object Model: Classes, Instances and Methods
15

The Java Object Model Overview
16

Account class definition examples for Foil 16

Defining a Class
17

API of a Class
18

Using a Class
19

A Computational Class
20

Header of Class Definition
21

Java Language -- Types of Classes - I
22

Java Language -- Types of Classes - II
23

Java Language -- Types of Methods
24

The Java Object Model: Inheritance and the Class Hierarchy
25

Account child class definition examples for Foil 25

Relationships between Classes
26

Use of Methods Defined in Parent
27

Use of Methods Defined in Parent but overridden in child class
28

Comments on Casting
29

Array - A Pseudo Class!
30

By value and By reference
31

Comments on Overloading and Overriding in Classes
32

Abstract Methods and Classes Interfaces (classes without implementation)
33

Abstract Methods and Classes
34

Java Language -- Interfaces - Overview
35

Interface Example -- Implementing Storable
36

Interfaces can be used as Classes in type specification
37

Further Features of Interfaces
38

Foil 1 Java Tutorial - 1998

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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

HTML version of Basic Foils prepared Sept 21 1998

Foil 2 Java Language Basics

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

HTML version of Basic Foils prepared Sept 21 1998

Foil 3 Java Language -- Lexical Issues I

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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

HTML version of Basic Foils prepared Sept 21 1998

Foil 4 Java Language -- Lexical Issues II

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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 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

HTML version of Basic Foils prepared Sept 21 1998

Foil 5 Java Language -- Program Structure

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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.

HTML version of Basic Foils prepared Sept 21 1998

Foil 6 Java Variable/Expression Types

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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!

HTML version of Basic Foils prepared Sept 21 1998

Foil 7 Primitive Types

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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

long l;
l = (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 ...

HTML version of Basic Foils prepared Sept 21 1998

Foil 8 Java Language -- Types: Array

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

Arrays are "true" or "first class" objects in Java and no pointer arithmetic is supported.

Like other objects, an array must be declared and created:

int states[]; // declaration
alternative syntax: int[] vec;
and then:
states = new int[128]; // creation
or concisely:
int states[] = new int[128];

Arrays of arbitrary objects can be constructed,

e.g. Color manycolors[] = new Color[1024];
The only difference is that in the case of primitive types, the array elements are actually created. 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.

HTML version of Basic Foils prepared Sept 21 1998

Foil 9 Java Language -- More on Arrays

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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];

HTML version of Basic Foils prepared Sept 21 1998

Foil 10 Java Language -- Expressions

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

Java's expressions are very similar to C and include the following forms. Both expressions and statements have values.

arithmetic:
- 2+3
- (2+3)*i
autoincriment and autodecriment
- i++ /* equivalent to i = i +1 */
boolean
- ((i > 0 ) && (jɬ)) ||(state = -1)
bit operations
- i <ə /* Left shift by 1 binary digit */
conditional expression
- (iɬ) ? expression1 : expression2
strings have operators such as catenation
- "fred" + "jim" is "fredjim"
object property operators
- (a instanceof B) /* True iff object a is of class B */

HTML version of Basic Foils prepared Sept 21 1998

Foil 11 Java Language -- Control Flow I

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

if (some boolean expression) { .. }

else { ... } // optional else

Nested: 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
- for ( int i=0; i<length(a); i++)
- a[i] = i * i;
- /* loop variable i is optionally declared to be local to loop as shown here. */

HTML version of Basic Foils prepared Sept 21 1998

Foil 12 Java Language -- Control Flow II

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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;
}

One can go to the next iteration of a loop by using

continue;

or break out of the loop by using

break;

HTML version of Basic Foils prepared Sept 21 1998

Foil 13 Method Definitions

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

Subprograms in Java are called methods. The definition format is

Modifiers 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.

HTML version of Basic Foils prepared Sept 21 1998

Foil 14 The Java Object Model: Classes, Instances and Methods

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

HTML version of Basic Foils prepared Sept 21 1998

Foil 15 The Java Object Model Overview

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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).

Instance

Variables

Methods

HTML version of Basic Foils prepared Sept 21 1998

Foil 16 Defining a Class

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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.

HTML version of Basic Foils prepared Sept 21 1998

Foil 17 API of a Class

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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);
. . . }

HTML version of Basic Foils prepared Sept 21 1998

Foil 18 Using a Class

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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!");
}}

HTML version of Basic Foils prepared Sept 21 1998

Foil 19 A Computational Class

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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.");
}}

HTML version of Basic Foils prepared Sept 21 1998

Foil 20 Header of Class Definition

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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.

HTML version of Basic Foils prepared Sept 21 1998

Foil 21 Java Language -- Types of Classes - I

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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 friendly(i.e. empty ClassModifier) -- class can be used only within current package
protected -- Only accessible to subclasses

HTML version of Basic Foils prepared Sept 21 1998

Foil 22 Java Language -- Types of Classes - II

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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

HTML version of Basic Foils prepared Sept 21 1998

Foil 23 Java Language -- Types of Methods

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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.

HTML version of Basic Foils prepared Sept 21 1998

Foil 24 The Java Object Model: Inheritance and the Class Hierarchy

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

HTML version of Basic Foils prepared Sept 21 1998

Foil 25 Relationships between Classes

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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 an 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.

HTML version of Basic Foils prepared Sept 21 1998

Foil 26 Use of Methods Defined in Parent

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

If you call a method in a class that was defined in some parent, the compiler has a simple algorithm to find the definition: it searches up the parent/child hierarchy.

Class:

method A

Definition of method

is given in parent

Class:

Object2

Object1

Object1 creates object2

and calls object2.A

HTML version of Basic Foils prepared Sept 21 1998

Foil 27 Use of Methods Defined in Parent but overridden in child class

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

This algorithm also works for the case when the method is overridden

Class:

method A

Definition of method

is given in parent

Class:

method A

Class:

Object2

Object1

Object1 creates object2

and calls object2.A

HTML version of Basic Foils prepared Sept 21 1998

Foil 28 Comments on Casting

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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

HTML version of Basic Foils prepared Sept 21 1998

Foil 29 Array - A Pseudo Class!

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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

HTML version of Basic Foils prepared Sept 21 1998

Foil 30 By value and By reference

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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!

HTML version of Basic Foils prepared Sept 21 1998

Foil 31 Comments on Overloading and Overriding in Classes

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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!)

HTML version of Basic Foils prepared Sept 21 1998

Foil 32 Abstract Methods and Classes Interfaces (classes without implementation)

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

HTML version of Basic Foils prepared Sept 21 1998

Foil 33 Abstract Methods and Classes

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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.

HTML version of Basic Foils prepared Sept 21 1998

Foil 34 Java Language -- Interfaces - Overview

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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.

HTML version of Basic Foils prepared Sept 21 1998

Foil 35 Interface Example -- Implementing Storable

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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 {
- . . .
- }

HTML version of Basic Foils prepared Sept 21 1998

Foil 36 Interfaces can be used as Classes in type specification

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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);
}
}

HTML version of Basic Foils prepared Sept 21 1998

Foil 37 Further Features of Interfaces

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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.

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() {...}
}

HTML version of Basic Foils prepared Sept 21 1998

Foil 38 More on Interfaces -- Why use them

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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

But Interfaces play a crucial role in the Remote Method Interface (RMI), where an Interface is the common specification between a Java applet or application and the set of methods that it can call remotely.

HTML version of Basic Foils prepared Sept 21 1998

Foil 39 Packages in Java

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

HTML version of Basic Foils prepared Sept 21 1998

Foil 40 Overview of Packages and Directory Structure

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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.

Directory name: mill

File: wheat.java: stone.java:

package mill package mill

public class wheat . . . public class stone . . .

HTML version of Basic Foils prepared Sept 21 1998

Foil 41 Using Java packages

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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
ithout 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.

HTML version of Basic Foils prepared Sept 21 1998

Foil 42 Java 1.0 System Packages

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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

HTML version of Basic Foils prepared Sept 21 1998

Foil 43 Additional Java 1.1 System Packages

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

java.awt.datatransfer Classes and interfaces to transfer data from a Java program to the system clipboard (enabling drag-and-drop)

java.beans Contains classes to write reusable software components

java.lang.reflect Enables a program to discover the accessible variables and methods of a class at run-time

java.rmi Remote Method Invocation

java.security Enables a Java program to encrypt data and control the access privileges provided

java.sql Java Database Connectivity (JDBC) enables Java programs to interact with a database using the SQL language

java.text Classes that provide internationalization capabilities for numbers, dates, characters and strings

java.util.zip Combines java .class files and other files into one compressed file called a Java archive (JAR) file.

HTML version of Basic Foils prepared Sept 21 1998

Foil 44 More on the Java Language: Exceptions

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

HTML version of Basic Foils prepared Sept 21 1998

Foil 45 Java Language -- Handling Runtime Errors Using Exceptions

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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

HTML version of Basic Foils prepared Sept 21 1998

Foil 46 User Created Exceptions

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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.

HTML version of Basic Foils prepared Sept 21 1998

Foil 47 Basic Structure of Exception Handling in Nested Calls

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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
}

HTML version of Basic Foils prepared Sept 21 1998

Foil 48 Examples of Exception Hierarchy

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

As Examples of hierarchy:

catch(FileNotFoundException e) { .. } would catch particular exception whereas

catch(IOException e) { .. } would catch all IOexceptions

Throwable

. . .

Error

Exception

Runtime Exception

IOException

Runtime Exception

HTML version of Basic Foils prepared Sept 21 1998

Foil 49 The complete try/catch/finally statement

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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();
}

HTML version of Basic Foils prepared Sept 21 1998

Foil 50 Classes of Exceptions

From Java Tutorial 98- 2: Java Language and Object Oriented Techniques NAVO Tutorial -- Sept 23 1998. *

Full HTML Index

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

Note that exceptions which are thrown but not caught appear as error message on stderr. For applets this is in the "Java console" of the browser.

If you have any comments about this server, send e-mail to webmaster@npac.syr.edu.

Page produced by wwwfoil on Sat Nov 28 1998