Protocol requirements (methods and properties) in Swift - Step-by-Step Execution

Concept Flow - Protocol requirements (methods and properties)

Define Protocol

↓

Declare Method & Property Requirements

↓

Create Struct/Class

↓

Implement Required Methods & Properties

↓

Use Instance of Struct/Class

↓

Call Methods & Access Properties

↓

Program Runs Successfully

This flow shows how you define a protocol with required methods and properties, then create a type that implements them, and finally use that type.

Execution Sample

Swift

protocol Vehicle {
    var speed: Int { get set }
    mutating func accelerate()
}

struct Car: Vehicle {
    var speed = 0
    mutating func accelerate() { speed += 10 }
}

Defines a protocol Vehicle with a property and method requirement, then a struct Car that implements them.

Execution Table

Step	Action	Variable/Property	Value	Note
1	Define protocol Vehicle	-	-	Protocol requires speed property and accelerate() method
2	Create Car instance	car.speed	0	Initial speed is 0
3	Call car.accelerate()	car.speed	10	Speed increases by 10
4	Call car.accelerate() again	car.speed	20	Speed increases by 10 again
5	End	-	-	Program ends after method calls

💡 No more method calls, execution ends

Variable Tracker

Variable/Property	Start	After 1 accelerate()	After 2 accelerate() calls	Final
car.speed	0	10	20	20

Key Moments - 2 Insights

Why must Car implement both the speed property and accelerate() method?

Because the protocol Vehicle requires both. The execution_table step 1 shows these requirements, and step 2 fails if Car does not implement them.

Why does speed change when calling accelerate()?

Because accelerate() method increases speed by 10 each time, as shown in execution_table steps 3 and 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is car.speed after the first accelerate() call?

A 10

B 0

C 20

D Undefined

💡 Hint

Check execution_table row 3 where car.speed changes to 10

At which step does the protocol requirement get fulfilled by Car?

A Step 1

B Step 2

C Step 3

D Step 5

💡 Hint

Step 2 shows Car instance created with speed property implemented

If accelerate() added 5 instead of 10, what would car.speed be after two calls?

A 10

B 5

C 15

D 20

💡 Hint

Each call adds 5, so after two calls speed is 5 + 5 = 15

Concept Snapshot

protocol ProtocolName {
  var propertyName: Type { get set }
  func methodName()
}

struct/ class TypeName: ProtocolName {
  var propertyName = initialValue
  func methodName() { /* implementation */ }
}

- Protocol defines required methods and properties.
- Types must implement all requirements.
- Properties can be gettable or get/set.
- Methods define behavior to implement.

Full Transcript

This example shows how to define a protocol in Swift with required properties and methods. The protocol Vehicle requires a speed property and an accelerate() method. The struct Car implements these requirements by defining speed and the accelerate() method that increases speed. The execution table traces creating a Car instance, calling accelerate twice, and how speed changes from 0 to 10 then 20. Key moments clarify why Car must implement all protocol requirements and how method calls change property values. The visual quiz tests understanding of property values after method calls and protocol fulfillment steps.