Swift Inheritance (original) (raw)

Last Updated : 23 Jul, 2025

Inheritance is one of the fundamental concepts of object-oriented programming (OOP) languages. It allows us to create a new class from an existing class and reuse the existing code and functionality. In this article, we will learn about inheritance in Swift and how to use it to create subclasses, override methods and properties, and implement polymorphism.

What is Inheritance?

Inheritance is a relationship between two classes, where one class inherits the methods, properties, and other characteristics from another class.

• The class that inherits from another class is called a **subclass and the class that is inherited from is called a **superclass.
• For example, if we have a class called Animal and another class called **Dog that inherits from **Animal, then **Dog is a subclass of Animal and Animal is a superclass of Dog.
• In Swift, we use the colon ":" to indicate that a class inherits from another class.

Below is a Swift program to implement inheritance:

Swift `

// Swift program to implement // Inheritance // Define a superclass class Animal {
// Property in the superclass var species: String = ""

// Method in the superclass func speak() { print("An animal of species (species) is making a sound.") } }

// Define a subclass that inherits from Animal class Dog: Animal { // Additional properties and methods in the subclass var breed: String = ""

func wagTail() { print("The dog of breed (breed) is wagging its tail.") } }

// Create an instance of Dog let myDog = Dog()

// Set values for properties myDog.species = "Canine" myDog.breed = "Golden Retriever"

// Access methods and properties // An animal of species Canine is making a sound. myDog.speak()

// The dog of breed Golden Retriever is wagging its tail. myDog.wagTail()

`

**Output:

An animal of species Canine is making a sound.
The dog of breed Golden Retriever is wagging its tail.

Explanation:

• In this code, we showcase the principles of inheritance in Swift. When a class inherits from a superclass, it gains access to the methods and properties of that superclass.
• This means that the **Dog subclass, in our example, inherits the **species property and the **speak method from its **Animal superclass.
• However, the power of inheritance extends beyond mere access. it enables us to extend and tailor the inherited functionalities. In the **Dog subclass, we introduce a new property named **breed and a method called **wagTail.
• This illustrates one of the primary advantages of inheritance – the ability to build on existing code while adding specialized behaviors.
• By following this approach, we effectively prevent the need to duplicate code across multiple classes.
• This not only streamlines our code but also enhances its modularity and maintainability.
• It's a prime example of how inheritance can help us create more efficient and adaptable software systems in Swift.

How to Override Methods and Properties?

Sometimes, we may want to modify or extend the behavior of a method or a property that is inherited from a superclass.

• For example, we may want to change how an animal makes noise or add more information to its description.
• To do this, we can override the method or property in the subclass and provide a new implementation.
• This is called method overriding or property overriding.
• In Swift, we use the **override keyword to indicate that we are overriding a method or a property in a subclass.

Below is Swift program to override methods and properties:

Swift `

// Swift program to override methods // and properties // Define a superclass class Animal { // Properties and methods of the superclass var name: String = ""

var description: String { return "I am an animal named (name)" }

func makeNoise() { print("I can make noise") } }

// Define a subclass that inherits from Animal class Dog: Animal { // Override the computed property override var description: String { return "I am a dog named (name)" }

// Override the method override func makeNoise() { print("I can bark") } }

// Create an instance of Dog let dog = Dog()

// Assign a name to the dog dog.name = "Rex"

// Access the overridden computed property // I am a dog named Rex print(dog.description)

// Call the overridden method // I can bark dog.makeNoise()

// Define a subclass that inherits from Dog class Labrador: Dog { // Override the computed property again override var description: String { return "I am a labrador named (name), (super.description)" } }

// Create an instance of Labrador let lab = Labrador()

// Assign a name to the labrador lab.name = "Max"

// Access the overridden computed property // I am a labrador named Max, I am a dog named Max print(lab.description)

// Call the inherited method // I can bark lab.makeNoise()

`

**Output:

I am a dog named Rex
I can bark
I am a labrador named Max, I am a dog named Max
I can bark

**Explanation:

• The code defines a superclass **Animal with properties and methods.
• A subclass **Dog inherits from **Animal and customizes the description and **makeNoise() properties and methods.
• An instance of a **Dog named **Rex is created.
• The overridden description property of **Dog displays "I am a dog named Rex."
• The overridden **makeNoise() method of **Dog prints "I can bark."
• Another subclass **Labrador is defined, as inheriting from "Dog."
• The description property of **Labrador is overridden, including the original superclass description using super.
• An instance of **Labrador named **Max is created.
• The overridden description property of **Labrador combines both class names, displaying "I am a labrador named Max, I am a dog named Max."
• The **makeNoise() method inherited from **Dog still prints "I can bark."

Types of Inheritance

Swift supports different types of inheritance, depending on the relationship between the classes involved. Some of the common types of inheritance are:

1. Single inheritance

A subclass inherits from only one superclass. This is the most common type of inheritance in Swift. For example:

class Vehicle
{
// properties and methods of Vehicle
}
class Car: Vehicle
{
// properties and methods of Car
}

Here, the **Car class inherits from the **Vehicle class, which means that a **Car instance can access the properties and methods of the **Vehicle class, as well as its properties and methods.

2. Multilevel inheritance

A subclass inherits from another subclass, which in turn inherits from a superclass. This creates a chain of inheritance from the top-level superclass to the bottom-level subclass. For example:

class Vehicle
{
// properties and methods of Vehicle
}
class Car: Vehicle
{
// properties and methods of Car
}
class ElectricCar: Car
{
// properties and methods of ElectricCar
}

Here, the **ElectricCar class inherits from the **Car class, which in turn inherits from the **Vehicle class. This means that an **ElectricCar instance can access the properties and methods of all three classes in the hierarchy.

3. Multiple inheritance

A subclass inherits from more than one superclass. This allows a subclass to combine the features and behaviors of multiple superclasses. However, Swift does not support multiple inheritance for classes directly. Instead, Swift uses protocols to achieve a similar effect. A protocol defines a set of requirements that a conforming type must implement, such as properties, methods or subscripts. A class can conform to multiple protocols by listing them after the colon: in its declaration. For example:

protocol Flyable
{
// requirements for flying
}
protocol Swimable
{
// requirements for swimming
}
class Duck: Animal, Flyable, Swimable
{
// properties and methods of Duck
}

Here, the **Duck class inherits from the Animal class and also conforms to the **Flyable and **Swimable protocols. This means that a **Duck instance can access the properties and methods of the **Animal class, as well as the requirements of the two protocols.

Is-a Relationship

In Swift, inheritance is an is-a relationship. That is, we use inheritance only if there exists an is-a relationship between two classes. An is-a relationship means that a subclass is a specific type or kind of its superclass. For example:

• A car is a vehicle.
• An apple is a fruit.
• A cat is an animal.

Here, we can use inheritance to model these relationships by creating subclasses for each specific type or kind.

Swift `

// Swift program to implement // is-a relationship // Define a base class for vehicles class Vehicle { var brand: String var year: Int

// Initialize the vehicle with a brand and year init(brand: String, year: Int) { self.brand = brand self.year = year }

// Method to start the vehicle's engine func startEngine() { print("The (brand) vehicle's engine is starting.") } }

// Create a subclass for cars class Car: Vehicle { var model: String

// Initialize the car with a brand, year, and model init(brand: String, year: Int, model: String) { self.model = model super.init(brand: brand, year: year) }

// Method to drive the car func drive() { print("The (year) (brand) (model) is driving.") } }

// Define a base class for fruits class Fruit { var name: String

// Initialize the fruit with a name init(name: String) { self.name = name }

// Method to describe the fruit func describe() { print("This is a (name).") } }

// Create a subclass for apples class Apple: Fruit { var variety: String

// Initialize the apple with a name and variety init(name: String, variety: String) { self.variety = variety super.init(name: name) }

// Method to describe the taste of the apple func taste() { print("This (name) is a (variety) apple, and it tastes delicious.") } }

// Define a base class for animals class Animal { var species: String

// Initialize the animal with a species init(species: String) { self.species = species }

// Method to make a sound func makeSound() { print("The (species) is making a sound.") } }

// Create a subclass for cats class Cat: Animal { var name: String

// Initialize the cat with a name init(name: String) { self.name = name super.init(species: "Cat") }

// Method for a cat to meow func meow() { print("(name) the cat says 'Meow!'") } }

// Creating and using objects let myCar = Car(brand: "Toyota", year: 2023, model: "Camry") myCar.startEngine() myCar.drive()

let myApple = Apple(name: "Apple", variety: "Honeycrisp") myApple.describe() myApple.taste()

let myCat = Cat(name: "Whiskers") myCat.makeSound() myCat.meow()

`

**Output:

The Toyota vehicle's engine is starting.
The 2023 Toyota Camry is driving.
This is a Apple.
This Apple is a Honeycrisp apple, and it tastes delicious.
The Cat is making a sound.
Whiskers the cat says 'Meow!'

Using inheritance to express an is-a relationship helps us to reuse code, avoid duplication and maintain consistency across related classes.

Method Overriding

A subclass can provide its custom implementation of an instance method, type method, instance property, type property or subscript that it would otherwise inherit from a superclass. This is known as overriding. To override a characteristic that would otherwise be inherited, we prefix our overriding definition with the override keyword.

Below is the Swift program to implement method overriding:

Swift `

// Swift program to implement // method overriding

// Define a base class for animals class Animal { // Method in the superclass func eat() { print("I can eat") } }

// Create a subclass for dogs, // which inherits from Animal class Dog: Animal { // Override the eat() method in the subclass override func eat() { print("I eat dog food") } }

// Creating and using objects let genericAnimal = Animal() let myDog = Dog()

genericAnimal.eat() myDog.eat()

`

**Output

I can eat
I eat dog food

**Explanation:

• The code overrides the **eat() method in the **Dog subclass, which is originally defined in the **Animal superclass.
• When you call the **eat() method using a **Dog object, the version of the method in the **Dog class is executed.
• This behavior occurs because method overriding allows the subclass to provide its implementation of the method, replacing the one from the superclass.
• It enables customization and specialization of method behavior in the subclass while maintaining a consistent interface with the superclass.

Overriding allows us to customize and modify the behavior of inherited methods, properties or subscripts according to the needs of the subclass.

super Keyword

In Swift, we can access methods, properties or subscripts of the superclass from a subclass using the **super keyword. The **super keyword refers to the superclass instance within the current subclass instance. This allows us to invoke the superclass's implementation of a method or access its properties.

Below is the Swift program to implement super keyword:

Swift `

// Swift program to implement // super keyword

// Define a base class for animals class Animal { // Method in the superclass func eat() { print("I can eat") } }

// Create a subclass for dogs, // which inherits from Animal class Dog: Animal { // Override the eat() method in the subclass override func eat() { // Call the eat() method of the superclass super.eat()

// Add additional behavior
print("I eat dog food")

} }

// Create an object of the subclass // (a Labrador dog) var labrador = Dog()

// Call the eat() method on the // Labrador object labrador.eat()

`

**Output

I can eat
I eat dog food

**Explanation:

• The code overrides the eat() method in the **Dog subclass, which originally belonged to the **Animal superclass.
• By using **super.eat(), we explicitly call the **eat() method of the **Animal superclass within the **Dog subclass.
• When you call the **eat() method using a Dog object, both the overridden **eat() method in the **Dog class and the superclass **eat() method in the **Animal class are executed.
• This behavior occurs because the **super keyword allows you to access and invoke the superclass's implementation of a method.
• It provides a way to extend or build upon the functionality of the superclass method while still using it.

Using super enables us to access and utilize inherited characteristics of the superclass from within the subclass, allowing for the customization of behavior while preserving and extending the functionality of the parent class.

Property Overriding

A subclass can also override inherited properties of a superclass by providing its custom getter and setter for the properties or adding property observers to them. Property observers are code blocks that are executed when a property’s value is set or changed. There are two types of property observers: **willSet and **didSet. The **willSet observer is called before the value of a property is stored and the **didSet observer is called after the value of a property is stored.

To override a property, we use the same syntax as for overriding a method, but we also specify what aspect of the property we want to override: its getter, its setter or its observers.

**Example 1: Below is the Swift program to implement property overriding:

Swift `

// Swift program to implement // property overriding

// Define a base class for vehicles class Vehicle { // Property in the superclass to represent // the current speed in miles per hour (mph) var currentSpeed = 0.0 }

// Create a subclass for cars, which // inherits from Vehicle class Car: Vehicle { // Override the property with a custom getter // and setter to convert speed to kilometers // per hour (kph) override var currentSpeed: Double { get { // Custom getter to convert mph to kph // Convert mph to kph return super.currentSpeed * 1.6 } set { // Custom setter to convert kph back to mph // Convert kph to mph super.currentSpeed = newValue / 1.6 } } }

// Create an instance of the Car class let myCar = Car()

// Set the current speed in miles per hour (mph) // Set the speed to 60 mph myCar.currentSpeed = 60.0

// Retrieve and print the current speed in // kilometers per hour (kph) let speedInKPH = myCar.currentSpeed print("Current speed: (speedInKPH) kph")

`

**Output

Current speed: 60.0 kph

**Explanation:

• The code overrides the **currentSpeed property in the **Car subclass, originally defined in the **Vehicle superclass.
• Custom getter and setter are provided in the **Car subclass to convert between miles per hour and kilometers per hour when accessing or setting the property.
• The **super keyword is used to access and modify the stored value of **currentSpeed in the **Vehicle superclass.
• This allows for specialized handling of the property within the subclass while still interacting with and modifying the underlying value in the superclass.

**Example 2:

Swift `

// Swift program to implement // Property overriding

// Define a base class for vehicles class Vehicle { // Computed property in the superclass // to describe the vehicle's speed var description: String { return "traveling at (currentSpeed) miles per hour" }

// Property to represent the current speed // in miles per hour (mph) var currentSpeed = 0.0 }

// Create a subclass for cars, which inherits // from Vehicle class Car: Vehicle { // Override the description property with a custom // getter to include "in a car" override var description: String { return super.description + " in a car" } }

// Create an instance of the Car class let myCar = Car()

// Set the speed to 60 mph myCar.currentSpeed = 60.0

// Access and print the description property let carDescription = myCar.description print(carDescription)

`

**Output

traveling at 60.0 miles per hour in a car

**Explanation:

• In this code, the description property of the **Car subclass is overridden, originally defined in the **Vehicle superclass.
• A custom getter is provided for the description property within the **Car subclass.
• The custom getter appends "in a car" to the value returned by **super.description, which is the description property of the **Vehicle superclass.
• This customization allows you to modify the behavior of the description property for the **Car subclass while incorporating the description from the superclass.

**Example 3:

Swift `

// Swift program to implement // Property overriding

// Define a base class for vehicles class Vehicle { // Property in the superclass with a // didSet observer var currentSpeed = 0.0 { didSet { print("The speed changed to (currentSpeed)") } } }

// Create a subclass for cars, which inherits // from Vehicle class Car: Vehicle { // Override the property with custom willSet // and didSet observers override var currentSpeed: Double { willSet { print("The speed will change to (newValue)") } didSet { print("The speed changed by (currentSpeed - oldValue)") } } }

// Create an instance of the Car class let myCar = Car()

// Set the current speed, triggering willSet // and didSet observers myCar.currentSpeed = 60.0

// Set the speed again to observe changes myCar.currentSpeed = 80.0

`

**Output

The speed will change to 60.0
The speed changed to 60.0
The speed changed by 60.0
The speed will change to 80.0
The speed changed to 80.0
The speed changed by 20.0

**Explanation:

• In this code, the **currentSpeed property of the **Car subclass is overridden, originally defined in the **Vehicle superclass.
• Custom **willSet and **didSet property observers are added to monitor and respond to changes in the property's value.
• In the **willSet observer, you can access and work with the new value (newValue) before it's set.
• In the **didSet observer, both the new value (newValue) and the previous value (oldValue) can be accessed for monitoring and responding to changes.
• This customization allows you to track and react to changes in the **currentSpeed property within the **Car subclass.

Overriding properties allows us to customize and modify how inherited properties are accessed or observed according to the needs of the subclass.

Final Property

Swift allows us to prevent a subclass from overriding a method, property, or subscript of a superclass by using the final modifier. We write the final keyword before the declaration of the characteristic that we want to protect from overriding (such as final var, final func, final class func and final subscript). If a subclass tries to override a final characteristic, it will cause a compile-time error.

Below is the Swift program to implement Final property:

Swift `

// Swift program to implement // Final

// Define a base class for vehicles class Vehicle { // Mark the property as final to prevent // overriding in subclasses final var currentSpeed = 0.0 }

// Create a subclass for cars, which // inherits from Vehicle class Car: Vehicle { // Attempt to override the final property // (this will cause an error) // Uncomment the following lines to see the error:

/* override var currentSpeed: Double { // This will result in a compilation error } */ }

// Attempting to create instances and override // the final property will result in an error

// Uncomment these lines to observe the error: /* let myVehicle = Vehicle() myVehicle.currentSpeed = 60.0 // Error: Cannot assign to property: 'currentSpeed' is a 'final' property

let myCar = Car() myCar.currentSpeed = 80.0 // Error: Cannot assign to property: 'currentSpeed' is a 'final' property */

`

**Explanation:

• In this code, the **currentSpeed property of the **Vehicle class is marked as final.
• The **final keyword indicates that no subclass can override this property.
• If an attempt is made to override this property in the **Car class or any other subclass, it will result in a compilation error.
• Marking a property or method as final prevents further modification in subclasses, providing a way to enforce the immutability or specific behavior of that element.

Using the final modifier helps us ensure that a superclass characteristic's behavior and functionality are consistent and reliable across all subclasses.

Conclusion

In this article, we have learned about inheritance in Swift and how to use it to create subclasses, override methods and properties, and implement polymorphism. Inheritance is a powerful feature of object-oriented programming that allows us to reuse and extend existing code and functionality. It also helps us to model real-world objects and relationships in our programs. We have also seen some of the types of inheritance and the is-a relationship that exists between classes. We have also learned how to use the super keyword to access the superclass characteristics from the subclass and how to use the final keyword to prevent overriding. We hope this article has helped you to understand the concept of inheritance in Swift better.