Date post: | 20-Jan-2016 |
Category: |
Documents |
Upload: | austin-fletcher |
View: | 214 times |
Download: | 0 times |
CPCS204: Data Structure 1Dr. Sahar Shabanah
Lecture 2
2
Outline
Review of O-O ConceptsInheritanceInterfacesPolymorphismCastingGenericsJava DocumentationExceptions
3
InheritanceThe capability of a class to use the properties
and methods of another class while adding its own functionality.
Example: employee records system. A generic employee class with states and actions
that are common to all employees. (parent, super, or base class)
Specific classes could be defined for salaried, commissioned and hourly employees. (children, subclasses or derived classes)
Advantage: enhances the ability to reuse code as well as making design a much simpler and cleaner process.
4
Inheritanceextends keyword set the relationship between a
parent and a child.public class GraphicsBox extends Box
GraphicsBox inherits all the properties of Box and can now add its own properties and methods as well as override existing methods.
Overriding: creating a new set of method statements for the same method signature.// define position locations private int left, top;// override a superclass method public int displayVolume() { System.out.println(length*width*height); System.out.println("Location: "+left+", "+top);
}
5
super & thissuper: allows the reuse of the superclass
constructor and methods by the subclasses
this: used to distinguish between the object's property and the passed in parameterGraphicsBox(l,w,h,left,top) {
super (l,w,h); //must come first in constructor
this.left=left; this.top=top; } public void showObj() { System.out.println(super.showObj()
+"more"); }
6
Object ClassThe Object class is the highest superclass
(ie. root class) of Java. All other classes are subclasses (children
or descendants) of the Object class. The Object class includes methods such
as:clone(), equals(), copy(Object src), finalize(), getClass(), hashCode(),notify(), notifyAll(), toString(), wait()
7
Concrete & Abstract ClassesFinal classes: cannot be extendedConcrete superclass: instance objects can be
created from Abstract superclass: does not allow objects of its
prototype to be created. Abstract methods: methods with no body
specification, must provided by the subclasses.public abstract class Animal{ // class is abstract
private String name; public Animal(String nm) // constructor method { name=nm; } public String getName() // regular method { return (name); } public abstract void speak(); //abstract method, no{} }
8
Interfaces Similar to abstract classes but all methods are
abstract and all properties are static final. can be inherited (sub-interface) using extends.No multiple inheritance for classes, can
implements only for interfaces. Advantages, Interfaces are used to:
tie elements of several classes together. separate design from coding as class method
headers are specified but not their bodies. This allows compilation and parameter consistency testing prior to the coding phase.
set up unit testing frameworks.
9
ExampleWorking interface for the subclasses of
Animals, method work(), that method must be
defined in any class using the Working interface:public interface Working{ public void work();}
When a class uses an interface, it reference the interface with the phrase implements Interface_list.
Interface_list is one or more interfaces as multiple interfaces are allowed.
10
Example cont.Any class that implements an interface must
include code for all methods in the interface. public class WorkingDog extends Dog implements Working {
public WorkingDog(String nm) { super(nm); // builds ala parent } public void work() // this method specific to WorkingDog
{ speak(); System.out.println("I can herd sheep and cows"); }
}
11
PolymorphismThe capability of an action or method to do
different things based on the object that it is acting upon.
The third basic principle of object oriented programming.
Three types:1. Overloaded methods are methods with the same
name signature but either a different number of parameters or different types in the parameter list.
2. Overridden methods are methods that are redefined within an inherited or subclass. They have the same signature and the subclass definition is used.
3. Dynamic method binding.
12
Dynamic method bindingThree subclasses (Cow, Dog and Snake) have been created
based on the Animal abstract class, each having their own speak() method.public class AnimalReference{ public static void main(String args[]) Animal ref // set up var for an Animal
Cow aCow = new Cow("Bossy"); // makes specific objects
Dog aDog = new Dog("Rover"); Snake aSnake = new Snake("Ernie"); // now reference each as an Animal ref = aCow; ref.speak(); //speak of Cow ref = aDog; ref.speak();// speak of Dog ref = aSnake; ref.speak();// speak of Snake}
13
Dynamic method bindingArray of objects example
public class AnimalArray{ public static void main(String args[]) Animal ref[] = new Animal[3]; // assign space for array
Cow aCow = new Cow("Bossy"); // makes specific objects
Dog aDog = new Dog("Rover"); Snake aSnake = new Snake("Earnie");
// now put them in an array ref[0] = aCow; ref[1] = aDog; ref[2] = aSnake;
// now demo dynamic method binding for (int x=0;x<3;++x) { ref[x].speak(); }}
14
Casting Widening Conversions (T converted into a
“wider” type U), if:U superclass of T, U superinterface of T, T
implements UEx: Integer extends NumberInteger i=new Integer(3);Number n=i; // widening from Integer to Number
Narrowing conversions (T converted into a “narrower” type S), if:S is a subclass of T, S is a subinterface of T, S
implements TNumber n=new Integer(2); //widening from Integer to NumberInteger i=(Integer) n; //narrowing from Number to Integer
15
Casting ExceptionsExample
Number n; Integer I;n= new Integer(3);i=(Integer)n;n=new Double(3.14);i=(Integer) n; //this is illegal
Solution: (object-type) instanceof (refrence-type)n=new Double(3.14); if ( n instanceof Integer)i=(Integer) n; //this will not attempted
16
Casting with Interfacespublic interface Person{ public boolean equalTo(Person other); public String getName();}public Student implements Person{ String id, name; int age; public Student(String I, String n, int a){id=I;name=n;age=a;}
public boolean equalTo(Person other){//from Person Interface
Student otherStudent=(Student)other;//cast Person to Student
return (id.equals(otherStudent.getID()); }}
17
Casting & Dynamic BindingWhen using a superclass array to hold many instances
of subclass objects, one can only access properties and methods that are in the superclass (ie. common to all).
By casting an individual instance to its subclass form, one can refer to any property or method.
make sure the cast is valid by using the instanceof operator. if (ref[x] instanceof Dog) // ok right type of object
{
Dog doggy = (Dog) ref[x]; // cast current instance to
subclass
doggy.someDogOnlyMethod();
}
18
GenericsGeneric programming refers to writing code that
will work for many types of data. The Java collections framework promotes generic
programming by applying a unifying philosophy that adds operational functionality, and dynamic growth to object classes.
Unification is accomplished through interfaces that each collection object inherits.
Various types of objects may be handled in a similar manner within collection framework classes.
Functionality such as searches, sorts, insertion and deletion use highly efficient algorithms.
19
Collection Interfaces
20
Collections ClassesConcrete collection classes implement the
appropriate interfaces and incorporate advanced and optimized data structures for programming ease.
The main collection classes include:ArrayList implements List and is very similar to arrays
but is dynamic (ie. its size does not have to be declared at compile time).
HashSet implements the Set interface and uses a hash table for efficient storage.
LinkedList implements the appropriate data structure which can be traversed and nodes inserted and deleted.
TreeSet implements a sorted set using a binary tree for storage, allowing rapid access to list elements.
21
Java Documentation classesJAVA API (Application Programming Interface):
http://download-llnw.oracle.com/javase/1.5.0/docs/api/The Java API includes several predefined class packages
(class libraries): Applets java.applet, language extensions java.lang, utilities java.util, formatters java.text, file streams java.io, GUIs java.awt and
javax.swing, database management java.sql
import is used to access classes from the libraries (except for java.lang).
Example classes of java.lang: Object, System, Math, String, Number, Integer, Double, Boolean,…….
Exceptions examples of java.lang: java.lang.ArithmeticException, java.lang.ArrayIndexOutOfBoundsException, java.lang.ClassCastExceptio
22
ExceptionsAn exception is an event, which occurs
during the execution of a program, that disrupts the normal flow of the program's instructions.
When an error occurs within a method, the method creates an object and hands it off to the runtime system.
The object, called an exception object, contains information about the error, including its type and the state of the program when the error occurred.
Creating an exception object and handing it to the runtime system is called throwing an exception.
23
The Exception Class HierarchyExceptions classes are related
by inheritance, forming a hierarchy
All error and exception classes are descendents of the Throwable class
A programmer can define an exception by extending the Exception class or one of its descendants
The parent class used depends on how the new exception will be used
24
Three Kinds of Exceptions1. Errors:
These are exceptional conditions that are external to the application (hardware failure), and that the application usually cannot anticipate or recover from.
not subject to the Catch or Specify Requirement. Errors are those exceptions indicated by Error and its subclasses.
2. Runtime exception:These are exceptional conditions that are internal to the
application, and that the application usually cannot anticipate or recover from.
These usually indicate programming bugs, such as logic errors or improper use of an API.
25
Three Kinds of Exceptions3. Checked exceptions:
these are exceptional conditions that a well-written application should anticipate and recover from.
must be enclosed by either of the following:1. A throws clause to pass the exception up the stack
to let another method to handle it:
public void writeList() throws IOException{ 2. A try statement that catches and handles the
exception
26
Exception HandlingAfter a method throws an exception,
the runtime system searches the call stack (ordered list of methods that had been called so far) for a method that contains a block of code that can handle the exception (exception handler)
When an appropriate handler is found, the runtime system passes the exception to the handler (catch the exception).
If no handler founds, the runtime system (and, consequently, the program) terminates.
27
try-catch syntax try: tests a section of code, if an exception error occurs. catch traps and handles the error, any number of catches
can be set up for various exception types. finally provides a block of code that is always performed.try{
// tested statement(s);}catch (ExceptionName e1){// trap handler statement(s);}catch (ExceptionName e2){ // any number of catch statementsSystem.out.println("Exception: " + e2);
}finally{// always executed block}
28
Throw statement Exceptions are thrown using the throw statement
Usually a throw statement is executed inside an if statement that evaluates a condition to see if the exception should be thrown
public class OutOfRangeException extends Exception
{
// Sets up the exception object with28 message.
OutOfRangeException (String message)
{super (message);}
}
OutOfRangeException problem =
new OutOfRangeException ("Input is out of range.");
-----
-----
if (value < MIN || value > MAX) throw problem;