Estruturas e classes
As estruturas e as classes são dois dos principais blocos de construção da programação em Swift. Ambas são formas de agrupar dados e funções relacionados em unidades de funcionalidade autónomas. E quando defines uma estrutura ou uma classe, estás a definir um novo tipo para usar em Swift, tal como usaste os tipos com que já trabalhaste, como Int e String.
Há muitas semelhanças entre estruturas e classes em Swift. Entre outras semelhanças, ambas conseguem armazenar valores em propriedades e fornecer funcionalidade através do uso de métodos.
Cada uma delas oferece também algumas funcionalidades adicionais, que estão fora do âmbito deste exercício.
Definir estruturas e classes
Tanto as estruturas como as classes são definidas de forma semelhante. Começam com a palavra-chave adequada, seguida do nome do tipo que está a ser definido; a seguir vem o corpo da estrutura ou da classe, colocado entre chavetas.
O corpo pode ser composto por propriedades armazenadas, que são definidas e se comportam exatamente como constantes ou variáveis normais.
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()
}
Instâncias
Como vimos acima, definir uma estrutura ou uma classe é apenas definir um novo tipo. É só o plano do que serão os valores desse tipo, mas não cria, na verdade, nenhum valor desse tipo com que possas trabalhar.
Para criar uma instância desse tipo, tens de escrever o nome do tipo seguido de um par de parênteses.
let someStats = CharacterStats()
let someCharacter = GameCharacter()
Isto cria valores desses tipos, em que as propriedades são preenchidas com os valores predefinidos fornecidos na definição. Repara que, em casos opcionais como a propriedade name de GameCharacter, se não for fornecido um valor, a propriedade assume nil por omissão, tal como acontece ao definir tipos opcionais normais em que não se fornece logo um valor.
No caso das estruturas, o Swift fornece automaticamente algo chamado inicializador membro a membro, em que os valores das propriedades da estrutura podem ser indicados dentro dos parênteses e substituem os valores predefinidos da definição.
let differentStats = CharacterStats(health: 100.0, speed: 6, strength: 18)
Aceder às propriedades
As propriedades das estruturas e das classes podem ser acedidas com a notação de ponto, em que o nome do valor é seguido de um ponto (.) e do nome da propriedade. Se uma propriedade de uma estrutura ou classe tiver propriedades próprias, também podes usar esta notação de ponto para aceder a essas propriedades aninhadas.
Esta notação pode ser usada tanto para obter o valor da propriedade como, quando permitido, para o alterar.
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
Métodos
Tal como as propriedades, que guardam dados nas tuas estruturas e classes, também podes definir métodos, que guardam funções na tua estrutura ou classe.
Os métodos são definidos da mesma forma que uma função normal, mas dentro do corpo da estrutura ou da classe. Repara que, se uma função alterar o valor de uma propriedade de uma estrutura, tem de ser precedida da palavra-chave mutating. Além disso, se uma propriedade puder ser alterada por um método, essa propriedade tem de ser definida com var e não com let, tal como as variáveis normais.
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."
}
}
}
Estes métodos podem ser chamados com a notação de ponto, tal como as propriedades.
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
Cada instância de uma estrutura ou classe tem uma propriedade implícita chamada self, que se refere à própria instância.
A utilização mais comum de self é distinguir entre uma propriedade da instância e um parâmetro com o mesmo nome:
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
}
}
Os tipos de Swift também disponibilizam a palavra-chave Self com maiúscula inicial, que se refere ao tipo da instância e não à própria instância.
Exercício de aprendizagem
