Object-oriented
Programming Features
Part 2
Inheritance
Learning Objectives
In this lesson, you will learn to:
◦ understand the concept of software reuse
◦ distinguish the types of inheritance
◦ explain the benefits of using inheritance
◦ apply inheritance in a Java application
◦ identify the rules and restrictions in using
inheritance
Inheritance
Inheritance allows child classes to inherit the
characteristics of an existing parent class
◦ Attributes (fields and properties)
◦ Operations (methods)
Child class can extend the parent class
◦ Add new fields and methods
◦ Redefine methods (modify existing behavior)
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.
Types of Inheritance
Inheritance terminology
Inheritance – Benefits
Inheritance has a lot of benefits
◦ Extensibility
◦ Reusability
◦ Provides abstraction
◦ Eliminates redundant code
Use inheritance for building “is-a”
relationships
◦ E.g. dog is-a animal (dogs are kind of animals)
Don't use it to build “has-a” relationship
◦ E.g. dog has-a name (dog is not kind of name)
Inheritance – Example
Types of Inheritance
Java supports only single-inheritance
so this one is not applicable
Class Hierarchies
Inheritance leads to a
hierarchy of classes
and/or interfaces in
an application:
The general
characteristics are
specified high up in
the hierarchy
More specific
characteristics are
specified below the
hierarchy
Inheritance in Java
A class can inherit only one base class
◦ Example: public class B extends A
A class can implement several interfaces
◦ Example: public class B implements IX, IY, IZ
A class can extend one class and implement
several interfaces
◦ Example: public class B extends A implements IX,
IY, IZ
How to Define Inheritance?
We must specify the name of the base class after
the name of the derived
public class Shape
{...}
public class Circle extends Shape
{...}
In the constructor of the derived class we use the
keyword super to invoke the constructor of the
base class
public Circle (int x, int y)
{
super(x);
...
}
Simple Inheritance Example
public class Mammal public class Dog extends Mammal
{ {
public int age; public String breed;
public void Sleep() public Dog(String breed)
{ {
System.out.println("Shhh! I'm this.breed = breed;
sleeping!"); }
}
} public void WagTail()
{
System.out.println("Tailwagging...");
}
}
Inheritance: Adding Functionality
Subclasses have all of the data members and
methods of the superclass
Subclasses can add to the superclass
◦ Additional data members
◦ Additional methods
Subclasses are more specific and have more
functionality
Inheritance: Important Aspects
In Java, there is no multiple inheritance
◦ Only multiple interfaces can be implemented
Constructors are not inherited
Inheritance is transitive relation
◦ If C is derived from B, and B is derived from A, then
C inherits A as well
Inheritance: Important Features
A derived class extends its base class
◦ It can add new members but cannot remove derived
ones
Declaring new members with the same name
or signature hides the inherited ones
Inheritance and Accessibility
class Creature class Dog extends Mammal
{ {
protected String name; String breed;
public String getName(){ public String getBreed() {
return name; return breed;
} }
private void Talk() // super.Talk() cannot be invoked here (it is private)
{ }
System.out.println("I am creature ...");
} class InheritanceAndAccessibility
{
protected void Walk() static void Main()
{ {
System.out.println("Walking ...");
} Dog joe = new Dog();
} System.out.println(joe.getBreed());
--------------------------------------------- // joe.Walk() is protected and can not be invoked
// joe.Talk() is private and can not be invoked
class Mammal extends Creature // joe.name = "Rex"; // Name cannot be accessed here
{ // joe.breed = "Shih Tzu"; // Can't modify breed
// super.Talk() can be invoked here }
// name can be read but cannot be modified }
here
}
The Object class
In Java, all classes are (direct or indirect)
subclasses of the Object class.
It is the root of the inheritance hierarchy in Java
If a class is not declared to inherit from another
then it implicitly inherits from the Object class
It defines a ToString() method which could be
overriden by the subclasses.
Example: From a class named Book
public String ToString()
{
return super.ToString() + “ by “ + author;
}
Summary
◦ Software reuse
◦ Types of inheritance
◦ Benefits of inheritance
◦ Inheritance in a Java
◦ Inheritance and Accessibility
Polymorphism
Polymorphism is the ability to take more
than one form (objects have more than
one type)
◦ A class can be used through its parent
interface. E.g. Circle class and Rectangle
class inherit from Shape class
Shape shape = new Circle();
shape = new Rectangle();
◦ A child class may override some of the
behaviors of the parent class
Polymorphism
Why handle an object of given type as object
of its base type?
E.g. Shape shape = new Circle();
◦ To invoke abstract operations
◦ To mix different related types in the same collection
E.g.
ArrayList <Circle> circles = new ArrayList <Circle>();
ArrayList <Rectangle> circles = new ArrayList <Rectangle>();
ArrayList <Shape> circles = new ArrayList <Shape>();
Polymorphism
◦ To pass a more specific object to a method that expects
a parameter of a more generic type
◦ To declare a more generic field which will be initialized
and "specialized" later.
◦ E.g. Circle and Rectangle inherits from Shape
Polymorphism: How it works?
Polymorphism ensures that the appropriate
method of the subclass is called through its
base class' interface
Polymorphism is implemented using a
technique called late method binding
◦ Exact method to be called is determined at runtime,
just before performing the call
Note: Late binding is slower than normal
(early) binding
Example:
