This document, "Xirius-JavaPolymorphism4-COS201.pdf," provides a comprehensive and detailed exploration of polymorphism in Java, specifically tailored for the COS201 course. It serves as the fourth part in a series, building upon foundational Java concepts to delve into one of the core principles of Object-Oriented Programming (OOP). The document systematically introduces polymorphism, distinguishing between its compile-time and runtime forms, and elaborates on the mechanisms that enable each.

The content progresses from fundamental definitions and illustrative code examples for method overloading and overriding to more advanced topics such as dynamic method dispatch, abstract classes, and interfaces. A significant portion is dedicated to explaining the rules governing method overriding, including the concept of covariant return types. The document also provides a crucial comparison between abstract classes and interfaces, highlighting their similarities, differences, and respective use cases in achieving polymorphism.

Ultimately, the document aims to equip students with a deep understanding of how polymorphism enhances code reusability, flexibility, extensibility, and maintainability in Java applications. It emphasizes practical application through numerous code snippets and conceptual explanations, ensuring that learners can not only define polymorphism but also implement it effectively in their programming endeavors.

Polymorphism, derived from Greek words "poly" (many) and "morph" (forms), is a fundamental concept in Object-Oriented Programming (OOP) that allows an object to take on many forms. In Java, it refers to the ability of an object to pass different forms of behavior based on the context or the type of the object. It enables a single interface to represent different underlying forms or types, promoting code reusability and flexibility.

Polymorphism in Java is broadly categorized into two main types:

1. Compile-time Polymorphism (Static Polymorphism): Achieved through Method Overloading. The decision of which method to call is made at compile time.

2. Runtime Polymorphism (Dynamic Polymorphism): Achieved through Method Overriding. The decision of which method to call is made at runtime by the Java Virtual Machine (JVM).

Method overloading occurs when a class has multiple methods with the same name but different parameter lists. The compiler determines which overloaded method to call based on the number, type, and order of arguments passed during the method invocation.

* Same method name.

* Different method signatures (different number of parameters, different types of parameters, or different order of parameters).

* The return type of the methods does not affect overloading.

Method overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. This is a core mechanism for achieving runtime polymorphism, where the actual method invoked depends on the type of the object at runtime, not the type of the reference variable.

* Requires an inheritance relationship (parent-child classes).

* The method in the subclass must have the exact same signature (name, parameter list, and return type) as the method in the superclass.

* The `@Override` annotation is often used for clarity and compile-time checking.

* The `super` keyword can be used in the subclass to call the superclass's overridden method.

Several rules must be followed for method overriding:

1. Same Signature: The overridden method in the subclass must have the same name, same parameter list, and same return type as the method in the superclass.

2. Access Modifier: The access modifier of the overriding method cannot be more restrictive than the overridden method (e.g., if the superclass method is `protected`, the subclass method can be `protected` or `public`, but not `private`).

3. `private`, `final`, `static` methods: These methods cannot be overridden.

* `private` methods are not inherited.

* `final` methods are designed to prevent overriding.

* `static` methods belong to the class, not an object, and thus cannot be overridden (they can be "hidden" by a static method in a subclass, but this is not overriding).

4. Checked Exceptions: If the overridden method declares a checked exception, the overriding method can declare the same exception, a subclass of that exception, or no exception. It cannot declare a broader or new checked exception.

5. Covariant Return Type: Since Java 5, the return type of an overriding method can be a subclass of the return type of the overridden method.

Introduced in Java 5, covariant return type allows an overriding method to have a return type that is a subclass of the return type of the method it overrides. This enhances flexibility and type safety.

Dynamic method dispatch is the mechanism by which the JVM determines which overridden method to call at runtime. This occurs when a superclass reference variable refers to an object of a subclass. The method invoked is determined by the actual type of the object (the object to which the reference variable points), not the type of the reference variable itself. This process is also known as upcasting, where a subclass object is referred to by a superclass reference.

The `instanceof` operator is a binary operator used to test if an object is an instance of a particular class, interface, or a subclass thereof. It returns `true` if the object is an instance of the specified type, and `false` otherwise. It's often used in conjunction with dynamic method dispatch to perform type checking before downcasting.

An abstract class is a class that cannot be instantiated directly. It is declared using the `abstract` keyword. Abstract classes can have both concrete (implemented) methods and abstract methods.

* Cannot be instantiated.

* Can have constructors (though not directly callable, they are called by subclass constructors).

* Can contain `final` and `static` methods.

* Can contain instance variables.

* A class becomes abstract if it contains at least one abstract method, or if it's explicitly declared abstract.

An interface in Java is a blueprint of a class. It contains abstract methods (implicitly `public` and `abstract` before Java 8) and constants (implicitly `public`, `static`, and `final`). From Java 8 onwards, interfaces can also contain `default` and `static` methods with implementations.

* All methods are implicitly `public` and `abstract` (before Java 8).

* All variables are implicitly `public`, `static`, and `final`.

* A class `implements` an interface, providing implementations for all its abstract methods.

* A class can implement multiple interfaces, achieving a form of multiple inheritance of type.

* Interfaces cannot be instantiated.

| Feature | Abstract Class | Interface |

| :------------------ | :---------------------------------------------- | :------------------------------------------------ |

| Multiple Inheritance | Not supported (Java does not allow multiple inheritance of classes) | Supported (a class can implement multiple interfaces) |

| Methods | Can have abstract and non-abstract (concrete) methods | All methods are abstract by default (before Java 8); can have `default` and `static` methods (Java 8+) |

| Variables | Can have `final`, `non-final`, `static`, `non-static` variables | All variables are implicitly `public`, `static`, and `final` |

| Constructors | Can have constructors | Cannot have constructors |

| Access Modifiers | Can have any access modifier (`public`, `protected`, `private`) for methods/variables | All methods are implicitly `public`; all variables are implicitly `public`, `static`, `final` |

| `implements`/`extends` | `extends` another class, `implements` interfaces | `extends` other interfaces, `implements` by classes |

Interfaces are a powerful mechanism for achieving polymorphism. A reference variable of an interface type can refer to any object of a class that implements that interface. This allows for writing generic code that can operate on different types of objects as long as they adhere to the contract defined by the interface.

Polymorphism offers significant advantages in software development:

1. Code Reusability: Write generic code that works with different types of objects.

2. Flexibility: Easily add new classes without modifying existing code, as long as they adhere to the polymorphic contract.

3. Extensibility: New functionalities can be added by creating new subclasses or implementing new interfaces.

4. Maintainability: Changes to specific implementations are localized within their respective classes, reducing impact on other parts of the system.

5. Reduced Coupling: Promotes loose coupling between components, as they interact through common interfaces or superclass types rather than concrete implementations.

* Polymorphism: The ability of an object to take on many forms; in Java, it allows a single interface to represent different underlying forms or types, enabling objects to behave differently based on their actual type at runtime or compile time.

* Method Overloading: A form of compile-time polymorphism where a class has multiple methods with the same name but different parameter lists (number, type, or order of arguments).

* Method Overriding: A form of runtime polymorphism where a subclass provides a specific implementation for a method that is already defined in its superclass, having the exact same method signature.

* Dynamic Method Dispatch: The mechanism by which the Java Virtual Machine (JVM) determines which overridden method to call at runtime, based on the actual type of the object being referred to by a superclass reference variable.

* Upcasting: The process of assigning a subclass object to a superclass reference variable. This is a prerequisite for dynamic method dispatch.

* Abstract Class: A class declared with the `abstract` keyword that cannot be instantiated directly. It can contain both abstract and concrete methods, and its purpose is to be extended by subclasses.

* Abstract Method: A method declared with the `abstract` keyword and no implementation (no method body). Subclasses must provide an implementation for all inherited abstract methods unless they are also abstract.

* Interface: A blueprint of a class that defines a contract. Before Java 8, it contained only abstract methods and constants. From Java 8, it can also include `default` and `static` methods with implementations. Classes `implement` interfaces.

* `instanceof` Operator: A binary operator used to test if an object is an instance of a particular class, interface, or a subclass thereof, returning `true` or `false`.

* Covariant Return Type: A feature introduced in Java 5 that allows an overriding method to have a return type that is a subclass of the return type of the method it overrides.

```java

class Calculator {

int add(int a, int b) {

return a + b;

}

int add(int a, int b, int c) {

return a + b + c;

}

double add(double a, double b) {

return a + b;

}

}

// Usage:

// Calculator calc = new Calculator();

// calc.add(10, 20); // Calls first add method

// calc.add(10, 20, 30); // Calls second add method

// calc.add(10.5, 20.5); // Calls third add method

```

This example demonstrates how the `add` method can take different numbers or types of arguments, and the compiler selects the appropriate method at compile time.

```java

class Vehicle {

void run() {

System.out.println("Vehicle is running");

}

}

class Car extends Vehicle {

@Override

void run() {

System.out.println("Car is running safely");

}

}

// Usage:

// Vehicle v = new Car();

// v.run(); // Output: Car is running safely (runtime polymorphism)

```

Here, the `Car` class provides its own specific implementation of the `run()` method inherited from `Vehicle`, showcasing method overriding.

```java

class Animal {

void makeSound() {

System.out.println("Animal makes a sound");

}

}

class Dog extends Animal {

@Override

void makeSound() {

System.out.println("Dog barks");

}

}

class Cat extends Animal {

@Override

void makeSound() {

System.out.println("Cat meows");

}

}

// Usage:

// Animal myAnimal;

// myAnimal = new Dog();

// myAnimal.makeSound(); // Output: Dog barks

// myAnimal = new Cat();

// myAnimal.makeSound(); // Output: Cat meows

```

This example clearly illustrates dynamic method dispatch. An `Animal` reference variable can point to `Dog` or `Cat` objects, and the `makeSound()` method called at runtime depends on the actual object type.

```java

abstract class Shape {

abstract void draw(); // Abstract method

void display() { // Concrete method

System.out.println("This is a shape.");

}

}

class Circle extends Shape {

@Override

void draw() {

System.out.println("Drawing a circle.");

}

}

class Rectangle extends Shape {

@Override

void draw() {

System.out.println("Drawing a rectangle.");

}

}

// Usage:

// Shape s1 = new Circle();

// s1.draw(); // Output: Drawing a circle.

// Shape s2 = new Rectangle();

// s2.draw(); // Output: Drawing a rectangle.

```

The `Shape` abstract class defines a common `draw()` behavior that its concrete subclasses (`Circle`, `Rectangle`) must implement, enforcing a contract.

```java

interface Drawable {

void draw(); // Implicitly public and abstract

}

class Circle implements Drawable {

@Override

public void draw() {

System.out.println("Drawing a circle from interface.");

}

}

class Rectangle implements Drawable {

@Override

public void draw() {

System.out.println("Drawing a rectangle from interface.");

}

}

// Usage:

// Drawable d1 = new Circle();

// d1.draw(); // Output: Drawing a circle from interface.

```

Similar to abstract classes, interfaces define a contract (`draw()`) that implementing classes must fulfill, enabling polymorphic behavior.

```java

interface Shape {

void draw();

}

class Circle implements Shape {

@Override

public void draw() { System.out.println("Drawing Circle"); }

}

class Rectangle implements Shape {

@Override

public void draw() { System.out.println("Drawing Rectangle"); }

}

class DrawingApp {

public static void drawShape(Shape s) {

s.draw(); // Polymorphic call

}

public static void main(String[] args) {

Shape circle = new Circle();

Shape rectangle = new Rectangle();

drawShape(circle); // Output: Drawing Circle

drawShape(rectangle); // Output: Drawing Rectangle

}

}

```

This example demonstrates the power of polymorphism with interfaces. The `drawShape` method can accept any object that implements the `Shape` interface, and the correct `draw()` method is invoked at runtime based on the actual object type. This promotes highly flexible and extensible code.

This document, "Xirius-JavaPolymorphism4-COS201.pdf," provides a thorough and structured exploration of polymorphism in Java, a cornerstone of Object-Oriented Programming. It begins by defining polymorphism as the ability of an object to take on "many forms," emphasizing its role in promoting code reusability, flexibility, and extensibility.

The document clearly distinguishes between the two main types of polymorphism: Compile-time Polymorphism and Runtime Polymorphism. Compile-time polymorphism is primarily achieved through Method Overloading, where multiple methods within the same class share the same name but differ in their parameter lists (number, type, or order of arguments). The compiler resolves which overloaded method to invoke during compilation. An example of an `add` method with varying parameter counts and types effectively illustrates this concept.

Runtime polymorphism, on the other hand, is realized through Method Overriding, which requires an inheritance relationship between classes. A subclass provides its own specific implementation for a method already defined in its superclass, maintaining the exact same method signature (name, parameters, and return type). The document meticulously outlines the rules for method overriding, including constraints on access modifiers (cannot be more restrictive), the inability to override `private`, `final`, or `static` methods, and rules for handling checked exceptions. A significant detail covered is the Covariant Return Type, introduced in Java 5, which allows an overriding method to return a subclass of the return type of the overridden method, enhancing type safety and flexibility.

A key mechanism for runtime polymorphism is Dynamic Method Dispatch. This concept explains how the Java Virtual Machine (JVM) determines which overridden method to execute at runtime when a superclass reference variable points to an object of a subclass (a process known as upcasting). The method invoked is always based on the actual object type, not the reference type. Practical examples involving `Animal`, `Dog`, and `Cat` classes vividly demonstrate this dynamic behavior. The `instanceof` operator is also introduced as a utility for runtime type checking, often used before downcasting.

The document then transitions to more advanced concepts that facilitate polymorphism: Abstract Classes and Methods and Interfaces. An abstract class is defined as a class that cannot be instantiated directly, serving as a blueprint for subclasses. It can contain both concrete and abstract methods, where abstract methods are declared without an implementation and must be implemented by concrete subclasses. Interfaces, conversely, are presented as pure blueprints, historically containing only abstract methods (implicitly `public` and `abstract`) and constants (implicitly `public`, `static`, `final`). The document notes the evolution of interfaces in Java 8, allowing `default` and `static` methods with implementations.

A crucial section provides a detailed comparison between Abstract Classes and Interfaces, highlighting their differences in terms of multiple inheritance (interfaces support it, abstract classes do not), types of methods and variables they can contain, constructor presence, and access modifiers. This comparison is vital for understanding when to use each construct.

Finally, the document emphasizes Polymorphism with Interfaces, demonstrating how an interface reference variable can point to any object of a class that implements that interface. This allows for highly flexible and generic code, where a single method can operate on various object types as long as they adhere to the interface's contract. The benefits of polymorphism are summarized, including enhanced code reusability, flexibility, extensibility, maintainability, and reduced coupling, all contributing to robust and scalable software design. Through its clear explanations, specific definitions, and numerous code examples, the document provides a comprehensive guide to understanding and applying polymorphism in Java for the COS201 course.