Preventing overrides with final in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the final keyword do in Swift?

The final keyword prevents a class, method, or property from being overridden or subclassed. It locks the behavior so it can't be changed in subclasses.

beginner

Can you subclass a class marked as <code>final</code> in Swift?

No, a class marked as <code>final</code> cannot be subclassed. It is the end of the inheritance chain.

intermediate

Why would you use final on a method in Swift?

Using final on a method stops subclasses from changing that method's behavior, which can improve safety and performance.

beginner

What happens if you try to override a final method in Swift?

The compiler will give an error and prevent the override, because final methods cannot be changed in subclasses.

intermediate

How does marking a class or method as <code>final</code> affect performance in Swift?

Marking as <code>final</code> allows the compiler to optimize calls because it knows the method or class won’t change, making the code faster.

What does the final keyword do when applied to a Swift class?

A Marks the class as deprecated

B Allows unlimited subclassing

C Prevents the class from being subclassed

D Makes the class abstract

A final class cannot be subclassed, which means no other class can inherit from it.

If a method is marked final, what happens if a subclass tries to override it?

A The override works normally

B The compiler throws an error

C The method is ignored

D The program crashes at runtime

The compiler prevents overriding a final method and shows an error.

Which of the following is a benefit of using final in Swift?

A Improves code safety and performance

B Allows dynamic method dispatch

C Enables multiple inheritance

D Automatically generates initializers

final improves safety by preventing unwanted overrides and can help the compiler optimize performance.

Can you mark a property as final in Swift?

A No, properties cannot be final

B Only in structs

C Only if the property is static

D Yes, to prevent it from being overridden

Properties can be marked final to stop subclasses from overriding them.

What is the default behavior of classes and methods in Swift regarding overriding?

A They can be overridden unless marked <code>final</code>

B They cannot be overridden by default

C They are always <code>final</code>

D They require <code>final</code> to be overridden

By default, classes and methods can be overridden unless you mark them final.

Explain how the final keyword helps prevent overrides in Swift and why this might be useful.

Think about how locking behavior can protect your code.

Describe a situation where you would want to use final on a class or method in your Swift code.

Consider when you want to keep something fixed and reliable.

Practice

1.

What does the final keyword do in Swift?

easy

A. Makes a method asynchronous

B. Allows a class to be subclassed multiple times

C. Marks a variable as constant

D. Prevents a class or method from being overridden or subclassed

Solution

1. Step 1: Understand the purpose of final

   The final keyword in Swift is used to stop classes or methods from being changed by subclasses.

2. Step 2: Identify what final prevents

   It prevents overriding methods or subclassing classes, ensuring the code stays as originally designed.

3. Final Answer:

   Prevents a class or method from being overridden or subclassed -> Option D

4. Quick Check:

   final stops overrides = A [OK]

Hint: Remember: final means no changes allowed to class or method [OK]

Common Mistakes:

• Confusing final with constant variables
• Thinking final allows subclassing
• Mixing final with async keyword

2.

Which of the following is the correct way to declare a method that cannot be overridden in Swift?

class Vehicle {
    _____ func startEngine() {
        print("Engine started")
    }
}

easy

A. override

B. mutating

C. final

D. static

Solution

1. Step 1: Identify the keyword to prevent overriding

   In Swift, the final keyword is used before a method to stop it from being overridden in subclasses.

2. Step 2: Check the method declaration

   Placing final before func correctly marks the method as non-overridable.

3. Final Answer:

   final -> Option C

4. Quick Check:

   Use final before func to prevent override [OK]

Hint: final before func means no override allowed [OK]

Common Mistakes:

• Using override keyword incorrectly
• Confusing static with final
• Using mutating which is for structs

3.

What will happen when you run this Swift code?

class Animal {
    final func sound() {
        print("Animal sound")
    }
}

class Dog: Animal {
    override func sound() {
        print("Bark")
    }
}

let pet = Dog()
pet.sound()

medium

A. Prints "Animal sound"

B. Compile-time error due to overriding a final method

C. Prints "Bark"

D. Runtime error

Solution

1. Step 1: Identify the use of final in the base class

   The method sound() in Animal is marked as final, so it cannot be overridden.

2. Step 2: Check the subclass method override

   The Dog class tries to override sound(), which causes a compile-time error because overriding a final method is not allowed.

3. Final Answer:

   Compile-time error due to overriding a final method -> Option B

4. Quick Check:

   Overriding final method = Compile error [OK]

Hint: Overriding final method causes compile error [OK]

Common Mistakes:

• Assuming it prints "Bark"
• Thinking it prints base method output
• Expecting runtime error instead of compile error

4.

Find the error in this Swift code and fix it:

final class Vehicle {
    func drive() {
        print("Driving")
    }
}

class Car: Vehicle {
    override func drive() {
        print("Car driving")
    }
}

medium

A. Remove final from Vehicle class

B. Remove override from Car's drive method

C. Change Vehicle to a struct

D. Add final to Car class

Solution

1. Step 1: Identify the use of final on the Vehicle class

   The Vehicle class is marked as final, so it cannot be subclassed.

2. Step 2: Check subclass declaration

   The Car class tries to subclass Vehicle, which causes a compile-time error because subclassing a final class is not allowed.

3. Final Answer:

   Remove final from Vehicle class -> Option A

4. Quick Check:

   Subclassing final class = Error; remove final [OK]

Hint: final class cannot be subclassed; remove final to fix [OK]

Common Mistakes:

• Trying to override without removing final
• Adding final to subclass instead of base
• Changing class to struct unnecessarily

5.

You want to create a base class BankAccount with a method calculateInterest() that should never be changed by subclasses. However, subclasses can add new methods. How should you declare BankAccount and calculateInterest()?

hard

A. Declare BankAccount normally and calculateInterest() as final

B. Declare both BankAccount and calculateInterest() as final

C. Declare BankAccount as final and calculateInterest() normally

D. Declare BankAccount as a struct and calculateInterest() as final

Solution

1. Step 1: Understand the requirement for subclassing

   The base class BankAccount should allow subclasses, so it must NOT be final.

2. Step 2: Protect the method from being overridden

   Mark calculateInterest() as final to prevent subclasses from changing it.

3. Final Answer:

   Declare BankAccount normally and calculateInterest() as final -> Option A

4. Quick Check:

   final method, normal class = C [OK]

Hint: final method stops override; class normal allows subclass [OK]

Common Mistakes:

• Making the whole class final, blocking subclassing
• Not marking method as final, allowing override
• Using struct instead of class incorrectly