Lecture#07

Inheritance & Method Overriding

Course: Object oriented Programming (CE-205)

Course Teacher: Dr Umm-e-Laila& Ms.Aneeta Siddiqui

Contact Info:
Room No: BS-04, CED
1 Email: ulaila@ssuet.edu.pk
 Course Books

 Text Book:
 Herbert Schildt, Java: The Complete Reference, 12th
Edition ,McGraw-Hill Education.
 Deitel, Paul, Java How to Program, 11th Edition, Pearson,
2017

 Reference Books:
 Horton, Ivor, Beginning Java, 7th Edition, Wrox, 2011

2
Course Instructors

 Dr. Umm-e-Laila ulaila@ssuet.edu.pk

Assistant Professor, CED
Room Number: BS-04
Tel: 111-994-994, Ext. 536

 Aneeta Siddiqui aarshad@ssuet.edu.pk

Assistant Professor, CED
Room Number: BS-03
Tel: 111-994-994,
 Marks Distribution

Assignments + Quiz ______________

20

Mid Term ______________

30

Semester Final Paper ______________

4
50
 Topics Covered

 Inheritance
 Method Overriding with example

5
 6 Inheritance

 Inheritance in java involves a relationship between

parent and child classes.
 The process by which one class acquires the
properties(data members) and
functionalities(methods) of another class is called
inheritance.
 7 Inheritance

 The aim of inheritance is to provide the

reusability of code so that a class has to write
only the unique features and rest of the
common properties and functionalities can
be extended from the another class.
 8 Inheritance
 Child Class:
 The class that extends the features of another
class is known as child class, sub class or derived
class( implementation inheritance)
 In Java, implementation inheritance is achieved
by extending classes
 Parent Class:
 The class whose properties and functionalities are
used(inherited) by another class is known as
parent class, super class or Base class.
 Inheritance Hierarchy

Object

Class Animal

Class Cat Class Dog Class Duck

Class spaniel
 Inheritance Hierarchy
 Classes higher up in the hierarchy are more generalized, as
they abstract the class behavior.
 Classes lower down in the hierarchy are more specialized, as
they customize the inherited behavior by additional properties
and behavior
 Inheritance defines the relationship is-a (also called the
superclass–subclass relationship) between a superclass and
its subclasses.
 This means that an object of a subclass can be used wherever
an object of the superclass can be used
 A class in Java can only extend one other class; that is, it can
only have one immediate superclass. This kind of inheritance is
sometimes called single or linear implementation
inheritance.
 An object of the Dog class is-an object of the superclass Animal
 inheritance relationship is transitive: if class B extends class A,
then a class C, which extends class B, will also inherit from class
A via class B.
 The is-a relationship does not hold between peer classes.
 11
Inheritance

# Example 01
class ParentClass{
public int parentVariable = 10;
public void parentFunction()
{ System.out.println( "Parent Function" ); }
}

class ChildClass extends ParentClass{

public void childFunction() {
parentFunction();
System.out.println( "In Child " + parentVariable ); }
}
}
public static void main(String args[]){
//Creating the object of child class
ChildClass example = new ChildClass();
example.childFunction();
example.parentFunction();
System.out.println( example.parentVariable ); }
}
}
12 Inheritance
# Example 01

Output:
Parent Function
In Child 10
Parent Function 10
13 SuperClass Members

 Inheritance of members is closely tied to

their declared accessibility.
 If a superclass member is accessible by
its simple name in the subclass (without
the use of any extra syntax like super),
then that member is considered
inherited.
 private, overridden, and hidden
members of the superclass are not
inherited
 If no extends clause is specified in the
header of a class declaration, then the
class implicitly inherits from the
java.lang.Object class.
 Important Points
 Note that constructors are not members and
are not inherited by subclasses.
 The following list itemizes the members that are
inherited by a subclass:
1. Subclasses inherit those superclass members declared as
public or protected.
2. Subclasses inherit those superclass members declared
with no access specifier as long as the subclass is in the
same package as the superclass.
3. Subclasses don't inherit a superclass's member if the
subclass declares a member with the same name. In the
case of member variables, the member variable in the
subclass hides the one in the superclass. In the case of
methods, the method in the subclass overrides the one in
the superclass
 15 Advantage of Inheritance

 Inheritance allows us to reuse of code, it improves reusability in your

java application.

 Note: The biggest advantage of Inheritance is that the code that is

already present in base class need not be rewritten in the child class.
 16 Method Overriding
 Declaring a method in sub class which is already
present in parent class is known as method
overriding.
 Overriding is done so that a child class can give its
own implementation to a method which is already
provided by the parent class.
 In this case the method in parent class is called
overridden method and the method in child class
is called overriding method.
 The method that will be executed depends on the
object.
 Overriding and Hiding Members
 Instance Method Overriding
 a subclass may override non-static methods methods
defined in the superclass .
 When the method is invoked on an object of the
subclass, it is the new method implementation in the
subclass that is executed.
 The overridden method in the superclass is not inherited
by the subclass, and the new method in the subclass
must uphold the following rules of method overriding:
 Method Overriding rules
1. The new method definition must have the same
method signature (i.e., method name and
parameters) and the same return type.
2. A subclass cannot override methods that are
declared final in the superclass (by definition,
final methods cannot be overridden). If you
attempt to override a final method, the compiler
displays an error message.
3. Whether parameters in the overriding method
should be final is at the discretion of the subclass A
method's signature does not encompass the
final modifier of parameters, only their types
and order.
4. The new method definition cannot narrow the
accessibility of the method, but it can widen it
5. Constructors cannot be overridden.
6. Accessibility modifier private for a method means
that the method is not accessible outside the class
in which it is defined; therefore, a subclass cannot
override it.
19 Method Overriding
# Example 01

class Human{
//Overridden method
public void eat()
{
System.out.println("Human is eating");
}
}
class Boy extends Human{
//Overriding method
public void eat(){
System.out.println("Boy is eating");
}
public static void main( String args[]) {
Boy obj = new Boy();
//This will call the child class version of eat()
obj.eat();
}
}
20 Method Overriding
# Example 01

Output:

Boy is eating
21 Method Overriding

# Example 02
 This is called
class Animals{
public void sound(){
overriding a method
System.out.println("This is parent class.");  Method sound in
}
} Dog overrides
class Dogs extends Animals{ method sound in
public void sound(){
System.out.println("Dogs bark");
Animal
}  A subclass variable
}
class m{ can shadow a
public static void main(String[] args){ superclass variable,
Dogs d = new Dogs();
d.sound();
but a subclass
} method can override
} a superclass method
22 Method Overriding
# Example 02 cont..

Output:

Dogs bark
23 Methods a Subclass Must Override
 A subclass must override methods that
are declared abstract in the superclass,
or the subclass itself must be abstract.
an abstract method requires the non-
abstract subclasses to override the
method, in order to provide an
implementation.
 24 Why override a method?

 Dog dog = new Dog();

System.out.println(dog);
 Prints something like Dog@feda4c00
 The println method calls the toString method, which is defined in
Java’s top-level Object class
 Hence, every object can be printed (though it might not look pretty)
 Java’s method public String toString() can be overridden
 If you add to class Dog the following:
public String toString() {
return name;
}
Then System.out.println(dog); will print the dog’s name, which may be
something like: Fido
 25 More about toString()

 It is almost always a good idea to override

public String toString()
to return something “meaningful” about the object
 When debugging, it helps to be able to print objects
 When you print objects with System.out.print or
System.out.println, they automatically call the objects
toString() method
 When you concatenate an object with a string, the
object’s toString() method is automatically called
 You can explicitly call an object’s toString() method
 26 Equality
 Consider these two assignments:
Thing thing1 = new Thing();
Thing thing2 = new Thing();
 Are these two “Things” equal?
 That’s up to the programmer!
 But consider:
Thing thing3 = new Thing();
Thing thing4 = thing3;
 Are these two “Things” equal?
 Yes, because they are the same Thing!
27
The equals method
 Primitives can always be tested for equality with ==
 For objects, == tests whether the two are the same object
 Two strings "abc" and "abc" may or may not be == !
 Objects can be tested with the method
public boolean equals(Object o)
in java.lang.
 Unless overridden, this method just uses ==
 It is overridden in the class String
 It is not overridden for arrays; == tests if its operands are the same
array
 Morals:
 Never use == to test equality of Strings or arrays or other objects
 Use equals for Strings, java. util.Arrays.equals(a1, a2) for arrays
 If you test your own objects for equality, override equals
 28 Calling an overridden method
 When your class overrides an inherited method, it
basically “hides” the inherited method
 Within this class (but not from a different class),
you can still call the overridden method, by
prefixing the call with super.
 Example: super.printEverything();
 You would most likely do this in order to observe
the DRY principle
 The superclass method will do most of the work, but you
add to it or adjust its results
 This isn’t a call to a constructor, and can occur anywhere
in your class (it doesn’t have to be first)
29 Super
 A subclass must use the keyword super
in order to invoke an overridden
method in the superclass
 Field Hiding
 A subclass cannot override fields of the
superclass, but it can hide them.
 The subclass can define fields with the same
name as in the superclass.
 If this is the case, the fields in the superclass cannot be
accessed in the subclass by their simple names;
therefore, they are not inherited by the subclass.
 Code in the subclass can use the keyword super
to access such members, including hidden fields.
 A client can use a reference of the superclass to
access members that are hidden in the subclass if
the hidden field is static, it can also be accessed
by the superclass name.
 When an instance method is invoked on an object
using a reference, it is the class of the current object
denoted by the reference, not the type of the
reference, that determines which method
implementation will be executed.
 Inheritance: Field Hiding
31
# Example 03
class Parent{
public String name = "Parent";
public void parentPrint() {
System.out.println( name ); }
}
class Child extends Parent{

String name = "Child";

public void print() {
System.out.println( name ); }

}
public static void main(String args[]){
Child whoAmI = new Child();
whoAmI.print();
whoAmI.parentPrint();
System.out.println( whoAmI.name );
System.out.println( ( (Parent ) whoAmI).name );

}
}
32 Inheritance

# Example 03

Output:

1.Child
2.Parent
3.Child
4.Parent
 Inheritance: Super keyword
33

# Example 04
class Parent{
public String name = "Parent";
}
class Child extends Parent{

String name = "Child";

public void print() {
System.out.println( name );
System.out.println( super.name );}

}
class GrandChild extend Child {
String name = "GrandChild"; }
class SuperMain {

public static void main(String args[]){

GrandChild whoAmI = new GrandChild();
whoAmI.print();
}
}
34 Inheritance

# Example 04

Output:

1.Child
2.Parent
 Casting and Classes
 An instance of a child class can be
assigned to a variable (field) of the
parent class.
 If a variable references an object of a subclass, the object
can be cast down to its actual type with an explicit cast. The
explicit cast is required.
 A runtime error occurs when explicitly casting an object to a
type that it is not hierarchy
 In the code below the cast "(Uncle)
object" is a runtime error because at
that time object holds an instance of the
Child class, which is not of type (or
subclass) of Uncle. An object of type
Parent cannot be cast to type Child.
36 Casting and Classes
 Inheritance: Casting
37

# Example 05
class Parent{
int data;
}
class Child extends Parent{
String name;
}
class Uncle {
String rich;
}
class Casting {
Object object;
Parent parent;
Child child = new Child();
Uncle uncle;
parent = child;
object = child;
parent = (Parent) object; // explicit cast down
child = (Child) object; // explicit cast down
uncle = (Uncle) object; //Runtime exception }
}
38 Inheritance

# Example 05

Output:

java.lang.ClassCastException: Child:
cannot cast to Uncle
 Constructors and Inheritance
 Before the constructor in a Child class is called, its
parent's constructor will be called
 If the Child class constructor does not do this, the
parent's constructor with no arguments will be
implicitly called.
 super( arg list) as the first line in a constructor
explicitly calls the parent's constructor with the
given signature If
1. Parent class implements a constructor with
arguments & Parent class does not implement
a constructor with no arguments
2. Then the Child constructors must eventually
explicitly call a parents constructor
40 Inheritance: Implicit Call to Parent
# Constructor
Example 06
class ParentClass{
//Parent class constructor
ParentClass(){
System.out.println("Constructor of Parent");
}
}
class JavaExample extends ParentClass{
JavaExample(){
/* It by default invokes the constructor of parent class
* You can use super() to call the constructor of parent.
* It should be the first statement in the child class
* constructor, you can also call the parameterized constructor
* of parent class by using super like this: super(10), now
* this will invoke the parameterized constructor of int arg
*/
System.out.println("Constructor of Child");
}
public static void main(String args[]){
//Creating the object of child class
new JavaExample();
}
}
41 Inheritance
# Example 06

Output:

Constructor of Parent
Constructor of Child
42 Inheritance: Explicit Call to Parent
Constructor
# Example 07
class Parent{
//Parent class constructor
public Parent( ) {
System.out.println( "In Parent, No Argument" );
}
public Parent( String message ) {
System.out.println( "In Parent" + message );
}
}
class Child extends Parent {
//Child class constructor
public Child( String message, int value )
{ this( message ); // if occurs must be first
System.out.println( "In Child" ); }
public Child( String message )
{ super( message ); // if occurs must be first
System.out.println( "In Child" + message ); }
Class Constructors
public static void main(String args[]){
System.out.println( "Construct Child" );
Child care = new Child( ">Start from Child<", 5 ); }
}
43 Inheritance
# Example 07

Output:

In Parent>Start from Child<

In Child>Start from Child<
In Child
 No Default Parent Constructor
 The compiler will not generate the default
constructor for the class "Parent", since "Parent" has
a constructor. The class "Child" makes an implicit call
to the default constructor in "Parent". This causes a
compile error.
# Example 08
class Parent {
public Parent( String message )
{ System.out.println( "In Parent" + message ); }
}
class Child extends Parent {
public Child( ) { // Compile Error
System.out.println( "In Child" ); }
public Child( String message ) {
super( message );
System.out.println( "In Child" + message ); } }
Difference between Method
Overloading
and Method Overriding
S Method Overloading Method Overriding
#
1 Method overloading is Method overriding is used to
used to increase the provide the specific
readability of the implementation of the
program method that is already
provided by its super class.
2 Method overloading is Method overriding occurs in
performed within class. two classes that have IS-A
(inheritance) relationship.
3 In case of method In case of method overriding,
overloading, parameter parameter must be same.
must be different.
4 Method overloading is the Method overriding is the
example of compile time example of run time
polymorphism. polymorphism.
5 In java, method Return type must be same or
overloading can't be covariant in method
performed by changing overriding.
46 Task
 Implement the following Hierarchy
47 Task
 Summary
48

 You should overload a method when you want to do

essentially the same thing, but with different parameters
 You should override an inherited method if you want to
do something slightly different than in the superclass
 It’s almost always a good idea to override public void
toString() -- it’s handy for debugging, and for many
other reasons
 To test your own objects for equality, override public
void equals(Object o)
 There are special methods (in java.util.Arrays) that you
can use for testing array equality
 You should never intentionally shadow a variable