Herança Swift

继承我们可以理解为一个类获取了另外一个类的方法和属性。

当一个类继承其它类时，继承类叫子类，被继承类叫超类（或父类)

在 Swift 中，类可以调用和访问超类的方法，属性和下标脚本，并且可以重写它们。

我们也可以为类中继承来的属性添加属性观察器。

基类

没有继承其它类的类，称之为基类（Base Class）。

以下示例中我们定义了基类 StudDetails ，描述了学生（stname）及其各科成绩的分数(mark1、mark2、mark3)：

class StudDetails {
    var stname: String!
    var mark1: Int!
    var mark2: Int!
    var mark3: Int!
    init(stname: String, mark1: Int, mark2: Int, mark3: Int) {
        self.stname = stname
        self.mark1 = mark1
        self.mark2 = mark2
        self.mark3 = mark3
    }
}
let stname = "swift"
let mark1 = 98
let mark2 = 89
let mark3 = 76
let sds = StudDetails(stname:stname, mark1:mark1, mark2:mark2, mark3:mark3);
print(sds.stname)
print(sds.mark)1)
print(sds.mark)2)
print(sds.mark)3)

O resultado da execução do programa acima é:

swift
98
89
76

Subclass

A subclass refers to a new class created based on an existing class.

To indicate the superclass of a class, write the superclass name after the subclass name, separated by a colon (:), in the following format:

class SomeClass: SomeSuperclass {
    // Class definition
}

Online examples

In the following example, we define the superclass StudDetails and then use the subclass Tom to inherit it:

class StudDetails
{
    var mark1: Int;
    var mark2: Int;
    init(stm1:Int, results stm2:Int)
    {
        mark1 = stm1;
        mark2 = stm2;
    }
    func show()
    {
        print("Mark1:\(self.mark1), Mark2:\(self.mark2)
    }
}
class Tom: StudDetails
{
    init()
    {
        super.init(stm1: 93, results: 89)
    }
}
let tom = Tom()
tom.show()

O resultado da execução do programa acima é:

Mark1:93, Mark2:89

Overriding (Overriding)

Subclasses can implement their own custom functionality by using the example methods, class methods, example properties, or subscripts inherited from the superclass, and we call this behavior overriding (overriding).

We can use the override keyword to implement overriding.

Access the superclass's methods, properties, and subscripts

You can access the superclass's methods, properties, or subscripts by using the super prefix.

Override	Access methods, properties, and subscripts
Method	super.somemethod()
Property	super.someProperty()
Subscript	super[someIndex]

Method and property overriding

Method overriding

In our subclass, we can use the override keyword to override the superclass's method.

In the following example, we override the show() method:

class SuperClass {
    func show() {
        print("This is the superclass SuperClass")
    }
}
class SubClass: SuperClass {
    override func show() {
        print("This is the subclass SubClass")
    }
}
let superClass = SuperClass()
superClass.show()
let subClass = SubClass()
subClass.show()

O resultado da execução do programa acima é:

Esta é a superclasse SuperClasse
Esta é a subclasse SubClasse

Sobrescrever atributo

Você pode fornecer getters (ou setters) personalizados para sobrescrever qualquer atributo herdado, seja um atributo de tipo armazenamento ou um atributo de tipo calculo.

A subclasse não sabe se o atributo herdado é de tipo armazenamento ou de tipo calculo, ela apenas sabe que o atributo herdado terá um nome e um tipo. Portanto, ao sobrescrever um atributo, você deve escrever seu nome e tipo.

Ponto de atenção:

• Se você fornecer um setter em uma sobrescrita de atributo, você também deve fornecer um getter.

• Se você não quiser modificar o valor do atributo herdado no getter da versão sobrescrita, você pode retornar diretamente o valor herdado usando super.someProperty, onde someProperty é o nome do atributo que você deseja sobrescrever.

Neste exemplo, definimos a superclasse Círculo e a subclasse Retângulo, na classe Retângulo, sobrescrevemos o atributo area:

class Círculo {
    var raio = 12.5
    var area: String {
        return "Raio do retângulo: \(raio) “
    }
}
// Herança da superclasse Círculo
class Rectangle: Circle {
    var print = 7
    override var area: String {
        return super.area + “，mas agora foi reescrevido como \(print)“
    }
}
let retângulo = Retângulo()
retângulo.raio = 25.0
retângulo.print = 3
print("Raio \(retângulo.area)")

O resultado da execução do programa acima é:

Raio Raio do retângulo 25.0 ，mas agora foi reescrevido como 3

Sobrescrever observador de atributo

Você pode adicionar um observador de atributo a um atributo herdado em uma sobrescrita de atributo. Dessa forma, você será notificado quando o valor do atributo herdado mudar.

Atenção:Você não pode adicionar um observador de atributo a um atributo de tipo constante herdado ou a um atributo de calculo apenas herdado.

class Círculo {
    var raio = 12.5
    var area: String {
        return "Raio do retângulo: \(raio) “
    }
}
class Rectangle: Circle {
    var print = 7
    override var area: String {
        return super.area + “，mas agora foi reescrevido como \(print)“
    }
}
let retângulo = Retângulo()
retângulo.raio = 25.0
retângulo.print = 3
print("Raio: \(retângulo.area)")
class Quadrado: Retângulo {
    override var radius: Double {
        didSet {}}}
            print = Int(radius/5.0)+1
        }
    }
}
let sq = Square()
sq.radius = 100.0
print("Raio: \(sq.area)")

Raio: Raio do retângulo 25.0 ，mas agora foi reescrevido como 3
Raio: Raio do retângulo 100.0 ，mas agora foi reescrevido como 21

Prevenir sobrescrita

Podemos usar a palavra-chave final para evitar que sejam sobrescritos.

Se você sobrescrever um método, atributo ou índice final, será emitido um erro na compilação.

Você pode marcar toda a classe como final adicionando a característica final antes da palavra-chave class (final class)，tais classes não podem ser herdadas, caso contrário, será emitido um erro de compilação.

final class Círculo {
    final var radius = 12.5
    var area: String {
        return "Raio do retângulo: \(raio) “
    }
}
class Rectangle: Circle {
    var print = 7
    override var area: String {
        return super.area + “，mas agora foi reescrevido como \(print)“
    }
}
let retângulo = Retângulo()
retângulo.raio = 25.0
retângulo.print = 3
print("Raio: \(retângulo.area)")
class Quadrado: Retângulo {
    override var radius: Double {
        didSet {}}}
            print = Int(radius/5.0)+1
        }
    }
}
let sq = Square()
sq.radius = 100.0
print("Raio: \(sq.area)")

Devido ao uso do palavra-chave final nas exemplo acima não permite sobrescrita, então a execução gerará um erro:

error: var overrides a 'final' var
    override var area: String {
                 ^
note: overridden declaration is here
    var area: String {
        ^
error: var overrides a 'final' var
    override var radius: Double {
                 ^
note: overridden declaration is here
    final var radius = 12.5
              ^
error: inheritance from a final class 'Circle'
class Rectangle: Circle {
      ^