SWIFT
Swift Inheritance: Syntax, Usage, and Examples
Swift inheritance lets you create a new class by extending an existing one. This helps you reuse code and organize your program efficiently. With inheritance, you can share properties and methods between related objects without rewriting the same code.
How to Use Inheritance in Swift
To make a class inherit from another, use a colon : followed by the name of the parent class.
class Animal {
var name: String
init(name: String) {
self.name = name
}
func makeSound() {
print("Some generic animal sound")
}
}
class Dog: Animal {
func bark() {
print("Woof!")
}
}
let dog = Dog(name: "Buddy")
dog.makeSound() // Output: Some generic animal sound
dog.bark() // Output: Woof!
Here, Dog inherits from Animal. This means Dog gets the name property and the makeSound method from Animal without needing to redefine them.
Overriding Methods
If you need a subclass to have a different behavior than its parent, you can override a method using override.
class Cat: Animal {
override func makeSound() {
print("Meow!")
}
}
let cat = Cat(name: "Whiskers")
cat.makeSound() // Output: Meow!
Preventing Inheritance
If you want to stop a class from being inherited, mark it as final.
final class Bird {
var canFly = true
}
// The following would cause an error:
// class Sparrow: Bird { }
When to Use Inheritance in Swift
Avoiding Code Duplication
If multiple classes share the same properties or methods, inheritance helps you avoid writing the same code over and over.
class Vehicle {
var speed = 0
func accelerate() {
speed += 10
}
}
class Car: Vehicle {
var fuelLevel = 100
}
let myCar = Car()
myCar.accelerate()
print(myCar.speed) // Output: 10
Specializing Behavior
You can use inheritance to define general behavior in a parent class and then specialize it in subclasses.
class Employee {
func work() {
print("Working...")
}
}
class Engineer: Employee {
override func work() {
print("Solving technical problems...")
}
}
let engineer = Engineer()
engineer.work() // Output: Solving technical problems...
Organizing Related Objects
Inheritance makes it easier to structure your program when you have related objects.
class Shape {
func draw() {
print("Drawing a shape")
}
}
class Circle: Shape {
override func draw() {
print("Drawing a circle")
}
}
let circle = Circle()
circle.draw() // Output: Drawing a circle
Examples of Inheritance in Swift
Using Superclass Properties
A subclass automatically gets the properties of its parent class.
class Animal {
var species: String
init(species: String) {
self.species = species
}
}
class Dog: Animal {
func describe() {
print("This is a \(species)")
}
}
let myDog = Dog(species: "Golden Retriever")
myDog.describe() // Output: This is a Golden Retriever
Calling Superclass Methods
If you need to call a method from the parent class inside an overridden method, use super.
class Parent {
func greet() {
print("Hello from Parent")
}
}
class Child: Parent {
override func greet() {
super.greet() // Calls the parent method
print("Hello from Child")
}
}
let child = Child()
child.greet()
// Output:
// Hello from Parent
// Hello from Child
Initializing Subclasses
If your subclass has additional properties, you must initialize them before calling the parent class’s initializer.
class Person {
var name: String
init(name: String) {
self.name = name
}
}
class Student: Person {
var grade: Int
init(name: String, grade: Int) {
self.grade = grade
super.init(name: name)
}
}
let student = Student(name: "Emma", grade: 10)
print(student.name) // Output: Emma
print(student.grade) // Output: 10
Learn More About Inheritance in Swift
Protocol Inheritance
Unlike classes, Swift protocols allow multiple inheritance. You can make a protocol inherit from one or more protocols.
protocol Readable {
func read()
}
protocol Writable {
func write()
}
protocol Document: Readable, Writable {}
class Book: Document {
func read() {
print("Reading a book")
}
func write() {
print("Writing notes in the book")
}
}
let myBook = Book()
myBook.read() // Output: Reading a book
myBook.write() // Output: Writing notes in the book
Multiple Inheritance in Swift
Swift doesn’t allow multiple class inheritance, but you can combine behaviors using protocol composition.
protocol Driver {
func drive()
}
protocol Mechanic {
func repair()
}
class RaceCarDriver: Driver, Mechanic {
func drive() {
print("Driving at high speed")
}
func repair() {
print("Fixing the car")
}
}
let racer = RaceCarDriver()
racer.drive() // Output: Driving at high speed
racer.repair() // Output: Fixing the car
Structs and Inheritance
Unlike classes, structs don’t support inheritance. If you need similar behavior, use protocol conformance.
protocol Identifiable {
var id: String { get }
}
struct User: Identifiable {
var id: String
}
let user = User(id: "12345")
print(user.id) // Output: 12345
Enum Inheritance
Swift enums don’t support inheritance, but you can extend them with methods.
enum Status {
case success
case failure
func message() -> String {
switch self {
case .success:
return "Operation succeeded"
case .failure:
return "Operation failed"
}
}
}
let status = Status.success
print(status.message()) // Output: Operation succeeded
Best Practices for Using Inheritance
- Use inheritance only when there’s a clear "is-a" relationship. A
Caris aVehicle, but aDriveris not aVehicle. - Prefer protocols when possible. If multiple unrelated classes need the same behavior, protocols are more flexible than deep inheritance chains.
- Minimize method overriding. Too many overrides can make your code harder to follow.
- Mark methods as
finalif you don’t want subclasses to override them. This prevents unintended behavior changes. - Call
super.init()properly. Always initialize subclass properties before calling the parent class initializer.
Sign up or download Mimo from the App Store or Google Play to enhance your programming skills and prepare for a career in tech.