Definition of the polymorphic problem.

Mariusz Postol

Recently I defined Object-oriented programming (OOP) as a program design pattern where employing abstraction and inheritance we can solve polymorphic problems including but not limited to decoupling. Polymorphism refers to the use of an abstraction to represent multiple different concrete types. Do you know a better and shorter definition?

9 Replies

Know the answer? Post it — somebody with the same question will find it here.

Sarthak Varshney2y ago
Accepted answer
Let's address your points systematically to clarify the distinctions and how polymorphism fits into different stages of programming.

1. Interface-based vs. Inheritance-based Polymorphism

Inheritance-based Polymorphism:
- Involves a base class (often abstract) and derived classes.
- Derived classes inherit from the base class and can override its methods.
- Polymorphism is achieved by treating objects of derived classes as instances of the base class.
Example:
```
abstract class Animal {
    public abstract void MakeSound();
}

class Dog : Animal {
    public override void MakeSound() {
        Console.WriteLine("Bark");
    }
}
```
Interface-based Polymorphism:
- Involves an interface which defines a contract that classes must implement.
- Classes implement the interface, providing concrete behavior for its methods.
- Polymorphism is achieved by treating objects of implementing classes as instances of the interface.
Example:
```
interface IAnimal {
    void MakeSound();
}

class Dog : IAnimal {
    public void MakeSound() {
        Console.WriteLine("Bark");
    }
}
```
Difference:
- Inheritance-based polymorphism relies on a class hierarchy where a base class provides a common interface, and derived classes provide specific implementations.
- Interface-based polymorphism relies on interfaces that can be implemented by any class, offering more flexibility because a class can implement multiple interfaces.
2. Operator Overloading vs. Method Overloading

Method Overloading:
- Allows multiple methods in the same class to have the same name but different parameters.
- Achieved by defining methods with the same name but different signatures (parameter lists).
Example:
```
class MathOperations {
    public int Add(int a, int b) {
        return a + b;
    }

    public double Add(double a, double b) {
        return a + b;
    }
}
```
Operator Overloading:
- Allows customizing the behavior of operators (like +, -, *, etc.) for user-defined types.
- Achieved by defining special methods in a class that specify the behavior of operators.
Example:
```
class Complex {
    public int Real, Imag;
    public Complex(int r, int i) {
        Real = r;
        Imag = i;
    }

    public static Complex operator + (Complex c1, Complex c2) {
        return new Complex(c1.Real + c2.Real, c1.Imag + c2.Imag);
    }
}
```
Difference:
- Method overloading is about having multiple methods with the same name but different parameters in the same scope.
- Operator overloading is about redefining how operators work with user-defined types.
3. Delegate Types and Variables

Delegates:
- Delegates are types that represent references to methods with a specific signature.
- They provide a way to encapsulate a method call as an object and pass it as a parameter.
- Delegates support polymorphism by allowing different methods to be assigned to the same delegate type.
Example:
```
public delegate void DisplayMessage(string message);

class Program {
    static void Main() {
        DisplayMessage messageDelegate = Console.WriteLine;
        messageDelegate("Hello, World!");
    }
}
```
Polymorphism in Different Stages

a. Algorithm Stage:
- At this stage, polymorphism is a conceptual problem where you need a way to handle different types uniformly.
- Example: An algorithm that processes different shapes (circle, square, etc.) in a uniform manner.
b. Program Design Stage:
- At design time, polymorphism is part of the solution. The programming language provides constructs (like inheritance, interfaces, and delegates) to implement polymorphism.
- Example: Designing an interface IShape with a method Draw that different shape classes implement.
c. Program Run Time:
- At runtime, polymorphism is observed when the program executes and different types are processed through a common interface or base class.
- Example: Creating a list of IShape objects and calling Draw on each, regardless of the actual shape type.
Conclusion
- Polymorphism as a concept addresses the need to handle different types in a uniform way (problem in the algorithm stage).
- Language Constructs like inheritance, interfaces, method overloading, operator overloading, and delegates are tools provided by the programming language to implement polymorphism (solution at design time).
- Runtime Behavior: Polymorphism is realized at runtime, allowing different types to be treated as instances of a common interface or base class, enabling flexible and reusable code (observed at runtime).
Mariusz Postol2y ago
@Sarthak Varshney - good point. Thanks.

1. Not sure what is the difference between interface-based and inheritance-based polymorphism- interface can be recognized as an abstract class

2. The same question is for operator-overloading and method overloading

3. I agree that method overloading can be recognized as a polymorphism form, but what about delegate types and variables?

In conclusion, to answer my doubts we need to consider three stages of the program, namely (a) the algorithm, (b) program design time, and (c) program run time. (a) Talking about algorithms ( knowledge required to solve a problem) polymorphism is a problem that we must address by a program. (b) Talking about the design stage the programming language should support constructs that can be applied to implement the polymorphism. In other words, at design time it is part of the solution. (c) At run-time polymorphism may be only observed to improve the program in the future and get back to the design stage.
Sarthak Varshney2y ago
Yes, besides inheritance, there are other ways to achieve polymorphism in object-oriented programming. Here are the primary ways:

1. Inheritance-based Polymorphism

This is the most common form of polymorphism where a subclass inherits from a superclass and overrides its methods. Objects of the subclass can be treated as objects of the superclass.

Example:
```
class Animal {
    public virtual void MakeSound() {
        Console.WriteLine("Some generic animal sound");
    }
}

class Dog : Animal {
    public override void MakeSound() {
        Console.WriteLine("Bark");
    }
}

// Usage
Animal myAnimal = new Dog();
myAnimal.MakeSound(); // Outputs: Bark
```
2. Interface-based Polymorphism

This involves defining interfaces that different classes implement. This allows for different classes to be treated polymorphically through the interface they implement.

Example:
```
interface IShape {
    void Draw();
}

class Circle : IShape {
    public void Draw() {
        Console.WriteLine("Drawing Circle");
    }
}

class Square : IShape {
    public void Draw() {
        Console.WriteLine("Drawing Square");
    }
}

// Usage
IShape myShape = new Circle();
myShape.Draw(); // Outputs: Drawing Circle
```
3. Method Overloading

Method overloading allows multiple methods in the same class to have the same name but different parameters. This is also considered a form of compile-time polymorphism.

Example:
```
class MathOperations {
    public int Add(int a, int b) {
        return a + b;
    }

    public double Add(double a, double b) {
        return a + b;
    }
}

// Usage
MathOperations math = new MathOperations();
Console.WriteLine(math.Add(5, 3)); // Outputs: 8
Console.WriteLine(math.Add(5.2, 3.3)); // Outputs: 8.5
```
4. Operator Overloading

In languages that support operator overloading, you can define or change the behaviour of operators for user-defined types.

Example in C++:
```
class Complex {
public:
    int real, imag;
    Complex(int r, int i) : real(r), imag(i) {}

    Complex operator + (const Complex& obj) {
        return Complex(real + obj.real, imag + obj.imag);
    }
};

// Usage
Complex c1(3, 4), c2(1, 2);
Complex c3 = c1 + c2;
```
Summary
- Inheritance-based Polymorphism: Achieved through subclasses overriding methods of the superclass.
- Interface-based Polymorphism: Achieved by implementing common interfaces.
- Method Overloading: Multiple methods with the same name but different parameters.
- Operator Overloading: Customizing the behaviour of operators for user-defined types.
There are various ways to achieve polymorphism in object-oriented programming, each providing different mechanisms for treating objects in a polymorphic manner.
Mariusz Postol2y ago
@Sarthak Varshney, - many thanks for your point - it looks like a common one. Last question. You said "Inheritance is one way to achieve polymorphism" - do you know another one?
Sarthak Varshney2y ago
You're absolutely correct. Inheritance and polymorphism are related concepts in object-oriented programming, but they are not interchangeable. Let's clarify the relationship between them and how they contribute to solving problems in OOP.
Inheritance:
Inheritance is a mechanism in object-oriented programming where a class (subclass or derived class) inherits properties and behaviors (methods) from another class (superclass or base class). It promotes code reusability by allowing a new class to inherit the characteristics of an existing class.
Polymorphism:
Polymorphism is the ability of different objects to respond to the same message (method call) in different ways. It allows objects of different types to be treated as objects of a common superclass. Polymorphism enables flexibility and extensibility in the code by providing a single interface to entities of different types.
Relationship:
- Inheritance facilitates Polymorphism: Inheritance is one way to achieve polymorphism. By inheriting from a common superclass, subclasses can share common behavior and be treated polymorphically.
- Polymorphism can exist without Inheritance: Polymorphism can also be achieved through other mechanisms like interface implementation, method overriding, and method overloading, without relying on class inheritance.
Conclusion:
In summary, while inheritance is one mechanism to enable polymorphism, polymorphism itself is a broader concept that encompasses various ways objects can behave differently in response to the same message. They are complementary concepts in OOP, with inheritance facilitating polymorphism but not replacing its concise definition.
Mariusz Postol2y ago
@Sarthak Varshney, I agree, but my concern is if Inheritance can replace the CONCISE DEFINITION of polymorphism.
I point out that something cannot simultaneously be a problem and a solution.
Sarthak Varshney2y ago
Polymorphism in OOP:

Polymorphism is a fundamental concept in object-oriented programming (OOP) that allows objects of different types to be treated as objects of a common supertype. It enables a single interface to represent different underlying forms (data types).
- As a Problem: Polymorphism addresses the problem of writing flexible and reusable code that can operate on objects of different types in a uniform manner.
- As a Solution: Polymorphism provides a solution by allowing methods to process objects of various types through a common interface, reducing code duplication and increasing the modularity and extensibility of the codebase.
Concise Definition:

Polymorphism is an OOP principle that allows objects of different types to be accessed through the same interface, enabling one interface to control access to a general class of actions. This supports code flexibility and reuse.

This definition captures both the essence of polymorphism and its role in solving specific problems in OOP.
Mariusz Postol2y ago
@Sarthak Varshney - I am sorry but I didn't ask what "Polymorphism allows" but what it is. It is two different questions.

To be precise:

1. It is a problem to be solved using OOP or alternatively
2. It is part of the solution
Sarthak Varshney2y ago
Object-oriented programming (OOP) is a programming paradigm based on the concepts of objects, which can contain data and methods. It leverages key principles like encapsulation, inheritance, and polymorphism to create modular, reusable, and maintainable code. Polymorphism allows objects of different types to be treated as instances of a common superclass.