Inheritance and Polymorphism in Java: Detailed Notes, Examples & Practice Questions (Object Oriented Programming)

Hello there, my dear students! I am really glad you are here today. Chapter 3 is one of those chapters that can make or break your exam score. But do not worry at all. I will walk you through every single concept step by step, just like we do in our classroom. Have your notebook ready, and let us get started!

Before we begin, let me ask you a quick question. Why do you think object-oriented programming became so popular? Think about it for a second. Okay, here is the answer: because it lets us reuse code that we already wrote. Instead of building everything from zero every time, we build on top of what exists. And the mechanism that makes this possible is called inheritance. Let us understand it deeply.

1. What Is Inheritance?

Imagine you are a teacher. You prepare detailed lecture notes for Chapter 3. Now your colleague, who teaches the same course at another campus, needs notes for the same chapter. Would they write everything from scratch? Of course not! They would simply take your notes and add their own examples or explanations on top. That is exactly how inheritance works in programming.

In simple words, inheritance is a mechanism where a new class acquires all the properties and behaviors of an existing class. The class that already exists is called the superclass (also known as base class or parent class). The new class that gets all those properties is called the subclass (also known as derived class or child class).

Now, why is this so useful? Let me give you a real-world analogy. Think about vehicles. All vehicles share some common features — they have a color, a speed, and they can move. A Car is a vehicle. A Truck is a vehicle. A Motorcycle is a vehicle. Instead of defining color, speed, and move() separately for Car, Truck, and Motorcycle, we create one Vehicle class with those features, and then each specific type simply inherits from Vehicle. Brilliant, right?

In Java, all classes are arranged in a hierarchy. At the very top of this hierarchy is the Object class. Every single class in Java, whether you write it yourself or use a built-in one, is a subclass of Object. So inheritance is everywhere in Java, even if you do not see it directly.

How to Declare Inheritance in Java

Java uses the reserved word extends to create an inheritance relationship between two classes. The syntax is straightforward:

Let me show you a complete, working example so you understand exactly what happens:

Look at that carefully. Inside the Car class, we never wrote the fields color and speed. We never wrote the move() method. But we can still use them! Why? Because Car extends Vehicle, and Vehicle already has those members. The Car class inherited them automatically. This is code reuse in action, and it saves you from writing redundant code.

UML Class Diagram Representation

In UML diagrams, inheritance is shown with an arrow that has an open arrowhead pointing from the child class to the parent class. This arrow means “extends” or “is a type of.” Here is a simple diagram:

• Compilation error because show() is not defined in B
• Compilation error because x is not accessible in B
• Output: 10
• Output: 20

• class Engine { } class Car { Engine e; }
• class Student { } class Classroom { Student s; }
• class Person { } class Employee extends Person { }
• class Book { } class Library { Book b; }

2. Types of Inheritance

Now here is something you must be very careful about. There are several types of inheritance in theory, but Java does not support all of them. Let me go through each type one by one with clear diagrams, and I will tell you exactly which ones Java supports and which ones it rejects. Pay close attention because this is a very common exam area.

(a) Single Inheritance

This is the simplest form. One subclass extends one superclass. Just one parent, one child. Nothing complicated here.

(b) Multiple Inheritance

In multiple inheritance, one child class tries to extend two or more parent classes at the same time. Now, this sounds useful in theory, but it creates a serious problem called the diamond problem. Here is what happens: if both parent classes have a method with the same name, and the child inherits from both, which version should the child use? There is no way to decide, and this creates ambiguity.

Because of this problem, Java does NOT support multiple inheritance through classes. This is a very important fact. Write it down and circle it.

(c) Hierarchical Inheritance

In hierarchical inheritance, one superclass has multiple subclasses. Many children, one parent. Think of it like a tree with one root and many branches. This is fully supported by Java and is very commonly used.

Notice how Dog, Cat, and Bird all share the eat() method from Animal, but each one adds its own unique behavior. That is the beauty of hierarchical inheritance — shared code at the top, specific code at the bottom.

(d) Multi-Level Inheritance

Here we have a chain of inheritance. A class extends a class that already extends another class. It is like a family tree: grandparent → parent → child. Each level adds more specific features.

(e) Hybrid Inheritance

Hybrid inheritance is a combination of two or more types of inheritance. For example, you might have hierarchical inheritance at one level and multi-level inheritance at another level, all mixed together. Since hybrid inheritance can involve multiple inheritance scenarios, Java supports it only when interfaces are used for the parts that would otherwise require multiple class inheritance.

(f) Multi-Path Inheritance

In multi-path inheritance, a class inherits from two different paths that lead back to a common ancestor. This is essentially the diamond problem in a different shape. The child class receives properties from two sources that share a common base. Java does NOT support this through classes, but it can be achieved using interfaces.

• Single inheritance
• Hierarchical inheritance
• Multi-level inheritance
• Hybrid inheritance

• It makes the code run slower
• It causes ambiguity when two superclasses have methods with the same signature
• It violates the IS-A relationship principle
• Java does not have a mechanism to call superclass constructors

• Single inheritance
• Multi-level inheritance
• Hierarchical inheritance
• Multiple inheritance

3. Benefits of Inheritance

Students often memorize the benefits without understanding them. Let me explain each one so you truly get it and can write about it in the exam with confidence.

1. Code Reusability: This is the number one benefit. When a subclass inherits from a superclass, it automatically gets all the fields and methods of the parent. You do not rewrite them. Imagine you have a Person class with name, age, and address fields. Now if you create Student, Teacher, and Employee classes, all of them need name, age, and address. Instead of writing these three fields three times, you write them once in Person and inherit them. That is reuse, and it saves a massive amount of time and effort.

2. Code Maintenance: When your code is organized in a hierarchy, maintaining it becomes much easier. Suppose you discover a bug in the eat() method of the Animal class. You fix it once in Animal, and all subclasses (Dog, Cat, Bird, etc.) automatically get the fix. You do not need to go to each subclass and fix the same bug repeatedly. This centralized maintenance is a huge advantage.

3. Implementing OOP Philosophy: The real world is hierarchical. Living things are organized as Animal → Mammal → Dog. Vehicles are organized as Vehicle → Car → Sedan. Inheritance lets your program structure mirror this natural hierarchy. This makes your code more intuitive and closer to how humans actually think about the world.

4. Increased Reliability: When you inherit from a superclass, you are reusing code that has already been tested and proven to work. Tested code is reliable code. Instead of writing new, untested code for common features, you rely on the battle-tested parent class code. This directly leads to fewer bugs and more robust software.

• Code reusability
• Code maintenance
• Increased reliability
• Implementing OOP philosophy

4. Method Overloading (Compile-Time Polymorphism)

Have you ever used System.out.println() to print an integer, then used the same println() to print a string, and then used it again to print a double? The method name is the same every time — println(). But it handles different types of data. How? This is possible because println() is overloaded.

Method overloading means having two or more methods in the same class with the same name but different parameter declarations. The methods perform similar tasks but accept different types or different numbers of input values.

There are exactly two ways to overload a method in Java:

Way 1: Change the number of arguments — one version takes 2 parameters, another takes 3.

Way 2: Change the data type of arguments — one version takes int, another takes double.

Let me show you a clear example that demonstrates both ways:

Output:

The Java compiler looks at the arguments you pass and matches them with the correct version of add(). This matching happens at compile time, which is why method overloading is called compile-time polymorphism or static polymorphism.

• This is valid method overloading
• Compilation error: duplicate method
• Compilation error: return type cannot be double
• Runtime error when compute is called

• int-long
• long-int
• Compilation error: ambiguous method call
• Runtime error

5. Method Overriding (Runtime Polymorphism)

Now here is a question for you. What if the child class inherits a method from the parent, but the child wants to do things differently? The child cannot change the parent’s code. So what does it do? It overrides the method.

Method overriding means a subclass provides its own implementation of a method that is already defined in its superclass. Both methods have the same name and the same parameter list, but the body (implementation) is different. The subclass says, “I know my parent does it this way, but I want to do it my way.”

The big benefit of overriding is that a subclass can define a behavior specific to its own type. A Dog moves differently from a generic Animal. A SavingsAccount calculates interest differently from a generic Account. Overriding lets each type be itself.

Let me show you the classic example:

I need you to look at this line very carefully:

This line creates a Dog object but stores it in an Animal reference variable. When we call b.move(), you might think it would call Animal’s move() because the reference type is Animal. But it does NOT. It calls Dog’s move(). Why? Because at runtime, the JVM looks at the actual object type (Dog), not the reference type (Animal). The actual object is a Dog, so Dog’s version of move() runs. This is called dynamic method dispatch.

• Animals can move
• Dogs can walk and run
• Puppies can crawl
• Compilation error

• The overriding method must have the same name and parameter list as the overridden method
• A static method in the parent class can be overridden in the child class
• A final method in the parent class cannot be overridden in the child class
• The access modifier of the overriding method cannot be more restrictive than the overridden method

• Child’s display() overrides Parent’s display() successfully
• Compilation error: attempting to assign weaker access privileges
• Runtime error when display() is called
• Both methods coexist and can be called depending on the reference type

6. Polymorphism in Depth

The word Polymorphism comes from Greek: Poly means “many” and Morph means “forms.” So polymorphism literally means “many forms.” In programming, it means the same thing can behave differently in different situations. A single method name can do different things depending on the context.

A polymorphic reference is a variable that can refer to different types of objects at different points in time during program execution. For example, an Animal reference can point to a Dog object now and a Cat object later. The same reference, different forms — that is polymorphism.

There are exactly two types of polymorphism in Java, and you must know both deeply:

6.1 Static Polymorphism (Compile-Time Polymorphism)

In static polymorphism, the compiler knows at compile time exactly which method will be called. There is no waiting until runtime. The compiler examines the method signature (name and parameter types) and makes the decision right then and there. This is also called static binding or early binding.

Method overloading is the primary example of static polymorphism. When you call an overloaded method, the compiler matches the arguments with the parameter list and selects the correct version at compile time.

Here is an important example from your textbook that uses static methods:

Notice that both methods are static. Static methods are called using the class name, and the compiler resolves the call immediately. There is no runtime decision. Also, even though Dog has a static move() with the same signature as Animal’s static move(), this is NOT overriding. This is method hiding. The Dog class hides Animal’s static move(), it does not override it.

6.2 Dynamic Polymorphism (Runtime Polymorphism)

In dynamic polymorphism, the compiler does NOT know at compile time which method will be called. The decision is postponed until runtime, when the JVM examines the actual object type and calls the appropriate method. This is also called dynamic binding or late binding.

Method overriding is the primary example of dynamic polymorphism. When a parent class reference points to a child class object, the JVM discovers the actual object type at runtime and calls the overridden method of that specific child class.

The magic happens at Animal b = new Dog(). At compile time, the compiler only knows that b is of type Animal. It checks that Animal has a move() method (it does) and says “okay, this is valid.” But at runtime, the JVM sees that the actual object is a Dog, and it calls Dog’s move(). The compiler’s decision is overridden by the JVM’s runtime decision. That is dynamic polymorphism.

• Shape / Shape
• Circle / Square
• Shape / Circle
• Compilation error

• The compiler links the method call to the method body during compilation
• The JVM links the method call to the method body during execution
• The method call is linked to a static method
• The method body is generated dynamically at runtime

7. The Super Keyword

Sometimes when you override a method, you still want to use the parent’s version inside the child’s version. You do not want to completely replace the parent’s behavior — you want to extend it. How do you call the parent’s method from inside the child? You use the super keyword.

The super keyword has exactly two uses in Java:

Use 1: To call the superclass constructor. When a child object is created, the parent’s constructor should run first to initialize the inherited fields. You call the parent’s constructor using super().

Use 2: To access superclass members. When the child class has a member with the same name as the parent’s member, you can use super.memberName to specifically access the parent’s version.

Use 1: Calling Superclass Constructor

Output:

Notice that super(name) is the very first line inside the Dog constructor. This is not optional — it is a strict Java rule. The parent constructor must complete before the child constructor runs. If you do not write super() explicitly, Java automatically inserts a call to the no-argument super() as the first line. But if the parent does not have a no-argument constructor, you MUST explicitly call super() with the right arguments, or you get a compilation error.

Use 2: Accessing Superclass Methods

Output:

Do you see what happened? Inside Dog’s move(), we first called super.move() to execute the parent’s behavior, and then we added Dog’s own behavior. The output shows both messages. This pattern is very common in real programming — you extend the parent’s behavior rather than completely replacing it.

• Parent no-arg / Child no-arg
• Parent param: 10 / Child no-arg
• Child no-arg / Parent param: 10
• Compilation error

• It still works correctly
• Compilation error
• The parent constructor runs after the child constructor
• The parent constructor is not called at all

8. Abstract Classes and Abstract Methods

Let me ask you a question. Can you draw a generic “Shape” on paper? Not a circle, not a rectangle — just a “Shape.” You cannot, right? Because “Shape” is too abstract. But you CAN draw a circle or a rectangle, which are specific shapes. Java has a way to represent this idea: the abstract class.

An abstract class is a class that is declared with the abstract keyword. It may contain:

• Abstract methods — methods with no body (just the signature, ending with a semicolon)
• Concrete methods — regular methods with a full body
• Constructors and instance variables — yes, abstract classes CAN have these!

The idea is simple: the abstract class defines what is common (concrete methods and fields) and what must be done by each subclass (abstract methods). The abstract method says, “Every subclass must do this, but I don’t know HOW — each subclass will figure that out.”

Complete Rules for Abstract Classes

Rule 1: Declared with the abstract keyword.

Rule 2: You CANNOT create an object of an abstract class. Why? Because it may have abstract methods with no body — incomplete code. Java will not let you instantiate something incomplete.

Rule 3: To use an abstract class, you must create a subclass that extends it and implements ALL abstract methods.

Rule 4: An abstract method has no body — it ends with a semicolon, not curly braces.

Rule 5: If a subclass does NOT implement all abstract methods, it must also be declared as abstract.

Rule 6: A class CANNOT be both abstract and final. This is a direct contradiction — abstract means “must be extended” and final means “cannot be extended.”

Rule 7: An abstract class reference can point to a subclass object (polymorphism works).

Rule 8: An abstract class reference cannot directly call methods that exist only in the subclass (not defined in the abstract class).

Syntax

Full Working Example from Your Textbook

Let me walk you through this carefully. The Figure class says: “I know every figure has two dimensions (dim1, dim2), but I don’t know how to calculate the area because I don’t know what shape I am.” So area() is abstract. Rectangle implements area() as dim1 * dim2 (length times width). Triangle implements area() as dim1 * dim2 / 2 (half of base times height for a right triangle). Each subclass provides its own specific implementation.

Also notice: Figure has a constructor that initializes dim1 and dim2. Both Rectangle and Triangle call super(a, b) to use this constructor. The abstract class constructor runs when a subclass object is created, even though you cannot create a Figure object directly.

• An abstract class can be instantiated using the new keyword
• An abstract class can have constructors
• An abstract method must have a body enclosed in curly braces
• A class can be declared with both abstract and final keywords

• The unimplemented method gets an empty body automatically
• Compilation error
• Runtime exception
• The class is automatically promoted to abstract

9. Interface in Java

Now, here is a problem. What if you want a class to inherit from TWO parents? We already know Java says NO to multiple inheritance through classes. So what is the solution? The answer is Interface.

An interface in Java is like a blueprint of a class. Think of it as a contract. The interface says, “If you want to be called [something], you must be able to do these things.” But the interface does not tell you HOW to do them — only WHAT you must be able to do. The class that signs the contract (implements the interface) provides the actual implementation.

For example, a Printable interface says: “If you want to be printable, you must have a print() method.” But it does not say what print() should print. Each class that implements Printable decides what to print.

Key Characteristics of Interfaces

1. An interface has only abstract methods (before Java 8) and static constants.

2. You cannot instantiate an interface — just like an abstract class.

3. A class uses the implements keyword to use an interface (NOT extends).

4. Interface methods are public and abstract by default — the compiler adds these keywords for you.

5. Interface fields are public, static, and final by default — they are constants.

6. A class can implement multiple interfaces — this is Java’s way of achieving multiple inheritance!

7. An interface can extend another interface (interfaces use extends with each other).

8. An interface represents an IS-A relationship — just like a class.

Simple Interface Example

The Printable interface has one abstract method: print(). The Printed class implements Printable and provides the body for print(). When we create a Printed object and call print(), it executes the implementation we wrote. Simple and clean.

Multiple Inheritance Through Interfaces

This is one of the most important concepts in this chapter. Let me show you how a class can implement multiple interfaces at the same time:

The class Demo implements both Printable and Showable. This is perfectly valid in Java. The class must provide implementations for ALL methods from ALL interfaces. This gives you the power of multiple inheritance without the diamond problem.

What If Two Interfaces Have the Same Method?

This is a great exam question. Suppose two interfaces both declare a method with the same signature. What happens?

Even though both interfaces have print(), the class only needs to provide one implementation. There is no ambiguity because interfaces have NO method bodies — they only declare the method signature. The class provides the single body, and that single body satisfies both interfaces. This is why multiple inheritance through interfaces is safe.

Three Reasons to Use Interfaces

1. To achieve full abstraction: Interfaces contain only abstract methods (by default), meaning they represent 100% abstraction. There is no concrete implementation inside an interface (before Java 8). This is “purer” abstraction than abstract classes, which can have concrete methods.

2. To support multiple inheritance: Since Java does not allow multiple inheritance through classes, interfaces provide the only way for a class to inherit behavior from multiple sources. A class can implement any number of interfaces.

3. To achieve loose coupling: When two classes interact through an interface rather than directly, they are loosely coupled. You can replace one class with another as long as both implement the same interface. This makes your system more flexible and easier to modify.

• extends
• implements
• interface
• abstract

• public and abstract
• public, static, and final
• protected and static
• private and final

• Two separate implementations
• One implementation that satisfies both
• Zero — the compiler provides a default
• Compilation error due to ambiguity

10. Additional Important Topics (From Assignment)

Your chapter assignment mentions several extra topics. Let me cover each one in detail because they often appear in exams.

10.1 Type Casting

Casting means converting a reference from one type to another. In inheritance, there are two directions:

Upcasting: Converting a child reference to a parent type. This is always safe and happens automatically (implicitly). You are going “up” the hierarchy toward the more general type.

After upcasting, the reference can only access methods defined in the parent class. Child-specific methods are not accessible through the parent reference.

Downcasting: Converting a parent reference to a child type. This is NOT always safe and requires an explicit cast. It is only safe if the actual object IS of the child type.

• Compilation error
• ClassCastException at runtime
• Runs successfully, calls bark()
• Runs but does nothing

10.2 Final Keyword

The final keyword means “cannot be changed” or “cannot be modified.” It has three uses:

Final variable: Once assigned, its value cannot be changed. It becomes a constant.

Final method: Cannot be overridden by any subclass.

Final class: Cannot be extended by any subclass.

• A final class can be extended
• A final method can be overridden
• A final variable can be reassigned once
• A final class cannot be extended

10.3 Object Class

The Object class (in java.lang) is the superclass of all Java classes. Every class directly or indirectly extends Object. Even when you write “class Dog { }”, Java treats it as “class Dog extends Object { }”.

Every class inherits these methods from Object:

• toString() — returns a string representation of the object
• equals(Object obj) — compares two objects for equality
• hashCode() — returns a hash code value for the object
• getClass() — returns the runtime class of the object
• clone() — creates and returns a copy of the object
• finalize() — called by the garbage collector before the object is destroyed

• Class
• Super
• Object
• Main

10.4 Hierarchical Inheritance – Detailed Example

In this example, both Manager and Developer extend the same Employee class. Each overrides display() to add its own information while still using the parent’s display() via super.display(). This is hierarchical inheritance with method overriding.

10.5 Hybrid and Multi-Path Inheritance

Hybrid inheritance combines two or more types. In Java, this is typically achieved by mixing class inheritance with interface implementation. For example, a class extends one class and implements multiple interfaces.

Multi-path inheritance involves a class receiving properties from two paths sharing a common ancestor. In Java, this is resolved through interfaces since interfaces avoid the ambiguity problem.

11. Final Comprehensive Quiz

Okay, my dear students! We have covered everything in this chapter. Now it is time to test yourself. Try these questions honestly before looking at the answers. Good luck!

• A
• B
• C
• Compilation error

• An interface can extend another interface
• An interface can have constructors
• An interface can have abstract methods
• A class can implement multiple interfaces

• class Circle extends Shape { }
• class Circle extends Shape { void draw() { } }
• abstract class Circle extends Shape { }
• Both B and C are valid

• Der
• Base Mid Der
• Der Mid Base
• Mid Base Der

• Interfaces run faster than classes
• Interfaces provide default implementations that resolve ambiguity
• Interfaces have no method bodies, so there is no ambiguity about which implementation to use
• Interfaces use a different memory model that prevents conflicts

12. Quick Revision – Everything at a Glance