Scribd
Upload
21 views13 pages

IMT304 Lecture4

Uploaded by

fareedahmusa5
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
21 views13 pages

IMT304 Lecture4

Uploaded by

fareedahmusa5
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 13

IMT304: Object Oriented Programming

Lecture 4: Inheritance and Polymorphism

A.S. Bunu
Recap of Previous lecture

Review of attributes, methods, constructors, and access
modifiers.

Discussion on the assignment and common issues
encountered.

1-2
Introduction to Inheritance

Definition: inheritance refers to a process by which one class
inherits properties (attributes and methods) from another. A key
feature of inheritance in this context is the extends keyword
Advantages of using Inheritance

Code Reusability: Avoid redundant code by inheriting
functionalities from the parent class.

Enhanced Readability: Hierarchical structures give a clearer,
more intuitive view of related classes.

Improved Maintainability: Change the parent class, and the
child classes get updated accordingly

1-3
When a class inherits from another, two main roles are defined:
Superclass (or Parent Class or Base class): This
class acts as the source for inheritance. Its blueprint
forms the basis from which subsequent classes
inherit attributes or methods from.
Subclass (or Child class or Derived class): This
is the class that does the inheriting. It will naturally
incorporate all non-private properties and methods
from its superclass and can also have additional
properties and methods of its own.

1-4
Syntax (Java):

public class Animal {


String name;
int age;
public void eat() {
System.out.println("This animal is eating.");
}
}
public class Dog extends Animal {
public void bark() {
System.out.println("The dog is barking.");
}
}

1-5
Method Overloading vs. Method Overriding

Method overloading lets a class have several methods with
the same name but different parameters, allowing varied
actions based on parameters.

In contrast, method overriding enables a subclass to offer a
distinct behavior for an inherited method.

The @Override Annotation: The @Override annota


tion in Java indicates that a method is meant to override one
in its superclass. It's a safeguard, ensuring that the overriding
is intentional and correctly done, helping catch errors during
compile time.
1-6
Example of Method Overloading and Method Overriding:
class Calculator {
// Method overloading - same method name with different
parameters
int add(int a, int b) {
return a + b;
}
int add(int a, int b, int c) {
return a + b + c;
}
}
class ScientificCalculator extends Calculator {
// Overriding the method to modify its behavior in the subclass
@Override
int add(int a, int b) {
return a + b + 10; // Just for illustration: adding 10 to
the result
}
}
1-7
Polymorphism

Definition:

Ability of a single function or method to work in different
ways based on the input or the object that calls it.
Two types:

Compile-time (method overloading) and

Runtime (method overriding).

1-8
a) Compile-time Polymorphism (Static
Polymorphism):
This type of polymorphism is achieved when we overload a
method.
void print(int a) { ... }
void print(double b) { ... }
Here, the method's name remains the same, but the parameter lists vary – this
distinction in parameters is known as method signatures.

b) Run-time Polymorphism (Dynamic Polymorphism):


This involves overriding methods from a superclass in its subclass.
class Animal {
void sound() { ... }
}
class Dog extends Animal {
void sound() { ... }
}
At runtime, Java uses the object's actual class (like Dog) to determine which version
of an overridden method should execute.

1-9
Benefits of Polymorphism
•Reusability: With Polymorphism, code components can
be leveraged across multiple classes, curtailing
redundancy.
•Extensibility: As business needs evolve, Polymorphism
ensures minimal disruptions when expanding
functionalities.
•Flexibility: Modules remain distinct, making systems
more manageable.
•Simplified Design: Systems designed with
Polymorphism are inherently organized and intuitive.
•Interchangeability: With Polymorphism, varying
implementations can be switched seamlessly.
•Enhanced Maintainability: With standardized
structures, tasks like debugging and updates become less
cumbersome.

1 - 10
Class Work
Create a Base Class and Derived Classes:

Write a class Vehicle with attributes make and model, and a
method displayInfo().

Create a derived class Car that extends Vehicle and adds an
attribute numDoors, and overrides displayInfo().

1 - 11
public class Vehicle {
String make;
String model;

public void displayInfo() {


System.out.println("Make: " + make);
System.out.println("Model: " + model);
}
}

public class Car extends Vehicle {


int numDoors;

@Override
public void displayInfo() {
super.displayInfo();
System.out.println("Number of doors: " + numDoors);
}

public static void main(String[] args) {


Car myCar = new Car();
myCar.make = "Toyota";
myCar.model = "Corolla";
myCar.numDoors = 4;
myCar.displayInfo();
}
} 1 - 12
Project02

Implement a Program Demonstrating Inheritance and
Polymorphism:

Create a class Shape with a method draw().

Create two derived classes Circle and Rectangle that extend
Shape and override draw().

Write a program that creates instances of Circle and Rectangle
and calls their draw() methods.

1 - 13

You might also like