Advanced Java · Week 5

Polymorphism

Step 1 of 8

Java 2 Guided Tutorials - Week 5: Polymorphism

What You'll Learn

Welcome to Week 5 of Java 2! This week, we'll explore polymorphism, a powerful concept in object-oriented programming. Polymorphism allows objects of different types to be treated as objects of a common superclass or interface, enabling more flexible and reusable code.

                    Lesson Overview:
                    Understanding Polymorphism
Method Overriding
Runtime Polymorphism
Polymorphism with Interfaces
Abstract Classes and Polymorphism
Quiz to test your knowledge
Weekly project to apply what you've learned

                

By the end of this week, you'll have a solid understanding of polymorphism and how to use it effectively in your Java programs. Let's get started!

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).

                    Key Points:
                    Polymorphism allows you to write more flexible and reusable code
It enables you to perform a single action in different ways
In Java, polymorphism is often achieved through method overriding and interfaces
It's closely related to inheritance and interfaces

                

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

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();
    }
}

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.

Write your code here

Make it print The animal makes a sound The dog barks The cat meows

Did it work?

Your program should print this:

The animal makes a sound
The dog barks
The cat meows

Paste what you got:

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.

                    Key Points:
                    The method in the subclass must have the same name and signature as the method in the superclass
The @Override annotation is recommended (but not required) to indicate an overridden method
Overriding methods can't have a more restrictive access modifier
Static and final methods can't be overridden

                

Here's an example demonstrating method overriding:

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());
    }
}

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?

Write your code here

Make it print Shape area: 0.0 Circle area: 78.53981633974483 Rectangle area: 24.0

Did it work?

Your program should print this:

Shape area: 0.0
Circle area: 78.53981633974483
Rectangle area: 24.0

Paste what you got:

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.

                    Key Points:
                    It's achieved through method overriding
The method to be executed is determined by the object being referred to at runtime
It allows you to write flexible and extensible code
It's the basis for the "program to an interface, not an implementation" principle

                

Here's an example demonstrating runtime polymorphism:

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();
        }
    }
}

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?

Write your code here

Make it print Car is driving Bicycle is pedaling Boat is sailing

Did it work?

Your program should print this:

Car is driving
Bicycle is pedaling
Boat is sailing

Paste what you got:

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.

                    Key Points:
                    Interfaces define a set of abstract methods
Classes that implement an interface must provide implementations for all its methods
A class can implement multiple interfaces
Interfaces enable you to program to a contract rather than an implementation

                

Here's an example demonstrating polymorphism with interfaces:

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);
    }
}

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?

Write your code here

Make it print Drawing a circle Drawing a rectangle Drawing a triangle

Did it work?

Your program should print this:

Drawing a circle
Drawing a rectangle
Drawing a triangle

Paste what you got:

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.

                    Key Points:
                    Abstract classes can have both abstract and concrete methods
Subclasses of an abstract class must implement all its abstract methods
Abstract classes can have constructors and instance variables
They provide a common interface while allowing for some shared implementation

                

Here's an example demonstrating polymorphism with abstract classes:

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();
    }
}

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?

Write your code here

Make it print Buddy barks Buddy is eating Whiskers meows Whiskers is eating

Did it work?

Your program should print this:

Buddy barks
Buddy is eating
Whiskers meows
Whiskers is eating

Paste what you got:

Quick check

1. What is polymorphism in Java?
2. Which of the following is NOT a way to achieve polymorphism in Java?
3. What is runtime polymorphism?

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.

                    Requirements:
                    Create an abstract Shape class with abstract methods for calculating area and perimeter
Implement at least three different shape classes (e.g., Circle, Rectangle, Triangle) that extend the Shape class
Create a ShapeCalculator class that can work with any shape
Demonstrate polymorphism by creating an array of shapes and performing calculations on them
Implement error handling for invalid inputs
Add a simple menu-driven interface for user interaction

                

Here's a template to get you started:

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.");
            }
        }
    }
}

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.

Write your code here

Make it print Shape: Circle Area: 78.54 Perimeter: 31.42 Shape: Rectangle Area: 24.00 Perimeter: 20.00 Shape: Triangle Area: 6.00 Perimeter: 12.00

Did it work?

Your program should print this:

Shape: Circle
Area: 78.54
Perimeter: 31.42
Shape: Rectangle
Area: 24.00
Perimeter: 20.00
Shape: Triangle
Area: 6.00
Perimeter: 12.00

Paste what you got:

PreviousInheritance NextLists