Struktúrák és osztályok
A struktúrák és az osztályok a Swift-programozás két legfontosabb építőköve. Mindkettő arra való, hogy a kapcsolódó adatokat és függvényeket önálló funkcionális egységekbe csoportosítsuk. Amikor pedig struktúrát vagy osztályt definiálsz, valójában egy új típust hozol létre a Swiftben, éppúgy, ahogy a korábban megismert típusokat is használtad, például az Int-et és a String-et.
A Swiftben a struktúrák és az osztályok között számos hasonlóság van. Többek között mindkettő képes értékeket tárolni tulajdonságokban, és funkcionalitást nyújtani metódusok segítségével.
Mindkettő nyújt emellett néhány további funkciót, amelyekre ebben a feladatban nem térünk ki.
Struktúrák és osztályok definiálása
A struktúrákat és az osztályokat nagyjából ugyanúgy definiáljuk. Egy megfelelő kulcsszóval kezdődnek, amelyet a definiált típus neve követ, majd a struktúra vagy osztály törzse következik, kapcsos zárójelek között.
A törzs tárolt tulajdonságokból állhat, amelyeket ugyanúgy definiálunk, és ugyanúgy viselkednek, mint a hagyományos konstansok vagy változók.
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()
}
Példányok
Ahogy fentebb említettük, egy struktúra vagy osztály definiálása csupán egy új típus definiálása. Ez csak egy tervrajz arra, hogy milyenek lesznek az adott típus értékei, de valójában nem hoz létre egyetlen ilyen típusú értéket sem, amellyel dolgozhatnál.
Ahhoz, hogy létrehozz egy példányt ebből a típusból, a típus nevét kell leírnod, majd utána egy pár zárójelet.
let someStats = CharacterStats()
let someCharacter = GameCharacter()
Ez létrehozza ezen típusok értékeit, ahol a tulajdonságok a definícióban megadott alapértelmezett értékekkel töltődnek fel. Vedd figyelembe, hogy opcionális esetekben, mint például a GameCharacter name tulajdonsága, ha nem adunk meg értéket, a tulajdonság értéke nil lesz, éppúgy, mint amikor hagyományos opcionális típusokat definiálunk úgy, hogy nem adunk meg azonnal értéket.
Struktúrák esetében a Swift automatikusan biztosít valamit, amit tagonkénti kezdőértéknek nevezünk. Ennek segítségével a struktúra tulajdonságaihoz a zárójelek között adhatsz meg értékeket, amelyek felülírják a definícióban szereplő alapértelmezett értékeket.
let differentStats = CharacterStats(health: 100.0, speed: 6, strength: 18)
Tulajdonságok elérése
A struktúrák és osztályok tulajdonságai pont jelöléssel érhetők el, ahol az érték nevét egy pont (.) követi, majd a tulajdonság neve. Ha egy struktúra vagy osztály valamely tulajdonságának saját tulajdonságai vannak, ezzel a pont jelöléssel ezek az egymásba ágyazott tulajdonságok is elérhetők.
Ez a jelölés arra is használható, hogy lekérdezzük a tulajdonság értékét, és ahol megengedett, meg is változtassuk azt.
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
Metódusok
A tulajdonságokhoz hasonlóan, amelyek az adatokat tárolják a struktúráidban és osztályaidban, metódusokat is definiálhatsz, amelyek függvényeket tárolnak a struktúrádban vagy osztályodban.
A metódusokat ugyanúgy definiáljuk, mint egy hagyományos függvényt, csak éppen a struktúra vagy osztály törzsén belül. Vedd figyelembe, hogy ha egy függvény megváltoztatja egy struktúra valamely tulajdonságának értékét, azt a mutating kulcsszóval kell megelőzni. Továbbá, ha egy tulajdonságot egy metódus megváltoztathat, akkor azt a tulajdonságot let helyett var-ral kell definiálni, éppúgy, mint a hagyományos változókat.
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."
}
}
}
Ezek a metódusok pont jelöléssel hívhatók meg, akárcsak a tulajdonságok.
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
A struktúrák és osztályok minden példányának van egy implicit self nevű tulajdonsága, amely magára a példányra utal.
A self leggyakoribb használata, hogy megkülönböztesse egymástól a példány egy tulajdonságát és egy vele azonos nevű paramétert:
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
}
}
A Swift-típusok emellett biztosítanak egy nagybetűs Self kulcsszót is, amely a példány típusára utal, nem magára a példányra.
Tanulófeladat
