Understanding OOPs Inheritance and Sealed Classes in C# with Examples
Object-Oriented Programming (OOP) is a fundamental paradigm in C# that revolves around the concepts of objects and classes. One of the key features of OOP is inheritance, which allows classes to inherit properties and methods from other classes. Another important concept in C# is the use of sealed classes, which prevent further inheritance. In this blog, we will delve into inheritance and sealed classes in C# with detailed explanations and valid examples.
Are you looking for Live Training in C#?
The upcoming batch for C#.NET is sceduled.
Book Your Seat Now.
What is Inheritance?
Inheritance is a mechanism in OOP that allows one class (called the derived or child class) to inherit fields and methods from another class (called the base or parent class). This promotes code reuse and establishes a natural hierarchy between classes.
Basic Example of Inheritance
Let’s consider a simple example where we have a base class Animal and a derived class Dog.
Example
// Base class
public class Animal
{
public void Eat()
{
Console.WriteLine("Animal is eating.");
}
}
// Derived class
public class Dog : Animal
{
public void Bark()
{
Console.WriteLine("Dog is barking.");
}
}
class Program
{
static void Main(string[] args)
{
Dog myDog = new Dog();
myDog.Eat(); // Inherited from Animal
myDog.Bark(); // Defined in Dog
}
}
In this example, the Dog class inherits the Eat method from the Animal class and adds its own method, Bark.
Sealed Classes
In C#, the sealed keyword is used to prevent a class from being inherited. This is useful when you want to restrict the inheritance of classes to ensure that certain functionality is not overridden or altered in derived classes.
Basic Example of a Sealed Class
Let’s modify the previous example to include a sealed class.
Example
// Base class
public class Animal
{
public void Eat()
{
Console.WriteLine("Animal is eating.");
}
}
// Derived class
public sealed class Dog : Animal
{
public void Bark()
{
Console.WriteLine("Dog is barking.");
}
}
// This will cause a compile-time error
// public class Bulldog : Dog
// {
// }
class Program
{
static void Main(string[] args)
{
Dog myDog = new Dog();
myDog.Eat(); // Inherited from Animal
myDog.Bark(); // Defined in Dog
}
}
In this example, the Dog class is sealed, which means no other class can inherit from it. Attempting to create a class that inherits from Dog will result in a compile-time error.
Are you looking for Live Training in C#?
The upcoming batch for C#.NET is sceduled.
Book Your Seat Now.
Combining Inheritance and Sealed Classes
Let’s take a more complex example where we have multiple levels of inheritance and use a sealed class to prevent further inheritance at a certain level.
Example
// Base class
public class Animal
{
public void Eat()
{
Console.WriteLine("Animal is eating.");
}
}
// Intermediate class
public class Mammal : Animal
{
public void Walk()
{
Console.WriteLine("Mammal is walking.");
}
}
// Sealed class
public sealed class Cat : Mammal
{
public void Meow()
{
Console.WriteLine("Cat is meowing.");
}
}
// This will cause a compile-time error
// public class PersianCat : Cat
// {
// }
class Program
{
static void Main(string[] args)
{
Cat myCat = new Cat();
myCat.Eat(); // Inherited from Animal
myCat.Walk(); // Inherited from Mammal
myCat.Meow(); // Defined in Cat
}
}
In this example, Cat is a sealed class that inherits from Mammal, which in turn inherits from Animal. The Cat class has its own method Meow, but no class can inherit from Cat due to the sealed keyword.
Practical Use Cases for Sealed Classes
Sealed classes are particularly useful in the following scenarios:
- Security: Preventing further inheritance can protect the class from being extended in potentially harmful ways.
- Performance: Sealed classes can sometimes offer performance optimizations since the runtime knows that no further derived classes exist.
- Design: Ensuring that certain classes are not modified through inheritance can help maintain the integrity of the class design.
Example in a Real-World Scenario
Consider a scenario where you have a library of utility classes, and you want to ensure that certain critical classes are not inherited or altered by users of the library.
Example
public class Utility
{
public void PerformAction()
{
Console.WriteLine("Performing an action.");
}
}
public sealed class CriticalUtility : Utility
{
public void PerformCriticalAction()
{
Console.WriteLine("Performing a critical action.");
}
}
class Program
{
static void Main(string[] args)
{
CriticalUtility criticalUtility = new CriticalUtility();
criticalUtility.PerformAction(); // Inherited from Utility
criticalUtility.PerformCriticalAction(); // Defined in CriticalUtility
}
}
In this example, CriticalUtility is a sealed class that ensures critical actions are not altered through inheritance, thus maintaining the integrity of the utility library.
Example Code
using System;
public class Animal
{
public void Eat()
{
Console.WriteLine("Animal is eating.");
}
}
public class Mammal : Animal
{
public void Walk()
{
Console.WriteLine("Mammal is walking.");
}
}
public sealed class Cat : Mammal
{
public void Meow()
{
Console.WriteLine("Cat is meowing.");
}
}
class Program
{
static void Main(string[] args)
{
Cat myCat = new Cat();
myCat.Eat(); // Inherited from Animal
myCat.Walk(); // Inherited from Mammal
myCat.Meow(); // Defined in Cat
}
}
By following this guide, you should now have a solid understanding of inheritance and sealed classes in C#, their differences, and how to use them effectively in your projects.
Conclusion
Understanding inheritance and sealed classes in C# is crucial for designing robust and maintainable object-oriented applications. Inheritance promotes code reuse and establishes class hierarchies, while sealed classes provide control over how classes can be extended. By following the principles and examples outlined in this blog, you can effectively leverage inheritance and sealed classes in your C# projects.
Are you looking for Live Training in C#?
The upcoming batch for C#.NET is sceduled.
Book Your Seat Now.