Noções Básicas de Upcasting e Downcasting
Transite entre tipos de superclasse e subclasse.
Noções Básicas de Upcasting e Downcasting é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.
Visão geral da conversão de tipos
A conversão de tipo permite tratar uma instância como um tipo diferente dentro da hierarquia de classes. Ela verifica ou altera o tipo estático, não converte dados.
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())Uma hierarquia de classes
A conversão de tipo exige uma hierarquia. Aqui, Dog e Cat herdam de Animal. Um Dog é um 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)Conversão ascendente com as
A conversão ascendente trata uma instância de uma subclasse como uma instância da superclasse. Ela sempre é bem-sucedida, por isso você usa o operador as simples.
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)Por que fazer conversão ascendente
A conversão ascendente é útil para armazenar diferentes subclasses juntas, por exemplo, em um vetor tipado com a superclasse comum.
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) }A conversão ascendente é sempre segura
Como toda instância de uma subclasse também é uma instância válida da superclasse, o compilador aceita as em conversões ascendentes sem risco de falha.
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)Perdendo acesso após a conversão ascendente
Depois de armazenar a instância como um tipo de superclasse, você só pode chamar os membros da superclasse. O bark() específico de Dog fica oculto até que você faça uma conversão descendente.
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 hereIntrodução à conversão descendente
A conversão descendente segue o caminho inverso: trata uma referência à superclasse como uma subclasse específica para recuperar seus membros. Ela pode falhar, portanto requer as? ou 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())
}Por que a conversão descendente pode falhar
O compilador não pode garantir que um determinado Animal seja realmente um Dog. Ele pode ser um Cat. Essa incerteza explica por que as conversões descendentes precisam ser verificadas.
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)Conversão descendente em um laço
Um padrão comum: percorrer um vetor de superclasse e converter cada elemento para baixo, tratando as subclasses de maneiras diferentes.
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()) }
}Resumo: conversão ascendente versus descendente
A conversão ascendente (as) move-se em direção ao tipo base e sempre é bem-sucedida. A conversão descendente (as? ou as!) move-se em direção a um tipo específico e pode falhar.
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")Conversão de tipo apenas dentro de uma hierarquia
Você só pode fazer conversões entre tipos relacionados na mesma hierarquia. Tipos não relacionados não podem ser convertidos uns nos outros.
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)Verificação rápida
Relembre qual direção de conversão sempre é bem-sucedida.
Recapitulação: conversão ascendente e descendente
Você aprendeu que a conversão de tipos funciona dentro de uma hierarquia de classes, que a conversão ascendente com as em direção ao tipo base sempre é bem-sucedida e que a conversão descendente em direção a uma subclasse específica pode falhar e, por isso, requer os operadores verificados apresentados a seguir.
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) }
}
Aprenda Swift com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 122
- Aulas
- 409
Perguntas Frequentes
A aula “Noções Básicas de Upcasting e Downcasting” é grátis?
Sim — o texto completo de “Noções Básicas de Upcasting e Downcasting” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.
O que vou aprender em “Noções Básicas de Upcasting e Downcasting”?
Transite entre tipos de superclasse e subclasse. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Swift Academy?
Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Noções Básicas de Upcasting e Downcasting”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Swift Academy?
Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Noções Básicas de Upcasting e Downcasting
- Conversão Condicional com as?
- Conversão Forçada com as! e Seus Riscos
- Verificação de Tipos com is