Inheritance and Polymorphism, Part 2

Abstract Classes and Methods Multiple Inheritance Interfaces Inner Classes

OOP:Inheritance and Polymorphism, Part 2

Abstract Class and Method

An abstract class is a class with an abstract method. An abstract method is method with out a body, i.e., only
declared but not defined.

It is not possible to make instances of abstract classes. Abstract method are defined in subclasses of the abstract class.

OOP:Inheritance and Polymorphism, Part 2

Abstract Class and Method, Example

C1 d1 d2 A B C Abstract class C1 with abstract methods A and B

C2 d3 d4 A

Abstract class C2. Defines method A but not method B. Adds data elements d3 and d4

C3 d5

B D E

Concrete class C3. Defines method B. Adds the methods D and E and the data element d5.

OOP:Inheritance and Polymorphism, Part 2

Abstract Classes in Java

abstract class ClassName { // <class body>; }

Classes with abstract methods must declared abstract Classes without abstract methods can be declared abstract A subclass to a concrete superclass can be abstract Constructors can be defined on abstract classes. Instances of abstract classes cannot be made.

OOP:Inheritance and Polymorphism, Part 2

Abstract Class in Java, Example

// [Source: Kurt Nrmark] abstract class Stack{ abstract abstract abstract abstract abstract abstract public public public public public public void push(Object el); void pop(); Object top(); boolean full(); boolean empty(); int size();

public void toggleTop(){ if (size() >= 2){ Object topEl1 = top(); pop(); Object topEl2 = top(); pop(); push(topEl1); push(topEl2); } } public String toString(){ return "Stack"; } }
OOP:Inheritance and Polymorphism, Part 2 5

Abstract Methods in Java

abstract [access modifier] return type methodName([parameters]);

A method body does not have be defined. Abstract method are overwritten in subclasses. Idea taken directly from C++ You are saying: The object should have this properties I just do
not know how to implement the property at this level of abstraction.

OOP:Inheritance and Polymorphism, Part 2

Abstract Methods in Java, Example

public abstract class Number { public abstract int intValue(); public abstract long longValue(); public abstract double doubleValue(); public abstract float floatValue(); public byte byteValue(){ // method body } public short shortValue(){ // method body } }

OOP:Inheritance and Polymorphism, Part 2

Multiple Inheritance, Example

Person name() cpr()

For the teaching assistant when

want the properties from both Employee and Student.

Employee Student salary() gpa() degree() courses() Teaching A.

OOP:Inheritance and Polymorphism, Part 2

Problems with Multiple Inheritance

Person name() cpr()

Name clash problem: Which

department does ta refers to? Combination problem: Can department from Employee and Student be combined in Teaching Assistant? Selection problem: Can you select between department from Employee and department from Student? there be two departments in Student?

Employee
department

Student
department

TeachingA.

ta = new TeachingAssistant(); ta.department;

Replication problem: Should

OOP:Inheritance and Polymorphism, Part 2 9

Multiple Classifications
Object Runable Comparable Storable Clonable

Multiple and overlapping classification for the classes X and Y.

OOP:Inheritance and Polymorphism, Part 2

10

Java's interface Concept

An interface is a collection of method declarations.
n n

An interface is a class-like concept. An interface has no variable declarations or method bodies.

Describes a set of methods that a class can be forced to An interface can be used as a type concept.
n

implement. An interface can be used to define a set of "constants".

Variable and parameter can be of interface types.

Interfaces can be used to implement multiple inheritance like

hierarchies.

OOP:Inheritance and Polymorphism, Part 2

11

Java's interface Concept, cont.

interface InterfaceName { // "constant" declarations // method declarations } class ClassName implements InterfaceName { ... } class ClassName extends SuperClass implements InterfaceName { ... } class ClassName extends SuperClass implements InterfaceName1, InterfaceName2 { ... } interface InterfaceName extends InterfaceName { // ... }
OOP:Inheritance and Polymorphism, Part 2 12

Semantic Rules for Interfaces

Type
n n

An interface can be used as a type, like classes A variable or parameter declared of an interface type is polymorph
u

Any object of a class that implements the interface can be referred by the variable

Instantiaztion
n

Does not make sense on an interface. An interface can be public or "friendly" (the default). All methods in an interface are default abstract and public.
u

Access modifiers
n n

Static, final, private, and protected cannot be used. Private, protected cannot be used.

All variables ("constants") are public static final by default

u

OOP:Inheritance and Polymorphism, Part 2

13

The Iterator Interface

The Iterator interface in java.util is a basic iterator
that works on collections.
package java.util; public interface Iterator { boolean hasNext(); Object next(); void remove(); // optional }

OOP:Inheritance and Polymorphism, Part 2

14

The Iterator Interface, cont

Iterator iter = myShapes.iterator(); while (iter.hasNext()) { Shape s = (Shape)iter.next(); s.draw(); }

Note the cast (Shape) since Collection and Iterator manage

anonymous objects. When collection has a natural ordering, Iterator will respect it.

OOP:Inheritance and Polymorphism, Part 2

15

The Cloneable Interface

A class X that implements the Cloneable interface tells Returns an identical copy of an object.
n n

clients that X objects can be cloned. The interface is empty.

A shallow copy, by default. A deep copy is often preferable.

Prevention of cloning
n n

Necessary if unique attribute, e.g., database lock or open file reference. Not sufficient to omit to implement Cloneable.
u

Sub classes might implement it. CloneNotSupportedException

16

clone should throw an exception:

u

OOP:Inheritance and Polymorphism, Part 2

The Cloneable Interface, Example

package geometric; // [Source: java.sun.com] /** A clonable Point */ public class Point extends java.awt.Point implements Cloneable { public Object clone(){ try { return (super.clone()); // protected in Object } // must catch exception will be covered later catch (CloneNotSupportedException e){ return null; } public Point(int x, int y){ super(x,y); } }

OOP:Inheritance and Polymorphism, Part 2

17

The Serializable Interface

A class X that implements the Serializable interface tells
clients that X objects can be stored on file or other persistent media.

The interface is empty.

OOP:Inheritance and Polymorphism, Part 2

18

Interface vs. Abstract Class

Interface Abstract Class

Methods can be declared. No method bodies Constants can be declared

Methods can be declared Method bodies can be defined All types of variables can be
declared Can have a constructor possible. Always inherits from Object.

Has no constructor Multiple inheritance possible. Multiple inheritance not Has no top interface. Multiple "parent" interfaces.
OOP:Inheritance and Polymorphism, Part 2

Only one "parent" class

19

Interfaces and Classes Combined

By using interfaces objects do not reveal which classes the
belong to.
n

With an interface it is possible to send a message to an object without knowing which class(es) it belongs. The client only know that certain methods are accessible By implementing multiple interfaces it is possible for an object to change role during its life span.

Design guidelines
n n

Use classes for specialization and generalization Use interfaces to add properties to classes.

OOP:Inheritance and Polymorphism, Part 2

20

Multiple Inheritance vs. Interface

Multiple Inheritance Interface

Declaration and definition is

inherited. Little coding to implement subclass. Hard conflict can exist. (C++ close to impossible). Flexible

Only declaration is inherited. Must coding to implement an Fairly easy to understand. Very flexible. Interface totally
separated from implementation. interface. No hard conflicts.

Very hard to understand

OOP:Inheritance and Polymorphism, Part 2

21

Inner Classes

Fundamental language feature, added in Java 1.1. Used a lot in JFC/Swing (GUI programming). Nest a class within a class. Class name is hidden. More than hiding and organization
n n

Call-back mechanism. Can access members of enclosing object.

OOP:Inheritance and Polymorphism, Part 2

22

Inner Classes, Example

public class Parcel1 { // [Source: bruceeckel.com] class Contents { private int i = 11; public int value() { return i; } } class Destination { private String label; Destination(String whereTo) { label = whereTo; } String readLabel() { return label; } } public void ship(String dest) { Contents c = new Contents(); Destination d = new Destination(dest); System.out.println(d.readLabel()); } public static void main(String[] args) { Parcel1 p = new Parcel1(); p.ship("Tanzania"); } }
OOP:Inheritance and Polymorphism, Part 2 23

Interfaces and Inner Classes

An outer class will often have a method that returns a reference
to an inner class.

// [Source: bruceeckel.com] public interface Contents { int value(); } public interface Destination { String readLabel(); }

OOP:Inheritance and Polymorphism, Part 2

24

Interfaces and Inner Classes, cont

public class Parcel3 { // [Source: bruceeckel.com] private class PContents implements Contents { private int i = 11; public int value() { return i; } } protected class PDestination implements Destination { private String label; private PDestination(String whereTo) { label = whereTo; } public String readLabel() { return label; } } public Destination dest(String s) { return new PDestination(s); } public Contents cont() { return new PContents(); } }
OOP:Inheritance and Polymorphism, Part 2 25

Interfaces and Inner Classes, cont

class Test { // [Source: bruceeckel.com] public static void main(String[] args) { Parcel3 p = new Parcel3(); Contents c = p.cont(); Destination d = p.dest("Tanzania"); // Illegal -- can't access private class: //! Parcel3.PContents pc = p.new PContents(); } }

OOP:Inheritance and Polymorphism, Part 2

26

Anonymous Inner Classes, Example

When a class in only needed in one place. Convenient shorthand. Works for both interfaces and classes.
// [Source: bruceeckel.com] public class Parcel6 { public Contents cont() { return new Contents() { private int i = 11; public int value() { return i; } }; } public static void main(String[] args) { Parcel6 p = new Parcel6(); Contents c = p.cont(); } }
OOP:Inheritance and Polymorphism, Part 2 27

Why Inner Classes?

Each inner class can independently inherit from other classes,
i.e., the inner class is not limited by whether the outer class is already inheriting from a class.

With concrete or abstract classes, inner classes are the only way
to produce the effect of "multiple implementation inheritance"

OOP:Inheritance and Polymorphism, Part 2

28

Summary
Abstract classes
n n

Complete abstract class no methods are abstract but instatiation does not make sense. Incomplete abstract class, some method are abstract.

Java only supports single inheritance. Java "fakes" multiple inheritance via interfaces.
n

Very flexible because the object interface is totally separated from the objects implementation. Name inner classes Anonymous inner classes

Classes can be nested in Java

n n

OOP:Inheritance and Polymorphism, Part 2

29