Mastering Polymorphism in Java: Beyond the Basics

Polymorphism is a key principle of Object-Oriented Programming (OOP) that allows different objects to be treated as instances of a common superclass. This approach reduces code duplication, enhances flexibility, and ensures maintainability.

But polymorphism is more than just method overriding. In this article, we’ll explore how to apply polymorphism effectively in Java using a real-world e-commerce example, focusing on:

✅ Using superclasses to manage different product types

✅ Handling polymorphic REST API responses with Jackson

✅ Applying wildcards (?) in generics for flexible collections

Let’s dive in! 🚀

1️⃣ Using a Superclass for Polymorphism in E-Commerce

Imagine we’re developing an e-commerce application that sells multiple types of products, including books, t-shirts, and smartphones. Each product shares common attributes (like id, name, and price), but each type has unique properties.

🔹 Example: Superclass & Subclasses

import java.math.BigDecimal;

class Product {
    String id;
    String name;
    BigDecimal price;
    ProductType type;
}

class Book extends Product {
    String author;
    String publisher;
    Integer pages;
}

class TShirt extends Product {
    String size;
    String color;
}

class Smartphone extends Product {
    String memory;
    String version;
    String color;
    String brand;
}        

Now, let’s create a polymorphic method that prints product details:

public interface ProductService {
    void printProductDetails(Product product);
}        

🔹 Why is this useful?

✅ Encapsulation of behavior: The printProductDetails method works for all product types, eliminating redundant code.

✅ Adherence to the Open/Closed Principle (OCP): New product types (e.g., Laptop, Headphones) can be added without modifying existing methods.

✅ Code maintainability: The system is modular, making it easy to scale as new products are introduced.

This approach ensures that our e-commerce product system remains adaptable and scalable.

2️⃣ Using @JsonSubTypes for Polymorphic REST APIs

When building RESTful APIs, we often need to return different product types dynamically. Jackson’s @JsonTypeInfo and @JsonSubTypes annotations allow us to serialize and deserialize polymorphic objects seamlessly.

🔹 Example: Handling Different Product Types in JSON

import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import java.math.BigDecimal;

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
@JsonSubTypes({
    @JsonSubTypes.Type(value = Book.class, name = "book"),
    @JsonSubTypes.Type(value = TShirt.class, name = "tshirt"),
    @JsonSubTypes.Type(value = Smartphone.class, name = "smartphone")
})
class Product {
    String id;
    String name;
    BigDecimal price;
    ProductType type;
}        

Now, when an API client sends the following JSON request:

{
    "type": "smartphone",
    "name": "iPhone 15",
    "price": 999.99,
    "brand": "Apple",
    "memory": "256GB",
    "version": "Pro Max",
    "color": "Graphite"
}        

Jackson will automatically map it to a Smartphone object without requiring manual if-else logic.

🔹 Why is this useful?

✅ Simplifies API responses: Clients can send different product types within a single API request.

✅ Improves scalability: New product types can be added without modifying the API contract.

✅ Reduces boilerplate code: Eliminates the need for complex type-checking logic.

This approach makes REST API development dynamic and maintainable.

3️⃣ Using Wildcards with Polymorphism in Generics

When dealing with collections of products, strict type constraints can limit flexibility. Wildcards (?) allow us to create methods that accept any subclass of Product.

🔹 Example: Processing a List of Products

import java.util.List;

public class InventoryService {
    public static void displayProducts(List<? extends Product> products) {
        for (Product product : products) {
            System.out.println("Product: " + product.name + ", Price: $" + product.price);
        }
    }
}        

Now, displayProducts can accept List<Book>, List<TShirt>, List<Smartphone>, or any future product type.

🔹 Why is this useful?

✅ Promotes reusability: Works for all product types without modification.

✅ Enhances flexibility: The method doesn’t need to be rewritten for each new product type.

✅ Future-proof design: The system can evolve without major refactoring.

By leveraging wildcards, we ensure our e-commerce system is adaptable to new product categories.

🚀 Key Takeaways

Polymorphism is a crucial tool for scalable, maintainable, and extensible software design.

✅ Use superclasses to define common attributes and behaviors while allowing specialization in subclasses.

✅ Leverage @JsonSubTypes to dynamically handle polymorphic JSON requests in REST APIs.

✅ Utilize wildcards (? extends) in generics to write flexible, reusable methods.

Mastering these concepts empowers Java developers to build cleaner, more efficient applications.

How have you applied polymorphism in your projects? Let’s discuss in the comments! 👇