Grundlagen von Upcasting und Downcasting
Wechseln Sie zwischen Oberklassen- und Unterklassen-Typen.
Grundlagen von Upcasting und Downcasting ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.
Überblick über Typ-Casting
Typ-Casting ermöglicht es, eine Instanz innerhalb ihrer Klassenhierarchie als einen anderen Typ zu behandeln. Dabei wird der statische Typ geprüft oder geändert, nicht die Daten konvertiert.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let d = Dog(name: "Rex")
print(d.bark())Eine Klassenhierarchie
Casting setzt eine Hierarchie voraus. Hier erben Dog und Cat beide von Animal. Ein Dog ist ein Animal.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let pet: Animal = Dog(name: "Rex")
print(pet.name)Upcasting mit as
Upcasting behandelt eine Instanz einer Unterklasse als Instanz ihrer Oberklasse. Es ist immer erfolgreich, daher verwenden Sie den einfachen as-Operator.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let dog = Dog(name: "Rex")
let asAnimal = dog as Animal
print(asAnimal.name)Warum Upcasting verwendet wird
Upcasting ist nützlich, um verschiedene Unterklassen gemeinsam zu speichern, etwa in einem Array, das mit dem gemeinsamen Oberklassentyp typisiert ist.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let zoo: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]
for a in zoo { print(a.name) }Upcasting ist immer sicher
Da jede Instanz einer Unterklasse auch eine gültige Instanz der Oberklasse ist, akzeptiert der Compiler as für Upcasts ohne das Risiko eines Fehlschlags.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let cat = Cat(name: "Mia")
let animal = cat as Animal
print("Treated as Animal:", animal.name)Nach dem Upcasting ist der Zugriff eingeschränkt
Sobald ein Wert als Oberklassentyp gespeichert ist, können Sie nur noch Mitglieder der Oberklasse aufrufen. Das für Dog spezifische bark() ist verborgen, bis Sie ein Downcasting durchführen.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
print(a.name)
// a.bark() would not compile hereEinführung in Downcasting
Downcasting geht in die andere Richtung: Eine Referenz auf die Oberklasse wird als bestimmte Unterklasse behandelt, damit deren Mitglieder wieder verfügbar sind. Dies kann fehlschlagen und erfordert daher as? oder as!.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
if let dog = a as? Dog {
print(dog.bark())
}Warum Downcasting fehlschlagen kann
Der Compiler kann nicht garantieren, dass ein bestimmtes Animal tatsächlich ein Dog ist. Es könnte auch ein Cat sein. Aufgrund dieser Unsicherheit müssen Downcasts überprüft werden.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Cat(name: "Mia")
let maybeDog = a as? Dog
print("Is it a Dog?", maybeDog != nil)Downcasting in einer Schleife
Ein häufiges Muster besteht darin, ein Array der Oberklasse zu durchlaufen und jedes Element downzucasten, um die Unterklassen unterschiedlich zu behandeln.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let zoo: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]
for a in zoo {
if let dog = a as? Dog { print(dog.bark()) }
if let cat = a as? Cat { print(cat.meow()) }
}Zusammenfassung von Upcasting und Downcasting
Upcasting (as) bewegt sich in Richtung des Basistyps und ist immer erfolgreich. Downcasting (as? oder as!) bewegt sich in Richtung eines bestimmten Typs und kann fehlschlagen.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let d = Dog(name: "Rex")
let up = d as Animal
let down = up as? Dog
print(up.name, down?.bark() ?? "no")Casting nur innerhalb einer Hierarchie
Sie können nur zwischen verwandten Typen innerhalb derselben Hierarchie casten. Nicht verwandte Typen können nicht ineinander gecastet werden.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
print(a is Animal)
print(a is Dog)Kurztest
Rufen Sie sich in Erinnerung, in welche Richtung ein Cast immer erfolgreich ist.
Zusammenfassung: Upcasting und Downcasting
Sie haben gelernt, dass Casting innerhalb einer Klassenhierarchie funktioniert, dass Upcasting mit as in Richtung des Basistyps immer erfolgreich ist und dass Downcasting in Richtung einer bestimmten Unterklasse fehlschlagen kann und daher die im nächsten Abschnitt eingeführten geprüften Operatoren benötigt.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let pets: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]
for p in pets {
if let d = p as? Dog { print(d.bark()) } else { print(p.name) }
}Häufig gestellte Fragen
Ist die Lektion „Grundlagen von Upcasting und Downcasting“ kostenlos?
Ja — der vollständige Text von „Grundlagen von Upcasting und Downcasting“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Grundlagen von Upcasting und Downcasting“?
Wechseln Sie zwischen Oberklassen- und Unterklassen-Typen. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Swift Academy zu starten?
Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Grundlagen von Upcasting und Downcasting“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?
Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Grundlagen von Upcasting und Downcasting
- Bedingtes Casting mit as?
- Erzwungenes Casting mit as! und seine Risiken
- Typen mit is prüfen