Swift-Methoden

Swift-Methoden sind Funktionen, die einem bestimmten Typ zugeordnet sind.

In Objective-C sind Klassen der einzige Typ, der Methoden definieren kann. In Swift können Sie jedoch nicht nur wählen, ob Sie eine Definition für class/struct/enum erstellen, sondern auch flexibel Methoden für die Typen definieren, die Sie erstellen (class/struct/enum).


Instanzmethoden

In Swift sind Instanzmethoden Methoden, die zu Instanzen einer bestimmten Klasse, Struktur oder eines Aufzählungstyps gehören.

Instanzmethoden bieten die folgenden Fähigkeiten:

  • Sie können auf Instanzeigenschaften zugreifen und diese ändern

  • Sie bieten Funktionalität, die mit dem Zweck der Instanz zusammenhängt

Instanzmethoden müssen zwischen den öffnenden und schließenden geschweiften Klammern ({}) des Typs, zu dem sie gehören, geschrieben werden.

Instanzmethoden können implizit auf alle anderen Instanzmethoden und Eigenschaften des Typs zugreifen, zu dem sie gehören.

Instanzmethoden können nur auf einer bestimmten Instanz der Klasse aufgerufen werden, zu der sie gehören.

Instanzmethoden können nicht unabhängig von einer vorhandenen Instanz aufgerufen werden.

Syntax

func funcname(Parameters) -> returntype
{
    Statement1
    Statement2
    ……
    Statement N
    return parameters
}

Beispiel

import Cocoa

class Counter {
    var count = 0
    func increment() {
        count += 1
    }
    func incrementBy(amount: Int) {
        count += amount
    }
    func reset() {
        count = 0
    }
}
// 初始计数值是0
let counter = Counter()

// 计数值现在是1
counter.increment()

// 计数值现在是6
counter.incrementBy(amount: 5)
print(counter.count)

// 计数值现在是0
counter.reset()
print(counter.count)

Die Ausgabe des obigen Programms ist:

6
0

Die Counter-Klasse definiert drei Instanzmethoden:

  • incrementErhöht den Zähler um 1;
  • incrementBy(amount: Int)Erhöht den Zähler um einen angegebenen ganzzahligen Wert;
  • resetSetzt den Zähler auf 0 zurück.

CounterDie Klasse deklariert außerdem eine variable Eigenschaftcount, um den aktuellen Zählerwert zu verfolgen.


Lokale und externe Parameternamen für Methoden

Swift-Funktionsparameter können sowohl einen lokalen Namen (der im Funktionskörper verwendet wird) als auch einen externen Namen haben (der beim Aufruf der Funktion verwendet wird).

Methoden in Swift sind Methoden in Objective-C äußerst ähnlich. Wie in Objective-C verwendet der Name einer Methode in Swift normalerweise eine Präposition, um auf den ersten Parameter der Methode zu verweisen, wie z. B. with, for, by usw.

Standardmäßig vergibt Swift nur dem ersten Parameternamen einen lokalen Parameternamen; standardmäßig vergibt es dem zweiten und den nachfolgenden Parameternamen externe Parameternamen.

Im folgenden Beispiel wird 'no1' in Swift als lokaler Parametername deklariert. 'no2' wird als externer Parametername deklariert und es wird von externem Code darauf zugegriffen.

import Cocoa

class division {
    var count: Int = 0
    func incrementBy(no1: Int, no2: Int) {
        count = no1 / no2
        print(count)
    }
}

let counter = division()
counter.incrementBy(no1: 1800, no2: 3)
counter.incrementBy(no1: 1600, no2: 5)
counter.incrementBy(no1: 11000, no2: 3)

Die Ausgabe des obigen Programms ist:

600
320
3666

Externe Parameternamen angeben

Wir erzwingen einen externen Namen für den ersten Parameter, indem wir den lokalen Namen als externen Namen behandeln (vor Swift 2.0 wurde das #-Symbol verwendet).

Umgekehrt können wir auch einen Unterstrich (_) verwenden, um für den zweiten und die nachfolgenden Parameter festzulegen, dass sie keinen externen Namen bereitstellen.
import Cocoa

class multiplication {
    var count: Int = 0
    func incrementBy(first no1: Int, no2: Int) {
        count = no1 * no2
        print(count)
    }
}

let counter = multiplication()
counter.incrementBy(first: 800, no2: 3)
counter.incrementBy(first: 100, no2: 5)
counter.incrementBy(first: 15000, no2: 3)

Die Ausgabe des obigen Programms ist:

2400
500
45000

Die self-Eigenschaft

Jede Instanz eines Typs besitzt eine implizite Eigenschaft namens self, die genau der Instanz selbst entspricht.

Sie können diese implizite self-Eigenschaft innerhalb einer Instanzmethode einer Instanz verwenden, um auf die aktuelle Instanz zu verweisen.

import Cocoa

class calculations {
    let a: Int
    let b: Int
    let res: Int
    
    init(a: Int, b: Int) {
        self.a = a
        self.b = b
        res = a + b
        print("Self 内: \(res)")
    }
    
    func tot(c: Int) -> Int {
        return res - c
    }
    
    func result() {
        print("结果为: \(tot(c: 20))")
        print("结果为: \(tot(c: 50))")
    }
}

let pri = calculations(a: 600, b: 300)
let sum = calculations(a: 1200, b: 300)

pri.result()
sum.result()

Die Ausgabe des obigen Programms ist:

Self 内: 900
Self 内: 1500
结果为: 880
结果为: 850
结果为: 1480
结果为: 1450

Werttypen aus Instanzmethoden heraus ändern

In Swift sind Strukturen und Enumerationen Werttypen. Standardmäßig können die Eigenschaften eines Werttyps nicht innerhalb seiner Instanzmethoden geändert werden.

Wenn Sie jedoch die Eigenschaften einer Struktur oder Enumeration wirklich in einer bestimmten Methode ändern müssen, können Sie die Methode als mutating kennzeichnen. Die Methode kann dann ihre Eigenschaften innerhalb der Methode ändern; und alle Änderungen, die sie vornimmt, bleiben in der ursprünglichen Struktur erhalten, wenn die Methode endet.

Eine Methode kann auch eine vollständig neue Instanz ihrer impliziten self-Eigenschaft zuweisen, und diese neue Instanz ersetzt die ursprüngliche Instanz, wenn die Methode endet.

import Cocoa

struct area {
    var length = 1
    var breadth = 1
    
    func area() -> Int {
        return length * breadth
    }
    
    mutating func scaleBy(res: Int) {
        length *= res
        breadth *= res
        
        print(length)
        print(breadth)
    }
}

var val = area(length: 3, breadth: 5)
val.scaleBy(res: 3)
val.scaleBy(res: 30)
val.scaleBy(res: 300)

Die Ausgabe des obigen Programms ist:

9
15
270
450
81000
135000

Zuweisung an self innerhalb einer mutating-Methode

Eine mutating-Methode kann eine vollständig neue Instanz der impliziten self-Eigenschaft zuweisen.

import Cocoa

struct area {
    var length = 1
    var breadth = 1
    
    func area() -> Int {
        return length * breadth
    }
    
    mutating func scaleBy(res: Int) {
        self.length *= res
        self.breadth *= res
        print(length)
        print(breadth)
    }
}
var val = area(length: 3, breadth: 5)
val.scaleBy(res: 13)

Die Ausgabe des obigen Programms ist:

39
65

Typmethoden

Instanzmethoden sind Methoden, die von einer Instanz eines Typs aufgerufen werden. Sie können auch Methoden definieren, die vom Typ selbst aufgerufen werden, und solche Methoden werden Typmethoden genannt.

Um Typmethoden für Strukturen und Enumerationen zu deklarieren, fügen Sie das Schlüsselwort static vor dem Schlüsselwort func der Methode hinzu. Klassen können das Schlüsselwort class verwenden, damit Unterklassen die Implementierung der Methode durch die Oberklasse überschreiben können.

Typmethoden werden mit der Punkt-Syntax (.) aufgerufen, genau wie Instanzmethoden.

import Cocoa

class Math
{
    class func abs(number: Int) -> Int
    {
        if number < 0
        {
            return (-number)
        }
        else
        {
            return number
        }
    }
}

struct absno
{
    static func abs(number: Int) -> Int
    {
        if number < 0
        {
            return (-number)
        }
        else
        {
            return number
        }
    }
}

let no = Math.abs(number: -35)
let num = absno.abs(number: -5)

print(no)
print(num)

Die Ausgabe des obigen Programms ist:

35
5
Andere Erweiterungen