Swift Academy · Lezione

Basi dell’upcasting e del downcasting

Passi dai tipi delle superclassi a quelli delle sottoclassi e viceversa.

Basi dell’upcasting e del downcasting è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Panoramica sul casting di tipo

Il casting di tipo consente di trattare un'istanza come un tipo diverso all'interno della relativa gerarchia di classi. Verifica o modifica il tipo statico, ma non converte i dati.

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())

Una gerarchia di classi

Il casting richiede una gerarchia. In questo caso Dog e Cat ereditano entrambi da Animal. Un'istanza di Dog is un'istanza di 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 con as

L'upcasting tratta un'istanza di una sottoclasse come un'istanza della relativa superclasse. Riesce sempre, quindi si usa il semplice operatore 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 dog = Dog(name: "Rex")
let asAnimal = dog as Animal
print(asAnimal.name)

Perché fare upcasting

L'upcasting è utile per memorizzare insieme sottoclassi diverse, ad esempio in un unico array tipizzato con la superclasse comune.

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) }

L'upcasting è sempre sicuro

Poiché ogni istanza di una sottoclasse è anche un'istanza valida della superclasse, il compilatore accetta as per gli upcast senza rischio di errore.

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)

Perdere l'accesso dopo l'upcasting

Una volta memorizzata con il tipo della superclasse, è possibile chiamare solo i membri della superclasse. Il metodo specifico di Dog, bark(), rimane nascosto finché non si esegue il downcasting.

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 here

Introduzione al downcasting

Il downcasting segue la direzione opposta: tratta un riferimento alla superclasse come una sottoclasse specifica per recuperarne i membri. Può fallire, quindi richiede as? o 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())
}

Perché il downcasting può fallire

Il compilatore non può garantire che un determinato Animal sia realmente un Dog. Potrebbe essere un Cat. Questa incertezza impone di verificare i downcast.

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 un ciclo

Un modello comune consiste nell'iterare un array della superclasse ed eseguire il downcast di ogni elemento per gestire le sottoclassi in modo diverso.

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()) }
}

Riepilogo di upcasting e downcasting

L'upcasting (as) procede verso il tipo base e riesce sempre. Il downcasting (as? o as!) procede verso un tipo specifico e può fallire.

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")

Il casting è possibile solo all'interno di una gerarchia

È possibile eseguire il casting solo tra tipi correlati nella stessa gerarchia. I tipi non correlati non possono essere convertiti l'uno nell'altro tramite casting.

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)

Controllo rapido

Ricordi quale direzione del cast riesce sempre.

Riepilogo: upcasting e downcasting

Ha imparato che il casting funziona all'interno di una gerarchia di classi, che l'upcasting con as verso il tipo base riesce sempre e che il downcasting verso una sottoclasse specifica può fallire e richiede quindi gli operatori con controllo presentati di seguito.

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) }
}

Domande Frequenti

La lezione «Basi dell’upcasting e del downcasting» è gratuita?

Sì — il testo completo di «Basi dell’upcasting e del downcasting» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Basi dell’upcasting e del downcasting»?

Passi dai tipi delle superclassi a quelli delle sottoclassi e viceversa. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Basi dell’upcasting e del downcasting»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Basi dell’upcasting e del downcasting
Casting condizionale con as?
Casting forzato con as! e relativi rischi
Controllo dei tipi con is

← Torna a Swift Academy