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.

Practice

1. Why is inheritance only allowed for classes in Swift?

easy

A. Because only classes can have properties

B. Because structs and enums are faster to create

C. Because classes are reference types and share data by reference

D. Because structs and enums cannot have methods

Solution

1. Step 1: Understand type behavior in Swift

   Classes are reference types, meaning instances share the same data in memory.

2. Step 2: Compare with structs and enums

   Structs and enums are value types, so they copy data instead of sharing it.

3. Final Answer:

   Because classes are reference types and share data by reference -> Option C

4. Quick Check:

   Inheritance = Reference types only [OK]

Hint: Inheritance needs shared data, so only classes can do it [OK]

Common Mistakes:

• Thinking structs can inherit like classes
• Believing enums can have inheritance
• Confusing methods with inheritance

2. Which Swift declaration correctly shows inheritance allowed only for classes?

easy

A. class MyClass: ParentClass {}

B. struct MyStruct: ParentClass {}

C. enum MyEnum: ParentClass {}

D. protocol MyProtocol: ParentClass {}

Solution

1. Step 1: Identify inheritance syntax in Swift

   Only classes can inherit from other classes using the colon syntax.

2. Step 2: Check each declaration

   Structs, enums, and protocols cannot inherit from classes.

3. Final Answer:

   class MyClass: ParentClass {} -> Option A

4. Quick Check:

   Inheritance syntax = class only [OK]

Hint: Only classes use colon for inheritance from classes [OK]

Common Mistakes:

• Trying to inherit a class in a struct
• Using enum to inherit a class
• Confusing protocol inheritance with class inheritance

3. What will happen if you try this Swift code?

struct ParentStruct {}
struct ChildStruct: ParentStruct {}

medium

A. ChildStruct inherits ParentStruct successfully

B. Compile-time error: structs cannot inherit

C. Runtime error when creating ChildStruct

D. ChildStruct copies ParentStruct properties automatically

Solution

1. Step 1: Analyze struct inheritance rules

   Structs in Swift cannot inherit from other structs or classes.

2. Step 2: Predict compiler behavior

   The compiler will produce an error because inheritance is not allowed for structs.

3. Final Answer:

   Compile-time error: structs cannot inherit -> Option B

4. Quick Check:

   Struct inheritance = error [OK]

Hint: Structs cannot inherit; expect compile error [OK]

Common Mistakes:

• Assuming structs inherit like classes
• Expecting runtime error instead of compile error
• Thinking structs copy properties via inheritance

4. Find the error in this Swift code:

enum ParentEnum {}
class ChildClass: ParentEnum {}

medium

A. Enums cannot be inherited by classes

B. Enums cannot have child classes

C. Classes cannot inherit from enums

D. All of the above

Solution

1. Step 1: Check inheritance rules for enums and classes

   Enums are value types and cannot be inherited or used as base classes.

2. Step 2: Understand class inheritance restrictions

   Classes can only inherit from other classes, not enums.

3. Step 3: Combine observations

   All statements about enums and classes here are correct.

4. Final Answer:

   All of the above -> Option D

5. Quick Check:

   Enum inheritance = disallowed [OK]

Hint: Classes inherit classes only; enums can't be base classes [OK]

Common Mistakes:

• Thinking enums can be base classes
• Confusing enum cases with inheritance
• Ignoring that classes can't inherit enums

5. You want to share behavior between a struct and a class in Swift. Given inheritance is class-only, what is the best approach?

hard

A. Use a protocol to define shared behavior

B. Convert the struct to a class to inherit

C. Make the struct inherit from the class

D. Use enum inheritance to share code

Solution

1. Step 1: Recall inheritance limits

   Inheritance works only for classes, so structs cannot inherit from classes.

2. Step 2: Identify alternative sharing method

   Protocols allow both structs and classes to share behavior by conforming to them.

3. Step 3: Evaluate options

   Using protocols is the best way to share behavior without inheritance.

4. Final Answer:

   Use a protocol to define shared behavior -> Option A

5. Quick Check:

   Protocols share behavior across types [OK]

Hint: Use protocols to share behavior with structs and classes [OK]

Common Mistakes:

• Trying to inherit struct from class
• Converting structs unnecessarily to classes
• Thinking enums can inherit