OO Design with Inheritance

C Sc 335 Rick Mercer 1

Justification and Outline

I introduce inheritance different than most books that just show the mechanics and a silly example (like this from Sun) I start with a reason to use inheritance – Show the objects found for a Library System – Recognize when to use of inheritance – Build an inheritance hierarchy – Design Guidelines related to inheritance – See another use of polymorphism 2

The 3 Pillars of OOP&D

Object-Oriented Programming – Encapsulation • Hide details in a class, provide methods – Polymorphism • Same name, different behavior, based on type – Inheritance • Capture common attributes and behaviors in a base class and extend it for different types 3

Object-Oriented Technology

OOT began with Simula 67 – developed in Norway – acronym for simulation language Why this “new” language? – to build accurate models of complex working systems The modularization occurs at the physical object level (not at a procedural level) 4

The Beginnings

Simula 67 was designed for system simulation (in Norway by Kristen Nygaard and Ole-Johan Dahl) – Caller and called subprogram had equal relationship – First notion of objects including class/instance distinctions – Ability to put code inside an instance to be executed – The class concept was first used here Kristen Nygaard invented inheritance – Won the Turing award for 2002 5

One way to Start OOA and D

Identify candidate objects that model (shape) the system as a natural and sensible set of abstractions Determine main responsibility of each – what an instance of the class must be able to do and what is should remember • This is part of Responsibility Driven Design ala Rebecca Wirfs-Brocks 6

System Specification

The college library has requested a system that supports a small set of library operations. The librarian allows a student to borrow certain items, return those borrowed items, and pay fees. Late fees and due dates have been established at the following rates: Late fee CDs Length of Borrow Books $0.50 per day 14 days Video tapes $5.00 plus 1.50 each additional day 2 days $2.50 per day 7 days The due date is set when the borrowed item is checked out. A student with three (3) borrowed items, one late item, or late fees greater than $25.00 may not borrow anything new.

7

Identify candidate objects

Candidate objects that model a solution with main responsibility. The model

(no GUIs, events, networking)

– Librarian: Coordinates activities – Student, renamed Borrower – Book: Knows due date, late fees, Borrower, checkin...

– Video: Knows due date, late fees, Borrower, checkin...

– CD: Know due date, late fees, Borrower, checkin...

– Three borrowed books: A collection of the things that can be borrowed, name it LendableList – BorrowList: maintains all possible borrowers 8

A Sketch

9

What do Books, Videos, and CDs have in common?

Common responsibilities (methods and data): – know call number, borrower, availability – can be borrowed – can be returned Differences: – compute due date – compute late fee – may have additional state • Books have an author, CDs an artist 10

When is inheritance appropriate?

Object-Oriented Design Heuristic:

If two or more classes have common data and behavior, then those classes should inherit from a common base class that captures those data and methods

11

An inheritance hierarchy

Lendable

Book CDRom Video

Lendable is also known as the base class or superclass

Lendable

is shown to abstract (in italic) Book, CD, and Video are concrete subclasses 12

Why not have just one class?

Some of the behavior differs – Determine due date (2, 7, or 14 days) – Compute late fee

not always daysLate * dayLateFee

Data differs – books have ISBNs and videos may have studio name Inheritance – allows you to share implementations – allows one change in a common method to affect all – allows other Lendables to be added later more easily 13

Examples of inheritance in Java

You've seen HAS-A relationships: – A Song HAS-A most recent date played Inheritance models IS-A relationships: – an oval IS-A shape – a rectangle IS-A shape – MyFrame extends JFrame makes MyFrame a JFrame with additional methods and listeners for a specific application 14

Java Examples of Inheritance

All Exceptions extend Exception: – RunTimeException IS-AN Exception – NullPointerException IS-A RunTimeException Many classes extend the Component class – a JButton IS-A Component – a JTextField IS-A Component A GregorianCalender IS-A Calendar Vector and ArrayList extends AbstractList EmptyQueueException IS-A RuntimeException 15

Designing An Inheritance Hierarchy

Start with an abstract class to define common alities and differences (abstract methods)

public abstract class Lendable {

private instance variables constructor(s) methods that Lendable implements when the behavior is common to all of its subclasses (what is common)

}

abstract methods the subclasses must implement that to represent what varies

16

Some common data fields

Every class in the hierarchy ended with these private instance variables in class Lendable: – Subclasses can not directly reference these

private String callNumber; private String title; private boolean availability; private String borrowerID; private DayCounter dueDate;

17

Lendable's constructor

Constructor needs a callNumber and title since it seems that all Lendables will need both The actual values will later come from the subclasses constructor

public Lendable(String callNumber, String initTitle) {

callNumber = callNumber; // from subclass title = initTitle; // from subclass

// Initialize others in a special way

borrowerID = null; dueDate = null; availability = true; }

18

Common Behavior

public String getCallNumber() { return callNumber; } public String getTitle() { return title; } public boolean isAvailable() { return availability; } public DayCounter getDueDate() { return dueDate; }

19

Common Behavior

continued

public int daysLate() {

// return a positive if dueDate is before today

DayCounter today = new DayCounter(); return dueDate.daysFrom(today); } } public boolean isOverdue() { if(this.isAvailable())

return false; // not even checked out

// Or check to see if this Lendable is overdue

DayCounter today = new DayCounter();

// Return true if today is greater than // the due date for this Lendable

return daysLate() > 0;

20

Common Behavior

continued

public boolean checkSelfIn() { if(this.isAvailable()) return false; else {

// Adjust state so this is checked out

dueDate = null; availability = true; return true; } }

21

checkSelfOut split between Lendable and its subclasses

// called from a subclass checkSelfOut

protected void checkOutAnyLendable(String borrowerID, int borrowLength ) {

// Record who is borrowing this Lendable

this.borrowerID = borrowerID;

// Set the due date

dueDate = new DayCounter

(); // today's date

dueDate.

adjustDaysBy (borrowLength); }

// Mark this as no longer available

availability = false;

22

Protected

The protected access mode means that subclasses inherit this method (

inherit all public & protected elements).

It's invoked by the subclass's

checkSelfOut

method.

23

Design Issues

So far, good design for the following reasons: – subclasses can't change the private variables of the superclass, even though the subclass has them – doesn't require a bunch of setter methods in Lendable for subclasses to modify their own instance variables – the common behavior is in the superclass • the same thing is done for all subclasses – We'll get a polymorphic

checkSelfOut

message 24

Abstract methods

– Subclasses differ:

setDueDate getLateFee

• declare the appropriate methods abstract, to force sub-classes to implement them in their own appropriate ways

public abstract class Lendable {

// Don't really borrow a Lendable // Nor do you or eat a Fruit ...

// Subclass must implement these two methods

abstract public void checkSelfOut(String ID); abstract public double getLateFee();

} // Done with Lendable for now 25

What can a subclass do?

General form for inheriting a Java class:

public class

subclass

extends

superclass

{

// subclass inherits all public and // protected methods of superclass

may add class constants may add instance variables may add 1 to many constructors may add new public and protected methods may override methods in the superclass may add additional private methods

} 26

The Constructor and Super

A subclass typically defines its constructor. If not – You will still get a default constructor with 0 parameters that automatically calls the base class constructor Constructors in a subclass often call the superclass constructor to initialize the objects Access superclass with the keyword

super

– can pass along arguments

super(callNum, title)

– if used,

super

must be the first message in the constructor of the derived classes 27

Book extends Lendable

public class Book extends Lendable { public static final int DAYS_TO_BORROW_BOOK = 14; public static final double BOOK_LATE_DAY_FEE = 0.50; private String author; public Book(String callNumber, String title, String author){ super(callNumber, title) ; author = author; } } public String getAuthor() { return author; }

28

Complete both required methods

checkSelfOut Lendable

delegates some work to and passes along the unique information

Book.DAYS_TO_BORROW_BOOK

/** Modify the state of this object so it is borrowed * @param borrowerID: The identification of borrower */

@Override public void checkSelfOut(String borrowerID) { checkOutAnyLendable(borrowerID, Book.DAYS_TO_BORROW_BOOK); }

29

getLateFee differs among the Lendable subclasses

@Override public double getLateFee() {

if(this.isAvailable()) // Not even checked out!

return 0.00; else {

// A positive daysLate means due date has passed

int daysOverdue = this.daysLate();

if(daysOverdue > 0) // This Lendable is overdue

return daysOverdue * Book.BOOK_LATE_DAY_FEE; else

return 0.00; // The due date has not passed

} } }

30

A few assertions

@Test public void testGetters() {

// Show that Book has many methods via inheritance

Book aBook = new Book("QA76.1", "C++", "Jo"); assertTrue(aBook.isAvailable()); assertFalse(aBook.isOverdue()); assertNull(aBook.getBorrowerID()); assertEquals("QA76.1", aBook.getCallNumber()); assertEquals("C++", aBook.getTitle()); assertEquals("Jo", aBook.getAuthor()); }

// Use the 2 methods that once were abstract and // now have concrete realizations

assertEquals(0.00, aBook.getLateFee(), 1e-12); assertTrue(aBook.isAvailable()); aBook.checkSelfOut("Rick"); assertFalse(aBook.isAvailable());

31

Adding Other Subclasses

Extend Lendable Optional: add class constants – days to borrow, late fee amounts Add a constructor that passes along arguments to the constructor in Lendable (super) Add the methods that Lendable requires of all sublclasses: use Override – checkSelfOut – getLateFee 32

33