Inheritance and Interfaces

Analogy categoryAnalogies

Inheritance Fundamentals

Inheritance lets a derived class acquire the fields, properties, and methods of a base class using the Inherits keyword placed as the first statement inside the class block. A class like Vehicle can define common behavior such as Accelerate(), and a derived class Car Inherits Vehicle automatically gains that method without rewriting it, letting VB.NET developers model 'is-a' relationships and reuse code across a class hierarchy.

🏏

Cricket analogy: A domestic first-class team feeding players into the national squad is like a base class Vehicle passing down core skills to a derived class Car -- India's Test team inherits batting fundamentals every player already built at the Ranji Trophy level.

Overriding and Extending Base Behavior

Because members are NotOverridable by default in VB.NET, a base class method must be explicitly marked Overridable before a derived class can replace its implementation using Overrides. Inside an overridden method, MyBase.MethodName() lets the derived class still call the original base implementation, so behavior can be extended rather than completely replaced.

🏏

Cricket analogy: A base class's standard bowling run-up marked Overridable lets a fast bowler like Jasprit Bumrah override it with his own unique action, while still calling MyBase for the core delivery-stride mechanics underneath.

vbnet

Public Class Vehicle
    Public Overridable Function DescribeSelf() As String
        Return "A generic vehicle"
    End Function
End Class

Public Class Car
    Inherits Vehicle

    Public Overrides Function DescribeSelf() As String
        Return MyBase.DescribeSelf() & " that is specifically a car"
    End Function
End Class

Dim v As Vehicle = New Car()
Console.WriteLine(v.DescribeSelf())  ' A generic vehicle that is specifically a car

Once a derived class overrides a member, you can prevent further overriding down the hierarchy by marking that override NotOverridable Overrides, sealing the implementation at that level.

Defining and Implementing Interfaces

An Interface defines a contract of member signatures with no implementation -- just Sub, Function, or Property declarations that any implementing class must fulfil using the Implements keyword. Unlike a base class, an interface carries no shared code or state; it only guarantees that a class exposing IShape will provide a working CalculateArea() Function, regardless of how that class internally computes it.

🏏

Cricket analogy: The ICC playing conditions document that every umpire must follow is like an Interface -- it specifies what decisions, such as LBW or no-ball, must be made without dictating exactly how each umpire mentally reaches them.

vbnet

Public Interface IShape
    Function CalculateArea() As Double
End Interface

Public Class Circle
    Implements IShape

    Private radius As Double

    Public Sub New(r As Double)
        radius = r
    End Sub

    Public Function CalculateArea() As Double Implements IShape.CalculateArea
        Return Math.PI * radius * radius
    End Function
End Class

Multiple Interface Implementation vs Single Inheritance

VB.NET classes may Inherit from only one base class, avoiding the ambiguity of the diamond problem, but a class can Implement any number of interfaces simultaneously by listing them comma-separated after Implements. This lets a Duck class inherit from a single Animal base while also implementing both ISwimmable and IFlyable, combining multiple independent capability contracts without needing multiple base classes.

🏏

Cricket analogy: A cricketer can only ever officially represent one national team, single inheritance, like Virat Kohli playing solely for India, but can hold multiple certifications simultaneously, like being both an ICC-accredited commentator and a coach, mirroring multiple interfaces.

VB.NET's Implements clause requires each interface member to be explicitly mapped with Implements InterfaceName.MemberName on the implementing member -- unlike C#, matching names and signatures alone is not enough to satisfy the interface.

Inherits gives a derived class the fields, properties, and methods of exactly one base class.
A member must be marked Overridable in the base class before Overrides can replace it in a derived class.
MyBase.MethodName() calls the original base implementation from inside an override.
An Interface defines a contract of member signatures with no implementation or state.
Implements InterfaceName.MemberName explicitly maps a class member to an interface requirement.
A class can Inherit from only one base class but can Implement any number of interfaces.
MustOverride/MustInherit combinations force concrete subclasses to supply their own implementation.