Structs e classes
Structs e classes são dois dos principais blocos de construção da programação em Swift. Ambos são formas de agrupar dados e funções relacionados em unidades de funcionalidade autocontidas. E quando você define um struct ou uma classe, você está definindo um novo tipo para usar dentro do Swift, assim como usou os tipos com os quais já trabalhou, como Int e String.
Existem muitas semelhanças entre structs e classes em Swift. Entre outras semelhanças, ambos conseguem armazenar valores em propriedades e oferecer funcionalidade por meio do uso de métodos.
Cada um deles oferece algumas funcionalidades adicionais, que estão fora do escopo deste exercício.
Definindo structs e classes
Tanto structs quanto classes são definidos mais ou menos da mesma forma. Eles começam com a palavra-chave apropriada, seguida do nome do tipo que está sendo definido; em seguida vem o corpo do struct/classe, colocado entre chaves.
O corpo pode consistir em propriedades armazenadas, que são definidas e se comportam exatamente como constantes ou variáveis comuns.
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 observado acima, definir um struct ou uma classe é apenas definir um novo tipo. É só o modelo de como serão os valores desse tipo, mas não cria de fato nenhum valor desse tipo para você trabalhar.
Para criar uma instância desse tipo, você precisa escrever o nome do tipo seguido de um par de parênteses.
let someStats = CharacterStats()
let someCharacter = GameCharacter()
Isso criará valores desses tipos, com as propriedades preenchidas com os valores padrão fornecidos na definição. Repare que, em casos opcionais como a propriedade name de GameCharacter, a menos que um valor seja fornecido, a propriedade terá o valor padrão nil, exatamente como ao definir tipos opcionais comuns em que um valor não é fornecido de imediato.
Com structs, o Swift fornece automaticamente algo chamado inicializador membro a membro, em que valores para as propriedades do struct podem ser fornecidos dentro dos parênteses e substituem os valores padrão da definição.
let differentStats = CharacterStats(health: 100.0, speed: 6, strength: 18)
Acessando propriedades
As propriedades de structs e classes podem ser acessadas 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 um struct ou classe tiver propriedades próprias, essa notação de ponto também pode ser usada para acessar essas propriedades aninhadas.
Essa notação pode ser usada tanto para obter o valor da propriedade quanto, quando for permitido, para alterá-lo.
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
Assim como as propriedades, que armazenam dados nos seus structs e classes, você também pode definir métodos, que armazenam funções no seu struct ou classe.
Os métodos são definidos da mesma forma que uma função comum, só que dentro do corpo do struct ou da classe. Repare que, se uma função altera o valor de uma propriedade em um struct, ela precisa ser precedida da palavra-chave mutating. Além disso, se uma propriedade puder ser alterada por um método, ela precisa ser definida com var em vez de let, assim como as variáveis comuns.
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."
}
}
}
Esses métodos podem ser chamados com a notação de ponto, assim 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
Toda instância de um struct ou classe tem uma propriedade implícita chamada self, que se refere à própria instância.
O uso mais comum de self é desambiguar entre uma propriedade de 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 do Swift também oferecem a palavra-chave Self com S maiúsculo, que se refere ao tipo da instância e não à instância em si.
Exercício de aprendizagem
