CoreJava-8 - OOP - Polymorphism

  

Polymorphism

Polymorphism is a key concept in object-oriented programming that allows objects of different classes to be treated as objects of a common superclass. In Java, this is achieved through method overriding and interface implementation and or method overriding. Polymorphism enables you to write more flexible and reusable code, as you can use a single interface to interact with multiple classes that share a common behaviour.

Polymorphism in Java can be categorized into two main types: compile-time polymorphism (also known as static polymorphism or early binding) and runtime polymorphism (also known as dynamic polymorphism or late binding).

Example 1: Bank Account Types

1. Compile-time Polymorphism (Method Overloading): This type of polymorphism occurs when there are multiple methods in the same class with the same name but different parameter lists. The methods are distinguished based on the number, order and type of parameters.

Class BankAccount {

void deposit(double amount) {

 // Implementation for deposit

}

void deposit(double amount, String source) {

 // overloaded method with an additional parameter

 } }

 

In this example, the deposit method is overloaded with different parameter lists. The appropriate method is chosen at compile time based on the method arguments.

2. Runtime Polymorphism (Method Overriding): This type of polymorphism occurs when a subclass provides a specific implementation for a method that is already defined in its superclass.

In the example you provided, the BankAccount interface defines the transaction method, and both SavingsAccount and CheckingAccount classes override this method with their own implementations. The specific method to be executed is determined at runtime based on the actual object's type.

class BankAccount {

    void transaction() {

        System.out.println("Performing a bank transaction.");

    }

}

 

class SavingsAccount extends BankAccount {

    @Override

    void transaction() {

        System.out.println("Performing a savings account transaction.");

    }

}

 

class CheckingAccount extends BankAccount {

    @Override

    void transaction() {

        System.out.println("Performing a checking account transaction.");

    }

}

 

public class Main {

    public static void main(String[] args) {

        BankAccount account1 = new SavingsAccount();

        BankAccount account2 = new CheckingAccount();

 

        account1.transaction(); // Output: Performing a savings account transaction.

        account2.transaction(); // Output: Performing a checking account transaction.

    }

}

 

Method overriding is an example of runtime polymorphism, as the specific method implementation is resolved at runtime based on the actual object's type. This is a core concept of object-oriented programming and allows for flexible and extensible code design.

Compile-time polymorphism through method overloading is not as explicitly demonstrated in your provided examples, but it's another way Java supports polymorphism by enabling you to define multiple methods with the same name but different parameter lists, and the appropriate method is chosen based on the arguments provided during compilation.

Difference between early and late binding:

Early binding and late binding are concepts related to how programming languages resolve method calls or function invocations. These terms are often used in the context of polymorphism and dynamic dispatch. Let's see their differences:

Early Binding (Static Binding):

1. Timing: Early binding occurs at compile time.
2. Method Resolution: The method to be executed is determined during the compilation phase based on the reference type of the object.
3. Performance: Early binding can lead to better performance because the method call is resolved at compile time, reducing the runtime overhead.
4. Method Overloading: Method overloading is an example of early binding. The compiler selects the appropriate method based on the argument types, and this decision is made at compile time.
5. Predictability: Early binding provides predictability in terms of which method will be called since it's determined at compile time.

Late Binding (Dynamic Binding):

1. Timing: Late binding occurs at runtime.
2. Method Resolution: The method to be executed is determined during runtime based on the actual object's type. This is a key concept in achieving polymorphism.
3. Performance: Late binding can introduce some runtime overhead due to the need to resolve method calls dynamically.
4. Method Overriding: Method overriding is an example of late binding. The actual method to be executed is determined by the runtime type of the object.
5. Polymorphism: Late binding enables polymorphism, as it allows different objects to respond differently to the same method call.

In Java, late binding is primarily associated with method overriding, where a subclass provides a specific implementation of a method declared in its superclass or interface. When an overridden method is invoked, the runtime type of the object determines which implementation will be executed. This flexibility allows for more extensible and adaptable code.

In contrast, early binding is typically related to method overloading and other situations where the method to be called is determined based on the static (compile-time) type of the reference, rather than the actual runtime object type.

In summary, the key distinction between early binding and late binding lies in when the method resolution occurs: compile time for early binding and runtime for late binding. This difference has implications for predictability, performance, and the ability to achieve polymorphism in object-oriented programming.

Benefits of implementing Polymorphism in coding:

Implementing polymorphism in coding offers several benefits that contribute to writing more flexible, modular, and extensible software. Here are some of the key advantages of using polymorphism:

1. Code Reusability: Polymorphism allows you to define common interfaces or base classes that multiple derived classes can implement or extend. This promotes code reuse as you can write code that works with a general interface and apply it to various specific implementations.
2. Modularity: Polymorphism helps you divide your code into smaller, more manageable modules. Each module can provide a specific set of behaviours through interfaces or base classes, making the codebase easier to understand and maintain.
3. Extensibility: Adding new functionality or introducing new subclasses becomes easier with polymorphism. You can extend existing classes or interfaces and create new implementations without needing to modify existing code that relies on the common interface.
4. Adaptability: Polymorphism enables your code to adapt to different scenarios and requirements. By interacting with objects through a common interface, your code can work with different implementations seamlessly, allowing for changes and enhancements with minimal impact.
5. Polymorphic Data Structures: Polymorphism allows you to create data structures that can hold objects of different types that share a common interface. This is particularly useful when dealing with collections of objects with diverse behaviours.
6. Dynamic Dispatch: Polymorphism supports dynamic method dispatch, meaning that the appropriate method implementation is determined at runtime based on the actual object's type. This is a key concept for achieving flexible and adaptable behaviour.
7. Enabling Design Patterns: Many design patterns, such as the Factory Method, Strategy, and Observer patterns, rely on polymorphism to provide clean and effective solutions to common programming problems.
8. Reduced Coupling: Polymorphism reduces the coupling between different parts of your code. Code that relies on interfaces is not tightly coupled to specific implementations, allowing for easier changes and updates without affecting other parts of the codebase.
9. Simpler Interfaces: Polymorphism allows you to define clear and minimal interfaces that only expose the necessary methods. This promotes the principle of "interface segregation" by ensuring that clients only depend on methods relevant to their needs.
10. Testing and Mocking: Polymorphism facilitates testing and mocking by allowing you to create mock objects or stubs that implement the same interface as the actual objects. This makes it easier to isolate and test individual components.
11. Parallel Development: Different teams or developers can work on different implementations of the same interface concurrently. As long as they adhere to the interface contract, the pieces can be integrated seamlessly.

In summary, polymorphism empowers you to write more adaptable and maintainable code by providing a way to interact with diverse objects through a common interface. It's a fundamental concept in object-oriented programming that supports the principles of modularity, encapsulation, and separation of concerns.

Explain constructor overloading in detail:

Constructor overloading is a concept in object-oriented programming where a class can have multiple constructors with different parameter lists. Each constructor provides a way to initialize objects of the class with varying sets of initial values. This allows you to create objects with different configurations or with different levels of detail provided during instantiation.

Here's a detailed explanation of constructor overloading:

1. Multiple Constructors: In Java, a class can have multiple constructors, each with a unique parameter list. These constructors can differ in the number of parameters, data types of parameters, or the order of parameters.
2. Method Signature: The method signature of a constructor includes the constructor's name and the types of its parameters. This means that constructors with different parameter lists are considered distinct methods.
3. Initialization Flexibility: Constructor overloading provides flexibility in how objects are initialized. Different constructors can be used to initialize objects with varying amounts of information, based on the needs of the program.
4. Default Constructor: If a class does not explicitly provide any constructors, Java automatically provides a default constructor with no parameters. However, if you define any constructor in the class, the default constructor won't be automatically generated.
5. Object Initialization: When you create an object of a class using the new keyword, the appropriate constructor is called based on the arguments provided. The constructor initializes the object's attributes or performs any necessary setup.
6. Example: Constructor Overloading:

public class Person {

                private String name;

                private int age;

// Constructor with no parameters (default values)

public Person() { name = "Unknown"; age = 0; }

// Constructor with name parameter

public Person(String n) { name = n; age = 0; // Age set to default value }

// Constructor with both name and age parameters

public Person(String n, int a) { name = n; age = a; }

// Getters and setters...

public void displayInfo() { System.out.println("Name: " + name + ", Age: " + age); } }

In the above example, the Person class has three constructors that demonstrate constructor overloading. These constructors provide different ways to initialize a Person object:

• The first constructor initializes both name and age attributes to default values.
• The second constructor initializes the name attribute based on the provided name parameter and sets age to the default value.
• The third constructor initializes both name and age attributes based on the provided parameters.

Constructor overloading is useful when you want to create objects with varying levels of detail or when you want to provide different options for object initialization. It allows you to make your classes more versatile and adaptable to different scenarios.

Explain coercion in polymorphism:

Coercion is a concept in programming languages, including object-oriented languages like Java that involves automatically converting or adapting values from one type to another, often to allow operations or interactions that wouldn't normally be valid. In the context of polymorphism, coercion can occur when different types are involved in operations, such as method calls or expressions, and the language automatically handles type conversions to make the operation meaningful.

Let's explore coercion in the context of polymorphism:

Example: Coercion in Polymorphism

Consider a scenario where you have a base class Shape and two subclasses Circle and Rectangle. You want to calculate the areas of these shapes. Since circles and rectangles have different formulas for area calculation, you need a different method for each shape type.

class Shape { // Base class for all shapes }

 

class Circle extends Shape {

double radius;

Circle(double r) { radius = r; }

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

 

class Rectangle extends Shape {

double width; double height;

Rectangle(double w, double h) { width = w; height = h; }

double calculateArea() { return width * height; } }

 

Now, let's say you want to create a method that accepts both Circle and Rectangle objects and calculates their areas. You can achieve this using polymorphism and coercion:

class AreaCalculator {

double calculateArea(Shape shape) {

 if (shape instanceof Circle) {

 Circle circle = (Circle) shape;

// Coercion from Shape to Circle

return circle.calculateArea(); }

 else if (shape instanceof Rectangle) {

Rectangle rectangle = (Rectangle) shape;

// Coercion from Shape to Rectangle

return rectangle.calculateArea(); }

else {

throw new IllegalArgumentException("Unsupported shape type"); } } }

In the calculateArea method of the AreaCalculator class, the parameter is of type Shape, the common superclass of Circle and Rectangle. Inside the method, type coercion is used to convert the parameter from Shape to the specific subclass type (either Circle or Rectangle). This enables you to call the calculateArea method specific to the subclass, leveraging the overridden method based on the actual runtime type of the object. Coercion is occurring when you perform explicit casting (Circle) shape and (Rectangle) shape to convert the Shape reference to the appropriate subclass reference, allowing you to access the methods specific to those subclasses. In this example, coercion plays a role in achieving polymorphism by allowing you to work with different types in a unified manner while maintaining the ability to call methods specific to those types.

Example for operator overloading:

Operator overloading in Java allows you to define custom behaviour for built-in operators when applied to objects of your classes. However, it's important to note that Java only supports limited operator overloading, and it's primarily used for predefined operators like +, -, *, /, and others. Here's a simple example of operator overloading using the + operator to concatenate strings:

class ComplexNumber {

 private double real;

 private double imaginary;

ComplexNumber(double real, double imaginary) {

this.real = real; this.imaginary = imaginary; }

ComplexNumber add(ComplexNumber other) {

double newReal = this.real + other.real;

double newImaginary = this.imaginary + other.imaginary;

 return new ComplexNumber(newReal, newImaginary); }

@Override public String toString() {

 return real + " + " + imaginary + "i"; } }

public class Main { public static void main(String[] args) {

 ComplexNumber num1 = new ComplexNumber(3.0, 4.0);

ComplexNumber num2 = new ComplexNumber(2.0, -1.0); \

ComplexNumber sum = num1.add(num2); System.out.println("Sum: " + sum);

// Output: Sum: 5.0 + 3.0i } }

In this example, the ComplexNumber class defines a add method to perform addition of complex numbers. The toString method is also overridden to provide a meaningful string representation of the complex number. Even though Java does not support custom operator overloading like some other languages do, you can achieve similar functionality by defining methods with clear names (like add, subtract, etc.) to represent the desired operations on your objects. This approach ensures code readability and maintainability while providing the desired behaviour for operators.

----------------------------------------------------------------------------------------------------------------------------------------

Question 1: What is polymorphism, and how does it relate to inheritance and interfaces?

Answer: Polymorphism is a fundamental concept in object-oriented programming that allows objects of different classes to be treated as objects of a common superclass or through a shared interface. It enables a single interface to represent multiple implementations. Inheritance and interfaces play a key role in achieving polymorphism. Inheritance allows a subclass to inherit the attributes and methods of its superclass, while interfaces define a contract that multiple classes can implement.

Question 2: How is polymorphism achieved through method overriding?

Answer: Method overriding allows a subclass to provide a specific implementation for a method that is already defined in its superclass. When an overridden method is invoked on an object, the implementation of the subclass is executed, based on the actual runtime type of the object. This dynamic dispatch enables polymorphism, as different objects can respond differently to the same method call.

Example Code:

class BankAccount {

void performTransaction() {

System.out.println("Performing transaction in BankAccount"); } }

class SavingsAccount extends BankAccount {

void performTransaction() {

System.out.println("Performing transaction in SavingsAccount"); } }

class CheckingAccount extends BankAccount {

 void performTransaction() {

System.out.println("Performing transaction in CheckingAccount"); } }

public class Main {

public static void main(String[] args) {

BankAccount account1 = new SavingsAccount();

BankAccount account2 = new CheckingAccount();

account1.performTransaction(); // Output: Performing transaction in SavingsAccount account2.performTransaction(); // Output: Performing transaction in CheckingAccount

} }

 

Question 3: What is compile-time polymorphism (method overloading)?

Answer: Compile-time polymorphism, also known as method overloading, occurs when a class has multiple methods with the same name but different parameter lists. The correct method to be called is determined at compile time based on the arguments provided. This allows a class to provide multiple ways of performing similar tasks with different input types.

Question 4: How is runtime polymorphism achieved?

Answer: Runtime polymorphism, also known as dynamic polymorphism, is achieved through method overriding. It allows a subclass to provide its own implementation of a method defined in its superclass. When the method is called on an object, the JVM determines the appropriate implementation to execute based on the actual runtime type of the object. This enables flexibility and adaptability in the code.

 

--------------------------------------------------------------------------------------------------------------------------------

 

Assignment 1: Simple Polymorphism

Problem: Create a class hierarchy for different types of animals. Implement a common method makeSound and provide specific implementations for cats, dogs, and birds.

Algorithm Steps:

1. Define a base class Animal with a method makeSound.
2. Implement subclasses Cat, Dog, and Bird.
3. Override the makeSound method in each subclass to produce appropriate animal sounds.

Assignment 2: Interface Implementation

Problem: Design an interface Shape with a method calculateArea. Implement this interface in classes for different shapes like circles, rectangles, and triangles.

Algorithm Steps:

1. Define an interface Shape with a method calculateArea.
2. Implement classes Circle, Rectangle, and Triangle.
3. Override the calculateArea method in each class with the appropriate area calculation formula.

Assignment 3: Banking System

Problem: Create a banking system with a base class BankAccount and subclasses SavingsAccount and CheckingAccount. Implement methods for deposit, withdrawal, and balance inquiry.

Algorithm Steps:

1. Define a base class BankAccount with attributes like account number and balance.
2. Implement subclasses SavingsAccount and CheckingAccount.
3. Provide methods for deposit, withdrawal, and balance inquiry in each subclass.

Assignment 4: Abstract Classes

Problem: Design a class hierarchy for vehicles, using an abstract class Vehicle with subclasses Car, Motorcycle, and Truck.

Algorithm Steps:

1. Define an abstract class Vehicle with attributes like model and year.
2. Implement subclasses Car, Motorcycle, and Truck.
3. Provide specific implementations for common methods like startEngine and stopEngine in each subclass.

Assignment 5: Dynamic Dispatch

Problem: Create a class hierarchy for electronics devices, including a base class Device and subclasses TV, Phone, and Laptop. Implement a displayInfo method in each subclass.

Algorithm Steps:

1. Define a base class Device with attributes like brand and model.
2. Implement subclasses TV, Phone, and Laptop.
3. Override the displayInfo method in each subclass to display device information.

Assignment 6: Polymorphic Collections

Problem: Build a class hierarchy for different types of fruits (Apple, Banana, etc.). Store instances of these classes in an ArrayList and demonstrate polymorphism by calling a common method like ripeOrUnripe.

Algorithm Steps:

1. Define a base class Fruit with attributes like name and color.
2. Implement subclasses Apple, Banana, and others.
3. Implement a method ripeOrUnripe in each subclass to provide information about the fruit's ripeness.

Assignment 7: Calculator Application

Problem: Create a simple calculator application using a polymorphic approach. Define an interface CalculatorOperation with methods like performOperation and getOperatorSymbol. Implement this interface for operations like addition, subtraction, multiplication, and division.

Algorithm Steps:

1. Define an interface CalculatorOperation with methods for performing the operation and getting the operator symbol.
2. Implement classes for each operation (e.g., Addition, Subtraction, etc.).
3. Create a calculator class that takes inputs and performs operations using polymorphism.

Assignment 8: Online Shopping System

Problem: Build a basic online shopping system. Design a class hierarchy for different types of products. Implement a shopping cart using polymorphism, allowing customers to add different products to their cart and calculate the total price.

Algorithm Steps:

1. Define a base class Product with attributes like name, price, and quantity.
2. Implement subclasses for different product categories (e.g., Electronics, Clothing, etc.).
3. Create a shopping cart class that stores instances of different products using polymorphism.

Assignment 9: Shape Drawing Application

Problem: Develop a shape drawing application where users can draw different shapes on a canvas. Implement a common method draw in a base class Shape, and provide specific implementations for subclasses like Circle, Rectangle, and Triangle.

Algorithm Steps:

1. Define a base class Shape with attributes like position and color.
2. Implement subclasses Circle, Rectangle, and Triangle.
3. Override the draw method in each subclass to visually represent the shape on the canvas.

Assignment 10: Social Media System

Problem: Create a basic social media system with users and posts. Design a class hierarchy with a base class User and subclasses RegularUser and AdminUser. Implement methods to post messages, comment on posts, and manage users.

Algorithm Steps:

1. Define a base class User with attributes like username and followers.
2. Implement subclasses RegularUser and AdminUser.
3. Provide methods for posting messages, commenting on posts, and managing users in each subclass.Top of Form