Why protocol-oriented programming matters in Swift - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a protocol named 'Drivable'.

Swift

protocol [1] {
    func drive()
}

Drag options to blanks, or click blank then click option'

ADrivable

BVehicle

CDriveable

DMovable

Attempts:

3 left

💡 Hint

Common Mistakes

Using a class or struct name instead of a protocol name.

Misspelling the protocol name.

The protocol name should be 'Drivable' to match the intended design.

2fill in blank

medium

Complete the code to make 'Car' conform to the 'Drivable' protocol.

Swift

struct Car: [1] {
    func drive() {
        print("Car is driving")
    }
}

Drag options to blanks, or click blank then click option'

AVehicle

BMovable

CDrivable

DDriveable

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong protocol name.

Forgetting to conform to the protocol.

The struct 'Car' must conform to the 'Drivable' protocol to implement the 'drive' method.

3fill in blank

hard

Fix the error in the protocol extension to provide a default implementation.

Swift

extension Drivable {
    func [1]() {
        print("Default driving behavior")
    }
}

Drag options to blanks, or click blank then click option'

Adrive

BDrive

Cdriving

Drun

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different method name in the extension.

Capitalizing the method name incorrectly.

The method name in the extension must match the protocol's method name exactly, which is 'drive'.

4fill in blank

hard

Fill both blanks to create a protocol and a struct that uses protocol-oriented programming.

Swift

protocol [1] {
    func [2]()
}

struct Bike: [1] {
    func [2]() {
        print("Bike is moving")
    }
}

Drag options to blanks, or click blank then click option'

AMovable

Bmove

Drun

Attempts:

3 left

💡 Hint

Common Mistakes

Using inconsistent names between protocol and struct.

Using method names that don't match the protocol.

The protocol is named 'Movable' with a method 'move()'. The struct 'Bike' conforms to 'Movable' and implements 'move()'.

5fill in blank

hard

Fill all three blanks to create a protocol with a default implementation and a struct that uses it.

Swift

protocol [1] {
    func [2]()
}

extension [1] {
    func [2]() {
        print("Default implementation")
    }
}

struct Scooter: [1] {}

Drag options to blanks, or click blank then click option'

ARideable

Bride

Drun

Attempts:

3 left

💡 Hint

Common Mistakes

Mismatching protocol names between declaration and extension.

Not matching method names exactly.

The protocol is 'Rideable' with method 'ride()'. The extension provides a default 'ride()' implementation. The struct 'Scooter' conforms to 'Rideable' and uses the default method.

Practice

1. What is the main purpose of protocols in Swift's protocol-oriented programming?

easy

A. To define a blueprint of methods and properties that a type must implement

B. To store data like variables and constants

C. To create user interfaces

D. To manage memory automatically

Solution

1. Step 1: Understand what protocols represent

   Protocols specify a set of methods and properties that a type must have, acting as a blueprint.

2. Step 2: Differentiate protocols from data storage

   Protocols do not store data themselves; they only define behavior and requirements.

3. Final Answer:

   To define a blueprint of methods and properties that a type must implement -> Option A

4. Quick Check:

   Protocols = Blueprint of behavior [OK]

Hint: Protocols define required behavior, not data storage [OK]

Common Mistakes:

• Thinking protocols store data
• Confusing protocols with classes or structs
• Assuming protocols manage memory

2. Which of the following is the correct syntax to declare a protocol named Drivable in Swift?

easy

A. struct Drivable { func drive() }

B. class Drivable { func drive() }

C. func protocol Drivable() { drive() }

D. protocol Drivable { func drive() }

Solution

1. Step 1: Recall protocol declaration syntax

   Protocols are declared using the keyword protocol followed by the name and curly braces.

2. Step 2: Identify correct method declaration inside protocol

   Inside protocols, methods are declared without implementation, just the signature.

3. Final Answer:

   protocol Drivable { func drive() } -> Option D

4. Quick Check:

   Use 'protocol' keyword and method signature [OK]

Hint: Protocols start with 'protocol' keyword, not class or struct [OK]

Common Mistakes:

• Using class or struct instead of protocol
• Trying to implement method inside protocol
• Incorrect keyword order

3. What will be the output of the following Swift code?

protocol Greetable {
    func greet() -> String
}

struct Person: Greetable {
    func greet() -> String {
        "Hello!"
    }
}

let p = Person()
print(p.greet())

medium

A. Error: Missing method implementation

B. greet()

C. Hello!

D. nil

Solution

1. Step 1: Check protocol and struct conformance

   The struct Person conforms to Greetable and implements greet() returning "Hello!".

2. Step 2: Understand the print statement output

   Calling p.greet() returns "Hello!", which is printed.

3. Final Answer:

   Hello! -> Option C

4. Quick Check:

   Protocol method implemented returns "Hello!" [OK]

Hint: Check if method returns a string and is called correctly [OK]

Common Mistakes:

• Assuming protocol methods print automatically
• Thinking missing implementation error occurs
• Confusing method name with output

4. Identify the error in this Swift code using protocol-oriented programming:

protocol Runnable {
    func run()
}

struct Athlete: Runnable {
    // Missing run() implementation
}

let athlete = Athlete()
athlete.run()

medium

A. Athlete struct must implement run() method

B. Protocol Runnable cannot be used with structs

C. run() method should return a value

D. Cannot create instance of Athlete

Solution

1. Step 1: Check protocol requirements

   The protocol Runnable requires a run() method to be implemented.

2. Step 2: Verify struct conformance

   The struct Athlete does not implement run(), so it does not conform properly.

3. Final Answer:

   Athlete struct must implement run() method -> Option A

4. Quick Check:

   Protocol methods must be implemented in conforming types [OK]

Hint: Check if all protocol methods are implemented in struct/class [OK]

Common Mistakes:

• Assuming protocols can't be used with structs
• Thinking run() must return a value
• Believing instance creation is the error

5. You want to create a reusable logging system in Swift using protocol-oriented programming. Which approach best supports easy reuse and maintenance?

hard

A. Use global variables to store logs

B. Define a protocol Loggable with a log() method, then extend it with default implementation

C. Write separate logging functions in each class without protocols

D. Create a base class Logger and inherit from it everywhere

Solution

1. Step 1: Understand protocol-oriented programming benefits

   Protocols with default implementations allow behavior sharing without inheritance.

2. Step 2: Evaluate options for reuse and maintenance

   Extending a protocol with default log() method lets many types reuse logging easily and maintain code in one place.

3. Final Answer:

   Define a protocol Loggable with a log() method, then extend it with default implementation -> Option B

4. Quick Check:

   Protocols + extensions = reusable, maintainable code [OK]

Hint: Use protocol with default methods for reusable behavior [OK]

Common Mistakes:

• Relying on inheritance instead of protocols
• Duplicating code in each class
• Using global variables for behavior