Swift - Eredità
La capacità di assumere più forme è definita eredità. Generalmente una classe può ereditare metodi, proprietà e funzionalità da un'altra classe. Le classi possono essere ulteriormente classificate in sottoclasse e superclasse.
Sub Class - quando una classe eredita proprietà, metodi e funzioni da un'altra classe, viene chiamata come sottoclasse
Super Class - La classe contenente proprietà, metodi e funzioni per ereditare altre classi da se stessa viene chiamata come una super classe
Le classi di Swift 4 contengono una superclasse che chiama e accede a metodi, proprietà, funzioni e metodi di sostituzione. Inoltre, gli osservatori di proprietà vengono utilizzati anche per aggiungere una proprietà e modificare i metodi di proprietà memorizzati o calcolati.
Classe base
Una classe che non eredita metodi, proprietà o funzioni da un'altra classe viene chiamata "Classe base".
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 4"
let mark1 = 98
let mark2 = 89
let mark3 = 76
print(stname)
print(mark1)
print(mark2)
print(mark3)Quando eseguiamo il programma precedente usando playground, otteniamo il seguente risultato:
Swift 4
98
89
76La classe con nome classe StudDetails è qui definita come una classe base che viene utilizzata per contenere il nome degli studenti e tre materie contrassegnate come mark1, mark2 e mark3. La parola chiave 'let' viene utilizzata per inizializzare il valore per la classe base e il valore della classe base viene visualizzato nel playground con l'aiuto della funzione 'print'.
Sottoclasse
L'atto di basare una nuova classe su una classe esistente è definito come "sottoclasse". La sottoclasse eredita le proprietà, i metodi e le funzioni della sua classe base. Per definire una sottoclasse ':' viene utilizzato prima del nome della classe base
class StudDetails {
var mark1: Int;
var mark2: Int;
init(stm1:Int, results stm2:Int) {
mark1 = stm1;
mark2 = stm2;
}
func print() {
print("Mark1:\(mark1), Mark2:\(mark2)")
}
}
class display : StudDetails {
init() {
super.init(stm1: 93, results: 89)
}
}
let marksobtained = display()
marksobtained.print()Quando eseguiamo il programma precedente usando playground, otteniamo il seguente risultato:
Mark1:93, Mark2:89La classe "StudDetails" è definita come super classe in cui vengono dichiarati i voti degli studenti e la sottoclasse "display" viene utilizzata per ereditare i voti dalla sua super classe. La sottoclasse definisce i voti degli studenti e chiama il metodo print () per visualizzare il voto degli studenti.
Overriding
L'accesso all'istanza della super classe, ai metodi di tipo, all'istanza, alle proprietà del tipo e alla sottoclasse dei pedici fornisce il concetto di sovrascrittura. La parola chiave 'override' viene utilizzata per sovrascrivere i metodi dichiarati nella superclasse.
Accesso a metodi, proprietà e pedici della super classe
La parola chiave 'super' viene utilizzata come prefisso per accedere a metodi, proprietà e pedici dichiarati nella super classe
| Overriding | Accesso a metodi, proprietà e pedici |
| Metodi | super.somemethod () |
| Proprietà | super.someProperty () |
| Pedici | super [someIndex] |
Metodi che sovrascrivono
I metodi di istanza e tipo ereditati possono essere sovrascritti dalla parola chiave 'override' sui nostri metodi definiti nella nostra sottoclasse. Qui print () viene sovrascritto nella sottoclasse per accedere alla proprietà type menzionata nella super classe print (). Anche la nuova istanza della super classe cricket () viene creata come "cricinstance".
class cricket {
func print() {
print("Welcome to Swift 4 Super Class")
}
}
class tennis: cricket {
override func print() {
print("Welcome to Swift 4 Sub Class")
}
}
let cricinstance = cricket()
cricinstance.print()
let tennisinstance = tennis()
tennisinstance.print()Quando eseguiamo il programma precedente usando playground, otteniamo il seguente risultato:
Welcome to Swift Super Class
Welcome to Swift Sub ClassSostituzione della proprietà
È possibile eseguire l'override di un'istanza ereditata o di una proprietà di classe per fornire il proprio getter e setter personalizzato per quella proprietà oppure aggiungere osservatori di proprietà per consentire alla proprietà di sovrascrittura di osservare quando il valore della proprietà sottostante cambia.
Sostituzione di proprietà get e setter
Swift 4 consente all'utente di fornire getter e setter personalizzati per sovrascrivere la proprietà ereditata sia che si tratti di una proprietà archiviata o calcolata. La sottoclasse non conosce il nome e il tipo di proprietà ereditata. Pertanto è essenziale che l'utente debba specificare nella sottoclasse, il nome e il tipo della proprietà sovrascritta specificata in super class.
Questo può essere fatto in due modi:
Quando setter è definito per sovrascrivere la proprietà, l'utente deve definire anche getter.
Quando non vogliamo modificare la proprietà getter ereditata, possiamo semplicemente passare il valore ereditato dalla sintassi "super.someProperty" alla super classe.
class Circle {
var radius = 12.5
var area: String {
return "of rectangle for \(radius) "
}
}
class Rectangle: Circle {
var print = 7
override var area: String {
return super.area + " is now overridden as \(print)"
}
}
let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("Radius \(rect.area)")Quando eseguiamo il programma precedente usando playground, otteniamo il seguente risultato:
Radius of rectangle for 25.0 is now overridden as 3Ignorare gli osservatori di proprietà
Quando è necessario aggiungere una nuova proprietà per una proprietà ereditata, il concetto di "sostituzione della proprietà" viene introdotto in Swift 4. Ciò notifica all'utente quando il valore della proprietà ereditata viene alterato. Ma l'override non è applicabile alle proprietà memorizzate costanti ereditate e alle proprietà calcolate di sola lettura ereditate.
class Circle {
var radius = 12.5
var area: String {
return "of rectangle for \(radius) "
}
}
class Rectangle: Circle {
var print = 7
override var area: String {
return super.area + " is now overridden as \(print)"
}
}
let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("Radius \(rect.area)")
class Square: Rectangle {
override var radius: Double {
didSet {
print = Int(radius/5.0)+1
}
}
}
let sq = Square()
sq.radius = 100.0
print("Radius \(sq.area)")Quando eseguiamo il programma precedente usando playground, otteniamo il seguente risultato:
Radius of rectangle for 25.0 is now overridden as 3
Radius of rectangle for 100.0 is now overridden as 21Proprietà finale per impedire l'override
Quando l'utente non ha bisogno che altri accedano a metodi, proprietà o pedici di una super classe, Swift 4 introduce la proprietà "finale" per impedire l'override. Una volta che la proprietà "finale" è stata dichiarata, gli indici non permetteranno di sovrascrivere i metodi, le proprietà e i relativi indici della super classe. Non è previsto che la proprietà "finale" sia in "super classe". Quando la proprietà 'finale' viene dichiarata, l'utente è limitato a creare ulteriori sottoclassi.
final class Circle {
final var radius = 12.5
var area: String {
return "of rectangle for \(radius) "
}
}
class Rectangle: Circle {
var print = 7
override var area: String {
return super.area + " is now overridden as \(print)"
}
}
let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("Radius \(rect.area)")
class Square: Rectangle {
override var radius: Double {
didSet {
print = Int(radius/5.0)+1
}
}
}
let sq = Square()
sq.radius = 100.0
print("Radius \(sq.area)")Quando eseguiamo il programma precedente usando playground, otteniamo il seguente risultato:
<stdin>:14:18: error: var overrides a 'final' var
override var area: String {
^
<stdin>:7:9: note: overridden declaration is here
var area: String {
^
<stdin>:12:11: error: inheritance from a final class 'Circle'
class Rectangle: Circle {
^
<stdin>:25:14: error: var overrides a 'final' var
override var radius: Double {
^
<stdin>:6:14: note: overridden declaration is here
final var radius = 12.5Poiché la super classe è dichiarata come "finale" e anche i suoi tipi di dati sono dichiarati come "finale", il programma non consentirà di creare ulteriori sottoclassi e genererà errori.