Inheritance in C#

# CHAPTER 15

Inheritance in C# #

1. Introduction #

2. Learning Objectives #

• Define Base (Parent) and Derived (Child) classes.

• Use the : syntax to establish inheritance.

• Use the protected access modifier.

• Understand the virtual and override keywords.

• Prevent inheritance using the sealed keyword.

3. Base and Derived Classes #

using System;

// 1. The Base Class (Parent)
class Enemy
{
    public int Health { get; set; } = 100;

    public void Move()
    {
        Console.WriteLine("Enemy moves forward.");
    }
}

// 2. The Derived Class (Child)
// Goblin INHERITS FROM Enemy
class Goblin : Enemy
{
    public void StealGold()
    {
        Console.WriteLine("Goblin stole 10 gold!");
    }
}

class Program
{
    static void Main()
    {
        Goblin myGoblin = new Goblin();
        
        // Goblin has access to its own methods...
        myGoblin.StealGold();
        
        // ... AND all public methods/properties from the Enemy class!
        myGoblin.Move();
        Console.WriteLine($"Goblin Health: {myGoblin.Health}");
    }
}

4. The protected Access Modifier #

class Enemy
{
    protected int attackPower = 50; // Hidden from Main(), visible to Goblin
}

class Goblin : Enemy
{
    public void Attack()
    {
        Console.WriteLine($"Goblin attacks for {attackPower} damage!"); // Allowed!
    }
}

5. virtual and override (Method Overriding) #

class Enemy
{
    // virtual: "You are allowed to override me"
    public virtual void Shout()
    {
        Console.WriteLine("Ahhhh!");
    }
}

class Zombie : Enemy
{
    // override: "I am changing the parent's logic"
    public override void Shout()
    {
        Console.WriteLine("Braaaaiiinnnsss!");
    }
}

6. The base Keyword #

class Boss : Enemy
{
    public override void Shout()
    {
        base.Shout(); // Calls Enemy.Shout() ("Ahhhh!")
        Console.WriteLine("I am the Boss!"); // Adds new functionality
    }
}

7. The sealed Keyword #

sealed class MathEngine
{
    // No class can ever inherit from MathEngine
}

8. OOP and Memory Explanation #

9. Common Mistakes #

• Multiple Inheritance: C++ allows a class to inherit from two parent classes. C# does NOT. A class in C# can only have ONE direct base class. (We use Interfaces to get around this, covered in Chapter 18).

• Forgetting virtual: If you try to override a method that isn't marked virtual in the base class, the C# compiler will throw an error.

10. Best Practices #

• Favor "Composition over Inheritance". Do not create massive, 7-level deep inheritance chains. If the relationship isn't strictly an "Is-A" relationship (e.g., A Car "Is-A" Vehicle), do not use inheritance.

11. Exercises #

1. 1. Create a Vehicle base class with a Speed property and a Drive() method. Create a Motorcycle child class that inherits from it.

1. 2. Make the Drive() method virtual, and override it in the Motorcycle class to print "Zooming on two wheels!".

12. MCQs with Answers #

13. Interview Questions #

• Q: Explain the difference between virtual/override and method hiding (new keyword).

• Q: Why does C# not support multiple inheritance for classes?

• Q: Explain the exact visibility of the protected access modifier.

14. Summary #

15. Next Chapter Recommendation #