Polymorphism

Polymorphism is a core concept in object-oriented programming (OOP) that allows methods to perform different tasks based on the object that invokes them. In Java, polymorphism enables you to define a single interface or method and have multiple implementations for it, depending on the object type.

Types of Polymorphism in Java

There are two main types of polymorphism in Java:

1. Compile-Time Polymorphism (Static Binding)
2. Run-Time Polymorphism (Dynamic Binding)

Polymorphism

Polymorphism allows methods to perform different functions based on the object that it is called on.

Compile-Time Polymorphism (Method Overloading)

This occurs when multiple methods have the same name but differ in their parameters.

Example:

class MathOperations {
    // Method to add two integers
    public int add(int a, int b) {
        return a + b;
    }

    // Method to add two doubles
    public double add(double a, double b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        MathOperations mathOp = new MathOperations();
        System.out.println(mathOp.add(3, 4));     // Output: 7 (integer addition)
        System.out.println(mathOp.add(3.5, 4.5)); // Output: 8.0 (double addition)
    }
}

Explanation:

• The MathOperations class has two add methods: one for integers and one for doubles. The correct method is determined at compile time based on the arguments provided.

Run-Time Polymorphism (Method Overriding)

This occurs when a subclass provides a specific implementation of a method that is already defined in its superclass.

Example:

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

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

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

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        myDog.makeSound(); // Output: Bark
        myCat.makeSound(); // Output: Meow
    }
}

Explanation:

• The Animal class has a method makeSound. The Dog and Cat classes override this method to provide their specific sounds.
• When makeSound is called on myDog or myCat, the correct method is determined at runtime based on the object type.

---

Abstract Classes and Functions

An abstract class cannot be instantiated on its own and often contains abstract methods that subclasses must implement.

Example:

abstract class Shape {
    // Abstract method for calculating area
    public abstract double area();
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

class Square extends Shape {
    private double side;

    public Square(double side) {
        this.side = side;
    }

    @Override
    public double area() {
        return side * side;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape square = new Square(4);
        System.out.println("Circle Area: " + circle.area()); // Output: Circle Area: 78.53981633974483
        System.out.println("Square Area: " + square.area()); // Output: Square Area: 16.0
    }
}

Explanation:

• The Shape class is abstract and defines an abstract method area.
• The Circle and Square classes implement the area method.
• The main method creates instances of Circle and Square and calls their area methods.

---

Abstract Functions Practical Example

This example demonstrates how abstract methods enforce a contract for subclasses.

Example:

abstract class Vehicle {
    // Abstract method
    public abstract void move();
}

class Car extends Vehicle {
    @Override
    public void move() {
        System.out.println("Driving on the road");
    }
}

class Boat extends Vehicle {
    @Override
    public void move() {
        System.out.println("Sailing on water");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle car = new Car();
        Vehicle boat = new Boat();
        car.move();  // Output: Driving on the road
        boat.move(); // Output: Sailing on water
    }
}

Explanation:

• The Vehicle class defines an abstract method move.
• The Car and Boat classes implement move to provide specific behaviors.
• The main method creates instances of Car and Boat and calls their move methods.

---

Interfaces

An interface defines a contract with methods that classes must implement.

Example:

interface SoundMaker {
    void makeSound();
}

class Dog implements SoundMaker {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

class Cat implements SoundMaker {
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        SoundMaker dog = new Dog();
        SoundMaker cat = new Cat();
        dog.makeSound(); // Output: Bark
        cat.makeSound(); // Output: Meow
    }
}

Explanation:

• The SoundMaker interface defines a method makeSound.
• The Dog and Cat classes implement the makeSound method.
• The main method creates instances of Dog and Cat and calls their makeSound methods.

---

Practical Uses of Interfaces

Interfaces allow different classes to implement the same methods, facilitating code organization and polymorphism.

Example:

public class Main {
    public static void animalSound(SoundMaker animal) {
        animal.makeSound();
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        animalSound(dog);  // Output: Bark
        animalSound(cat);  // Output: Meow
    }
}

Explanation:

• The animalSound method accepts any object that implements the SoundMaker interface.
• This promotes loose coupling and flexibility in code design.

---

Interfaces Focused View

A focused view emphasizes how interfaces standardize method implementations across classes.

Example:

class Bird implements SoundMaker {
    @Override
    public void makeSound() {
        System.out.println("Chirp");
    }
}

public class Main {
    public static void main(String[] args) {
        SoundMaker bird = new Bird();
        bird.makeSound(); // Output: Chirp
    }
}

Explanation:

• The Bird class implements the SoundMaker interface.
• All classes that implement the interface can be treated the same way, regardless of their actual type.

---

Interfaces Different Implementation

Different classes can implement the same interface in distinct ways, showcasing polymorphism.

Example:

class Car implements SoundMaker {
    @Override
    public void makeSound() {
        System.out.println("Vroom");
    }
}

public class Main {
    public static void main(String[] args) {
        SoundMaker car = new Car();
        car.makeSound(); // Output: Vroom
    }
}

Explanation:

• The Car class provides a different implementation of makeSound.
• The car object demonstrates polymorphism by being treated as a SoundMaker.

---

Interfaces Unrelated Inheritance

Interfaces enable classes from different hierarchies to implement the same methods, allowing interchangeable usage.

Example:

class Truck implements SoundMaker {
    @Override
    public void makeSound() {
        System.out.println("Honk");
    }
}

public class Main {
    public static void main(String[] args) {
        SoundMaker truck = new Truck();
        truck.makeSound(); // Output: Honk
    }
}

Explanation:

• The Truck class implements the SoundMaker interface.
• Even though Truck is unrelated to Dog and Cat, it can be used in the same context, allowing for flexibility.

---

Summary

1. Polymorphism enables methods to act differently based on the object type.
2. Abstract Classes and Functions provide a template for subclasses to follow.
3. Interfaces define contracts for classes to implement, allowing for uniform behavior across unrelated classes.