FreeBasic Extends Keyword

last modified June 16, 2025

The FreeBasic Extends keyword enables inheritance in object-oriented programming. It allows a derived type to inherit members from a base type. Inheritance promotes code reuse and hierarchical relationships between types.

Basic Definition

In FreeBasic, Extends creates an inheritance relationship between types. The derived type inherits all fields and methods from the base type. The derived type can add new members or override inherited ones.

Inheritance follows an "is-a" relationship. For example, a Dog extends Animal because a dog is an animal. The base type is more general, while derived types are more specific.

Simple Inheritance

This example demonstrates basic inheritance using the Extends keyword.

extends_simple.bas

Type Animal
    Public:
        name As String
        Declare Constructor(name As String)
        Declare Sub MakeSound()
End Type

Constructor Animal(name As String)
    This.name = name
End Constructor

Sub Animal.MakeSound()
    Print "Some generic animal sound"
End Sub

Type Dog Extends Animal
    Public:
        Declare Constructor(name As String)
        Declare Sub MakeSound()
End Type

Constructor Dog(name As String)
    Base(name)
End Constructor

Sub Dog.MakeSound()
    Print name; " says: Woof!"
End Sub

Dim d As Dog = Dog("Rex")
d.MakeSound()

Here, Dog extends Animal, inheriting its name field. The Dog constructor calls the base constructor using Base(). Dog overrides MakeSound() with its own implementation. This demonstrates polymorphism in action.

Accessing Base Class Members

Derived types can access base class members using the Base keyword.

extends_base.bas

Type Vehicle
    Public:
        speed As Integer
        Declare Constructor(speed As Integer)
        Declare Sub Display()
End Type

Constructor Vehicle(speed As Integer)
    This.speed = speed
End Constructor

Sub Vehicle.Display()
    Print "Speed: "; speed; " km/h"
End Sub

Type Car Extends Vehicle
    Public:
        model As String
        Declare Constructor(model As String, speed As Integer)
        Declare Sub Display()
End Type

Constructor Car(model As String, speed As Integer)
    Base(speed)
    This.model = model
End Constructor

Sub Car.Display()
    Base.Display()
    Print "Model: "; model
End Sub

Dim c As Car = Car("Toyota", 120)
c.Display()

The Car type extends Vehicle and adds a model field. Its Display() method calls the base class Display() before adding its own output. Base allows accessing the immediate parent's members.

Multi-level Inheritance

FreeBasic supports multi-level inheritance chains.

extends_multilevel.bas

Type Person
    Public:
        name As String
        Declare Constructor(name As String)
End Type

Constructor Person(name As String)
    This.name = name
End Constructor

Type Employee Extends Person
    Public:
        id As Integer
        Declare Constructor(name As String, id As Integer)
End Type

Constructor Employee(name As String, id As Integer)
    Base(name)
    This.id = id
End Constructor

Type Manager Extends Employee
    Public:
        department As String
        Declare Constructor(name As String, id As Integer, department As String)
        Declare Sub Display()
End Type

Constructor Manager(name As String, id As Integer, department As String)
    Base(name, id)
    This.department = department
End Constructor

Sub Manager.Display()
    Print "Name: "; name
    Print "ID: "; id
    Print "Department: "; department
End Sub

Dim m As Manager = Manager("Alice", 1001, "Engineering")
m.Display()

This shows a three-level inheritance hierarchy: Manager extends Employee, which extends Person. Each derived type adds new fields while inheriting all previous ones. The Manager constructor chains through both parent constructors.

Overriding Methods

Derived types can override base type methods to provide specialized behavior.

extends_override.bas

Type Shape
    Public:
        Declare Function Area() As Double
End Type

Function Shape.Area() As Double
    Return 0
End Function

Type Circle Extends Shape
    Public:
        radius As Double
        Declare Constructor(radius As Double)
        Declare Function Area() As Double
End Type

Constructor Circle(radius As Double)
    This.radius = radius
End Constructor

Function Circle.Area() As Double
    Return 3.14159 * radius * radius
End Function

Type Square Extends Shape
    Public:
        side As Double
        Declare Constructor(side As Double)
        Declare Function Area() As Double
End Type

Constructor Square(side As Double)
    This.side = side
End Constructor

Function Square.Area() As Double
    Return side * side
End Function

Dim shapes(1 To 2) As Shape Ptr
shapes(1) = New Circle(5.0)
shapes(2) = New Square(4.0)

For i As Integer = 1 To 2
    Print "Area: "; shapes(i)->Area()
    Delete shapes(i)
Next

Shape defines a generic Area() method. Circle and Square override it with their specific implementations. The array of Shape pointers demonstrates polymorphism - calling Area() invokes the appropriate derived class implementation.

Abstract Base Class

FreeBasic can simulate abstract base classes using pure virtual methods.

extends_abstract.bas

Type Animal Abstract
    Public:
        Declare Abstract Sub Speak()
End Type

Type Cat Extends Animal
    Public:
        Declare Sub Speak()
End Type

Sub Cat.Speak()
    Print "Meow"
End Sub

Type Dog Extends Animal
    Public:
        Declare Sub Speak()
End Type

Sub Dog.Speak()
    Print "Woof"
End Sub

Dim animals(1 To 2) As Animal Ptr
animals(1) = New Cat()
animals(2) = New Dog()

For i As Integer = 1 To 2
    animals(i)->Speak()
    Delete animals(i)
Next

The Animal type is marked Abstract with an Abstract Speak() method. Derived types must implement Speak(). This enforces an interface that all animals must follow. The Abstract keyword prevents instantiation of the base class.

Multiple Inheritance with Interfaces

FreeBasic supports multiple inheritance through abstract interfaces.

extends_interface.bas

Type IPrintable Abstract
    Public:
        Declare Abstract Sub Print()
End Type

Type IScannable Abstract
    Public:
        Declare Abstract Sub Scan()
End Type

Type Printer
    Public:
        Declare Sub Print()
End Type

Sub Printer.Print()
    Print "Printing document..."
End Sub

Type Scanner
    Public:
        Declare Sub Scan()
End Type

Sub Scanner.Scan()
    Print "Scanning document..."
End Sub

Type MultiFunctionDevice Extends Printer, Scanner
    Public:
        Declare Sub Fax()
End Type

Sub MultiFunctionDevice.Fax()
    Print "Sending fax..."
End Sub

Dim mfd As MultiFunctionDevice
mfd.Print()
mfd.Scan()
mfd.Fax()

This demonstrates multiple inheritance. MultiFunctionDevice inherits from both Printer and Scanner. Each parent type implements a different interface. The derived type combines all capabilities and adds new ones.

Constructor Chaining

Constructors in inheritance hierarchies must properly chain to base constructors.

extends_constructors.bas

Type BaseType
    Public:
        value As Integer
        Declare Constructor(v As Integer)
End Type

Constructor BaseType(v As Integer)
    value = v
    Print "BaseType constructor: "; value
End Constructor

Type DerivedType Extends BaseType
    Public:
        text As String
        Declare Constructor(v As Integer, t As String)
End Type

Constructor DerivedType(v As Integer, t As String)
    Base(v)
    text = t
    Print "DerivedType constructor: "; text
End Constructor

Dim d As DerivedType = DerivedType(42, "Hello")
Print "Final object: "; d.value; ", "; d.text

The DerivedType constructor must call the BaseType constructor using Base(). Constructors are called from the base up to the most derived type. Fields are initialized in the same order. Proper constructor chaining ensures complete object initialization.

Best Practices

Design: Use inheritance only for true "is-a" relationships.
Depth: Limit inheritance depth to 2-3 levels for clarity.
Composition: Prefer composition over deep inheritance.
Abstract: Use abstract base classes to define interfaces.
Virtual: Mark methods as virtual when they should be overridable.

This tutorial covered the FreeBasic Extends keyword with practical examples showing inheritance in different scenarios. Proper use of inheritance leads to cleaner, more maintainable code.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all FreeBasic Tutorials.

Ebooks