Object-Oriented Programming in Swift

# CHAPTER 7

Object-Oriented Programming in Swift #

1. Introduction #

2. Learning Objectives #

• Define custom data models using struct and class.

• Add variables (Properties) and functions (Methods) to your models.

• Instantiate Objects from your blueprints.

• Understand the difference between Value Types (Structs) and Reference Types (Classes).

• Build a basic architectural model for an application.

3. What is a Blueprint? #

• The Blueprint is the Class / Struct.

• The physical cars are the Objects (Instances).

4. Structs (The Swift Standard) #

// 1. Defining the Blueprint
struct Player {
    // Properties (Data)
    var name: String
    var health: Int
    
    // Methods (Behaviors inside the struct)
    func takeDamage(amount: Int) {
        print("\(name) took \(amount) damage!")
    }
}

// 2. Creating the Object (Spawning the physical car!)
var playerOne = Player(name: "Arthur", health: 100)
var playerTwo = Player(name: "John", health: 80)

// 3. Accessing the Object using 'Dot Notation'
print(playerOne.name) // Prints "Arthur"
playerOne.takeDamage(amount: 20)

Notice how Swift automatically created an initializer Player(name:health:) for us! This is called a *Memberwise Initializer*, and it is a massive benefit of Structs.

5. Classes (The Legacy System) #

class Enemy {
    var name: String
    var health: Int
    
    // Classes DO NOT get automatic initializers. You MUST write it manually!
    init(name: String, health: Int) {
        self.name = name
        self.health = health
    }
}

var boss = Enemy(name: "Bowser", health: 500)

6. The Big Interview Question: Structs vs Classes #

• Structs are VALUE Types: If you copy a struct, Swift creates a physically separate clone. Modifying the clone does NOT affect the original.

• Classes are REFERENCE Types: If you copy a class, you are just creating a new pointer to the exact same object in memory. Modifying the copy *mutates the original*.

// STRUCT BEHAVIOR (Clones)
var a = Player(name: "A", health: 100)
var b = a  // CLONES 'a'
b.name = "B"
print(a.name) // Prints "A". The original is safe!

// CLASS BEHAVIOR (Shared Memory)
var x = Enemy(name: "X", health: 100)
var y = x  // Points to the SAME EXACT ENEMY!
y.name = "Y"
print(x.name) // Prints "Y". The original was mutated!

*Apple highly recommends using Structs for almost everything in SwiftUI, as immutability prevents massive bugs!*

7. Mini Project: Student Management Model #

struct Student {
    let id: String
    var name: String
    var grade: Double
    
    // A method to evaluate the student
    func isPassing() -> Bool {
        return grade >= 60.0
    }
}

// Spawning the objects
let student1 = Student(id: "001", name: "Alice", grade: 85.5)
let student2 = Student(id: "002", name: "Bob", grade: 45.0)

// Utilizing the methods
print("\(student1.name) passing? \(student1.isPassing())") // true
print("\(student2.name) passing? \(student2.isPassing())") // false

8. Visual Learning: OOP Structure #

[ BLUEPRINT: struct Car ]
    |-- Properties (Color, TopSpeed)
    |-- Methods (Drive(), Brake())

        | (Instantiating)
        v
[ OBJECT 1 ]                 [ OBJECT 2 ]
color: Red                   color: Blue
TopSpeed: 150                TopSpeed: 90

9. Common Mistakes #

• Mutating Struct Methods: If you have a struct and you write a method that tries to change one of its own properties (e.g., self.health -= 10), the compiler will error! Because structs are value types (immutable by default), you must explicitly mark the method with the mutating keyword: mutating func takeDamage().

10. Best Practices #

• Default to Structs: In Objective-C, everything was a Class. In modern Swift, you should always start by creating a struct. Only upgrade it to a class if you explicitly need shared memory (reference semantics) or Inheritance (which structs do not support).

11. Exercises #

1. 1. Create a struct named Book with properties for title (String) and author (String). Create an instance of this book.

1. 2. Add a method read() to the struct that prints "Now reading [title]".

12. Coding Challenges #

13. MCQ Quiz with Answers #

14. Interview Questions #

• Q: Explain the mechanical difference between a Value Type and a Reference Type in Swift memory architecture.

• Q: Why did Apple architect SwiftUI to rely almost entirely on Structs for its UI View hierarchy instead of traditional UIKit Classes?

• Q: What is the specific purpose of the mutating keyword when writing a function inside a Swift Struct?

15. FAQs #

16. Summary #

17. Next Chapter Recommendation #