Why inheritance is class-only in Swift - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why does Swift restrict inheritance to classes only?

In Swift, only classes can inherit from other classes. Why is inheritance limited to classes and not allowed for structs or enums?

A Because structs and enums are slower than classes and cannot inherit.

B Because classes support reference semantics which allow shared mutable state, making inheritance meaningful.

C Because Swift does not allow any type to inherit from another type.

D Because inheritance is only useful for value types like structs and enums.

💡 Hint

Think about how classes and structs differ in how they store and share data.

Classes in Swift use reference semantics, meaning multiple variables can point to the same instance. This shared mutable state makes inheritance useful to extend or modify behavior. Structs and enums use value semantics, so each copy is independent, making inheritance less meaningful and potentially confusing.

❓ Predict Output

intermediate

What is the output of this Swift code involving class inheritance?

Consider the following Swift code. What will be printed when it runs?

Swift

class Animal {
    func sound() -> String {
        return "Some sound"
    }
}

class Dog: Animal {
    override func sound() -> String {
        return "Bark"
    }
}

let pet: Animal = Dog()
print(pet.sound())

A "Bark"

B "Some sound"

C Compilation error due to missing override keyword

D Runtime error due to type mismatch

💡 Hint

Remember how method overriding works with class inheritance and polymorphism.

The variable pet is of type Animal but holds an instance of Dog. Because sound() is overridden in Dog, the Dog version is called, printing "Bark".

🔧 Debug

advanced

Identify the error when trying to inherit from a struct in Swift

What error will this Swift code produce and why?

Swift

struct Vehicle {
    var wheels: Int
}

struct Car: Vehicle {
    var brand: String
}

A Error: Inheritance from non-class type 'Vehicle' is not allowed

B Error: Missing initializer for struct 'Car'

C Error: Cannot override stored property 'wheels'

D No error, code compiles and runs fine

💡 Hint

Recall which types support inheritance in Swift.

Structs in Swift do not support inheritance. Trying to inherit from a struct causes a compile-time error stating inheritance from non-class type is not allowed.

📝 Syntax

advanced

Which Swift code snippet correctly overrides a method in a subclass?

Choose the code snippet that correctly overrides the describe() method in a subclass.

A

class Parent {
    func describe() { print("Parent") }
}
class Child: Parent {
    override describe() { print("Child") }
}

B

class Parent {
    func describe() { print("Parent") }
}
class Child: Parent {
    func describe() { print("Child") }
}

C

class Parent {
    func describe() { print("Parent") }
}
class Child: Parent {
    override func describe() { print("Child") }
}

D

class Parent {
    func describe() { print("Parent") }
}
class Child: Parent {
    override func describe() -> String { return "Child" }
}

💡 Hint

Remember the syntax for method overriding in Swift requires the 'override' keyword and matching method signature.

Option C correctly uses the override keyword and matches the method signature of the parent. Option C misses override. Option C misses the return type and func keyword. Option C changes the return type, which is not allowed.

🚀 Application

expert

How does Swift's class-only inheritance affect protocol design?

Given that inheritance is class-only in Swift, which approach best allows sharing default behavior across multiple types including structs and enums?

A Use multiple inheritance with classes to share behavior.

B Use class inheritance for all types including structs and enums.

C Use global functions instead of protocols or inheritance.

D Use protocols with default implementations via protocol extensions.

💡 Hint

Think about how Swift encourages code reuse without class inheritance.

Swift uses protocols with default implementations in extensions to share behavior across classes, structs, and enums. This approach works around the class-only inheritance limitation and supports value types.