Categoría: Articulo personal

Estas son mis notas para el curso https://www.hackingwithswift.com/100

100 Días de Swift Día 9

“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 POO

Referencias

https://www.hackingwithswift.com

https://www.hackingwithswift.com/100/10

Proximo día

100 Días de Swift Día 11