Inheritance

(1)

Inheritance + Polymorphism

(2)

What is Inheritance

• _{Classes can inherit common state and/or}

behavior from other classes

• Parent classes are more generic

• _{Child classes are more specific} • Single-Inheritance

(3)

Inheritance

• _{“A class that is derived from another class is}

called a subclass (also a derived class,

extended class, or child class). The class from which the subclass is derived is called a

superclass (also a base class or a parent class).

“

• https://

docs.oracle.com/javase/tutorial/java/IandI/subc lasses.html

(4)

Inheritance

• _{“Excepting Object, which has no superclass,}

every class has one and only one direct

superclass (single inheritance). In the absence of any other explicit superclass, every class is implicitly a subclass of Object.”

• https://

(5)

Inheritance

• “Classes can be derived from classes that are derived from classes that are derived from

classes, and so on, and ultimately derived from the topmost class, Object. Such a class is said to be descended from all the classes in the

inheritance chain stretching back to Object. “

• https://

docs.oracle.com/javase/tutorial/java/IandI/subc lasses.html

(6)

Inheritance Example

Examples:

Food is a superclass of Fruit, Vegetable, Meat, and Grain

(7)

Inheritance Example 2

7

Examples:

Vehicle is a superclass of Air Vehicle, Land Vehicle, and Sea Vehicle

(8)

Inheritance Advantages

• _{Prevents duplicate code for similar classes}

– _{No copy/paste code}

– _{Copy and pasting code makes you look bad!}

• Makes programs easier to extend and maintain

– _{*Usually but not always*}

(9)

Inheritance Disadvantages

• Harder to program

– Need to think about which attributes and functions belong in which classes

– Harder to design the classes

• Harder to make changes

– If a superclass method is modified, subclass methods may be broken

• Requires more knowledge to work with a single class

– Ancestor + descendent classes

(10)

Inheritance Disadvantages

• Not always easy to visualize the inheritance hierarchy

– _{Example: Throwable class}

– https://

docs.oracle.com/javase/8/docs/api/java/lang/Thro wable.html

• Code is harder to understand to programmers not familiar with the inheritance design

– _Example:

• MythicalAnimal ma = new Unicorn(); – //Apparently there is a Unicorn class

(11)

Animal Example

• _{Pick an animal and make a class to represent it}

– _{What properties does that animal have}

• _{Private attributes}

– _{What can that animal do}

• _{Functions/methods}

(12)

Animal Example Continued

• _{Pick another animal and make a class to}

represent it

– _{What properties does that animal have}

• _{Private attributes}

– _{What can that animal do}

(13)

Animal Example Continued

• _{Do these two animals have anything in}

common

– _{Common attributes?}

– _{Common functions?}

(14)

• _{Make a superclass for these animal classes}

– _{Take common code and store in the superclass}

– _{Have these animals be a subclass of the new class}

(15)

extends

• _{The extends keyword is used by classes to}

inherit from another class

• Java does not support multiple inheritance

– _{A class may only extend a single class}

– _{Interfaces (to be discussed later) are used to}

compensate for this restriction

(16)

Example - ExtendsExample

• _Main.java • A.java

(17)

Extends Example

public class A {

private int numericValue;

public A() {

numericValue = 1; }

public int getNumericValue() {

return numericValue; }

} ₁₇

public class B extends A {

public B() {

numericValue = 2; }

(18)

Extends Example

public class A {

public A() {

numericValue = 1; }

}

public B() {

numericValue = 2; }

}

(19)

Extends Example

public class A {

public A() {

numericValue = 1; }

} ₁₉

public B() {

numericValue = 2; }

}

(20)

Extends Example

public class A {

public A() {

numericValue = 1; }

}

public B() {

numericValue = 2; }

}

Override the default constructor and initialize

(21)

Extends Example

public class A {

public A() {

numericValue = 1; }

} ₂₁

public B() {

numericValue = 2; }

}

(22)

Extends Example

public class A {

public A() {

numericValue = 1; }

}

public B() {

numericValue = 2; }

}

(23)

Extends Example

public class A {

public A() {

numericValue = 1; }

} ₂₃

public B() {

numericValue = 2; }

}

(24)

Extends Example

public class A {

public A() {

numericValue = 1; }

}

public B() {

numericValue = 2; }

}

(25)

Extends Example

public class A {

public A() {

numericValue = 1; }

} ₂₅

public B() {

numericValue = 2; }

}

numericValue is private

(26)

Extends Example

public class A {

public A() {

numericValue = 1; }

}

public B() {

numericValue = 2; }

}

Could change the scope to protected, but numericValue

(27)

Extends Example

public class A {

public A() {

numericValue = 1; }

} ₂₇

public B() {

numericValue = 2; }

}

Better solution: Create another constructor in class A to take an

(28)

Extends Example

public class A {

public A() {

numericValue = 1; }

public A(int numericValue) {

this.numericValue = numericValue;

}

//get method still here

} 28

public B() {

numericValue = 2; }

}

(29)

Extends Example

public class A {

public A() {

numericValue = 1; }

public A(int numericValue) {

this.numericValue = numericValue;

}

//get method still here

} 29

public class B extends A { public B() { super(2); } }

(30)

Constructor Invocation

• Constructors are not inherited

• Constructors are invoked (called)

– _Implicitly

• If not done explicitly

– Explicitly

• Using super as the first word in the constructor of the subclass

• _{Must be the first word}

(31)

Constructor Example

31

public A() {

//statements }

public A() {

super();

//statements }

Implicit super constructor call

(32)

Constructor Chaining

• _{Constructor chaining is where there can be a}

long chain of constructors being invoked

(33)

Example - ConstructorChaining

• _A.java • B.java

• C.java

• D.java

• Trace code

(34)

Super

• _{Not just for constructors}

• Super can be used in a subclass to call a method of a super class

• _Format

– _{super.<superclass method name>}

(35)

Object Class

• _{Every class inherits from the Object class} • Every class is an Object

• Commonly overridden methods

– _toString()

– _{equals() + hashCode()}

• https://

docs.oracle.com/javase/8/docs/api/java/lang/O bject.html

(36)

toString()

• Represents your class as a String

• Every class has a toString method

– _{Because the Object class has it}

• Classes that do not override the existing toString() method, get the default Object toString() method

• _{Often used for printing out the class attributes} • System.out.println(<some class>)

(37)

equals

• _{Used to determine if two Objects are equal} • Always use equals when comparing Objects

– _{Never use “==“}

• If the class is expected to be compared to

another Object, then the equals method should be overridden

• If equals is overridden then hashCode should be overridden

(38)

hashCode()

• _{Used to uniquely identify the object when used}

in hash tables

• If hashCode is overridden then equals should be overridden as well

(39)

Generating equals and hashCode

(40)

(41)

Generating equals and hashCode

41

• Choose all the variables that you want to use in your equals comparison

• Usually all the variables are selected

(42)

Generating equals and hashCode

• Choose to insert the generated functions as the last member of the class

• These functions are

(43)

Generating equals and hashCode

43

• Choose to generate method comments

• Why not?

• Choose to use instanceof to compare types

• Because Josh Bloch says so

• Choose to use blocks in “if” statements

• Makes it easier to read

(44)

Note

• _{Use auto-generated methods carefully}

• toString() is better implemented manually

– _{Possible with the use of StringBuilder for objects}

that contain arrays

• You may want to restrict scope on constructors or setters and getters

– _{You may not want certain ones}

(45)

Override vs Overload

• _Override

– _{Redefine a superclass method}

– When the object calls this method the overridden method gets called and not the method in the

superclass

• _{Unless the subclass method uses super in its overridden}

method

• _Overload

– _{Defines a different method with the same name but a}

different number of parameters

(46)

What is wrong here?

Public class A {

public boolean equals(A otherInstance) {

//code here }

(47)

What is wrong here?

Public class A {

//code here }

}

47

(48)

What is wrong here?

Public class A {

//code here }

}

(49)

@Override Annotation

• _{Using “@Override” above the method can tell}

the compiler that you are overriding the method

• The compiler is your friend not your enemy

• If you incorrectly overload a method instead of overriding it, the compiler will stop your

program from compiling

(50)

What is wrong here?

Public class A {

@Override

//code here }

}

(51)

What is wrong here?

Public class A {

@Override

public boolean equals(Object otherInstance) {

//code here }

}

51

(52)

• _{Override the following methods in your animal}

classes

– _toString()

– _equals()

– _hashCode()

(53)

What is Polymorphism?

• _{Polymorphism is when a subclass can be used}

wherever a superclass can be used

• Example

– _{Any function that takes an Object as a parameter}

can also take any subclasses of an Object as a parameter

(54)

Example – Polymorphism Example

• _A.java • B.java

• C.java

(55)

Example Continued

• _{A b1 = new B();}

– _{What is happening here?}

• _{b1.getNumericValue()}

– _{Which function gets called?}

– _{A.getNumericValue() or B.getNumericValue()}

(56)

Declared Type vs. Actual Type

• _{Declared type}

– _{Type of the variable that is declared}

– _{b1 is declared type A}

• Actual Type

– _{Type the variable is}

– _{new B()} Indicates the type of b1 is B

• A superclass can hold subclass types

(57)

Dynamic Binding

• _{The type of the variable is bound at runtime} • Functions are chosen by the actual type of the

variable

• _{A declared object type can be set to hold any}

other class type

– Can also be changed during runtime

(58)

Casting

• _Implicit

– _{Example: Vehicle vehicle = new Car();}

– _{Can only cast from a subclass to a superclass}

– _{Car car = new Vehicle(); //Does not work}

– A car is a vehicle, a vehicle is not necessarily a car

• Explicit

(59)

Casting Continued

• _Upcasting

– _{Cast a variable to a superclass type}

– _{Vehicle v = (Vehicle)Car}

• _{A Car is a Vehicle} • Downcasting

– _{Cast a variable to a subclass type}

– _{Car car = (Car)vehicle}

• _{Can try but might fail if the vehicle is not a car}

(60)

Downcasting

• _{Use with caution}

• Check or use try/catch blocks when attempting to downcast

• _{Try to avoid explicit casting (up or down)}

whenever possible

• Remember equals method

– _{Used “instanceof” to check the class before}

(61)

Casting primitives

• _{Casting primitives creates a new value}

• Casting objects does not create a new object

– _{Except for cases where “new” is used}

(62)

Common Problem

• _{A common problem is where you want to have}

a list of some class

• _{The class holding the list can hold any type of}

object

• _{However you are not storing multiply different}

types in the list

– You are typically storing just a single type

(63)

Generics

• _{Enforce a user-specified class type}

• _{ArrayList<Integer> list= new ArrayList<Integer>()}

– _{Creates an ArrayList that must store only Integer objects} – _{The generic type is in angle brackets}

• “<Integer>”

• https://

docs.oracle.com/javase/8/docs/api/java/util/Arr ayList.html

• “public class ArrayList<E>”

– “<E>” stands for the type of the objects expected

(64)

Other Notes

• _{Using the final keyword for a class modifier}

makes the class un-extendable

• Subclasses cannot weaken the scope of superclass methods

– _private__{public = okay}

https://docs.oracle.com/javase/tutorial/java/IandI/subc

https://docs.oracle.com/javase/8/docs/api/java/lang/Thro

https://docs.oracle.com/javase/8/docs/api/java/lang/O

https://docs.oracle.com/javase/8/docs/api/java/util/Arr