An Overview of Java Part III - Classes and Objectsmason.gmu.edu/~jbaldo/432Lec08B-JavaII.pdf · An...

An Overview of JavaPart III - Classes and Objects

Jeff OffuttRoger Alexander

http://www.ise.gmu.edu/~offutt/

SWE 432Design and Implementation of Software for the Web

Fall 2007 : Created 432Lec08-Java.ppt – cut most of JavaI and JavaII, then merged.

© Alexander & Offutt, 1999-2007 2

Organization

III. Classes in Java

IV. Exceptions

V. Inheritance

VI. JavaDoc

VII. Some Useful Libraries


Part III - Classes in Java


Java Classes• The class is the basic data abstraction mechanism in Java

• Classes combine records, data structures, and information hiding into one structure

• Classes are used to construct Abstract Data Types (ADTs)


Java Classes (cont’d)

Class Characteristics:

• Name: Used to declare objects of the class• State definition: Collection of variables (fields)• Behavior: Collection of methods• Semantics: Constraints on state-space and behavior• Access Levels: Private, protected, public, default



A Java class defines a set of values and a set of operations. Together, these form a type. An instance, or object, of that class is a variable of the class type.

Watch W = new Watch ();

W is an instance of the class Watch.



A class is a type constructor:

• Similar in use to an Ada package, a Modula-2 module, or a C++ class

• A class is more than a type ... it is an encapsulation unit

• A class is used in place of type definitions and collections of functions


Java Classes (cont’d)Classes are used to create objects

• Objects have:– identity : name– state : a set of values for the data members– behavior: sequence of operations

• Objects may be dynamically allocated• References to objects can be passed as parameters to methods


Java Classes (cont’d)Abstract Data Types

A class with a private representation and a public set of operations is used to implement abstract data types

Fraction myFraction;myFraction = new Fraction ();



Class

variablesmethods

instanceobject 1

declare

instanceobject N

instanceobject 2

declaredeclare

Fraction

int Numeratorint DenominatorAdd ()Multiply ()

(Type)

F1

declare

NumDen

allocate F2

declare

NumDen

allocate



• Classes can be grouped together to form packages

• Packages are usually used to implement design-level components

• All classes in the same package are usually stored in the same directory

• The directory has the same name as the package

• Examplepackage myADTs;public class queueADT { } // part of package myADTs


Java Classes (cont’d)The Class Definition

• Class head: Access, keyword class and class tag name• Class body: Variables and methods enclosed in curly braces

public class Fraction { ... }Fraction myFraction, yourFraction;


Java Classes (cont’d)Variable Members

Often referred to as instance variables

public class Fraction{

private int Numerator;private int Denominator;

}


Initial Values• Class instance variables can be initialized in its declaration:

double pi = 3.14159;

• If not, Java assigns default values to instance variables, dependent upon the type of the variable

• Note that local variables in methods, constructors, static initializers, and instance initializers do not get default values


Initial Values (cont’d)Typeboolean

char

integer (byte, short, int, long)

floating point

object reference

Initial Valuefalse

`/u0000’

0

+0.0f or +0.0d

null



Variable Members

Classes may be self-referential, through the class tag name

public class List{

private int Value;private List Next;

}



Methods, or Member Functions

Operations to be performed on class objects are defined as member functions


public Fraction (int Num, int Den) { … }public void Add (Fraction Right) { … }public void Multiply (Fraction Right) { … }public void PrintFrac () { … }

}



Fraction Class


// variable membersprivate int Numerator; // Only available to member functionsprivate int Denominator;// methodspublic Fraction (int Num, int Den) { … } // Constructorpublic void Add (Fraction Right) { … } // F1 = F1 + F2public void Multiply (Fraction Right) { … } // F1 = F1 * F2public void PrintFrac () { … }

}


Variable Characteristics• Name• Type

(primitive or user-defined)

• Optional access specifier(public, private, or protected)

• Per-Instance (instance variables) or per-Class (class variables) (static)

• May be constant( final )


Method Characteristics

• Name• Return Type

(primitive, user-defined, or void)

• Optional access Specifier(public, protected, or private)

• Body (code)• Per-instance (instance methods) or per-Class (class

methods) (static)


Access Control• All variables and methods of a class are available to methods

inside the class

• Four access specifiers define accessibility by other classes:1. public - members are accessible anywhere the class is accessible2. private - members are accessible only inside the class3. protected - accessible by subclasses (through inheritance) and within the

same package4. default – next slide …


Access Control (cont’d)

4. default: Members with no access specifier are accessible to code in the containing class, and are inherited by classes defined in the same package


Class 4

Access Control (cont’d)

Class 1

inheritance

Class 3

Class 2

Package

Class 5

private members

default

protected members

public members


Creating Objects• In Java, variables of user defined types are pointers, or

references, to the actual type instance (i.e. object)

• References must be declared and initialized with an instance before use

• An object instance is created using the new operator


Creating Objects (cont’d)

• Example:Fraction F1;F1 = new Fraction ( );F1.PrintFrac ( ); // oops!!! Num=0, Den=0 …

• How do we properly initialize state variables?


Three Categories of Methods1) Constructors: Called automatically when an object is created.

Usually used to give initial values to the variables.

2) Mutators: Modify the state of the object (changes the value of one or more variables).

3) Accessors: Examine the state of the object (returns current values of state variables).


Constructors• Newly created objects are always given initial values.

• Variables can be initialized with a value when they are created.But often, more is needed than simple initialization.

• Constructors are special routines that establish an initial state for an object.


Rules for Constructors• Have the same name as their class

• Have zero or more parameters

• Have no return type

• Invoked …– after instance variables of newly created class instance have been assigned

their default initial values– after initialization during declaration (int i=0;)


Constructor Examples

public Fraction () // constructor{ // Constructor with no arguments is called a default constructor

Numerator = 0;Denominator = 1;

}

public Fraction (int Num, int Den) // constructor{

Numerator = Num;Denominator = Den;

}

F1 = new Fraction ();F2 = new Fraction (3, 4);


Constructor Examples• May invoke other constructors in same class via this (explicit

constructor invocation)– Must be the first statement– May pass parameters

• Example:public Fraction ( ) // default constructor{

this (0, 1);}


Importance of Constructors

• Ensure that instances are in a consistent initial state

• If no constructors, a default constructor is provided that supplies default values

• Some classes will have no reasonable default state without constructors

• A non-public constructor restricts who can create instances of a class


Mutator and Accessor Methods

• Methods contain the code that defines the object’s behavior (semantics)

• Methods having public access specifier constitute the class interface

• Methods are invoked as operations on objects with the dot operator:

F1.Add (F2)


Methods (cont’d)

• Methods may have a return type, or no return type (void)

• Methods may have an access specifier(public, protected, private)


Method Examples

public void Add (Fraction Right){ // Mutator

Numerator = Numerator + Right.Numerator;}

public void Multiply (Fraction Right){ // Mutator

Numerator = Numerator * Right.Numerator;Denominator = Denominator * Right.Denominator;

}

public void PrintFrac (){ // Accessor

System.out.println (Numerator + " / " + Denominator);}


Four Special Common Methods

1) toString : Converts an object to a stringUsed by print and println

2) equals : Compares two objects

3) clone: Makes a copy

4) main : Main method


toString Method• Returns a string version of the object’s values• Called implicitly by System.out.println• Example:

public String toString (){

return (Numerator + " / " + Denominator);}

Fraction f1 = new (3, 7);System.out.println (f1);


equals Method

• Compares two objects

• Standard signature, parameter is type Object

• Use instanceof to see if parameter is correct type


Object Class

All classes inherit from the Java built-in class Object

Object

Fraction Watch String

Assign up, cast down

An object of type Fraction can be assigned to an Object, but not vice-versa

Object O = new Object ();Fraction f = new Fraction ();

O = f; // Assign upF = (Fraction) O; // Cast down


equals Method Example

public boolean equals (Object Right) // Matches any object{

if (!(Right instanceof Fraction)) // Is Right a Fraction?return (false);

Fraction rhs = (Fraction) Right; // Cast to Fractionreturn (Numerator == rhs.Numerator &&

Denominator == rhs.Denominator);}

Fraction f1 = new (3, 7);Fraction f2 = new (3, 7);if (f1.equals (f2))

. . .


clone Method• Copies all values• Example:

public Object clone (){

Fraction newf = new Fraction ();newf.Numerator = Numerator;newf.Denominator = Denominatorreturn (newf); // implicit "assign up" to Object

}

Fraction f2 = (Fraction) f1.clone(); // Must cast


main Method• Every class can have a main method

– Called when java ClassName is executed– Ignored when ClassName is used in another program

• Use to test classes– Put a main () inside every class– Call every method at least once


main Method Example

public static void main (String argv[]){

Fraction f1, f2;

f1 = new Fraction (1, 4);f2 = new Fraction (3, 4);

f1.PrintFrac ();System.out.println (f2); // Implicit call to f2.toString()f1.Add (f2);System.out.println (f1);f1.Multiply (f2);System.out.println (f1);

}


Class (Static) Variables• Only one per class, not per instance object• All instance objects reference the same copy• Static variables are initialized before any static variable is used

or any method is run


// Should be incremented in constructor methodsprivate static int CurNumFracs = 0;

…}


Class (Static) Variables (cont’d)

Fraction

F1

declare

NumDen

allocate F2

declare

NumDen

allocate

CurNumFracs


Class (Static) Methods

• Effects all instantiated objects of the class, not a specific object

• Typically performs general tasks for all objects of a class

• Can only access static variables and other staticmethods

• If public, accessed from outside class using the classname rather than object reference:

<class name>.<method name> ()


Static Method Example


public static int getNumFracs (){

return (CurNumFracs);}

. . .}

N = Fraction.GetNumFracs ();


Static Initialization Blocks• Used to initialize static variables and set up other resources, as

necessary

• Consists of one or more statements

• Cannot throw exceptions

• May only call static methods

• Must catch all exceptions thrown by called methods

Skip, 432 …


Static Initialization Blocks (cont’d)• May be more than one static initializer in a class. If so, they are

executed in order of appearance.

• Initializers for static variables cannot invoke methods that throw checked exceptions.

• Initializers are run when class is loaded (which is unpredictable).

Skip, 432 …


finalize

• Special method written by programmer• Called automatically when object is being destructed• Used to release resources held by object, and any last-

minute cleanup• Cannot predict when it will execute• Might not execute at all!

Skip, 432 …


finalize (cont’d)

An Example:

protected void finalize () throws throwable{

super.finalize (); // must call this first!// Put cleanup code here.

}

Skip, 432 …


Garbage Collection• When an object is no longer referenced, the space it occupies is

automatically reclaimed

• Eliminates burden of having to manage memory

• Eliminates possibility of memory leaks and dangling references


Part IV - Exceptions


Errors and Exceptions• During execution, “stuff” happens• Many kinds of errors• Many kinds of exceptional situations• Varying degrees of severity• Code to handle errors adds complexity

– Often, more code required to handle errors than the original function

• Code to handle errors adds robustness– program can behave reasonably in more situations


Java Exceptions• A clean way to check for exceptional conditions

• Mechanism to signal programmer-defined exceptions

• Exceptions that a method can signal part of the signature

• Automatically checked by compiler


Java Exceptions• Handlers attached to explicit “try” blocks

• Terminates execution of block

• Exceptions propagated dynamically

• Exceptions are named objects

• Can be raised explicitly and implicitly


Java Exceptions -- Five Parts

1) try : A block of code that can catch exceptions

2) throw : Explicitly signal or raise an exception

3) catch : Code to handle a named exception

4) finally : A special handler (rules later)

5) throws : Exceptions a method can throw


Exceptions – General Form

try{

// block of code to be monitored for exceptions}catch (ExceptionType1 obj1){

// exception handler for ExceptionType1}catch (ExceptionType2 obj2){

// exception handler for ExceptionType2}finally{

// special exception handler}


Exceptions – RulesIf an exception is thrown, control passes to the innermost enclosing try block that has a catch handler for that type of exception.

If there is no handler, control propagates up through main ()until a handler is found, or until the program terminates.


Exceptions – Example

class ExcExample{

public static void main (String args[]){

int d, a;try{ // monitor a block of code.

d= 0;a = 42 / d;System.out.println (“This will never be printed.”);

}catch (ArithmeticException e){ // catch divide-by-zero error

System.out.println (“Division by zero.”);}System.out.println (“After catch.”);

}}


Exceptions – Throwing Your Own

public void Add (Fraction Right){

try{

Numerator = Numerator + Right.Numerator;if (Denominator != Right.Denominator)

throw new ArithmeticException ();}catch (ArithmeticException e){

System.out.println ("Fraction add error:Denominators must be the same.");

}}


Exceptions – Throwing Your Own

public void Add (Fraction Right) throws ArithmeticException{

Numerator = Numerator + Right.Numerator;if (Denominator != Right.Denominator)

throw new ArithmeticException ();

}

try {f1.Add (f2);

}catch {

…}


finally

• Executes a section of code even when an exception is not thrown

• Used to clean up internal state and release resources

• Used to clean up after break, continue, and return


finallyA finally block is executed when:

1) try block executes without exception

2) exception occurs in the try block, but is not caught• exception propagates after finally block

3) exception occurs in the try block, and is caught• finally block executes after the catch block


Java’s Built-in Exceptions

• ArithmeticException• ArrayIndexOutOfBoundsException• ArrayStoreException• ClassCastException• IllegalArgumentException• IllegalMonitorStateException• IllegalStateException• IllegalThreadStateException• IndexOutOfBoundsException• NegativeArraySizeException

• NullPointerException• NumberFormatException• SecurityException• StringIndexOutOfBounds• ClassNotFoundException• CloneNotSupportedException• IllegalAccessException• InstantiationException• InterruptedException• NoSuchFieldException• NoSuchMethodException


Making Your Own Exceptions• All exceptions are represented by a specific class that extends

class Exception

• Create a class for each type of exception that can occur

• Add variables to capture information to describe exception


Making Your Own Exceptions

class MyException extends Exception{

private int detail;

MyException (int a){

detail = a;}

public String toString (){

return “MyException[“ + detail + “]”;}

}


Making Your Own Exceptions

class ExcDemo {static void compute (int a) throws MyException {

System.out.println (“Called compute (“ + a + “)”);if (a > 10)

throw new MyException (a);System.out.println (“Normal exit”);

}

public static void main (String args[]) {try {

compute (1);compute (20);

} catch (MyException e) {System.out.println (“Caught “ + e);

}}

}


Part V - Inheritance


Inheritance• If class A inherits from class B, then A has all methods and

variables that B has

• A can also add new methods and variables

• This is a technique for abstraction


Basic Terminology

Class Member Functions(methods)

Instantiate

ObjectHas

Identity

Define

Behavior

Yields

State


Inheritance Terminology

• Parent class and Superclass refer to the class from which another inherits

• Child class, derived class, and subclass refer to a class that inherits from one or more classes


What is “Object-oriented”?

Object-oriented programming language

Object-based programming language

Object-oriented design


Encapsulation(data hiding)

Clients cannot know about or depend on the implementation of the class


Data Abstraction

• Creation of a new data type from previously existing components

• Abstract Data Type:– Set of values– Connection of operations– Semantics of operations


Inheritance

Allows common features of many classes to be defined in one class

A child class, derived class, or subclass

inherits

from aparent class, base class, or super class


Inheritance (2)

• Enhance derived features (overriding)• Restrict derived features (not in Java)• Add new features (extension)

A derived class has everything its parent has, plus it can:


Polymorphism

• The same variable can have different types depending on the program execution

• If B inherits from A, then an object of type B can be used when an object of type A is expected

• If both A and B define the same method M (B overrides A), then the same statement will sometimes call A’s version of M, and sometimes B’s version


Subtype and Subclass Inheritance

• Subtype Inheritance: If B inherits from A, any object of type B can be substituted for an object of type A– A laptop “is a” special type of computer– Called substitutability

• Subclass Inheritance: Objects of type B may not be substituted for objects of type A– Objects of B may not be “type compatible”


Inheritance Example

ClockhourminutesecondsetTime()getTime()

AlarmClockModealarmHouralarmMinutealarmModesetAlarm()getAlarm()

WatchmonthdayyearmodesetDate()getDate()

WallClocksetTime()getTime()

Inherits from


Inheritance Example (2)

class Clock{

private int hour, minute, second;

public setTime (int h, int m, int s){

hour = h;minute = m;second = s;

}…

} // end Clock

class Watch extends Clock{

private int month, day, year;private String mode;

…public setTime (int h, int m, int s, String d){

super.setTime (h, m, s)mode = d;

}} // end Watch


Part VI – Java Doc


javadoc Utility• Documentation comments can be embedded into Java programs

/** documentation comment **/

• The javadoc program will create HTML documentation, using javadoc comments

• javadoc comments can include javadoc “tags” to specify certain information


javadoc Tags

• @author : identifies the author of a class• @exception : Identifies an exception thrown by a method• @see : Specifies a link to another topic• @param : Documents a method’s parameter• @return : Documents a method’s return value• @version : Specifies the version of a class• HTML tags may also be used

javadoc -author -version ClassName.java


javadoc Example

/** ********************************************************** Fraction implements a Fraction ADT.* @author Jeff Offutt* @version 1.2, 1/99********************************************************* **/

/** ********************************************************** Mutator : Adds two fractions, F1 = F1+F2. <BR>* Precondition: Both denominators must be the same. <BR>* This is checked with the exception ArithmeticException.* @param Right Fraction right-hand-side* @return None********************************************************* **/


Part VII – Some Useful Libraries


Java Collections Framework (Java 1.5)• http://java.sun.com/j2se/1.5.0/docs/guide/collections/• http://g.oswego.edu/dl/classes/collections/

• A collection is an object that represents a group of objects (such as the familiar Vector class)

• A collections framework is a unified architecture for representing and manipulating collections, allowing them to be manipulated independently of the details of their representation

• Contains most of the familiar ADTs• … and lots of unfamiliar ADTs


Java Interface & Generic• A Java interface defines a type, including definitions of variables

and methods, but does not implement methods• Used to help ensure consistency

public interface Set<E> extends Collection<E>{ //Basic operations

int size ();boolean isEmpty (); boolean contains (Object element);boolean add (E element);boolean remove (Object element);

}

Keyword implies methods have no bodies

Generic – can be used with arbitrary type

(Formal type parameter)

Set<String> strSet = new Set<String>();Set<Integer> intSet = new Set<Integer>();

strSet.add (“George”);strSet.add (“Burdell”);intSet.add (new Integer (1935));intSet.add (“oops”); // ERROR !!!

Set can only hold Strings

Run-time type checking


Nine Collection Interfaces• Collection• Five interfaces extend Collection

– Set– List– SortedSet– Queue– BlockingQueue

• Three mapping interfaces– Map– SortedMap– ConcurrentMap


Classes that Implement Collection Interfaces

LinkedHashMapTreeMapHashMapMap

LinkedListArrayListList

LinkedHashSetTreeSetHashSetSet

Interfaces

Hash Table+

Linked List

Linked List

Balanced Tree

Resizable Array

Hash Table

Implementations


Collections• public interface Collection<E> extends Iterable<E>• Root interface in the collection inheritance hierarchy• Methods (partial list - also available in all collections)

– boolean add (E o) // adds one element– void clear () // removes all elements– boolean contains (Object o) // true if o is in collection– boolean equals (Object o) // compares two collections– boolean isEmpty () // true if no elements– iterator iterator () // returns an iterator– boolean remove (Object o) // removes o– int size () // number of elements– <T> T [ ] toArray (T[ ] a) // returns an array of elements of type T


Interface Iterator <E>• Allows programs to access every member from a collection, in

order• Most collection classes implement Iterator• Methods

– boolean hasNext () // true if iterator has more elements– E next () // returns the next element– void remove () // removes the last element returned

Iterator <String> strSetIter = new strSet.Iterator <String> ();while strSetIter.hasNext (){

System.out.println (strSetIter.next () );}


public class HashMap <K,V>• Maps keys to values

– K is the type of the key– V is the type of the values

• HashMap <String, String> is useful for associating parameter names with values in web applications

• Methods– Boolean containsKey (Object key) // true if a mapping for key is present– Boolean containsValue (Object value) // true if value is present– V Get (Object key) // returns value for key– V put (K key, V value) // associates value with key, returns previous value– V remove (Object key) // removes value associated with key, returns

previous value– Collection<V> values () // returns all values


Regular Expressions• A regular expression is a compact representation of a set of

strings– a* – any string of any number of ‘a’s (a, aa, aaa, aaaa, …)– [46]32 – either “432” or “632”– [sc][wsy][e s] – “swe” or “cs ” or “sys” (also “cws”, etc.)– \\\\.*$ – Java comment, two backslashes, any sequence of characters,

followed by an end of line

• http://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/Pattern.html for a full description

• Java includes a built-in library for handling regular expressions

import com.sun.server.util.regexp.*;RE r = new RE (“a(.*)b”); // strings that begin with ‘a’ and end with ‘b’


Regular Expressions Methods

• Regular expression methods can throw “RESyntaxException”• r.setMatchFlags (int)

– MATCH_CASEINDEPENDENT == 1 // ignores case– MATCH_MULTILINE == 2 // ??

• r.match (“aGMUb”)– returns true if the string is a member of the set of strings defined by r

• Splitting strings– RE r = new RE (“:”);– String substrings [ ] = r.split (“swe:cs:ece:ee:syst”);– substrings will now contain 5 strings, “swe”, “cs”, “ece”, “ee”, “syst”

• Replacing substrings– RE r = new RE (“hermes”);– String newStr = r.substr (“http://www.hermes.gmu.edu:8080/offutt/servlet”, “ise”);– newString will now contain “http://www.ise.gmu.edu:8080/offutt/servlet”.

RE r = new RE (“a(.*)b”); // strings that begin with ‘a’ and end with ‘b’


Compiling Java Programs• Get Java JDK compiler from Sun

– http://java.sun.com/j2se/• javac Fraction.java // compiles Fraction.java

– Most command line compilers (Sun’s JDK)– Creates a file called Fraction.class

• java Fraction // Runs main() in Fraction• CLASSPATH:

– Classpath defines where java.class files will be found– When you compile, classes that you inherit from or use must be in the

CLASSPATH– When you execute, the program must be in your CLASSPATH– Win 2K: settings, control panel, system, advanced, Environment variables

C:\j2sdk1.4.1_01\bin;.;


Compiling Java Programs – Packages• Java packages encapsulate several classes in one structure• Putting classes into the same package is simple:

– package myPackage; // at the beginning of the class file– Store all classes in myPackage into a package subdirectory called

myPackage• Compile from the parent directory:

– javac myPackage/Fraction.java• Run by using the “dot” notation:

– java myPackage.Fraction // Runs main() in Fraction

An Overview of Java Part III - Classes and Objectsmason.gmu.edu/~jbaldo/432Lec08B-JavaII.pdf · An...

Documents

Transcript of An Overview of Java Part III - Classes and Objectsmason.gmu.edu/~jbaldo/432Lec08B-JavaII.pdf · An...