Initializers and designated init in Swift - Deep Dive

Overview - Initializers and designated init

What is it?

Initializers in Swift are special functions that prepare a new instance of a class, struct, or enum for use. They set up initial values for properties and perform any setup needed before the instance is ready. A designated initializer is the main initializer for a class that fully initializes all properties introduced by that class and calls an initializer from its superclass if it has one. This ensures every instance starts in a valid state.

Why it matters

Without initializers, you would have to manually set up every property after creating an object, which is error-prone and inefficient. Designated initializers guarantee that all properties are properly set before use, preventing bugs and crashes. They also provide a clear, structured way to create objects, making code safer and easier to understand.

Where it fits

Before learning initializers, you should understand basic Swift types like classes, structs, and properties. After mastering initializers and designated initializers, you can learn about convenience initializers, initializer delegation, and inheritance rules in Swift.

Mental Model

Core Idea

An initializer is like a recipe that fully prepares a new object so it’s ready to use, and a designated initializer is the main recipe that makes sure every ingredient (property) is added correctly.

Think of it like...

Think of building a sandwich: the designated initializer is the main step where you add all the essential ingredients like bread, meat, and cheese to make a complete sandwich before you can eat it.

┌─────────────────────────────┐
│        Initializer          │
│  (sets up new instance)     │
└─────────────┬───────────────┘
              │
    ┌─────────┴─────────┐
    │                   │
┌───────────────┐  ┌───────────────┐
│Designated Init│  │Convenience Init│
│(main setup)   │  │(helper setup)  │
└───────────────┘  └───────────────┘

Build-Up - 7 Steps

1

Foundation

What is an initializer in Swift

Concept: Introduce the basic idea of an initializer as a special function to create and prepare an object.

In Swift, an initializer is a special function named init() that sets up a new instance of a class or struct. It assigns initial values to all properties so the object is ready to use. For example: class Dog { var name: String init(name: String) { self.name = name } } Here, init(name:) sets the dog's name when creating a new Dog.

Result

You can create a Dog with a name right away: let myDog = Dog(name: "Buddy")

Understanding that initializers prepare objects before use helps avoid errors from uninitialized properties.

2

Foundation

Difference between classes and structs initializers

Concept: Explain how initializers work for both classes and structs, noting automatic memberwise initializers for structs.

Structs in Swift get a free initializer that sets all properties automatically if you don't write one. For example: struct Point { var x: Int var y: Int } You can create a Point with Point(x: 3, y: 4) without writing init(). Classes, however, need you to write initializers unless you provide default values for all properties.

Result

Structs can be created easily without custom init, but classes usually require explicit initializers.

Knowing this difference helps you decide when to use structs or classes and how to write initializers efficiently.

3

Intermediate

What is a designated initializer

🤔Before reading on: do you think all initializers in a class are equal, or is there a special main initializer? Commit to your answer.

Concept: Introduce designated initializers as the primary initializers that fully initialize a class’s properties and call superclass initializers.

A designated initializer is the main initializer for a class. It must initialize all properties introduced by that class and call a superclass initializer if the class inherits from another. For example: class Vehicle { var wheels: Int init(wheels: Int) { self.wheels = wheels } } class Car: Vehicle { var color: String init(wheels: Int, color: String) { self.color = color super.init(wheels: wheels) } } Here, Car’s init(wheels:color:) is a designated initializer.

Result

Designated initializers ensure every property is set and superclass setup is done, so Car instances are fully ready.

Understanding designated initializers clarifies how Swift enforces safe and complete object setup in inheritance.

4

Intermediate

Initializer delegation rules in classes

🤔Before reading on: do you think a designated initializer can call another designated initializer in the same class? Commit to yes or no.

Concept: Explain how designated initializers must call superclass initializers, and convenience initializers delegate to designated ones within the same class.

Swift has rules for initializer calls: - A designated initializer must call a designated initializer from its superclass. - A convenience initializer must call another initializer from the same class. - Convenience initializers eventually call a designated initializer. This ensures a clear path to fully initialize all properties. Example: class Person { var name: String init(name: String) { self.name = name } convenience init() { self.init(name: "Unknown") } }

Result

Initializer delegation keeps initialization organized and prevents missing property setups.

Knowing delegation rules helps avoid common bugs where properties remain uninitialized or superclass setup is skipped.

5

Intermediate

How designated init differs from convenience init

🤔Before reading on: do you think convenience initializers can fully initialize all properties? Commit to yes or no.

Concept: Clarify that designated initializers fully initialize properties, while convenience initializers provide shortcuts and must call designated ones.

Designated initializers are the main initializers that set all properties and call superclass initializers. Convenience initializers are helpers that provide simpler ways to create an object but must call a designated initializer. Example: class Rectangle { var width: Double var height: Double init(width: Double, height: Double) { self.width = width self.height = height } convenience init(size: Double) { self.init(width: size, height: size) } } Here, init(width:height:) is designated, and init(size:) is convenience.

Result

Convenience initializers simplify object creation but rely on designated initializers to do the full setup.

Understanding this distinction helps write clear, maintainable initializers and use them correctly.

6

Advanced

Designated init in inheritance chains

🤔Before reading on: do you think a subclass’s designated initializer can skip calling its superclass’s designated initializer? Commit to yes or no.

Concept: Explain how designated initializers in subclasses must call a superclass designated initializer to ensure full initialization up the chain.

In a class inheritance chain, each designated initializer must call a designated initializer from its immediate superclass. This guarantees that all properties from every class in the chain are initialized properly. Example: class Animal { var age: Int init(age: Int) { self.age = age } } class Dog: Animal { var breed: String init(age: Int, breed: String) { self.breed = breed super.init(age: age) } } If Dog’s init did not call super.init, the Animal’s age would remain uninitialized, causing errors.

Result

This rule prevents incomplete initialization and runtime crashes in inheritance.

Knowing this prevents the most common bugs in subclass initializers and enforces safe object construction.

7

Expert

How Swift enforces initializer safety

🤔Before reading on: do you think Swift allows creating an object with uninitialized properties? Commit to yes or no.

Concept: Reveal Swift’s compile-time checks that ensure all stored properties are initialized before use, and how designated initializers play a key role.

Swift’s compiler enforces strict rules so no stored property is left uninitialized. It requires that designated initializers initialize all properties introduced by their class before calling super.init. This prevents runtime crashes from uninitialized memory. Additionally, Swift prevents calling methods or accessing properties before initialization completes, ensuring safe, predictable object state. This safety is why you must call super.init in subclass designated initializers and why convenience initializers must delegate properly.

Result

Swift guarantees objects are fully and safely initialized before use, catching errors early at compile time.

Understanding Swift’s safety checks explains why initializer rules exist and helps write robust, crash-free code.

Under the Hood

When you create an instance, Swift runs the initializer code to assign values to every stored property. For classes, this happens in two phases: first, the class initializes its own properties, then it calls the superclass initializer to initialize inherited properties. The compiler tracks initialization state to prevent using properties before they are set. This is done at compile time with strict rules, so runtime errors from uninitialized properties are avoided.

Why designed this way?

Swift was designed with safety and clarity in mind. Early languages allowed uninitialized properties, causing bugs and crashes. Swift’s initializer rules enforce a clear, step-by-step setup process, especially in inheritance, to prevent these issues. The two-phase initialization and delegation rules balance flexibility with safety, making code easier to reason about and maintain.

┌───────────────────────────────┐
│        Create Instance         │
└───────────────┬───────────────┘
                │
      ┌─────────┴─────────┐
      │ Initialize subclass│
      │  stored properties │
      └─────────┬─────────┘
                │
      ┌─────────┴─────────┐
      │ Call superclass    │
      │ designated init    │
      └─────────┬─────────┘
                │
      ┌─────────┴─────────┐
      │ Initialize superclass│
      │ stored properties    │
      └─────────┬─────────┘
                │
      ┌─────────┴─────────┐
      │ Instance ready to  │
      │ use               │
      └───────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think convenience initializers can call superclass initializers directly? Commit to yes or no.

Common Belief: Convenience initializers can call superclass initializers directly to set up inherited properties.

Reality: Convenience initializers must call another initializer within the same class, never a superclass initializer directly. Only designated initializers call superclass initializers.

Why it matters: Misusing convenience initializers to call super.init breaks Swift’s safety rules and causes compile errors or runtime crashes.

Quick: Do you think a class can have multiple designated initializers? Commit to yes or no.

Common Belief: A class can only have one designated initializer.

Reality: A class can have multiple designated initializers, each fully initializing the class’s properties and calling a superclass initializer.

Why it matters: Believing there can be only one limits design flexibility and leads to unnecessary code duplication.

Quick: Do you think structs require calling super.init? Commit to yes or no.

Common Belief: Structs must call super.init like classes do.

Reality: Structs do not have inheritance, so they never call super.init. Their initializers only set their own properties.

Why it matters: Confusing structs with classes leads to incorrect initializer code and compiler errors.

Quick: Do you think Swift allows creating an object without initializing all properties? Commit to yes or no.

Common Belief: Swift lets you create objects even if some properties are not initialized yet.

Reality: Swift requires all stored properties to be initialized before an object is created. The compiler enforces this strictly.

Why it matters: Assuming otherwise causes runtime crashes and bugs from uninitialized memory.

Expert Zone

1

Designated initializers can be overloaded to provide multiple ways to fully initialize a class, improving API flexibility.

2

Swift’s two-phase initialization prevents accessing self or calling instance methods before all properties are initialized, avoiding subtle bugs.

3

In complex inheritance hierarchies, understanding initializer delegation is key to avoiding infinite loops or missing initialization.

When NOT to use

Designated initializers are not used in structs with default memberwise initializers unless custom setup is needed. For simple data containers, relying on automatic initializers is better. Also, in protocols or enums, initializers behave differently, so designated initializers are not applicable.

Production Patterns

In real-world Swift apps, designated initializers are used to enforce required properties and dependencies at creation time. They often work with dependency injection and are combined with convenience initializers to provide flexible, readable APIs. Proper use avoids runtime crashes and makes code easier to maintain and test.

Connections

Constructor functions in other languages

Similar pattern

Understanding Swift initializers helps grasp constructors in languages like Java or C++, as they serve the same purpose of preparing new objects safely.

Factory design pattern

Builds-on

Designated initializers are the foundation for factory methods that create objects with complex setup, showing how initialization relates to design patterns.

Biological cell development

Analogous process

Just as a cell must complete all stages of development before functioning, an object must complete all initialization steps before use, illustrating the importance of complete setup.

Common Pitfalls

#1 Forgetting to call super.init in subclass designated initializer

Wrong approach:

class Bird: Animal {
var canFly: Bool
init(canFly: Bool) {
self.canFly = canFly
// Missing super.init call
}
}

Correct approach:

class Bird: Animal {
var canFly: Bool
init(canFly: Bool) {
self.canFly = canFly
super.init(age: 0) // or appropriate call
}
}

Root cause:

Misunderstanding that subclass initializers must call superclass initializers to fully initialize inherited properties.

#2 Calling superclass initializer from a convenience initializer

Wrong approach:

class Car: Vehicle {
convenience init(color: String) {
super.init(wheels: 4) // Incorrect
self.color = color
}
}

Correct approach:

class Car: Vehicle {
convenience init(color: String) {
self.init(wheels: 4, color: color) // Calls designated init
}
}

Root cause:

Confusing the roles of convenience and designated initializers and their delegation rules.

#3 Not initializing all properties in designated initializer

Wrong approach:

class House {
var rooms: Int
var address: String
init(rooms: Int) {
self.rooms = rooms
// Missing address initialization
}
}

Correct approach:

class House {
var rooms: Int
var address: String
init(rooms: Int, address: String) {
self.rooms = rooms
self.address = address
}
}

Root cause:

Forgetting to initialize every stored property before completing the initializer.

Key Takeaways

Initializers in Swift prepare new objects by setting all properties before use, ensuring safety.

Designated initializers are the main initializers that fully initialize a class and call superclass initializers.

Convenience initializers provide shortcuts but must delegate to designated initializers within the same class.

Swift enforces strict rules at compile time to prevent uninitialized properties and unsafe object states.

Understanding initializer delegation and inheritance rules is key to writing robust, maintainable Swift code.