Strukturen und Klassen
Strukturen und Klassen sind zwei der wichtigsten Bausteine der Programmierung in Swift. Mit beiden bündelst du zusammengehörige Daten und Funktionen zu in sich geschlossenen Einheiten. Und wenn du eine Struktur oder eine Klasse definierst, definierst du einen neuen Typ, den du in Swift verwenden kannst, genau wie die Typen, mit denen du schon gearbeitet hast, etwa Int und String.
Strukturen und Klassen haben in Swift viele Gemeinsamkeiten. Unter anderem können beide Werte in Eigenschaften speichern und über Methoden Funktionalität bereitstellen.
Jede von ihnen bietet noch zusätzliche Funktionalität, die in dieser Übung keine Rolle spielt.
Strukturen und Klassen definieren
Strukturen und Klassen werden ungefähr gleich definiert. Sie beginnen mit dem passenden Schlüsselwort, gefolgt vom Namen des Typs, der definiert wird. Danach folgt der Body der Struktur bzw. der Klasse, eingeschlossen von geschweiften Klammern.
Der Body kann gespeicherte Eigenschaften enthalten, die genauso definiert werden und sich genauso verhalten wie normale Konstanten oder Variablen.
struct CharacterStats {
var health = 0.0
var speed = 0
var strength = 0
}
class GameCharacter {
var stats = CharacterStats()
var characterClass: String?
var name: String?
var active = false
let id = makeRandomID()
}
Instanzen
Wie oben erwähnt, definierst du beim Definieren einer Struktur oder Klasse nur einen neuen Typ. Das ist nur der Bauplan dafür, wie die Werte dieses Typs aussehen werden. Es werden aber noch keine Werte dieses Typs erzeugt, mit denen du arbeiten kannst.
Um eine Instanz dieses Typs zu erzeugen, schreibst du den Namen des Typs gefolgt von einem Paar runder Klammern.
let someStats = CharacterStats()
let someCharacter = GameCharacter()
Dadurch werden Werte dieser Typen erzeugt, wobei die Eigenschaften mit den Standardwerten aus der Definition befüllt werden. Beachte, dass in optionalen Fällen wie der Eigenschaft name von GameCharacter die Eigenschaft standardmäßig nil ist, wenn kein Wert angegeben wird, genau wie beim Definieren gewöhnlicher optionaler Typen, bei denen nicht sofort ein Wert angegeben wird.
Bei Strukturen stellt Swift automatisch etwas bereit, das memberwise Initializer heißt. Darin kannst du in den Klammern Werte für die Eigenschaften der Struktur angeben, die die Standardwerte aus der Definition überschreiben.
let differentStats = CharacterStats(health: 100.0, speed: 6, strength: 18)
Auf Eigenschaften zugreifen
Auf Eigenschaften von Strukturen und Klassen greifst du mit der Punktnotation zu: Auf den Namen des Werts folgt ein Punkt (.) und dann der Name der Eigenschaft. Hat eine Eigenschaft einer Struktur oder Klasse selbst Eigenschaften, kannst du mit dieser Punktnotation auch auf diese verschachtelten Eigenschaften zugreifen.
Mit dieser Notation kannst du den Wert der Eigenschaft sowohl abrufen als auch, wo erlaubt, ändern.
someStats.health
// => 0
someCharacter.name
// => nil
someStats.health = 87.3
someStats.health
// => 87.3
someCharacter.name = "Luther"
someCharacter.name
// => "Luther"
someCharacter.id = "new id"
// Error: Cannot assign to property: 'id' is a 'let' constant
Methoden
Wie Eigenschaften, die Daten in deinen Strukturen und Klassen speichern, kannst du auch Methoden definieren, die Funktionen in deiner Struktur oder Klasse speichern.
Methoden werden genauso definiert wie eine normale Funktion, nur innerhalb des Bodys der Struktur oder Klasse. Beachte, dass eine Funktion mit dem Schlüsselwort mutating versehen werden muss, wenn sie den Wert einer Eigenschaft in einer Struktur ändert. Außerdem muss eine Eigenschaft mit var statt let definiert werden, wenn eine Methode sie ändern können soll, genau wie bei normalen Variablen.
struct CharacterStats {
var health = 0.0
var speed = 0
var strength = 0
mutating func takeHit(_ damage: Double) {
health = max(0.0, health - damage)
}
func canLift(_ weight: Int) -> Bool {
weight < strength * 100
}
}
class GameCharacter {
var stats = CharacterStats()
var characterClass: String?
var name: String?
var active = false
let id: String = makeRandomID()
func takesDamage(_ damage: Double) {
stats.takeHit(damage)
if stats.health <= 0 {
active = false
}
}
func sayName() -> String {
return "My name is \(name ?? "no one"), my class is \(characterClass ?? "undetermined")"
}
func lift(_ weight: Int) -> String {
if stats.canLift(weight) {
return "No problem!"
} else {
return "Ooof! No way."
}
}
}
Diese Methoden rufst du mit der Punktnotation auf, genau wie Eigenschaften.
var myChar = GameCharacter()
myChar.stats = CharacterStats(health: 72.8, speed: 19, strength: 6)
myChar.active = true
myChar.lift(750)
// => "Ooof! No way."
myChar.takesDamage(80)
myChar.active
// => false
Self
Jede Instanz einer Struktur oder Klasse hat eine implizite Eigenschaft namens self, die auf die Instanz selbst verweist.
Am häufigsten wird self verwendet, um zwischen einer Eigenschaft der Instanz und einem Parameter mit demselben Namen zu unterscheiden:
struct Position {
var x = 0
mutating func move(x: Int) {
// Here, 'self.x' refers to the struct's property,
// while 'x' refers to the parameter passed to the method.
self.x = x
}
}
Swift-Typen bieten außerdem das großgeschriebene Schlüsselwort Self, das auf den Typ der Instanz verweist und nicht auf die Instanz selbst.
Lernübung
