Скачать или смотреть C# - Part 24 - Polymorphism and Method Overriding - Tutorial For Beginners

In this video we will be learning about polymorphism in C#

Timestamps
00:00 Intro
00:14 Demo
03:00 Virtual and Overriding Method
07:20 Summary

Polymorphism: A Multifaceted Approach to Object Behavior

Polymorphism, a concept central to object-oriented programming (OOP), grants objects the ability to exhibit diverse behaviors in C#. Imagine actors playing different roles in a play – a single entity (the actor) can take on various identities (the roles). Similarly, objects in C# can showcase multiple functionalities depending on the context.

Two Avenues of Polymorphism: Compile Time and Runtime

C# offers polymorphism through two main channels:

1. Compile-Time Polymorphism (Static Binding):
The C# compiler makes decisions about which method to invoke at compile time. This occurs via two techniques:
Method Overloading: A class can define multiple methods with the same name but distinct parameter configurations (number, types, or order of parameters). The compiler selects the appropriate method based on the arguments provided when calling the method. This allows for handling different scenarios within a single class.
Operator Overloading: Specific operators (like addition, subtraction, or multiplication) can be redefined for custom classes to provide customized behavior when used with objects of those classes. This enhances code readability and intuitiveness.

Example (Method Overloading in Action):

Imagine a `Shape` class with separate `Draw` methods, one for drawing squares and another for circles. Based on whether you provide a side length or a radius when calling `Draw`, the compiler selects the appropriate method.

2. Runtime Polymorphism (Dynamic Binding):
Decisions regarding which method to execute are postponed until runtime. This leverages inheritance, a fundamental principle of OOP:
A base class acts as a blueprint, outlining methods and properties that derived classes (subclasses) inherit.
Derived classes can specialize or override inherited methods to provide their own implementations.
When a reference variable of a base class type holds an object of a derived class, runtime polymorphism comes into play. The actual method called depends on the object's dynamic type (the derived class it belongs to), not its declared type (the base class type of the reference variable).

Example (Method Overriding in Action):

Think of an `Animal` base class with a `MakeSound` method. Derived classes like `Dog` and `Cat` can override this method to produce barks and meows, respectively. When you call `MakeSound` on a reference variable of type `Animal` that points to a `Dog` object, the `Dog` class's overridden `MakeSound` method executes at runtime, resulting in a bark. This is runtime polymorphism in action.

Advantages of Polymorphism:

Flexibility: Code can adapt to various situations without substantial changes, making it easier to maintain.
Code Reusability: Well-designed base classes with well-defined methods and properties can be leveraged by derived classes, promoting code efficiency.
Design Patterns: Polymorphism facilitates the implementation of design patterns like the Strategy pattern, where algorithms can be swapped dynamically, or the Template Method pattern, which establishes a skeletal structure for operations with customizable steps.

Considerations When Using Polymorphism:

Clarity in Base Class Design: Base classes should provide clear contracts (method signatures and expected behavior) to guide derived class implementations.
Overriding vs. Hiding: When overriding methods, ensure the derived class implementation aligns with the intent of the base class method. Hiding, where the derived class completely overshadows the base class method, can lead to unexpected behavior.
Proper Use of `virtual` and `abstract` Keywords: The `virtual` keyword allows methods to be overridden, while `abstract` prevents objects from being directly instantiated from the base class, forcing derived classes to provide implementations.

In Essence:

Polymorphism is a powerful tool in C#'s object-oriented programming arsenal. By understanding its compile-time and runtime aspects, you can create well-structured, maintainable, and expressive C# applications.