Swift Methoden

Swift-Methoden sind Funktionen, die mit bestimmten Typen verbunden sind

in Objective-In C sind Klassen der einzige Typ, der Methoden definieren kann. Aber in Swift können Sie nicht nur entscheiden, ob Sie eine Klasse/Struktur/und können flexibel in den von Ihnen erstellten Typen (Klasse/Struktur/auf Enumeration) Methoden definiert.

Beispielmethoden

In der Swift-Sprache sind Beispielmethoden Methoden, die zu einem bestimmten Beispiel einer bestimmten Klasse, Struktur oder Enumeration gehören.

Beispielmethoden bieten folgende Methoden an:

• Zugriff auf und Änderung der Beispielattribute

• Funktionen bereitstellen, die mit dem Beispielzweck in Verbindung stehen

Beispielmethoden müssen zwischen den großen Klammern ({}) des eigenen Typs geschrieben werden.

Beispielmethoden können implizit auf alle anderen Methoden und Eigenschaften des eigenen Typs zugreifen.

Beispielmethoden können nur von einem bestimmten Beispiel der eigenen Klasse aufgerufen werden.

Beispielmethoden können nicht unabhängig von bestehenden Beispielen aufgerufen werden.

Syntax

func funcname(Parameters) -> Rückgabetyp
{
    Anweisung1
    Anweisung2
    ……
    Anweisung N
    return parameters
}

Online-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 folgenden Programms ist:

6
0

Counter类定义了三个示例方法：

• increment 让计数器按 1 递增；
• incrementBy(amount: Int) 让计数器按一个指定的整数值递增；
• reset 将计数器重置为0。

Counter 这个类还声明了一个可变属性 count，用它来跟踪当前计数器值。

方法的局部参数名称和外部参数名称

Swift 函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用

Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如：with，for，by等等。

Swift 默认仅给方法的第一个参数名称一个局部参数名称；默认同时给第二个和后续的参数名称为全局参数名称。

以下示例中 'nein1在swift中声明为局部参数名称。'nein2用于全局的声明并通过外部程序访问。

import Cocoa
class division {
    var count: Int = 0
    func incrementBy(nein1: Int, nein2: Int) {
        count = nein1 / nein2
        print(count)
    }
}
let counter = division()
counter.incrementBy(nein1: 1800, no2: 3)
counter.incrementBy(nein1: 1600, no2: 5)
counter.incrementBy(nein1: 11000, no2: 3)

Die Ausgabe des folgenden Programms ist:

600
320
3666

是否提供外部名称设置

我们强制在第一个参数添加外部名称，把这个局部名称当作外部名称使用（Swift 2.0前面是使用 # 号）。

Ganz相反，我们也可以使用下划线（_）来设置第二个及后续的参数不提供一个外部名称。

import Cocoa
class multiplication {
    var count: Int = 0
    func incrementBy(first nein1: Int, nein2: Int) {
        count = nein1 * nein2
        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 folgenden Programms ist:

2400
500
45000

self-Eigenschaft

Jedes Beispiel eines Typs hat eine implizite Eigenschaft namens self, self ist vollständig gleich dem Beispiel selbst.

Sie können die implizite Eigenschaft self in einer Beispielmethoden eines Beispiels verwenden, um auf das aktuelle Beispiel 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("Innerhalb von Self: \(res)")
    }
    func tot(c: Int) -> Int {
        return res - c
    }
    func result() {
        print("Ergebnis: \(tot(c: 20))
        print("Ergebnis: \(tot(c: 50))
    }
}
let pri = calculations(a: 600, b: 300)
let sum = calculations(a: 1200, b: 300)
pri.result()
sum.result()

Die Ausgabe des folgenden Programms ist:

Innerhalb von Self: 900
Innerhalb von Self: 1500
Ergebnis: 880
Ergebnis: 850
Ergebnis: 1480
Ergebnis: 1450

Veränderung von Werttypen in Beispielmethoden

Strukturelemente und Enumerationen in der Swift-Sprache sind Werttypen. In der Regel können die Eigenschaften von Werttypen nicht in ihren Beispielmethoden geändert werden.

Wenn Sie jedoch tatsächlich in einer bestimmten Methode die Eigenschaften eines Strukturelements oder einer Enumeration ändern möchten, können Sie die Methode "veränderbar" (mutating) wählen, dann kann die Methode ihre Eigenschaften aus dem Inneren der Methode ändern; und alle Änderungen werden am Ende der Methode im ursprünglichen Struktur element beibehalten.

Die Methode kann auch der impliziten Eigenschaft self einen neuen Beispiel zuweisen, das am Ende der Methode den ursprünglichen Beispiel ersetzen wird.

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 folgenden Programms ist:

9
15
270
450
81000
135000

self zuweisen in veränderbaren Methoden

Veränderbare Methoden können der impliziten Eigenschaft self einen neuen Beispiel 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 folgenden Programms ist:

39
65

类型方法

Methoden, die von einer Instanz eines Typs aufgerufen werden, werden als Beispielmethode bezeichnet. Sie können auch Methoden definieren, die vom Typ selbst aufgerufen werden, und diese Methoden werden als Typenmethoden bezeichnet.

Typenmethoden für Strukturen und Enumerationen werden vor dem Funktionskeyword func mit dem Schlüsselwort static hinzugefügt. Klassen können das Schlüsselwort class verwenden, um den Überarbeitung der Implementierung durch Subklassen zu erlauben.

Typenmethoden werden wie die Methoden eines Typs mit dem Punkt-Notation (.) aufgerufen. Methoden, die von einer Instanz eines Typs aufgerufen werden, können auch Methoden definiert werden, die vom Typ selbst aufgerufen werden, und diese Methoden werden als Typenmethoden bezeichnet.

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 folgenden Programms ist:

35
5