Estas son mis notas para el curso https://www.hackingwithswift.com/100
“Any fool can write code that a computer can understand, but good programmers write code that humans can understand.”
Martin Fowler
«Cualquier tonto puede escribir código que una computadora pueda entender, pero buenos programadores pueden escribir código qué humanos pueden entender.»
Martin Fowler
Classes
Las clases son similares a las structs, te permiten nuevos tipos de datos, con propiedades y métodos.
Las clases tienen por lo menos cinco diferencias principales con las Clases
Creating your own classes
La primera es que las clases no vienen un un inicializador por default, siempre debes crearlo tú.
class Perro {
var nombre: String
var raza: String
init(nombre: String, raza: String) {
self.nombre = nombre
self.raza = raza
}
}Crear instancias de una clase es igual que crear instancias de una estructura.
let cachorrito = perro(nombre: "Toby", raza: "Poodle")Class inheritance
La segunda diferencia es que puedes crear una clase partir de otra clase ya existente, esto hereda todas las propiedades y métodos de la clase padre.
Por ejemplo creemos una clase en base a nuestra clase anterior Perro
class Sabueso: Perro {
}Esta clase nueva hereda el inicializador y los parámetros de su clase padre
Aun así podemos crear un inicializador propio de Sabueso por ejemplo ya que sabemos que nuestro perro es un sabueso podemos iniciar nuestra clase sabueso solo con el nombre.
class Sabueso: Perro {
init(nombre: String) {
super.init(nombre: nombre, raza: "Sabueso")
}
}Por razones de seguridad, swift siempre te pedirá llamar al «super.init» al crear una clase hija
let cazador = Sabueso(nombre: "Maylo")Overriding methods
Las clases hijas pueden remplazar los métodos de sus padres con implementaciones propias.
Este proceso se conoce como «overriding»
Añadamos un método a nuestra clase Perro
class Perro {
var nombre: String
var raza: String
init(nombre: String, raza: String) {
self.nombre = nombre
self.raza = raza
}
}Ahora podemos llamar este método desde cualquier instancia de su clase hija
cazador.ladrar()Ahora podemos remplazar el método en nuestra clase hija para ponerle nuestra propia implementación.
Para eso usamos la palabra reservada «override» esto sire para evitar remplazar métodos por accidente.
class Sabueso: Perro {
init(nombre: String) {
super.init(nombre: nombre, raza: "Sabueso")
}
override func ladrar() {
print("¡Woolf! ¡Woolf! ¡Woolf!")
}
}
let cazador = Sabueso(nombre: "Maylo")
cazador.ladrar()
// esto imprime "¡Woolf! ¡Woolf! ¡Woolf!"
Final classes
Sin bien la herencia es algo genial, no es algo que siempre queramos, por ejemplo si queremos marcar nuestras clases como finales y evitar que otros desarrolladores remplacen nuestros métodos solo debemos marcar la clase como final.
final class Perro {
var nombre: String
var raza: String
init(nombre: String, raza: String) {
self.nombre = nombre
self.raza = raza
}
func ladrar (){
print("¡Guau! ¡Guau! ¡Guau!")
}
}
Copying objects
La tercera diferencia entre clases y estructuras es lo que ocurre al copiarla
Al copiar una estructura, tanto la original como la copia son instancias diferentes, cambiar una no afecta la otra.
Cuando copias una clase, tanto la original como la copia son la misma, cambiar algo en una afecta a la otra.
let cachorrito = Perro(nombre: "Toby", raza: "Poodle")
let copiaDeCachorrito = cachorrito
copiaDeCachorrito.nombre = "Firulais"
print(cachorrito.nombre)Al correr este código veras que al editar la copia de cachorrito también afecta al original. Esto ocurre por que ambas instancias apuntan al mismo espacio en al memoria
Deinitializers
La curta diferencia entre clases y estructuras es que las clases pueden tener «Deinitializers» código que se ejecuta cuando una instancia de la clase es destruida.
Para crear un Deinitializer usamos la palabra reservada «deinit»
class Chihuahua: Perro {
init() {
super.init(nombre: "Panchito", raza: "Chihuahua")
print("¡Ahy ahy \(nombre) esta vivo!")
}
deinit {
print("¡Ahy ahy 🤧😭 \(nombre) ya se murio!")
}
}
for _ in 1...3 {
let perro = Chihuahua()
}
Mutability
La quinta y ultima diferencia entre clases y estructuras es la manera en como lidian con las constantes
En una estructura si tenemos una instancia que es una constante, y dentro de ella variables, la variable no puede ser cambiada pues toda la estructura es una constante.
Sin embargo en una clase si tenemos una instancia que es una constante y dentro tenemos una variable esta si que puede ser cambiada, por eso clases no necesitan mutating en sus métodos que cambian propiedades.
let perrito = Perro(nombre: "Toby", raza: "Callejero")
perrito.nombre = "Clifor"
print(perrito.nombre)
Si queremos evitar que esto pase debemos definir nuestra parámetro como una constante.
class Perro {
//ahora ya no podrá ser cambiado
let nombre: String
var raza: String
init(nombre: String, raza: String) {
self.nombre = nombre
self.raza = raza
}
func ladrar (){
print("¡Guau! ¡Guau! ¡Guau!")
}
}
Resumen
Las clases y las estructuras son similares, ambas pueden crear tipos de datos personalizados, con sus propias propiedades y métodos
Las clases pueden heredar propiedades y métodos a otras, mediante un sistema de jerarquía llamado herencia en el cual creas clases a partir de otras
Puedes evitar la herencia marcando tu clase como final
El remplazo de métodos en una clase hija permite crear un remplazo del método de la clase padre con su propia implementación esto en POO se conoce como polimorfismo.
Cuando dos variables (o instancias) apuntan a la misma clase ambos comparten el mismo espacio de memoria, modificar una modifica a la otra.
Las clases tienen desinicializadores que es código que corre cuando una instancia de la clase es destruida.
Las clases aunque sean constantes pueden ser modificadas si alguna de sus propiedades es una variable.
//y bueno esas fueron mis notas para clases sin duda un tema super interesante y muy relacionado con POOReferencias
https://www.hackingwithswift.com
https://www.hackingwithswift.com/100/10
