Polymorphism

Method Overloading (Compile-Time Polymorphism)

Multiple methods with same name but different parameters.

Basic Overloading

public class Calculator {
    // Different parameter types
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
    
    // Different number of parameters
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

Calculator calc = new Calculator();
System.out.println(calc.add(1, 2));        // 3
System.out.println(calc.add(1.5, 2.5));   // 4.0
System.out.println(calc.add(1, 2, 3));    // 6

Overloading Rules

public class Example {
    // Valid - different types
    public void method(int x) { }
    public void method(double x) { }
    
    // Valid - different count
    public void method(int x, int y) { }
    
    // Valid - different order
    public void method(String s, int i) { }
    public void method(int i, String s) { }
    
    // INVALID - same signature
    // public void method(int x) { }
    // public void method(int y) { }  // Same!
}

Return Type Doesn't Matter

public class Example {
    public int method(int x) { return x; }
    // public double method(int x) { return x; }  // COMPILE ERROR!
    // Return type alone cannot differentiate overloads
}

Constructor Overloading

public class Person {
    String name;
    int age;
    
    public Person() { this("Unknown"); }
    public Person(String name) { this(name, 0); }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Method Overriding (Runtime Polymorphism)

Child class provides specific implementation of parent method.

Basic Overriding

public class Animal {
    public void makeSound() {
        System.out.println("Some sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

Animal animal = new Dog();
animal.makeSound();  // "Woof!"
animal = new Cat();
animal.makeSound();  // "Meow!"

Overriding Rules

public class Parent {
    public void method() { }
}

public class Child extends Parent {
    // Must have same name, parameters, return type
    // Access modifier can be same or less restrictive
    // Cannot throw new/broader checked exceptions
    
    @Override  // Optional but recommended
    public void method() { }
    
    // INVALID:
    // private void method() { }  // More restrictive
    // public int method() { }    // Different return type
    // public void method(int x) { }  // Different params (overloading)
}

@Override Annotation

public class Child extends Parent {
    @Override  // Helps catch errors
    public void method() { }
    
    @Override  // Compiler checks if actually overriding
    public void nonExistentMethod() { }  // COMPILE ERROR!
}

Covariant Return Types

public class Animal {
    public Animal create() {
        return new Animal();
    }
}

public class Dog extends Animal {
    @Override
    public Dog create() {  // Return type is Dog (covariant)
        return new Dog();
    }
}

Dynamic Method Dispatch

The JVM determines which method to call at runtime based on actual object type.

Basic Example

public class Animal {
    public void makeSound() {
        System.out.println("Animal sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

// Dynamic dispatch
Animal animal;
animal = new Dog();
animal.makeSound();  // "Woof!" (Dog's version)

animal = new Cat();
animal.makeSound();  // "Meow!" (Cat's version)

Array of Parent Type

Animal[] animals = { new Dog(), new Cat(), new Animal() };

for (Animal a : animals) {
    a.makeSound();  // Each calls its own version
}
// Output:
// Woof!
// Meow!
// Animal sound

Method Parameters

public class Vet {
    public void checkup(Animal animal) {
        animal.makeSound();  // Calls actual type's method
    }
}

Vet vet = new Vet();
vet.checkup(new Dog());  // "Woof!"
vet.checkup(new Cat());  // "Meow!"

Polymorphism Benefits

// Without polymorphism - lots of if/else
public void makeAnimalSound(Animal animal) {
    if (animal instanceof Dog) {
        ((Dog) animal).makeSound();
    } else if (animal instanceof Cat) {
        ((Cat) animal).makeSound();
    }
}

// With polymorphism - clean code
public void makeAnimalSound(Animal animal) {
    animal.makeSound();  // Polymorphism handles it!
}

instanceof Operator

Checks if an object is an instance of a specific class or interface.

Basic Usage

Animal animal = new Dog();

if (animal instanceof Dog) {
    System.out.println("It's a dog!");
}

if (animal instanceof Animal) {
    System.out.println("It's an animal!");
}

if (animal instanceof Cat) {
    System.out.println("It's a cat!");  // Not printed
}

Safe Casting

public void processAnimal(Animal animal) {
    if (animal instanceof Dog) {
        Dog dog = (Dog) animal;  // Safe cast
        dog.fetch();
    }
}

// Or with pattern matching (Java 16+)
if (animal instanceof Dog dog) {
    dog.fetch();  // No explicit cast needed
}

With null

Animal animal = null;

if (animal instanceof Dog) { }  // false (not exception!)
// null instanceof anything is always false

Interface Checking

public class Dog implements Pet, Serializable {
    // ...
}

Dog dog = new Dog();

if (dog instanceof Pet) { }      // true
if (dog instanceof Serializable) { }  // true
if (dog instanceof Object) { }   // true (everything is Object)

When to Use

// 1. When you need type-specific behavior
public void feed(Animal animal) {
    if (animal instanceof Dog) {
        ((Dog) animal).eatKibble();
    } else {
        animal.eat();
    }
}

// 2. When you can't avoid casting
public void serialize(Object obj) {
    if (obj instanceof Serializable) {
        // Safe to cast
    }
}

// 3. Prefer polymorphism over instanceof when possible