Methods & Initializers

Functions that live inside your types become methods . In this lesson you'll write instance and type methods, use mutating on structs, master self , and set up new values with designated and convenience init ializers.

Learn Methods & Initializers in our free Swift course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick reference.

Part of the free Swift course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

• • Write instance methods that read and change a type's properties
• • Mark struct methods mutating when they modify the instance
• • Use self to refer to the current instance
• • Define type methods with static (and class func )
• • Initialize values with init
• • Tell designated from convenience initializers

1️⃣ Instance Methods

An instance method is a function written inside a type. It can read the instance's properties directly. Because a struct is a value type , any method that changes a property must be marked mutating — Swift's way of making mutation explicit.

2️⃣ The self Keyword

self refers to the current instance. You only need it when a local name (often an init parameter) would otherwise hide a property of the same name. Elsewhere it's optional.

3️⃣ Type Methods

A type method belongs to the type itself, not an instance. Mark it static and call it on the type, like Temperature.fromFahrenheit(212) . These are perfect for factory helpers and shared constants.

4️⃣ Initializers: Designated vs Convenience

An initializer prepares a new instance by giving every stored property a value. In a class a designated init fully sets up the object, while a convenience init is a helper that must delegate to another init in the same class with self.init(...) .

Your turn. Fill in the blank so the deposit method can change the balance.

Pro Tips

• 💡 Only add mutating when you must. A method that just reads properties doesn't need it.
• 💡 Use type methods for factories. A static func make... reads better than scattering setup code.
• 💡 Keep designated inits simple. Push convenience defaults into convenience inits that call self.init .
• 💡 Write self. only when needed. Reach for it when a parameter shadows a property.

Common Errors (and the fix)

• "Cannot assign to property: 'self' is immutable" — a struct method changed a property without mutating . Add the keyword.
• "Return from initializer without initializing all stored properties" — a designated init left a property unset. Assign every stored property.
• "Cannot call value of non-function type" — you called a type method on an instance, or vice versa. Call type methods on the type name.
• "Self.init isn't called on all paths in delegating initializer" — a convenience init must always call self.init(...) .

📋 Quick Reference

Task

Code

Note

Instance method

func go() { … }

on an instance

Mutating

mutating func add() { … }

struct changes self

Type method

static func make() { … }

on the type

Designated init

init(x: Int) { … }

sets all props

Convenience init

convenience init() { self.init(...) }

delegates

Frequently Asked Questions

Mini-Challenge: Thermostat

No blanks this time — just a brief and an outline. Build it, run it, and check your output against the example in the comments.

🎉 Lesson Complete!

• ✅ Methods are functions defined inside a type
• ✅ Struct methods that change properties need mutating
• ✅ self refers to the current instance; required when names clash
• ✅ Type methods use static and are called on the type
• ✅ Convenience inits delegate to another init with self.init
• ✅ Next lesson: Closures in Depth

Practice quiz

Continue this course

• Previous: Properties: Stored, Computed & Observers
• Next: Closures in Depth