Les méthodes

1. Méthodes d'Instance

Les méthodes d'instance sont des fonctions qui opèrent sur une instance spécifique d'une classe ou d'une struct. Elles peuvent accéder et modifier les propriétés de l'instance à laquelle elles appartiennent.

class Car {
    var brand: String
    var year: Int
    init(brand: String, year: Int) {
        self.brand = brand
        self.year = year
    }
    func startEngine() {
        print("Le moteur de la \(brand) démarre.")
    }
    func drive(distance: Int) {
        print("La \(brand) a parcouru \(distance) kilomètres.")
    }
}

let myCar = Car(brand: "Tesla", year: 2024)
myCar.startEngine()  // Affiche : "Le moteur de la Tesla démarre."
myCar.drive(distance: 150)  // Affiche : "La Tesla a parcouru 150 kilomètres."

2. Méthodes Mutantes (Mutating Methods)

Les méthodes mutantes sont des méthodes d'instance dans une struct ou une enum qui modifient les propriétés de l'instance. Comme les structs sont des types de valeur, vous devez marquer la méthode avec le mot-clé mutating pour indiquer qu'elle modifie l'instance.

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

var point = Point(x: 1.0, y: 1.0)
point.moveBy(x: 2.0, y: 3.0)  // Le point est maintenant à (3.0, 4.0)
print("Le nouveau point est à (\(point.x), \(point.y))")  // Affiche : "Le nouveau point est à (3.0, 4.0)"

3. Méthodes de Type (Type Methods)

Les méthodes de type sont des méthodes associées à la classe, la struct, ou l'énumération elle-même, plutôt qu'à une instance spécifique. Elles sont définies en utilisant le mot-clé static pour les structs et enums, et class ou static pour les classes.

class MathUtility {
    class func square(number: Int) -> Int {
        return number * number
    }
}

let result = MathUtility.square(number: 5)
print("Le carré de 5 est \(result)")  // Affiche : "Le carré de 5 est 25"

Dans cet exemple, square est une méthode de type, et vous pouvez l'appeler directement sur le type MathUtility, sans avoir besoin de créer une instance.

Pour les structs, cela fonctionne de manière similaire, mais avec static :

struct Circle {
    static let pi = 3.14159
    static func circumference(radius: Double) -> Double {
        return 2 * pi * radius
    }
}

let circumference = Circle.circumference(radius: 5.0)
print("La circonférence est \(circumference)")  // Affiche : "La circonférence est 31.4159"

4. Méthodes d'Instance et de Type dans une Classe

Les classes en Swift peuvent contenir à la fois des méthodes d'instance et des méthodes de type, ce qui permet de gérer des comportements globaux ainsi que ceux spécifiques à chaque instance.

class BankAccount {
    static var interestRate: Double = 0.02  // Propriété de type
    var balance: Double
    init(balance: Double) {
        self.balance = balance
    }
    func applyInterest() {
        balance += balance * BankAccount.interestRate
    }
    static func updateInterestRate(newRate: Double) {
        interestRate = newRate
    }
}

let account = BankAccount(balance: 1000)
account.applyInterest()  // Applique l'intérêt sur le solde actuel
print("Le solde après application des intérêts est de \(account.balance) euros.")  // Affiche : "Le solde après application des intérêts est de 1020.0 euros."
BankAccount.updateInterestRate(newRate: 0.03)  // Met à jour le taux d'intérêt global pour toutes les instances

5. Utilisation Avancée des Méthodes

Les méthodes en Swift peuvent également :

• Accepter des paramètres : Les méthodes peuvent accepter un ou plusieurs paramètres pour effectuer des opérations plus complexes.
• Retourner des valeurs : Elles peuvent retourner des valeurs, ce qui permet d'utiliser leur résultat dans d'autres parties du code.
• Utiliser des paramètres par défaut : Les méthodes peuvent avoir des paramètres avec des valeurs par défaut, simplifiant les appels de méthode.

Exemple de Méthode avec Paramètres par Défaut :

class Printer {
    func printMessage(_ message: String, uppercase: Bool = false) {
        if uppercase {
            print(message.uppercased())
        } else {
            print(message)
        }
    }
}

let printer = Printer()
printer.printMessage("Bonjour tout le monde")  // Affiche : "Bonjour tout le monde"
printer.printMessage("Bonjour tout le monde", uppercase: true)  // Affiche : "BONJOUR TOUT LE MONDE"