• Introduction
• OO Concepts
• (break)
• Java Language Fundamentals
• JDK Components
• (discussion, questions)
• References
• Sample Programs

• Class objectives
• Logistics
• Additional Material
• Projects/homework
• Meeting outlines

• Based on "real world", intuitive, visualization
• Programming unit is class

• Each class consists of fields (data) and methods (functions)
• Fields and methods have scope and accessibility rules (more specifics below for Java)
• Classes have hierarchy (inherit from parent)
• Object is instance of a Class (dynamically and explicitly created using "new" operator, "constructor" method)
• Actions on objects are performed by referencing the object plus one or more methods. Example: myObject.getDescription()
• Public fields of an object are accessed by referencing the object plus the fieldname (not recommended in general except for static). Example: myObject.name
• Memory allocation, other OS resources implicit

Syntax -

Very similar to C and C++

Statement delimiter is ; Blank lines anywhere, continuation character (if needed) is \

Comments can be added by using:

• // to begin a comment, comment end is the end of the current line
• /* to begin a comment; comment end is next occurrence of */ (across many lines if desired)
• /** to begin a comment and comment end at next occurrence of */ (this should only be used to describe methods, etc that you wish to be picked up by the documentor utility)

Block structure used to begin and end related statements using { }. Variable scope, by default, is limited to the block (and any nested blocks) in which it is defined.

Names (field, method, class) must begin with a letter, underscore or dollar sign; remaining characters can include digit (0-9). Java implicitly supports unicode so "letter" means lower or upper case a-z plus unicode values greater than x00c0. There are approximately 50 reserved names which cannot be used.

Modifiers for fields, methods and classes determine accessibility from external and sub classes:

Special names include:

• this - refers to the current object
• super - refers to class of which this is an extension (especially useful in constructor)

• Numeric Integer (byte, short, int, long)
• Floating point (float, double)
• char (single character)
• boolean (true, false)
• Arrays (dynamically allocated, use "length" instance variable to determine size)
• Casting can be used between various dissimilar intrinsics
• Type wrappers (Integer, Float, Long, Double) should be used to convert between intrinsics and object data Example: Integer.parseInt("123") OR int x1 = i2.intValue() where i2 is an Integer

• combinative (+ - * / % & | ^ etc)
• logical (== != && || etc)
• confusing, such as += -=, etc
• special ? :
• class related (new, instanceof)

• if … else
• for
• switch
• break
• continue
• return
• while
• do … while
• label (used in conjunction with nested statements and "break" or "continue" no "goto" although it is kept as one of the reserved words)
• import
• class
• interface
• package

Classes are strictly hierarchical - multiple inheritance not provided. Classes are defined using the "class" keyword with appropriate modifiers as described above. The class definition will contain its instance variables and objects as well as its methods. A special method called the constructor is identified by using the class name as its name.

The class methods (including the constructor) can be "overloaded" meaning that the same method can be defined serveral times. Each definition must contain a unique set of input parameters.

Classes can be:

• self-contained (in which case they are really under "java.lang.Object") - all fields and methods are defined in this class file
• extensions of one other class (parent or super) indicated by using "extends" in definition - fields and methods can be inherited from parent class or superceded by redefination. Use "super" to reference parent class methods and variables if necessary
• abstract - indicated by using "abstract" modifier in definition - this type of class indicates implementation requirements only; it does not contain the actual implementation details
• completion of an interface - indicated by using "implements" in definition - methods specified by abstract class definition must be defined. Note that the class can be an implementation of more than one interface

Interfaces are collections of abstract classes that are used to indicate content. They are defined using the "interface" keyword and may contain only static fields and/or a list of methods (which are automatically abstract). The listed methods must be defined by any class which implements the interface (this is their main purpose).

Packages are groups of related classes and/or interfaces. The benefits of combining classes into a package are:

• the package (or some of its components) can be imported into an external class using the "import" statement
• the default accessibility of fields and methods includes all classes in the package

To create a package, you must include the "package" statement at the beginning of each class file in the package. This statement contains the package name. Example: package Polygons

Source input is maintaned in .java files; compiled output is to .class files. There can be only one public class defined in each .java file; its name must match the name of the file.

• Java Website Links

• IBM Java Development
There is a complete HTML Java API reference included with the JDK. After you have installed all components, you can view it by pointing your browser to the file: x:\javaos2\docs\api\API_users_guide_html where x is the drive letter on which the JDK was installed
• This and the other class outlines will be made available on the Programming SIG page of the SCOUG website; more detailed examples will also be posted there.