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 5Andere Erweiterungen