Swift - Herencia
La capacidad de tomar más forma se define como herencia. Generalmente, una clase puede heredar métodos, propiedades y funcionalidades de otra clase. Las clases se pueden categorizar aún más en subclase y superclase.
Sub Class - cuando una clase hereda propiedades, métodos y funciones de otra clase, se llama subclase
Super Class - La clase que contiene propiedades, métodos y funciones para heredar otras clases de sí misma se llama como una superclase
Las clases de Swift 4 contienen una superclase que llama y accede a métodos, propiedades, funciones y métodos primordiales. Además, los observadores de propiedades también se utilizan para agregar una propiedad y modificar los métodos de propiedad almacenados o calculados.
Clase base
Una clase que no hereda métodos, propiedades o funciones de otra clase se denomina 'Clase 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)Cuando ejecutamos el programa anterior usando el patio de recreo, obtenemos el siguiente resultado:
Swift 4
98
89
76La clase con nombre de clase StudDetails se define aquí como una clase base que se utiliza para contener el nombre de los estudiantes, y tres asignaturas marcan como mark1, mark2 y mark3. La palabra clave 'let' se usa para inicializar el valor de la clase base y el valor de la clase base se muestra en el patio de recreo con la ayuda de la función 'imprimir'.
Subclase
El acto de basar una nueva clase en una clase existente se define como 'Subclase'. La subclase hereda las propiedades, métodos y funciones de su clase base. Para definir una subclase ':' se usa antes del nombre de la clase 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()Cuando ejecutamos el programa anterior usando el patio de recreo, obtenemos el siguiente resultado:
Mark1:93, Mark2:89La clase 'StudDetails' se define como una superclase donde se declaran las calificaciones de los estudiantes y la subclase 'display' se usa para heredar las calificaciones de su superclase. La subclase define las calificaciones de los estudiantes y llama al método print () para mostrar las calificaciones de los estudiantes.
Primordial
Acceder a la subclase de instancia de superclase, métodos de tipo, instancia, propiedades de tipo y subíndices proporciona el concepto de anulación. La palabra clave 'override' se usa para invalidar los métodos declarados en la superclase.
Acceso a métodos, propiedades y subíndices de superclase
La palabra clave 'super' se utiliza como prefijo para acceder a los métodos, propiedades y subíndices declarados en la superclase
| Primordial | Acceso a métodos, propiedades y subíndices |
| Métodos | super.somemethod () |
| Propiedades | super.someProperty () |
| Subíndices | super [someIndex] |
Anulación de métodos
Los métodos heredados de instancia y tipo pueden ser reemplazados por la palabra clave 'override' a nuestros métodos definidos en nuestra subclase. Aquí print () se anula en la subclase para acceder a la propiedad type mencionada en la superclase print (). También se crea una nueva instancia de la superclase cricket () como '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()Cuando ejecutamos el programa anterior usando el patio de recreo, obtenemos el siguiente resultado:
Welcome to Swift Super Class
Welcome to Swift Sub ClassAnulación de propiedad
Puede anular una propiedad de clase o instancia heredada para proporcionar su propio captador y definidor personalizado para esa propiedad, o agregar observadores de propiedad para permitir que la propiedad primordial observe cuándo cambia el valor de la propiedad subyacente.
Anulando los captadores y definidores de propiedades
Swift 4 permite al usuario proporcionar un captador y definidor personalizados para anular la propiedad heredada, ya sea una propiedad almacenada o calculada. La subclase no conoce el nombre ni el tipo de propiedad heredada. Por lo tanto, es esencial que el usuario especifique en la subclase, el nombre y el tipo de la propiedad principal especificada en la superclase.
Esto se puede hacer de dos formas:
Cuando se define setter para anular la propiedad, el usuario también tiene que definir getter.
Cuando no queremos modificar el getter de propiedad heredada, simplemente podemos pasar el valor heredado por la sintaxis 'super.someProperty' a la superclase.
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)")Cuando ejecutamos el programa anterior usando el patio de recreo, obtenemos el siguiente resultado:
Radius of rectangle for 25.0 is now overridden as 3Observadores de propiedades primordiales
Cuando es necesario agregar una nueva propiedad para una propiedad heredada, se introduce el concepto de "anulación de propiedad" en Swift 4. Esto notifica al usuario cuando se modifica el valor de la propiedad heredada. Pero la invalidación no es aplicable para propiedades almacenadas constantes heredadas y propiedades computadas heredadas de solo lectura.
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)")Cuando ejecutamos el programa anterior usando el patio de recreo, obtenemos el siguiente resultado:
Radius of rectangle for 25.0 is now overridden as 3
Radius of rectangle for 100.0 is now overridden as 21Propiedad final para evitar la anulación
Cuando el usuario no necesita que otros accedan a métodos, propiedades o subíndices de superclase, Swift 4 introduce la propiedad 'final' para evitar la anulación. Una vez que se declara la propiedad 'final', los subíndices no permitirán que se anulen los métodos, propiedades y subíndices de la superclase. No hay ninguna disposición para tener propiedad 'final' en 'superclase'. Cuando se declara la propiedad 'final', el usuario está restringido a crear más subclases.
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)")Cuando ejecutamos el programa anterior usando el patio de recreo, obtenemos el siguiente resultado:
<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.5Dado que la superclase se declara como 'final' y sus tipos de datos también se declaran como 'finales', el programa no permitirá crear más subclases y arrojará errores.