Swift Academy · Aula

Herança de classes e a palavra-chave super

Aprenda a criar subclasses, chamar super.init() e estender o comportamento da superclasse.

Herança de classes e a palavra-chave super é 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.

Boas-vindas

As classes permitem herança — uma subclasse pode estender ou especializar uma superclasse. Isso possibilita a reutilização de código e o polimorfismo, pilares fundamentais do projeto orientado a objetos.

Definindo uma subclasse

```swift class Animal { var name: String init(name: String) { self.name = name } func speak() { print("...") } } class Dog: Animal { func fetch() { print("\(name) fetches!") } } let d = Dog(name: "Rex") d.speak() // "..." d.fetch() // "Rex fetches!" ```

super.init() — chamada obrigatória

```swift class Vehicle { var speed: Double init(speed: Double) { self.speed = speed } } class Car: Vehicle { var brand: String init(brand: String, speed: Double) { self.brand = brand super.init(speed: speed) // must call super } } ```

Inicialização em duas fases

Regras de inicialização em duas fases do Swift: 1. Todas as propriedades armazenadas *próprias* devem ser definidas *antes* da chamada a `super.init()` 2. Depois de `super.init()`, é possível personalizar as propriedades herdadas Isso impede o uso de memória não inicializada.

Chamando métodos da superclasse

```swift class Shape { func draw() { print("Drawing shape") } } class Circle: Shape { override func draw() { super.draw() // call parent implementation print("Drawing circle") } } ```

Herança de propriedades

As subclasses herdam todas as propriedades da superclasse: ```swift class Person { var name: String = "" var age: Int = 0 } class Employee: Person { var company: String = "" } let e = Employee() e.name = "Alice" e.company = "Acme" ```

Inicializadores designados e de conveniência

• *Designado* — inicializa completamente todas as propriedades; chama `super.init()` • *De conveniência* — delega para outro inicializador usando `self.init()` ```swift convenience init(name: String) { self.init(name: name, age: 0) // delegates to designated } ```

Inicializador obrigatório

Marque um inicializador como `required` para obrigar todas as subclasses a implementá-lo: ```swift class Base { required init(id: Int) { ... } } class Sub: Base { required init(id: Int) { super.init(id: id) } } ``` Isso é comum quando um método de fábrica precisa criar instâncias por meio de um protocolo.

Hierarquia de classes e tipo

```swift let a: Animal = Dog(name:"Buddy") print(a is Dog) // true print(a is Animal) // true ``` Um `Dog` é um `Animal` — as instâncias da subclasse atendem aos requisitos de tipo da superclasse.

Herança única

As classes do Swift aceitam apenas *herança única* (uma superclasse). Porém, uma classe pode estar em conformidade com muitos protocolos: ```swift class MyVC: UIViewController, UITableViewDelegate, UITableViewDataSource { } ``` Os protocolos são o mecanismo do Swift para obter herança múltipla de comportamento.

Verificação rápida

Em um inicializador designado de uma subclasse, quando é necessário chamar `super.init()`?

Recapitulação

Principais conclusões: • Crie uma subclasse com `class Sub: Super` • Chame `super.init()` depois de definir as propriedades próprias • Inicialização em duas fases: primeiro as propriedades próprias, depois a superclasse • `super.method()` chama a implementação da superclasse • O Swift tem herança única; use protocolos para obter comportamento múltiplo Próximo: substituição, final e prevenção de herança.

Perguntas Frequentes

A aula “Herança de classes e a palavra-chave super” é grátis?

Sim — o texto completo de “Herança de classes e a palavra-chave super” é 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 “Herança de classes e a palavra-chave super”?

Aprenda a criar subclasses, chamar super.init() e estender o comportamento da superclasse. 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 “Herança de classes e a palavra-chave super”?

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

Herança de classes e a palavra-chave super
override, final e prevenção de subclasses
Conversão de tipos: is, as?, as! e as
Desinicializadores e ciclo de vida da memória

← Voltar para Swift Academy