Working with Type Casting in Swift

Type casting in Swift enables you to check and interpret the type of a class instance at runtime. This is particularly useful when working with hierarchies of classes or protocols, allowing you to treat objects as instances of their superclass or a specific subclass. There are two types of type casting in Swift: ‘as?’ for optional type casting and as! for forced type casting.

Example:

class Animal {
    func makeSound() {
        print("Animal makes a sound")
    }
}

class Dog: Animal {
    func bark() {
        print("Dog barks")
    }
}

let animal = Animal()
let dog = Dog()

let animals: [Any] = [animal, dog]

for animal in animals {
    if let dog = animal as? Dog {
        dog.bark()
    } else if let animal = animal as? Animal {
        animal.makeSound()
    }
}

Explanation:

In the example above, we have a superclass `Animal` and a subclass `Dog`. We create instances of both classes and store them in an array `animals`. We then loop through each element in the array and use optional type casting `as?` to check if the element can be cast as a `Dog` or `Animal`. If it can be cast as a `Dog`, we call the `bark()` method on the `Dog` instance. If it can be cast as an `Animal`, we call the `makeSound()` method on the `Animal` instance. Type casting in Swift is a powerful feature that allows you to work with objects in a flexible and dynamic manner. It enables you to handle different types of objects in a polymorphic way, making your code more robust and adaptable to different scenarios.