Swift - Methods

In Swift, methods are functions that are associated with a particular type. Classes, structures, and enumerations can all define instance methods, which encapsulate specific tasks and functionality for that instance. Classes can also define type methods, which are associated with the type itself, rather than any one instance.

1. Instance Methods

Instance methods are functions that belong to instances of a particular class, structure, or enumeration.

class Counter {
    var count = 0

    func increment() {
        count += 1
    }

    func increment(by amount: Int) {
        count += amount
    }

    func reset() {
        count = 0
    }
}

let counter = Counter()
counter.increment()   // count now is 1
counter.increment(by: 5)  // count now is 6
counter.reset()  // count now is 0

In instance methods, you can access and modify the properties of the instance using self to differentiate between the property and a method parameter with the same name.

2. Type Methods

These are methods that you call on the type itself, rather than on an instance. They are similar to static methods in other languages. In Swift, you define type methods with the static keyword for value types (like structures and enumerations). For classes, you can use the class keyword to allow subclasses to override the superclass's implementation of that method.

struct Math {
    static func square(_ number: Int) -> Int {
        return number * number
    }
}

let squaredValue = Math.square(5)  // squaredValue is 25

class MyClass {
    class func myTypeMethod() {
        // type method body
    }
}

MyClass.myTypeMethod()

3. Modifying Value Types from Within Instance Methods

Structures and enumerations are value types in Swift. By default, the properties of value types cannot be modified from within their instance methods. However, you can opt in to modifying behavior by prefixing the method with the mutating keyword.

struct Point {
    var x = 0.0, y = 0.0
    mutating func moveBy(x deltaX: Double, y deltaY: Double) {
        x += deltaX
        y += deltaY
    }
}

var somePoint = Point(x: 1.0, y: 1.0)
somePoint.moveBy(x: 2.0, y: 3.0)

In the example above, the moveBy method needed to modify the properties of the structure, so it's marked with the mutating keyword.

Remember, methods are a crucial part of the type definition in Swift. They allow you to encapsulate functionality and behavior and provide a clean and clear API for those using these types.

How to define methods in Swift classes:
Description: Methods in Swift are functions that are associated with a particular type, often a class.
```
class MyClass {
    func myMethod() {
        print("Hello from myMethod!")
    }
}

let myInstance = MyClass()
myInstance.myMethod()
```

Instance methods vs. class methods in Swift:

Description: Instance methods are associated with an instance of a class, while class methods are associated with the class itself.

class MyClass {
    var value = 0

    // Instance method
    func increment() {
        value += 1
    }

    // Class method
    class func printDefaultValue() {
        print("Default value: 0")
    }
}

let myInstance = MyClass()
myInstance.increment()

MyClass.printDefaultValue()

Swift method parameters and return types:

Description: Methods can take parameters and return values, just like functions.

class MathOperations {
    func add(_ a: Int, _ b: Int) -> Int {
        return a + b
    }
}

let calculator = MathOperations()
let result = calculator.add(5, 3)
print(result) // Output: 8

Method overloading in Swift:

Description: Method overloading allows defining multiple methods with the same name but different parameters.

class Calculator {
    func add(_ a: Int, _ b: Int) -> Int {
        return a + b
    }

    func add(_ a: Double, _ b: Double) -> Double {
        return a + b
    }
}

let intResult = Calculator().add(5, 3)
let doubleResult = Calculator().add(2.5, 3.5)

Swift method visibility modifiers:

Description: Swift provides access control modifiers like private, internal, and public to control the visibility of methods.

class MyClass {
    private func privateMethod() {
        print("This method is private")
    }

    func publicMethod() {
        print("This method is public")
    }
}

Working with mutating methods in Swift:

Description: mutating keyword is used for methods that modify the properties of a value type (struct or enum).

struct Point {
    var x = 0
    var y = 0

    mutating func moveByX(_ deltaX: Int, y deltaY: Int) {
        x += deltaX
        y += deltaY
    }
}

var point = Point()
point.moveByX(3, y: 5)

Swift methods with optional parameters:

Description: Methods can have parameters with default values to make them optional.

class Greeting {
    func greet(name: String = "Guest") {
        print("Hello, \(name)!")
    }
}

let greeter = Greeting()
greeter.greet() // Output: Hello, Guest!
greeter.greet(name: "John") // Output: Hello, John!

Using self in Swift methods:

Description: self refers to the instance the method is called on and is used to differentiate between instance variables and method parameters.

class Counter {
    var value = 0

    func increment() {
        self.value += 1
    }
}

let counter = Counter()
counter.increment()
print(counter.value) // Output: 1