Polymorphism Concepts in Java

Table of Contents

Introduction

Imagine you have a universal remote control that can operate different devices—TV, stereo, DVD player—each responding differently to the same "power" button. That's polymorphism in Java! It allows objects of different types to be treated as objects of a common supertype, with each executing their own specific behavior.

Polymorphism is like having multiple forms—the same action can behave differently depending on the actual object type, enabling flexible and extensible code design.

What is Polymorphism?

Polymorphism (from Greek "poly" meaning many, "morph" meaning forms) is the ability of an object to take on many forms. In Java, it allows methods to do different things based on the actual object being operated upon.

Key Characteristics:

🔄 Multiple forms: Same interface, different implementations
🎯 Runtime binding: Method resolution at execution time
📈 IS-A relationship: Based on inheritance and interfaces
⚡ Flexible design: Code works with general types
🚀 Extensibility: Easy to add new types

Code Explanation with Examples

Example 1: Basic Polymorphism with Inheritance

public class BasicPolymorphism {
public static void main(String[] args) {
System.out.println("=== BASIC POLYMORPHISM WITH INHERITANCE ===");
// Creating objects of different types
Animal genericAnimal = new Animal();
Animal myDog = new Dog();      // Polymorphism - Dog treated as Animal
Animal myCat = new Cat();      // Polymorphism - Cat treated as Animal
Animal myBird = new Bird();    // Polymorphism - Bird treated as Animal
// Same method call, different behaviors
System.out.println("Generic Animal: " + genericAnimal.makeSound());
System.out.println("Dog as Animal: " + myDog.makeSound());
System.out.println("Cat as Animal: " + myCat.makeSound());
System.out.println("Bird as Animal: " + myBird.makeSound());
// Polymorphism in arrays
System.out.println("\n=== POLYMORPHISM IN ARRAYS ===");
Animal[] animals = { genericAnimal, myDog, myCat, myBird };
for (Animal animal : animals) {
System.out.println(animal.getClass().getSimpleName() + " says: " + animal.makeSound());
}
// Method parameters polymorphism
System.out.println("\n=== METHOD PARAMETERS POLYMORPHISM ===");
AnimalHelper helper = new AnimalHelper();
helper.describeAnimal(genericAnimal);
helper.describeAnimal(myDog);
helper.describeAnimal(myCat);
helper.describeAnimal(myBird);
// Return type polymorphism
System.out.println("\n=== RETURN TYPE POLYMORPHISM ===");
AnimalFactory factory = new AnimalFactory();
Animal animal1 = factory.createAnimal("dog");
Animal animal2 = factory.createAnimal("cat");
Animal animal3 = factory.createAnimal("bird");
System.out.println("Created: " + animal1.getClass().getSimpleName() + " - " + animal1.makeSound());
System.out.println("Created: " + animal2.getClass().getSimpleName() + " - " + animal2.makeSound());
System.out.println("Created: " + animal3.getClass().getSimpleName() + " - " + animal3.makeSound());
}
}
class Animal {
public String makeSound() {
return "Some generic animal sound";
}
public String move() {
return "Animal is moving";
}
}
class Dog extends Animal {
@Override
public String makeSound() {
return "Woof! Woof!";
}
@Override
public String move() {
return "Dog is running happily";
}
// Dog-specific method
public void fetch() {
System.out.println("Dog is fetching the ball!");
}
}
class Cat extends Animal {
@Override
public String makeSound() {
return "Meow! Meow!";
}
@Override
public String move() {
return "Cat is moving gracefully";
}
// Cat-specific method
public void climb() {
System.out.println("Cat is climbing the tree!");
}
}
class Bird extends Animal {
@Override
public String makeSound() {
return "Chirp! Chirp!";
}
@Override
public String move() {
return "Bird is flying in the sky";
}
// Bird-specific method
public void fly() {
System.out.println("Bird is flying high!");
}
}
class AnimalHelper {
// Method accepts any Animal (polymorphic parameter)
public void describeAnimal(Animal animal) {
System.out.println("=== " + animal.getClass().getSimpleName() + " ===");
System.out.println("Sound: " + animal.makeSound());
System.out.println("Movement: " + animal.move());
// Type checking and casting for specific behaviors
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.fetch();
} else if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.climb();
} else if (animal instanceof Bird) {
Bird bird = (Bird) animal;
bird.fly();
}
System.out.println();
}
}
class AnimalFactory {
// Polymorphic return type - returns different Animal subtypes
public Animal createAnimal(String type) {
return switch (type.toLowerCase()) {
case "dog" -> new Dog();
case "cat" -> new Cat();
case "bird" -> new Bird();
default -> new Animal();
};
}
}

Output:

=== BASIC POLYMORPHISM WITH INHERITANCE ===
Generic Animal: Some generic animal sound
Dog as Animal: Woof! Woof!
Cat as Animal: Meow! Meow!
Bird as Animal: Chirp! Chirp!
=== POLYMORPHISM IN ARRAYS ===
Animal says: Some generic animal sound
Dog says: Woof! Woof!
Cat says: Meow! Meow!
Bird says: Chirp! Chirp!
=== METHOD PARAMETERS POLYMORPHISM ===
=== Animal ===
Sound: Some generic animal sound
Movement: Animal is moving
=== Dog ===
Sound: Woof! Woof!
Movement: Dog is running happily
Dog is fetching the ball!
=== Cat ===
Sound: Meow! Meow!
Movement: Cat is moving gracefully
Cat is climbing the tree!
=== Bird ===
Sound: Chirp! Chirp!
Movement: Bird is flying in the sky
Bird is flying high!
=== RETURN TYPE POLYMORPHISM ===
Created: Dog - Woof! Woof!
Created: Cat - Meow! Meow!
Created: Bird - Chirp! Chirp!

Example 2: Polymorphism with Interfaces

public class InterfacePolymorphism {
public static void main(String[] args) {
System.out.println("=== POLYMORPHISM WITH INTERFACES ===");
// Different payment processors implementing same interface
PaymentProcessor creditCard = new CreditCardProcessor();
PaymentProcessor paypal = new PayPalProcessor();
PaymentProcessor crypto = new CryptoProcessor();
// Polymorphic payment processing
processPayment(creditCard, 100.0);
processPayment(paypal, 150.0);
processPayment(crypto, 200.0);
// Notification system polymorphism
System.out.println("\n=== NOTIFICATION SYSTEM ===");
Notification email = new EmailNotification();
Notification sms = new SMSNotification();
Notification push = new PushNotification();
sendNotification(email, "Welcome to our service!");
sendNotification(sms, "Your verification code: 123456");
sendNotification(push, "New message received!");
// Shape drawing polymorphism
System.out.println("\n=== SHAPE DRAWING ===");
Drawable[] shapes = {
new Circle(5.0),
new Rectangle(4.0, 6.0),
new Triangle(3.0, 4.0, 5.0)
};
drawAllShapes(shapes);
// Calculator polymorphism
System.out.println("\n=== CALCULATOR POLYMORPHISM ===");
Calculator basic = new BasicCalculator();
Calculator scientific = new ScientificCalculator();
Calculator programmer = new ProgrammerCalculator();
performCalculations(basic);
performCalculations(scientific);
performCalculations(programmer);
}
// Polymorphic method - works with any PaymentProcessor
public static void processPayment(PaymentProcessor processor, double amount) {
System.out.println("\nProcessing $" + amount + " payment...");
processor.authenticate();
processor.processPayment(amount);
System.out.println("Payment completed!");
}
// Polymorphic method - works with any Notification
public static void sendNotification(Notification notification, String message) {
notification.send(message);
System.out.println("Notification sent via: " + notification.getType());
}
// Polymorphic method - works with any Drawable
public static void drawAllShapes(Drawable[] shapes) {
for (Drawable shape : shapes) {
shape.draw();
System.out.println("Area: " + shape.calculateArea());
System.out.println("Perimeter: " + shape.calculatePerimeter());
System.out.println();
}
}
// Polymorphic method - works with any Calculator
public static void performCalculations(Calculator calculator) {
System.out.println("=== " + calculator.getClass().getSimpleName() + " ===");
System.out.println("10 + 5 = " + calculator.add(10, 5));
System.out.println("10 - 5 = " + calculator.subtract(10, 5));
System.out.println("10 * 5 = " + calculator.multiply(10, 5));
System.out.println("10 / 5 = " + calculator.divide(10, 5));
calculator.showCapabilities();
System.out.println();
}
}
// Payment processing interface
interface PaymentProcessor {
void authenticate();
void processPayment(double amount);
void refundPayment(String transactionId);
default String getProcessorName() {
return this.getClass().getSimpleName();
}
}
class CreditCardProcessor implements PaymentProcessor {
@Override
public void authenticate() {
System.out.println("Authenticating credit card...");
System.out.println("Card validated successfully");
}
@Override
public void processPayment(double amount) {
System.out.println("Processing credit card payment of $" + amount);
System.out.println("Charging card... Transaction approved!");
}
@Override
public void refundPayment(String transactionId) {
System.out.println("Processing refund for transaction: " + transactionId);
}
}
class PayPalProcessor implements PaymentProcessor {
@Override
public void authenticate() {
System.out.println("Authenticating with PayPal...");
System.out.println("PayPal account verified");
}
@Override
public void processPayment(double amount) {
System.out.println("Processing PayPal payment of $" + amount);
System.out.println("Redirecting to PayPal... Payment authorized!");
}
@Override
public void refundPayment(String transactionId) {
System.out.println("Processing PayPal refund for: " + transactionId);
}
}
class CryptoProcessor implements PaymentProcessor {
@Override
public void authenticate() {
System.out.println("Authenticating cryptocurrency wallet...");
System.out.println("Wallet address verified");
}
@Override
public void processPayment(double amount) {
System.out.println("Processing cryptocurrency payment of $" + amount);
System.out.println("Converting to BTC... Blockchain transaction confirmed!");
}
@Override
public void refundPayment(String transactionId) {
System.out.println("Processing crypto refund for: " + transactionId);
}
}
// Notification interface
interface Notification {
void send(String message);
String getType();
}
class EmailNotification implements Notification {
@Override
public void send(String message) {
System.out.println("Sending email: " + message);
}
@Override
public String getType() {
return "Email";
}
}
class SMSNotification implements Notification {
@Override
public void send(String message) {
System.out.println("Sending SMS: " + message);
}
@Override
public String getType() {
return "SMS";
}
}
class PushNotification implements Notification {
@Override
public void send(String message) {
System.out.println("Sending push notification: " + message);
}
@Override
public String getType() {
return "Push Notification";
}
}
// Drawable interface for shapes
interface Drawable {
void draw();
double calculateArea();
double calculatePerimeter();
}
class Circle implements Drawable {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public void draw() {
System.out.println("Drawing Circle with radius: " + radius);
}
@Override
public double calculateArea() {
return Math.PI * radius * radius;
}
@Override
public double calculatePerimeter() {
return 2 * Math.PI * radius;
}
}
class Rectangle implements Drawable {
private double width;
private double height;
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
@Override
public void draw() {
System.out.println("Drawing Rectangle: " + width + " x " + height);
}
@Override
public double calculateArea() {
return width * height;
}
@Override
public double calculatePerimeter() {
return 2 * (width + height);
}
}
class Triangle implements Drawable {
private double side1, side2, side3;
public Triangle(double side1, double side2, double side3) {
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
}
@Override
public void draw() {
System.out.println("Drawing Triangle with sides: " + side1 + ", " + side2 + ", " + side3);
}
@Override
public double calculateArea() {
// Heron's formula
double s = (side1 + side2 + side3) / 2;
return Math.sqrt(s * (s - side1) * (s - side2) * (s - side3));
}
@Override
public double calculatePerimeter() {
return side1 + side2 + side3;
}
}
// Calculator interface
interface Calculator {
double add(double a, double b);
double subtract(double a, double b);
double multiply(double a, double b);
double divide(double a, double b);
void showCapabilities();
}
class BasicCalculator implements Calculator {
@Override
public double add(double a, double b) {
return a + b;
}
@Override
public double subtract(double a, double b) {
return a - b;
}
@Override
public double multiply(double a, double b) {
return a * b;
}
@Override
public double divide(double a, double b) {
if (b == 0) throw new ArithmeticException("Division by zero");
return a / b;
}
@Override
public void showCapabilities() {
System.out.println("Basic arithmetic operations");
}
}
class ScientificCalculator implements Calculator {
@Override
public double add(double a, double b) {
return a + b;
}
@Override
public double subtract(double a, double b) {
return a - b;
}
@Override
public double multiply(double a, double b) {
return a * b;
}
@Override
public double divide(double a, double b) {
if (b == 0) throw new ArithmeticException("Division by zero");
return a / b;
}
@Override
public void showCapabilities() {
System.out.println("Scientific functions: sin, cos, tan, log, etc.");
}
// Additional scientific methods
public double power(double base, double exponent) {
return Math.pow(base, exponent);
}
public double squareRoot(double number) {
return Math.sqrt(number);
}
}
class ProgrammerCalculator implements Calculator {
@Override
public double add(double a, double b) {
return a + b;
}
@Override
public double subtract(double a, double b) {
return a - b;
}
@Override
public double multiply(double a, double b) {
return a * b;
}
@Override
public double divide(double a, double b) {
if (b == 0) throw new ArithmeticException("Division by zero");
return a / b;
}
@Override
public void showCapabilities() {
System.out.println("Programmer functions: binary, hex, octal, bit operations");
}
// Additional programmer methods
public String toBinary(int number) {
return Integer.toBinaryString(number);
}
public String toHex(int number) {
return Integer.toHexString(number);
}
}

Output:

=== POLYMORPHISM WITH INTERFACES ===
Processing $100.0 payment...
Authenticating credit card...
Card validated successfully
Processing credit card payment of $100.0
Charging card... Transaction approved!
Payment completed!
Processing $150.0 payment...
Authenticating with PayPal...
PayPal account verified
Processing PayPal payment of $150.0
Redirecting to PayPal... Payment authorized!
Payment completed!
Processing $200.0 payment...
Authenticating cryptocurrency wallet...
Wallet address verified
Processing cryptocurrency payment of $200.0
Converting to BTC... Blockchain transaction confirmed!
Payment completed!
=== NOTIFICATION SYSTEM ===
Sending email: Welcome to our service!
Notification sent via: Email
Sending SMS: Your verification code: 123456
Notification sent via: SMS
Sending push notification: New message received!
Notification sent via: Push Notification
=== SHAPE DRAWING ===
Drawing Circle with radius: 5.0
Area: 78.53981633974483
Perimeter: 31.41592653589793
Drawing Rectangle: 4.0 x 6.0
Area: 24.0
Perimeter: 20.0
Drawing Triangle with sides: 3.0, 4.0, 5.0
Area: 6.0
Perimeter: 12.0
=== CALCULATOR POLYMORPHISM ===
=== BasicCalculator ===
10 + 5 = 15.0
10 - 5 = 5.0
10 * 5 = 50.0
10 / 5 = 2.0
Basic arithmetic operations
=== ScientificCalculator ===
10 + 5 = 15.0
10 - 5 = 5.0
10 * 5 = 50.0
10 / 5 = 2.0
Scientific functions: sin, cos, tan, log, etc.
=== ProgrammerCalculator ===
10 + 5 = 15.0
10 - 5 = 5.0
10 * 5 = 50.0
10 / 5 = 2.0
Programmer functions: binary, hex, octal, bit operations

Example 3: Real-World Polymorphism Applications

import java.util.*;
public class RealWorldPolymorphism {
public static void main(String[] args) {
System.out.println("=== REAL-WORLD POLYMORPHISM APPLICATIONS ===");
// Employee management system
System.out.println("=== EMPLOYEE MANAGEMENT SYSTEM ===");
EmployeeManager manager = new EmployeeManager();
Employee fullTime = new FullTimeEmployee("Alice", 50000, 5000);
Employee partTime = new PartTimeEmployee("Bob", 25, 160);
Employee contractor = new Contractor("Charlie", 75, 200);
manager.addEmployee(fullTime);
manager.addEmployee(partTime);
manager.addEmployee(contractor);
manager.processPayroll();
manager.generateReports();
// E-commerce payment system
System.out.println("\n=== E-COMMERCE PAYMENT SYSTEM ===");
ShoppingCart cart = new ShoppingCart();
cart.addItem(new Product("Laptop", 999.99));
cart.addItem(new Product("Mouse", 29.99));
cart.addItem(new Product("Keyboard", 79.99));
// Polymorphic payment processing
cart.checkout(new CreditCardPayment());
cart.checkout(new PayPalPayment());
cart.checkout(new CryptoPayment());
// Vehicle rental system
System.out.println("\n=== VEHICLE RENTAL SYSTEM ===");
RentalService rental = new RentalService();
Vehicle car = new Car("Toyota Camry", 2023, 5);
Vehicle bike = new Motorcycle("Harley Davidson", 2022, 1200);
Vehicle truck = new Truck("Ford F-150", 2023, 2000);
rental.rentVehicle(car, 3);
rental.rentVehicle(bike, 2);
rental.rentVehicle(truck, 5);
rental.displayRentalSummary();
// Database operations
System.out.println("\n=== DATABASE OPERATIONS ===");
DatabaseManager dbManager = new DatabaseManager();
Database mysql = new MySQLDatabase();
Database postgres = new PostgreSQLDatabase();
Database mongodb = new MongoDB();
dbManager.performDatabaseOperations(mysql);
dbManager.performDatabaseOperations(postgres);
dbManager.performDatabaseOperations(mongodb);
}
}
// Employee Management System
abstract class Employee {
protected String name;
protected String employeeId;
public Employee(String name) {
this.name = name;
this.employeeId = generateEmployeeId();
}
// Abstract methods - polymorphic behavior
public abstract double calculateSalary();
public abstract double calculateBonus();
public abstract String getEmployeeType();
// Concrete method
public String getName() {
return name;
}
public String getEmployeeId() {
return employeeId;
}
private String generateEmployeeId() {
return "EMP" + System.currentTimeMillis() % 10000;
}
}
class FullTimeEmployee extends Employee {
private double baseSalary;
private double bonus;
public FullTimeEmployee(String name, double baseSalary, double bonus) {
super(name);
this.baseSalary = baseSalary;
this.bonus = bonus;
}
@Override
public double calculateSalary() {
return baseSalary + bonus;
}
@Override
public double calculateBonus() {
return bonus;
}
@Override
public String getEmployeeType() {
return "Full-Time";
}
// Full-time specific method
public double calculateAnnualBonus() {
return baseSalary * 0.1;
}
}
class PartTimeEmployee extends Employee {
private double hourlyRate;
private int hoursWorked;
public PartTimeEmployee(String name, double hourlyRate, int hoursWorked) {
super(name);
this.hourlyRate = hourlyRate;
this.hoursWorked = hoursWorked;
}
@Override
public double calculateSalary() {
return hourlyRate * hoursWorked;
}
@Override
public double calculateBonus() {
return hourlyRate * 10; // Fixed bonus for part-time
}
@Override
public String getEmployeeType() {
return "Part-Time";
}
// Part-time specific method
public double calculateOvertime(int overtimeHours) {
return hourlyRate * 1.5 * overtimeHours;
}
}
class Contractor extends Employee {
private double hourlyRate;
private int hoursWorked;
public Contractor(String name, double hourlyRate, int hoursWorked) {
super(name);
this.hourlyRate = hourlyRate;
this.hoursWorked = hoursWorked;
}
@Override
public double calculateSalary() {
return hourlyRate * hoursWorked;
}
@Override
public double calculateBonus() {
return 0; // Contractors don't get bonuses
}
@Override
public String getEmployeeType() {
return "Contractor";
}
// Contractor specific method
public double calculateProjectFee(double projectRate, int projectHours) {
return projectRate * projectHours;
}
}
class EmployeeManager {
private List<Employee> employees = new ArrayList<>();
public void addEmployee(Employee employee) {
employees.add(employee);
}
// Polymorphic payroll processing
public void processPayroll() {
System.out.println("=== PROCESSING PAYROLL ===");
double totalPayroll = 0;
for (Employee employee : employees) {
double salary = employee.calculateSalary();
double bonus = employee.calculateBonus();
double total = salary + bonus;
System.out.printf("%s (%s): $%.2f (Salary: $%.2f, Bonus: $%.2f)%n",
employee.getName(), employee.getEmployeeType(),
total, salary, bonus);
totalPayroll += total;
}
System.out.printf("Total Payroll: $%.2f%n", totalPayroll);
System.out.println();
}
public void generateReports() {
System.out.println("=== EMPLOYEE REPORTS ===");
for (Employee employee : employees) {
System.out.printf("ID: %s, Name: %s, Type: %s, Salary: $%.2f%n",
employee.getEmployeeId(), employee.getName(),
employee.getEmployeeType(), employee.calculateSalary());
}
System.out.println();
}
}
// E-commerce System
class Product {
private String name;
private double price;
public Product(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() { return name; }
public double getPrice() { return price; }
}
interface PaymentMethod {
void processPayment(double amount);
String getPaymentMethodName();
boolean isPaymentSuccessful();
}
class CreditCardPayment implements PaymentMethod {
@Override
public void processPayment(double amount) {
System.out.println("Processing credit card payment of $" + amount);
System.out.println("Validating card... Charging amount...");
System.out.println("Credit card payment successful!");
}
@Override
public String getPaymentMethodName() {
return "Credit Card";
}
@Override
public boolean isPaymentSuccessful() {
return true;
}
}
class PayPalPayment implements PaymentMethod {
@Override
public void processPayment(double amount) {
System.out.println("Processing PayPal payment of $" + amount);
System.out.println("Redirecting to PayPal... Authorizing payment...");
System.out.println("PayPal payment successful!");
}
@Override
public String getPaymentMethodName() {
return "PayPal";
}
@Override
public boolean isPaymentSuccessful() {
return true;
}
}
class CryptoPayment implements PaymentMethod {
@Override
public void processPayment(double amount) {
System.out.println("Processing cryptocurrency payment of $" + amount);
System.out.println("Converting to BTC... Confirming blockchain transaction...");
System.out.println("Cryptocurrency payment successful!");
}
@Override
public String getPaymentMethodName() {
return "Cryptocurrency";
}
@Override
public boolean isPaymentSuccessful() {
return true;
}
}
class ShoppingCart {
private List<Product> items = new ArrayList<>();
public void addItem(Product product) {
items.add(product);
}
public double calculateTotal() {
return items.stream().mapToDouble(Product::getPrice).sum();
}
// Polymorphic checkout - accepts any PaymentMethod
public void checkout(PaymentMethod paymentMethod) {
double total = calculateTotal();
System.out.println("\n=== CHECKOUT ===");
System.out.println("Items in cart: " + items.size());
System.out.println("Total amount: $" + total);
paymentMethod.processPayment(total);
if (paymentMethod.isPaymentSuccessful()) {
System.out.println("Order completed using " + paymentMethod.getPaymentMethodName());
items.clear();
} else {
System.out.println("Payment failed. Please try again.");
}
System.out.println();
}
}
// Vehicle Rental System
abstract class Vehicle {
protected String model;
protected int year;
protected boolean isRented;
public Vehicle(String model, int year) {
this.model = model;
this.year = year;
this.isRented = false;
}
// Abstract methods
public abstract double calculateRentalCost(int days);
public abstract String getVehicleType();
public abstract void displayFeatures();
// Concrete methods
public String getModel() { return model; }
public int getYear() { return year; }
public boolean isRented() { return isRented; }
public void rent() {
if (!isRented) {
isRented = true;
System.out.println(model + " has been rented.");
} else {
System.out.println(model + " is already rented.");
}
}
public void returnVehicle() {
if (isRented) {
isRented = false;
System.out.println(model + " has been returned.");
} else {
System.out.println(model + " was not rented.");
}
}
}
class Car extends Vehicle {
private int passengerCapacity;
public Car(String model, int year, int passengerCapacity) {
super(model, year);
this.passengerCapacity = passengerCapacity;
}
@Override
public double calculateRentalCost(int days) {
return 50.0 * days; // $50 per day
}
@Override
public String getVehicleType() {
return "Car";
}
@Override
public void displayFeatures() {
System.out.println("Car Features: " + passengerCapacity + " passengers, AC, Radio");
}
// Car-specific method
public void enableChildLock() {
System.out.println("Child safety locks enabled");
}
}
class Motorcycle extends Vehicle {
private int engineCapacity;
public Motorcycle(String model, int year, int engineCapacity) {
super(model, year);
this.engineCapacity = engineCapacity;
}
@Override
public double calculateRentalCost(int days) {
return 30.0 * days; // $30 per day
}
@Override
public String getVehicleType() {
return "Motorcycle";
}
@Override
public void displayFeatures() {
System.out.println("Motorcycle Features: " + engineCapacity + "cc engine, Helmet included");
}
// Motorcycle-specific method
public void wheelie() {
System.out.println("Performing wheelie! (Please drive safely)");
}
}
class Truck extends Vehicle {
private double cargoCapacity;
public Truck(String model, int year, double cargoCapacity) {
super(model, year);
this.cargoCapacity = cargoCapacity;
}
@Override
public double calculateRentalCost(int days) {
return 80.0 * days; // $80 per day
}
@Override
public String getVehicleType() {
return "Truck";
}
@Override
public void displayFeatures() {
System.out.println("Truck Features: " + cargoCapacity + "kg cargo capacity, Tow hitch");
}
// Truck-specific method
public void loadCargo(double weight) {
if (weight <= cargoCapacity) {
System.out.println("Cargo loaded: " + weight + "kg");
} else {
System.out.println("Cargo exceeds capacity!");
}
}
}
class RentalService {
private List<Vehicle> rentedVehicles = new ArrayList<>();
private double totalRevenue = 0;
// Polymorphic vehicle rental
public void rentVehicle(Vehicle vehicle, int days) {
System.out.println("=== RENTING VEHICLE ===");
vehicle.displayFeatures();
double cost = vehicle.calculateRentalCost(days);
System.out.printf("Rental cost for %d days: $%.2f%n", days, cost);
vehicle.rent();
rentedVehicles.add(vehicle);
totalRevenue += cost;
System.out.println();
}
public void displayRentalSummary() {
System.out.println("=== RENTAL SUMMARY ===");
System.out.println("Total vehicles rented: " + rentedVehicles.size());
System.out.printf("Total revenue: $%.2f%n", totalRevenue);
for (Vehicle vehicle : rentedVehicles) {
System.out.printf("- %s %s (%s)%n", 
vehicle.getVehicleType(), vehicle.getModel(), vehicle.getYear());
}
System.out.println();
}
}
// Database System
interface Database {
void connect();
void disconnect();
void executeQuery(String query);
void commitTransaction();
void rollbackTransaction();
String getDatabaseType();
}
class MySQLDatabase implements Database {
@Override
public void connect() {
System.out.println("Connecting to MySQL database...");
}
@Override
public void disconnect() {
System.out.println("Disconnecting from MySQL database...");
}
@Override
public void executeQuery(String query) {
System.out.println("Executing MySQL query: " + query);
}
@Override
public void commitTransaction() {
System.out.println("Committing MySQL transaction...");
}
@Override
public void rollbackTransaction() {
System.out.println("Rolling back MySQL transaction...");
}
@Override
public String getDatabaseType() {
return "MySQL";
}
// MySQL specific method
public void enableBinaryLogging() {
System.out.println("MySQL binary logging enabled");
}
}
class PostgreSQLDatabase implements Database {
@Override
public void connect() {
System.out.println("Connecting to PostgreSQL database...");
}
@Override
public void disconnect() {
System.out.println("Disconnecting from PostgreSQL database...");
}
@Override
public void executeQuery(String query) {
System.out.println("Executing PostgreSQL query: " + query);
}
@Override
public void commitTransaction() {
System.out.println("Committing PostgreSQL transaction...");
}
@Override
public void rollbackTransaction() {
System.out.println("Rolling back PostgreSQL transaction...");
}
@Override
public String getDatabaseType() {
return "PostgreSQL";
}
// PostgreSQL specific method
public void enableReplication() {
System.out.println("PostgreSQL replication enabled");
}
}
class MongoDB implements Database {
@Override
public void connect() {
System.out.println("Connecting to MongoDB...");
}
@Override
public void disconnect() {
System.out.println("Disconnecting from MongoDB...");
}
@Override
public void executeQuery(String query) {
System.out.println("Executing MongoDB operation: " + query);
}
@Override
public void commitTransaction() {
System.out.println("MongoDB doesn't support traditional transactions");
}
@Override
public void rollbackTransaction() {
System.out.println("MongoDB doesn't support rollback in same way");
}
@Override
public String getDatabaseType() {
return "MongoDB";
}
// MongoDB specific method
public void createCollection(String name) {
System.out.println("Creating MongoDB collection: " + name);
}
}
class DatabaseManager {
// Polymorphic database operations
public void performDatabaseOperations(Database database) {
System.out.println("=== " + database.getDatabaseType() + " OPERATIONS ===");
database.connect();
database.executeQuery("SELECT * FROM users");
database.commitTransaction();
// Database-specific operations
if (database instanceof MySQLDatabase) {
((MySQLDatabase) database).enableBinaryLogging();
} else if (database instanceof PostgreSQLDatabase) {
((PostgreSQLDatabase) database).enableReplication();
} else if (database instanceof MongoDB) {
((MongoDB) database).createCollection("users");
}
database.disconnect();
System.out.println();
}
}

Output:
```
=== REAL-WORLD POLYMORPHISM APPLICATIONS ===
=== EMPLOYEE MANAGEMENT SYSTEM ===
=== PROCESSING PAYROLL ===
Alice (Full-Time): $55000.00 (Salary: $55000.00, Bonus: $5000.00)
Bob (Part-Time): $4000.00 (Salary: $4000.00, Bonus: $250.00)
Charlie (Contractor): $15000.00 (Salary: $15000.00, Bonus: $0.00)
Total Payroll: $74000.00

=== EMPLOYEE REPORTS ===