Mastering Polymorphism with Interfaces in C#
🚀 Introduction
Hey there, future C# pro! 🎯 Have you ever wondered how different classes can share a common behavior while implementing their own unique way of doing things? That’s where Polymorphism with Interfaces in C# comes in!
Imagine you’re playing a video game. You press the same “Jump” button, but different characters (a human, a robot, or a bird) jump in their own unique ways. That’s polymorphism in action! 🎮
📚 What You Are Going to Learn in This Lesson
✔️ What is Polymorphism with Interfaces in C#?
✔️ Why do we need it?
✔️ Syntax and explanation 📝
✔️ Hands-on coding examples 💻
✔️ A real-world example to make it crystal clear 🌎
✔️ Common mistakes and best practices 🏆
🧐 What is Polymorphism with Interfaces in C#?
Polymorphism means “many forms.” When a class implements an interface, it provides its own version of the methods declared in that interface.
An interface only defines what needs to be done, but the class decides how to do it!
❓ Why is Polymorphism with Interfaces in C# Important?
✅ Encourages code reusability
✅ Supports multiple inheritance (since a class can implement multiple interfaces)
✅ Makes code flexible and scalable
✅ Helps decouple code for better maintainability
📌 Syntax of Interfaces in C#
interface IAnimal
{
void MakeSound(); // Method without implementation
}
class Dog : IAnimal
{
public void MakeSound()
{
Console.WriteLine("Dog says: Woof! 🐶");
}
}
class Cat : IAnimal
{
public void MakeSound()
{
Console.WriteLine("Cat says: Meow! 🐱");
}
}
💻 Example 1: Basic Polymorphism with Interfaces
using System;
interface IShape
{
void Draw();
}
class Circle : IShape
{
public void Draw()
{
Console.WriteLine("Drawing a Circle 🟢");
}
}
class Square : IShape
{
public void Draw()
{
Console.WriteLine("Drawing a Square 🟥");
}
}
class Program
{
static void Main()
{
IShape shape1 = new Circle();
IShape shape2 = new Square();
shape1.Draw();
shape2.Draw();
}
}
🏆 Output:
Drawing a Circle 🟢
Drawing a Square 🟥
🔍 Explanation
- IShape is an interface that defines a method
Draw(). - Circle and Square classes implement the interface and provide their own versions of
Draw(). - In
Main(), we use polymorphism by assigning objects ofCircleandSquareto theIShapetype. - When we call
Draw(), it executes the method specific to the actual object.
🌍 Real-World Example: Payment System
Imagine an online shopping website 🛒. Users can pay with a credit card, PayPal, or cryptocurrency. Each payment method follows the same process but has different implementations.
using System;
interface IPayment
{
void ProcessPayment(double amount);
}
class CreditCard : IPayment
{
public void ProcessPayment(double amount)
{
Console.WriteLine($"Processing Credit Card Payment of ${amount} 💳");
}
}
class PayPal : IPayment
{
public void ProcessPayment(double amount)
{
Console.WriteLine($"Processing PayPal Payment of ${amount} 🅿️");
}
}
class Bitcoin : IPayment
{
public void ProcessPayment(double amount)
{
Console.WriteLine($"Processing Bitcoin Payment of ${amount} ₿");
}
}
class Program
{
static void Main()
{
IPayment paymentMethod;
paymentMethod = new CreditCard();
paymentMethod.ProcessPayment(100);
paymentMethod = new PayPal();
paymentMethod.ProcessPayment(50);
paymentMethod = new Bitcoin();
paymentMethod.ProcessPayment(200);
}
}
🏆 Output:
Processing Credit Card Payment of $100 💳
Processing PayPal Payment of $50 🅿️
Processing Bitcoin Payment of $200 ₿
🔍 Explanation
IPaymentdefines aProcessPayment()method.CreditCard,PayPal, andBitcoinimplementIPaymentin different ways.- In
Main(), we assign different payment methods to theIPaymenttype and callProcessPayment(). - The correct method runs based on the actual object.
⚠️ Common Mistakes and Best Practices
❌ Mistake: Forgetting to implement all methods from an interface.
✅ Fix: Always provide implementations for all interface methods.
❌ Mistake: Trying to create an object of an interface.
✅ Fix: You cannot instantiate an interface directly. Use a class that implements it.
🎯 Conclusion
You did it! 🎉 Now you understand Polymorphism with Interfaces in C# and why it’s so powerful. Interfaces allow us to enforce a contract in different classes while enabling flexibility. Whether it’s drawing shapes, processing payments, or handling game characters, interfaces make it easy to achieve polymorphism.
👉 Keep practicing! Try creating your own interfaces and implementing them in different ways.
⏭️ Next What?
In the next chapter, you will learn Polymorphism with Abstract Classes in C#. It’s going to be another fun ride! Stay tuned. 🚀
