Polymorphism

1. Understanding Polymorphism

What is Polymorphism?

Polymorphism is a fundamental concept in object-oriented programming that allows objects of different types to be treated as objects of a common superclass. The word "polymorphism" means "many forms," and in Java, it refers to the ability of a single interface to represent different underlying forms (data types or classes).

Here's a simple example to illustrate the concept of polymorphism:

<code>class Animal {
    public void makeSound() {
        System.out.println("The animal makes a sound");
    }
}

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

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

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myAnimal.makeSound();
        myDog.makeSound();
        myCat.makeSound();
    }
}</code>

In this example, we have a superclass Animal and two subclasses Dog and Cat. Each subclass overrides the makeSound() method. When we create objects of these classes and call the makeSound() method, the appropriate version of the method is called based on the actual object type, not the reference type. This is polymorphism in action.

Try running this code in the compiler below and observe how polymorphism allows different objects to respond to the same method call in different ways.

2. Method Overriding

Understanding Method Overriding

Method overriding is a key mechanism for achieving polymorphism in Java. It allows a subclass to provide a specific implementation of a method that is already defined in its superclass.

Here's an example demonstrating method overriding:

<code>class Shape {
    public double calculateArea() {
        return 0;
    }
}

class Circle extends Shape {
    private double radius;

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

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

class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double calculateArea() {
        return length * width;
    }
}

public class MethodOverridingExample {
    public static void main(String[] args) {
        Shape shape = new Shape();
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);

        System.out.println("Shape area: " + shape.calculateArea());
        System.out.println("Circle area: " + circle.calculateArea());
        System.out.println("Rectangle area: " + rectangle.calculateArea());
    }
}</code>

In this example, both Circle and Rectangle override the calculateArea() method from the Shape class. When we call calculateArea() on each object, the appropriate version of the method is called based on the actual object type.

Try running this code in the compiler and observe how method overriding allows each shape to calculate its area differently. Can you add another shape, like a Triangle, and override its calculateArea() method?

3. Runtime Polymorphism

Understanding Runtime Polymorphism

Runtime polymorphism, also known as dynamic method dispatch, is a process in which a call to an overridden method is resolved at runtime rather than at compile time. This is one of the most powerful features of object-oriented programming.

Here's an example demonstrating runtime polymorphism:

<code>class Vehicle {
    public void move() {
        System.out.println("Vehicle is moving");
    }
}

class Car extends Vehicle {
    @Override
    public void move() {
        System.out.println("Car is driving");
    }
}

class Bicycle extends Vehicle {
    @Override
    public void move() {
        System.out.println("Bicycle is pedaling");
    }
}

class Boat extends Vehicle {
    @Override
    public void move() {
        System.out.println("Boat is sailing");
    }
}

public class RuntimePolymorphismExample {
    public static void main(String[] args) {
        Vehicle[] vehicles = new Vehicle[3];
        vehicles[0] = new Car();
        vehicles[1] = new Bicycle();
        vehicles[2] = new Boat();

        for (Vehicle vehicle : vehicles) {
            vehicle.move();
        }
    }
}</code>

In this example, we have a Vehicle superclass and several subclasses. We create an array of Vehicle objects, but each element is actually a different subclass. When we call the move() method on each object, the appropriate version of the method is called based on the actual object type at runtime.

Try running this code in the compiler. Can you add another vehicle type and see how it fits into the polymorphic structure without changing the main method?

4. Polymorphism with Interfaces

Using Interfaces for Polymorphism

Interfaces provide another way to achieve polymorphism in Java. An interface defines a contract of methods that a class must implement, allowing for a high degree of abstraction and flexibility in your code.

Here's an example demonstrating polymorphism with interfaces:

<code>interface Drawable {
    void draw();
}

class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

class Rectangle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

class Triangle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a triangle");
    }
}

public class InterfacePolymorphismExample {
    public static void drawShape(Drawable shape) {
        shape.draw();
    }

    public static void main(String[] args) {
        Drawable circle = new Circle();
        Drawable rectangle = new Rectangle();
        Drawable triangle = new Triangle();

        drawShape(circle);
        drawShape(rectangle);
        drawShape(triangle);
    }
}</code>

In this example, we define a Drawable interface and several classes that implement it. The drawShape method takes a Drawable object as a parameter, allowing it to work with any class that implements the Drawable interface. This is polymorphism through interfaces.

Try running this code in the compiler. Can you add another shape that implements the Drawable interface? How does this approach differ from using inheritance for polymorphism?

5. Abstract Classes and Polymorphism

Using Abstract Classes for Polymorphism

Abstract classes provide a way to achieve polymorphism while also allowing for some implementation details to be shared among subclasses. An abstract class is a class that cannot be instantiated and may contain abstract methods (methods without a body) that must be implemented by its subclasses.

Here's an example demonstrating polymorphism with abstract classes:

<code>abstract class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public abstract void makeSound();

    public void eat() {
        System.out.println(name + " is eating");
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " barks");
    }
}

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " meows");
    }
}

public class AbstractClassPolymorphismExample {
    public static void main(String[] args) {
        Animal dog = new Dog("Buddy");
        Animal cat = new Cat("Whiskers");

        dog.makeSound();
        dog.eat();

        cat.makeSound();
        cat.eat();
    }
}</code>

In this example, we have an abstract Animal class with an abstract makeSound() method and a concrete eat() method. The Dog and Cat classes extend Animal and provide their own implementations of makeSound(). This allows for polymorphic behavior while also sharing common functionality through the abstract class.

Try running this code in the compiler. Can you add another animal type that extends the Animal class? How does using an abstract class compare to using an interface in this scenario?

6. Polymorphism Quiz

7. Weekly Project: Shape Calculator

Project Description

For this week's project, you'll create a Shape Calculator that demonstrates polymorphism. You'll implement various shapes and calculate their areas and perimeters using polymorphic methods.

Here's a template to get you started:

<code>import java.util.Scanner;

abstract class Shape {
    abstract double calculateArea();
    abstract double calculatePerimeter();
}

class Circle extends Shape {
    // Implement Circle class
}

class Rectangle extends Shape {
    // Implement Rectangle class
}

class Triangle extends Shape {
    // Implement Triangle class
}

class ShapeCalculator {
    public void printShapeDetails(Shape shape) {
        System.out.println("Area: " + shape.calculateArea());
        System.out.println("Perimeter: " + shape.calculatePerimeter());
    }
}

public class ShapeCalculatorApp {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        ShapeCalculator calculator = new ShapeCalculator();
        Shape[] shapes = new Shape[3];

        while (true) {
            System.out.println("\n1. Create Circle");
            System.out.println("2. Create Rectangle");
            System.out.println("3. Create Triangle");
            System.out.println("4. Calculate for all shapes");
            System.out.println("5. Exit");
            System.out.print("Enter your choice: ");

            int choice = scanner.nextInt();

            switch (choice) {
                case 1:
                    // TODO: Create Circle
                    break;
                case 2:
                    // TODO: Create Rectangle
                    break;
                case 3:
                    // TODO: Create Triangle
                    break;
                case 4:
                    // TODO: Calculate for all shapes
                    break;
                case 5:
                    System.out.println("Exiting...");
                    return;
                default:
                    System.out.println("Invalid choice. Please try again.");
            }
        }
    }
}</code>

Implement the missing parts of the Shape classes and the calculator logic. Use the online compiler to write and test your code. Once you're satisfied with your program, paste a sample output showing the calculations for different shapes in the autograder to check your work.