Polymorphism

Static (compile-time) vs dynamic (run-time) polymorphism

Polymorphism is an essential concept in object-oriented programming that allows objects to be treated as instances of their parent class rather than their actual class. It enables a single interface to represent different types of behaviors. Polymorphism is categorized into static and dynamic based on when the method to be executed is determined.

Static polymorphism (compile-time)

• Also known as method overloading or operator overloading
• Occurs when multiple methods have the same name but different parameters within the same class
• The method to be executed is resolved at compile time based on the method signature
• Improves performance due to early binding
• Example: a print method that takes either a string, an integer, or a double

Characteristics of static polymorphism

• Implemented using method overloading or operator overloading
• Compiler determines which method version to execute
• Does not support run-time decision making
• Cannot override static polymorphic behavior in subclasses

Dynamic polymorphism (run-time)

• Also known as method overriding
• Occurs when a subclass provides a specific implementation of a method that is already defined in its parent class
• The method call is resolved at runtime based on the object type
• Supports runtime flexibility and late binding
• Example: a base class Animal with a method speak, and subclasses like Dog and Cat each overriding it

Characteristics of dynamic polymorphism

• Implemented using method overriding
• Uses dynamic dispatch to determine the method to call at runtime
• Enables polymorphic behavior through inheritance and interfaces
• Requires method signatures to be identical in both base and derived classes

Key differences

• Static polymorphism is resolved during compilation, while dynamic polymorphism is resolved during execution
• Static polymorphism uses method overloading, whereas dynamic polymorphism uses method overriding
• Static polymorphism cannot adapt behavior at runtime, but dynamic polymorphism can
• Dynamic polymorphism is more flexible and supports polymorphic substitution through upcasting

Both static and dynamic polymorphism enhance code readability and maintainability, but dynamic polymorphism is generally preferred in systems that require flexibility and extensibility through inheritance and interfaces.

Method Overloading

Method overloading is a feature in object-oriented programming that allows a class to have more than one method with the same name but different parameters. It enhances code readability and enables multiple ways to perform similar operations with different inputs.

Definition and concept

• Occurs when two or more methods in the same class have the same name but different parameter lists
• Parameter differences can include the number of parameters, the types of parameters, or their sequence
• Return type can be different but cannot be the only difference
• Method selection is resolved at compile time, making it a form of static polymorphism

Purpose of method overloading

• Increases code reusability by allowing the same method name to perform related tasks with various inputs
• Improves readability and reduces the need to create uniquely named methods for every variation
• Provides cleaner and more intuitive APIs for classes

How it works

• The compiler differentiates the methods based on the method signature, which includes method name and parameter types
• Overloaded methods must be in the same class or one can be inherited from a superclass
• Return type alone is not enough to distinguish overloaded methods

Examples of method overloading

• A method calculate(int a, int b) adds two integers
• Another method calculate(double a, double b) adds two decimal numbers
• A third version calculate(int a, int b, int c) adds three integers

Advantages of method overloading

• Makes code cleaner and reduces complexity
• Allows flexibility in the number and type of inputs passed to a method
• Enables developers to use the same method name for related operations

Rules for method overloading

• Must change the number or type of parameters
• Changing the order of parameters can create a valid overload if parameter types are different
• Cannot overload solely by changing return type or access modifier

Method overloading is a core technique in building flexible and intuitive interfaces in object-oriented programming. It supports static polymorphism and helps in managing variations of the same logical operation without confusing method names.

Method Overriding

Method overriding is an object-oriented programming feature that allows a subclass to provide a specific implementation of a method that is already defined in its superclass. This enables runtime polymorphism, allowing behavior to be determined dynamically based on the object instance.

Definition and concept

• Occurs when a subclass declares a method with the same name, return type, and parameters as a method in its superclass
• The overriding method replaces the parent class method when called through the subclass object
• It is used to implement behavior specific to the subclass while preserving a consistent interface

Purpose of method overriding

• Allows a subclass to define customized behavior for an inherited method
• Supports runtime polymorphism where method calls are resolved dynamically based on the object type
• Enhances code flexibility, maintainability, and extensibility

How it works

• The method in the subclass must have the exact same method signature as in the superclass
• When the method is called on a subclass instance, the subclass version is executed, even if the object is referenced using a superclass variable
• The superclass version can still be accessed using the super keyword

Rules for method overriding

• The method must be inherited from the superclass
• The method name, return type, and parameter list must match exactly
• The access level of the overriding method cannot be more restrictive than the overridden method
• Final, static, and private methods cannot be overridden
• Constructors cannot be overridden

Example scenario

• A base class Animal has a method speak
• A subclass Dog overrides the speak method to provide its own implementation, such as printing “Bark”
• When speak is called on a Dog object, the Dog version is executed

Benefits of method overriding

• Supports dynamic method dispatch, enabling runtime decision-making
• Improves flexibility by allowing subclasses to change or extend base class behavior
• Encourages consistent interfaces and polymorphic usage

Method overriding is a key element of dynamic polymorphism. It allows subclasses to provide their own behavior for methods defined in a parent class, making systems more flexible and adaptable to change without modifying the base implementation.

Using interfaces or abstract classes (language-dependent)

Interfaces and abstract classes are both used in object-oriented programming to define contracts or blueprints for other classes to follow. They provide a way to achieve abstraction, but their usage and behavior vary depending on the programming language being used.

Concept of Abstraction

• Abstraction is the process of hiding the implementation details and showing only the essential features
• Interfaces and abstract classes help in defining a standard structure without providing full implementations

Abstract classes

• Cannot be instantiated directly and must be subclassed
• May contain both abstract methods (without implementation) and concrete methods (with implementation)
• Can have fields (variables), constructors, and access modifiers
• Used when classes share a common base and some default behavior is needed

Interfaces Classes

• Define a contract that classes must implement without providing any implementation themselves (in most languages)
• Cannot contain constructors or instance variables (except constants)
• Used to represent capabilities or behaviors that can be applied to unrelated classes
• In some languages like Java 8+, interfaces can have default and static methods

Key differences

• Abstract classes support partial implementation, while interfaces generally do not (except default methods in some languages)
• A class can inherit only one abstract class (single inheritance) but can implement multiple interfaces (multiple inheritance)
• Abstract classes are used for hierarchical relationships, whereas interfaces are used for capability-based design
• Abstract classes may maintain state through instance variables; interfaces cannot (except constants)

Language-dependent behavior

• In Java: abstract classes can include both abstract and concrete methods; interfaces are purely abstract (with default/static methods in later versions)
• In C#: abstract classes can contain full and partial implementations; interfaces cannot have any implementation prior to C# 8
• In Python: abstract classes are created using the abc module; interfaces are typically simulated using abstract base classes

When to use an abstract class

• When you need a base class with shared behavior among related classes
• When you want to provide some common functionality that can be reused
• When you need to maintain a class hierarchy

When to use an interface

• When unrelated classes need to follow the same contract
• When you want to enforce certain behavior without dictating how it’s implemented
• When multiple inheritance of type is required

Both interfaces and abstract classes serve the purpose of abstraction, but their use depends on the design goals and the capabilities of the programming language. Choosing between them requires an understanding of the relationship between classes and the level of flexibility required in the system.