more about inheritance exploring polymorphism 5.0

More about inheritance

Exploring polymorphism

5.0

2

Main concepts to be covered

• method polymorphism• static and dynamic type• overriding• dynamic method lookup• protected access

Objects First with Java - A Practical Introduction using BlueJ, © David J. Barnes, Michael Kölling

3

The inheritance hierarchy


display() method is in superclass Post

4

Conflicting output


Leonardo da VinciHad a great idea this morning.But now I forgot what it was. Something to do with flying ... 40 seconds ago - 2 people like this. No comments.

Alexander Graham Bell[experiment.jpg]I think I might call this thing 'telephone'.12 minutes ago - 4 people like this. No comments.

Leonardo da Vinci40 seconds ago - 2 people like this. No comments.

Alexander Graham Bell12 minutes ago - 4 people like this. No comments.

What we want(original w/oinheritance)

What we have(results w/

inheritance)

5

The problem

• The display method in Post only prints the common fields

• Inheritance is a one-way street:– A subclass inherits the superclass fields– Superclass knows nothing about subclass’s

fieldsObjects First with Java - A Practical Introduction using BlueJ, © David J. Barnes, Michael Kölling

6

Attempting to solve the problem

• Place display where it has access to the information it needs

• Each subclass has its own version

• But Post’s fields are private

• NewsFeed cannot find a display method in Post


7

Static type and dynamic type

• A more complex type hierarchy requires further concepts to describe it

• Some new terminology:– static type

– dynamic type

– method dispatch/lookup


8

Static and dynamic type


Car c1 = new Car();What is the type of c1?

Vehicle v1 = new Car();What is the type of v1?

9



Car c1 = new Car();What is the type of c1?

Vehicle v1 = new Car();What is the type of v1?

Car (type)

Vehicle (static type)Car (dynamic type)

10


• The declared type of a variable is its static type

• The type of the object a variable refers to is its dynamic type

• The compiler’s job is to check for static-type violations:

for(Post post : posts) { post.display(); // Compile-time error.}


11

Overriding: the solution


display method in both super- and subclasses

Satisfies both static and

dynamic type checking

NOTE: display method in Post would never execute!

12

Overriding• Superclass and subclass define

methods with the same signature

• Each has access to the fields of its own class

• Superclass satisfies static type check

• Subclass method is called at runtime – it overrides the superclass version

• What becomes of the superclass version?


13

Distinct static anddynamic types


The variable post has a:• static type of Post• dynamic type of PhotoPost

14

Method lookup


No inheritance or polymorphism.The obvious method is selected.display is executed from PhotoPost

15

Method lookup


Inheritance (without overriding) where the inheritance hierarchy is ascended, searching for a match.

display is NOT found in PhotoPost, but it is found and executed from Post

16

Method lookup


Polymorphism and overriding exists, where search starts with dynamic type (ascending up)

and the first version found is used.display is found & executed in PhotoPost

17

Method lookup summary

• The variable is accessed

• The object stored in the variable is found

• The (dynamic) class of the object is found

• The class is searched for a method match

• If no match is found, the superclass is searched

• This is repeated until a match is found, or the class hierarchy is exhausted

• Overriding methods take precedence


18

Super call in methods• Overridden methods are hidden, but

we may still want to be able to call them

• An overridden method can be called from the method that overrides it by using super (i.e. super.method())

• Compare with the use of super in constructors (i.e. super())– method name is explicitly stated (i.e. super.method())– super.method may be used anywhere, and

not just the first statement (as with constructors)– no automatic super call (as in constructors) is

generated, nor is a super.method call required

19

Calling an overridden method


public void display(){ super.display(); System.out.println(" [" + filename

+ "]"); System.out.println(" " + caption);}

Calls the superclass display method and then continues with printing its own fields.

20

Method polymorphism

• We have been discussing polymorphic method dispatch

• A polymorphic variable can store objects of varying types

• Method calls are also polymorphic

– The actual method called depends on the dynamic object type


21

The Object class’s methods

• Methods in the Object library class are inherited by ALL classes

• Any of those found in Object may be overridden (i.e. toString)

• The implicitly-defined toString method is commonly overridden:– public String toString()– returns a string representation of

the object


22

Overriding toString in Post


public String toString(){ String text = username + "\n" + timeString(timestamp); if(likes > 0) { text += " - " + likes + " people like this.\n"; } else { text += "\n"; } if(comments.isEmpty()) { return text + " No comments.\n"; } else { return text + " " + comments.size() + " comment(s). Click here to view.\n"; }}

23

Overriding toString

• Explicit print methods can often be omitted from a class: System.out.println(post.toString());

• Calls to println and print with just an object automatically result in toString being called: System.out.println(post);


24

StringBuilder• Consider using StringBuilder as

an alternative to concatenation:StringBuilder builder = new StringBuilder();builder.append(username);builder.append('\n');builder.append(timeString(timestamp));…return builder.toString();


The overloaded append method takes a parameter of any type and effectively converts it to its string representation before appending

it to the original StringBuilder object.

25

Object equality• What does it mean for two objects

to be ‘the same’?– Reference equality

(only 1 object)– Content equality

(2 objects with the same internal states)

• Compare use of == with equals() in with strings in the String class:– == compares reference equality– equals() compares content equality

26

Overriding equals

public boolean equals(Object obj){ if(this == obj) { return true; // reference to itself } if(!(obj instanceof ThisType)) { return false; // different object types } ThisType other = (ThisType) obj;

// cast into right variable type return field.equals(other.field) && … // compare all field contents of this and other} // for content equality

public boolean equals(Object obj){ return this == obj; // reference to itself}

Object class method actually tests for reference equality!

To test for content equality, we must override the method!

27

Overriding equals in Student

public boolean equals(Object obj){ if(this == obj) { return true; // reference equality } if(!(obj instanceof Student)) { return false; // different object types } Student other = (Student) obj; // cast return name.equals(other.name) && id.equals(other.id) && credits == other.credits;} // test content equality

28

Overriding hashCode in Student

/** * Uses values of name, id & credits fields * to calculate the distinct hashCode * representation of a specific Student object */public int hashCode(){ int result = 17; result = 37 * result + name.hashCode(); result = 37 * result + id.hashCode(); result = 37 * result + credits; return result;}

hashCode method should also be overridden whenever the equals method is overridden.

29

Protected access• Private access in the superclass may be

too restrictive for a subclass

• The closer inheritance relationship is supported by protected access

• Protected access is more restricted than public access

• But allows access to fields/methods within a class itself AND from all its subclasses– protected accessors, mutators & constructors

• We still recommend keeping fields private – to maintain encapsulation

30

Access levels

Method calls from Subclass to protected methods in its superclass SomeClass are made similar to calls to its own

internal methods. Thus, NO object variable (with dot notation) is necessary. getSomeClassField()

31

The instanceof operator

• Used to determine the dynamic type

• Recovers ‘lost’ type information

• Usually precedes assignment with a cast to the dynamic type:

if(post instanceof MessagePost) { MessagePost msg =(MessagePost) post; … access MessagePost methods via msg …}


32

Review

• The declared type of a variable is its static type– Compilers check static types

• The type of an object is its dynamic type– Dynamic types are used at runtime

• Methods may be overridden in a subclass

• Method lookup starts with the dynamic type

• Protected access supports inheritance


more about inheritance exploring polymorphism 5.0

Documents

dynamic type objects

type of c1

type of v1

declared type

statictype violations

michael klling slide

practical introduction

michael klling display