Inheritance, Polymorphism, and Interfaces are foundational concepts in Object-Oriented Programming (OOP) that enable the creation of scalable, modular, and reusable code. Understanding and applying these principles effectively is essential for building robust software systems. This guide explores these concepts in depth, with practical examples and scenarios where they are particularly useful.
1. Why Are These Concepts Important?
Scalability and Modularity
- Inheritance allows code reuse by enabling new classes to build upon existing ones.
- Polymorphism simplifies extensibility by allowing methods to behave differently based on the object type.
- Interfaces define contracts that ensure consistency while allowing flexibility in implementation.
When to Choose Inheritance vs Interfaces
- Use inheritance when you want to establish an "is-a" relationship (e.g., a Dog "is a" type of Animal).
- Use interfaces when you want to define capabilities or behaviours that multiple unrelated classes can share (e.g., a Bird and an Airplane can both implement IFlyable).
2. Inheritance
Inheritance allows a class (subclass) to inherit properties and methods from another class (superclass), promoting code reuse and hierarchy creation.
Practical Example of Inheritance
public class Animal
{
public string Name { get; set; }
public void Eat()
{
Console.WriteLine($"{Name} is eating.");
}
}
public class Dog : Animal
{
public void Bark()
{
Console.WriteLine($"{Name} is barking.");
}
}
// Using inheritance
Dog myDog = new Dog();
myDog.Name = "Buddy";
myDog.Eat();
myDog.Bark();
3. Polymorphism
Polymorphism allows methods to have different behaviours depending on the object type. This can be achieved through method overriding or interfaces.
Example of Polymorphism with Method Overriding
public class Bird
{
public virtual void Fly()
{
Console.WriteLine("The bird is flying.");
}
}
public class Eagle : Bird
{
public override void Fly()
{
Console.WriteLine("The eagle soars at great heights.");
}
}
// Using polymorphism
Bird myBird = new Eagle();
myBird.Fly(); // Output: The eagle soars at great heights.
4. Interfaces
An interface defines a contract that classes must adhere to, ensuring consistency while allowing flexibility in implementation.
Example of Interface Implementation
public interface IFlyable
{
void Fly();
}
public class Airplane : IFlyable
{
public void Fly()
{
Console.WriteLine("The airplane is flying.");
}
}
public class Bird : IFlyable
{
public void Fly()
{
Console.WriteLine("The bird is flying.");
}
}
// Using interfaces
IFlyable airplane = new Airplane();
IFlyable bird = new Bird();
airplane.Fly();
bird.Fly();
Handling Errors with Interfaces
Adding validations can make implementations more robust:
public class BankAccount
{
private decimal balance;
public void Deposit(decimal amount)
{
if (amount <= 0)
{
Console.WriteLine("Deposit amount must be greater than zero.");
return;
}
balance += amount;
Console.WriteLine($"Deposit successful. New balance: {balance}");
}
}
5. Combined Example: Inheritance, Polymorphism, and Interfaces
Let’s create a practical example that combines all three concepts:
public interface IDriveable
{
void Drive();
}
public class Vehicle
{
public string Make { get; set; }
public string Model { get; set; }
public virtual void DisplayInfo()
{
Console.WriteLine($"Vehicle: {Make} {Model}");
}
}
public class Car : Vehicle, IDriveable
{
public override void DisplayInfo()
{
Console.WriteLine($"Car: {Make} {Model}");
}
public void Drive()
{
Console.WriteLine("The car is driving.");
}
}
public class Motorcycle : Vehicle, IDriveable
{
public override void DisplayInfo()
{
Console.WriteLine($"Motorcycle: {Make} {Model}");
}
public void Drive()
{
Console.WriteLine("The motorcycle is driving.");
}
}
// Using the combined example
IDriveable car = new Car { Make = "Toyota", Model = "Corolla" };
IDriveable motorcycle = new Motorcycle { Make = "Harley-Davidson", Model = "Sportster" };
car.Drive();
motorcycle.Drive();
6. Advanced Concepts and Patterns
Patterns Related to These Concepts
- Strategy Pattern: Use interfaces to switch between algorithms dynamically.
- Template Method Pattern: Use inheritance to define a common structure with specific behaviours implemented by subclasses.
Example of the Strategy Pattern
public interface IShippingStrategy
{
decimal CalculateShipping(decimal weight);
}
public class StandardShipping : IShippingStrategy
{
public decimal CalculateShipping(decimal weight) => weight * 1.5m;
}
public class ExpressShipping : IShippingStrategy
{
public decimal CalculateShipping(decimal weight) => weight * 3.0m;
}
}
// Usage
IShippingStrategy strategy = new ExpressShipping();
Console.WriteLine($"Shipping cost: {strategy.CalculateShipping(10)}");
Top comments (0)