ereditarietà Swift

L'ereditarietà può essere inteso come una classe otteniamo i metodi e le proprietà di un'altra classe.

Quando una classe eredita da un'altra classe, la classe derivata viene chiamato una sottoclasse, la classe ereditaria chiamata superclasse (o il genitore)

In Swift, le classi possono chiamare e accedere ai metodi, proprietà, e lo script pedice della superclasse, e possono ignorare.

Possiamo anche aggiungere proprietà osservatore proprietà ereditata per la classe.

classe base

Non ci sono altre classi ereditano una classe, chiamare la classe di base (classe base).

Il seguente esempio, si definisce una StudDetails classe di base, descrive lo studente (stname) e tutti i soggetti punteggi (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

print(stname)
print(mark1)
print(mark2)
print(mark3)

L'output sopra l'esecuzione del programma è il seguente:

swift
98
89
76

swift
98
89
76

sottoclasse

Si riferisce a una sottoclasse è quello di creare una nuova classe basata su una classe esistente.

Per specificare la superclasse di una classe, il nome della classe super-scritto sul retro del nome della classe, (:) sintassi separata da due punti è la seguente

class SomeClass: SomeSuperclass {
    // 类的定义
}

Esempi

Il seguente esempio, definiamo un StudDetails superclasse, quindi sottoclasse Tom eredita esso:

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()

L'output sopra l'esecuzione del programma è il seguente:

Mark1:93, Mark2:89

Rewrite (override)

Sottoclasse può essere ereditata metodi di istanza, metodi di classe, esempio, la proprietà o lo script pedice per realizzare le loro capacità di personalizzazione, che noi chiamiamo questo comportamento riscritto (primario).

Possiamo usare la parola chiave override per raggiungere riscrittura.

Metodi di accesso superclasse, proprietà e lo script pedice

Il metodo è possibile utilizzare per accedere al prefisso super super classe, di proprietà o uno script pedice.

metodi e proprietà

Sostituzione di metodi

Nel nostro sottoclasse, possiamo usare la parola chiave override per eseguire l'override del metodo della superclasse.

Gli esempi che seguono, riscriviamo il metodo show ():

class SuperClass {
    func show() {
        print("这是超类 SuperClass")
    }
}

class SubClass: SuperClass  {
    override func show() {
        print("这是子类 SubClass")
    }
}

let superClass = SuperClass()
superClass.show()

let subClass = SubClass()
subClass.show()

L'output sopra l'esecuzione del programma è il seguente:

这是超类 SuperClass
这是子类 SubClass

Proprietà di priorità assoluta

È possibile fornire un getter personalizzato (o setter) per riscrivere qualsiasi proprietà ereditata, se la proprietà è ereditata ad un tipo di archiviazione o il tipo di calcolo di proprietà.

Sottoclasse non conosce la proprietà ereditata è il tipo di archiviazione o il tipo di calcolo, solo sa proprietà ereditata avrà un nome e tipo. Così si riscrive una proprietà, è necessario nome e il tipo scritto.

precauzioni:

• Se si forniscono setter nel riscrivere le proprietà, quindi è necessario fornire getter.

• Se non si desidera getter versione riscritta nel modificare i valori delle proprietà ereditate, è possibile tornare ai valori ereditati dalla super.someProperty, dove someProperty è il nome che si desidera sovrascrivere la proprietà.

Il seguente esempio si definisce una sottoclasse di superclasse cerchio e rettangolo, abbiamo riscrivere l'area di proprietà classe Rectangle:

class Circle {
    var radius = 12.5
    var area: String {
        return "矩形半径 \(radius) "
    }
}

// 继承超类 Circle
class Rectangle: Circle {
    var print = 7
    override var area: String {
        return super.area + " ，但现在被重写为 \(print)"
    }
}

let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("Radius \(rect.area)")

L'output sopra l'esecuzione del programma è il seguente:

Radius 矩形半径 25.0  ，但现在被重写为 3

Overriding Proprietà Viewer

È possibile aggiungere una proprietà di ereditare la proprietà nelle proprietà osservate nella riscrittura. Di conseguenza, quando il valore della proprietà ereditate cambia, si saranno monitorati.

Nota: non èpossibile aggiungere proprietà osservatore per il tipo di attributo ereditato memoria costanti o di sola lettura computazionale proprietà ereditata.

class Circle {
    var radius = 12.5
    var area: String {
        return "矩形半径为 \(radius) "
    }
}

class Rectangle: Circle {
    var print = 7
    override var area: String {
        return super.area + " ，但现在被重写为 \(print)"
    }
}


let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("半径: \(rect.area)")

class Square: Rectangle {
    override var radius: Double {
        didSet {
            print = Int(radius/5.0)+1
        }
    }
}


let sq = Square()
sq.radius = 100.0
print("半径: \(sq.area)")

半径: 矩形半径为 25.0  ，但现在被重写为 3
半径: 矩形半径为 100.0  ，但现在被重写为 21

Prevenire riscrittura

Possiamo usare la parola finale impedisce loro di sovrascrittura.

Se si ignora un ultimo metodo, la proprietà, o uno script pedice, al momento della compilazione errore.

È possibile aggiungere il finale prima della classe parola chiave caratteristica (classe finale) per l'intera classe è contrassegnata finale, quindi la classe non può essere ereditata, in caso contrario verranno segnalati errori di compilazione.

final class Circle {
    final var radius = 12.5
    var area: String {
        return "矩形半径为 \(radius) "
    }
}
class Rectangle: Circle {
    var print = 7
    override var area: String {
        return super.area + " ，但现在被重写为 \(print)"
    }
}

let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("半径: \(rect.area)")

class Square: Rectangle {
    override var radius: Double {
        didSet {
            print = Int(radius/5.0)+1
        }
    }
}

let sq = Square()
sq.radius = 100.0
print("半径: \(sq.area)")

Grazie all'esempio precedente utilizza la parola finale non è permesso di riscrivere, così sarà dato esecuzione:

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 {
      ^