Herencia

Clase 26 de 46 • Curso de Swift 4 2018

Resumen

Crearemos herencia entre nuestras clases, y veremos de manera practica su uso y limitantes

Ivan Quintana

student•

para cambiar el nombre de una variable se puede hacer con (ctrl+cmd+e) y modificara el nombre en todos lados del codigo donde se use

Alejandro Sol Villaseñor

student•

Muchas gracias, es muy útil.

Jesus Daniel Sánchez Rueda

student•

class Transaction {
    var value: Float
    var name: String
    
    init(value: Float, name: String) {
        self.value = value
        self.name = name
    }
}

class Debit: Transaction {
    var category: String
    
    init(value: Float, name: String, category: String) {
        self.category = category
        super.init(value: value, name: name)
    }
}

class Gain: Transaction {
    
}

class Account2 {
    var amount: Float = 0{
        //willSet {
          //  print("\nSe va a realizar una transacción por $" + (amount - newValue).description)
        //}
        //Alertara cada ver que tenemos un nuevo valor
        didSet {
            print("...Transacción exitosa...")
            print("Saldo disponible" + " $" + amount.description)
        }
    }
    var name: String = ""
    var transactions: [Transaction] = []
    
    init(amount: Float, name: String){
        self.amount = amount
        self.name = name
    }
    //El valor de la estructura se convertira como el de afuera
    
    @discardableResult
    func addTransactionDebit(debit: Debit) -> Float {

        if(amount - debit.value) < 0{
            return 0
        }
        print("\nSe realizo un pago por $" + debit.value.description + " en " + debit.name + "\nCategoria: " + debit.category)
        amount -= debit.value
    
        transactions.append(debit)
        return amount
    }
    
    @discardableResult
    func addTransactionGain(transaction: Transaction) -> Float {
        if transaction is Gain {
          print("\nSe recibio una transacción por $" + transaction.value.description + "\nMotivo: " + transaction.name)
        amount += transaction.value
        }
        transactions.append(transaction)
        return amount
    }
    
    func debits() -> [Transaction] {
        return transactions.filter({ $0 is Debit})
    }
    
    func gains() -> [Transaction] {
        return transactions.filter({ $0 is Gain})
    }
}
class Person2 {
    var name: String = ""
    var lastName: String = ""
    var account2: Account2?
    
    var fullName: String{
        get {
            return "\(name) \(lastName)"
        }
        set {
            name = "Antes: " + name + " ---> Ahora: " + newValue
            print(name)
        }
    }
    
    init(name: String, lastName: String) {
        self.name = name
        self.lastName = lastName
    }
}

var me2 = Person2(name: "Daniel", lastName: "Sanchez")
var account2 = Account2(amount: 100_000, name: "BBVA")

me2.account2 = account2
print("Titular:", me2.name, me2.lastName, "\nBanco:", account2.name, "\nSaldo:", account2.amount)

me2.account2?.addTransactionDebit(debit: Debit(value: 17_000, name: "Hamburguesa", category: "Comida"))
me2.account2?.addTransactionDebit(debit: Debit(value: 10_000, name: "Burrito", category: "Comida"))
me2.account2?.addTransactionDebit(debit: Debit(value: 8_500, name: "Camisa", category: "Ropa"))
me2.account2?.addTransactionGain(transaction: Gain(value: 250_000, name: "Venta de cargador"))
me2.account2?.addTransactionGain(transaction: Gain(value: 1_100_000, name: "Venta de Bitcoins"))

print("\nSaldo actual:" + "$" + me2.account2!.amount.description)

Salida

Titular: Daniel Sanchez 
Banco: BBVA 
Saldo: 100000.0

Se realizo un pago por $17000.0 en Hamburguesa
Categoria: Comida
...Transacción exitosa...
Saldo disponible $83000.0

Se realizo un pago por $10000.0 en Burrito
Categoria: Comida
...Transacción exitosa...
Saldo disponible $73000.0

Se realizo un pago por $8500.0 en Camisa
Categoria: Ropa
...Transacción exitosa...
Saldo disponible $64500.0

Se recibio una transacción por $250000.0
Motivo: Venta de cargador
...Transacción exitosa...
Saldo disponible $314500.0

Se recibio una transacción por $1100000.0
Motivo: Venta de Bitcoins
...Transacción exitosa...
Saldo disponible $1414500.0

Saldo actual:$1414500.0

Rodrigo Guerra Castilla

student•

Sin meterme en detalles de arrays solo agregue la variable pero a la clase Debit donde modifique el init.

class Transaction {
    var value: Float
    var name: String
    init(value: Float, name:String) {
        self.value = value
        self.name = name
    }
}

class Debit: Transaction{
    var categoria: String
    
    init(value: Float, name:String, categoria: String) {
        self.categoria = categoria
        super.init(value: value, name: name)
    }
    
    override convenience init(value: Float, name: String) {
        self.init(value: value, name: name)
    }
//https://docs.swift.org/swift-book/LanguageGuide/Initialization.html

}

class Gain: Transaction{
    
}

class Account {
    var amount: Float = 0{
        willSet{
            print("Vamos a cambiar el valor", newValue)
        }
        didSet {
            print("Tenemos nuevo valor", amount)
        }
    }
    var name: String = ""
    var transactions:[Transaction] = []
    
    init(amount: Float, name: String) {
        self.amount = amount
        self.name = name
    }
    
    @discardableResult
    func addTransaction(transaction: Transaction) -> Float {
        if transaction is Gain{
            amount += transaction.value
        }
        
        if transaction is Debit{
            if (amount - transaction.value) < 0{
                return 0
            }
            amount -= transaction.value
        }
        
        transactions.append(transaction)
        return amount
    }
    func debits() -> [Transaction] {
        return transactions.filter({$0 is Debit})
    }
    func gains() -> [Transaction] {
        return transactions.filter({$0 is Gain})
    }
}

class Person{
    var name: String = ""
    var lastname: String = ""
    var account: Account?
    
    var fullName: String {
        get{
            return "\(name), \(lastname)"
        }
        set{
            name = String(newValue.split(separator: " ").first ?? "")
            lastname = "\(newValue.split(separator: " ").last ?? "")"
        }
    }
    
    
    init(name: String, lastname: String) {
        self.name = name
        self.lastname = lastname
    }
}

var me =  Person(name: "Rodrigo", lastname: "Guerra")

var account = Account(amount: 100_000, name: "x bank")

me.account = account

print(me.account!)

me.account?.addTransaction(transaction: Debit(value: 20, name: "cafe con amigos", categoria: "Alimentos"))
me.account?.addTransaction(transaction: Debit(value: 100, name: "juego ps4", categoria: "Diversión"))
me.account?.addTransaction(transaction: Gain (value: 1000, name: "Salario"))
print(me.account!.amount)```

Manuel Alejandro Aguilar Téllez Girón

student•

Después de todo, lo logré xD

import Foundation

class USUARIO {
    var nombreUsuario: String
    var apellidoUsuario: String
    var cuentaUsuario: CUENTA?
    
    init(nombreUsuario: String, apellidoUsuario: String) {
        self.nombreUsuario = nombreUsuario
        self.apellidoUsuario = apellidoUsuario
    }
}

class CUENTA {
    var nombreBanco: String
    var saldoCuenta: Float = 0 {
        willSet{
            print("el saldo de la cuenta es:", saldoCuenta)
        }didSet{
            print("el saldo de la cuenta ahora es:", saldoCuenta)
        }
    }
    var transactions: [TRANSACTION] = []
    
    @discardableResult
    func addTransaction(transaction: TRANSACTION) -> Float {
        if transaction is DEBIT {
            if (saldoCuenta - transaction.transValue) < 0 {
                return 0
            }else{
                transactions.append(transaction)
                saldoCuenta -= transaction.transValue
            }
        }else if transaction is GAIN {
            saldoCuenta += transaction.transValue
        }
        return saldoCuenta
    }
    
    func debits() -> [TRANSACTION] {
        return transactions.filter({$0 is DEBIT})
    }
    
    func gains() -> [TRANSACTION] {
        return transactions.filter({$0 is GAIN})
    }
    
    init(nombreBanco: String, saldoCuenta: Float){
        self.nombreBanco = nombreBanco
        self.saldoCuenta = saldoCuenta
    }
}

class TRANSACTION {
    var transValue: Float = 0
    var transDescription: String
    
    init(transValue: Float, transDescription: String) {
        self.transValue = transValue
        self.transDescription = transDescription
    }
}

class DEBIT : TRANSACTION {
    var transCategorie: String
    
    init(transValue: Float, transDescription: String, transCategorie: String){
        self.transCategorie = transCategorie
        super.init(transValue: transValue, transDescription: transDescription)
    }
}

class GAIN : TRANSACTION{
    
}

var me = USUARIO(nombreUsuario: "Manuel", apellidoUsuario: "Aguilar")
me.cuentaUsuario = CUENTA(nombreBanco: "Bancomer", saldoCuenta: 1_500_000)

print(me.cuentaUsuario!.saldoCuenta)

me.cuentaUsuario?.addTransaction(transaction: DEBIT(transValue: 500_000, transDescription: "Compré una iMac", transCategorie: "TRABAJO"))

me.cuentaUsuario?.addTransaction(transaction: GAIN(transValue: 60_000, transDescription: "Sueldo apple xD"))

print(me.cuentaUsuario!.saldoCuenta)

Imprime esto:

1500000.0
el saldo de la cuenta es: 1500000.0
el saldo de la cuenta ahora es: 1000000.0
el saldo de la cuenta es: 1000000.0
el saldo de la cuenta ahora es: 1060000.0
1060000.0

Manuel Alejandro Aguilar Téllez Girón

student•

Se escribe category xD
Perdón

Alejandro Sol Villaseñor

student•

Muy bueno!

Irvin Mejia

student•

class Transaction {
    
    var value: Float
    var name: String
    var categoria: String
    
    init(value: Float, name: String, categoria: String) {
        self.value = value
        self.name = name
        self.categoria = categoria
    }
    
}

me.account?.addTransaction(
    transaction: Debit(value: 500, name: "Consola", categoria: "Entretenimiento")
)

Jonathan Macalupu Reyes

student•

El código del reto:

import Foundation
//Herencia tengo un objeto con las mismas similitudes de las propiedades de otro objeto

class Transaction {
    var value : Float
    var name : String
    var category : String
    init(value : Float, name : String, category : String) {
        self.value = value
        self.name = name
        self.category = category
    }
    
}

class Debit : Transaction {
}

class Gain : Transaction {
}

class Account {
    var amount : Float = 0 {
        //Esto es antes de que el valor se cambie. El valoer newValue es un valor implicito, podemos cambiarlo. El newValue es el valor futuro que obtendrá
        willSet {
            //print("Vamos a cambiar el valor", amount, newValue)
            print("Monto inicial: \(amount). Monto final: \(newValue)")
        }
        
        //Se puede agregar eventos en las propiedades. Se ejecuta cuando la varuable ha sido modificada.
        didSet {
            print("Tu saldo actual es:", amount)
        }
    }
    var name : String = ""
    var transactions: [Transaction] = []
    
    init(amount: Float, name : String) {
        self.amount = amount
        self.name = name
    }
    
    @discardableResult
    func addTransaction(transaction: Transaction) -> Float {
        if transaction is Gain {
            amount += transaction.value
            print("Se ingresó \(transaction.value) por concepto de \(transaction.name). Se guardó en la categoría: \(transaction.category)")
        }
        if transaction is Debit {
            if amount - transaction.value < 0 {
                return 0
            }
            amount -= transaction.value
            print("Se gastó \(transaction.value) por concepto de \(transaction.name). Se guardó en la categoría: \(transaction.category)")
        }
        transactions.append(transaction)
        return amount
    }
    
    func debits() -> [Transaction] {
        return transactions.filter({$0 is Debit})
    }
    func gains() -> [Transaction] {
        return transactions.filter({$0 is Gain})
    }
    
}

class Person {
    var name : String = ""
    var lastName : String = ""
    var account : Account?
    
    var fullName : String {
        //también se puede hacer eso sin colocar el get.
        get {
            return "\(name) \(lastName)"
        }
        //Esta funcion puede hacer que se ejecute la funcion antes de que obtenga el valor
        set {
            name = String(newValue.split(separator: " ").first ?? "")
            lastName = "\(newValue.split(separator: " ").last ?? "")"
        }
    }
    
    //Un inicializador es una funcion que crea la clase como tal.
    init(name : String, lastName : String) {
        self.name = name
        self.lastName = lastName
    }
}
var me = Person(name: "Jonathan", lastName: "Macalupu")
var account = Account(amount: 100_000, name: "X bank")

me.account = account


print("Cliente: \(me.fullName)")
print("Transacciones Realizadas")
me.account?.addTransaction(transaction: Debit(value: 20, name: "Cafe con amigos", category: "Comida"))
me.account?.addTransaction(transaction: Debit(value: 100, name: "Juego de Nintendo Switch", category: "Diversión"))
me.account?.addTransaction(transaction: Debit(value: 1200, name: "Nintendo Switch", category: "Diversión"))
me.account?.addTransaction(transaction: Gain(value: 2000, name: "Salario", category: "Ingresos Fijos"))
me.account?.addTransaction(transaction: Gain(value: 1500, name: "Proyecto de diseño web", category: "Ingresos Freelos"))
print("Saldo en tu cuenta es: \(me.account!.amount)")

Jonathan Macalupu Reyes

student•

Lo que imprime:

Ismael Antonio Sánchez Hernández

student•

Pensando en que categoría es un catálogo, la agrego como una clase, con el fin de tener un control sobre estas. Aunque debería ser un Array, Enum o algo por el estilo ya que aun no existe una BD :D

import UIKit
//Clases vs Estructuras (Structs)
class Account {
    varamount: Float = 0 {
        didSet{
            print("Cambió", amount)
        }
    }
    varname: String = ""
    vartransactions: [Transaction] = []
    
    init(amount: Float, name:String){
        self.amount = amount
        self.name = name
    }
    
    @discardableResult
    func addTransaction(transaction: Transaction)-> Float {
        
        amount += transaction is Income ? transaction.amount : 0
        amount -= transaction is Discharge && (amount - transaction.amount) >= 0 ? transaction.amount : 0
        
        transactions.append(transaction)
        return amount
        
    }
    
}

class Person {
    varname: String = ""
    varlastName: String = ""
    varaccount: Account?
    varfullName: String {
        get {
            return"\(name) \(lastName)"
        }
        
        set {
            name = String(newValue.split(separator: " ").first!)
            lastName = "\(newValue.split(separator: "").last!)"
        }
    }
    //Indica las propiedades que se inicializan al momento de crear una nueva instancia
    init(name: String, lastName: String) {
        self.name = name
        self.lastName = lastName
    }
}

class Category {
    varname: String
    init(name: String){
        self.name = name
    }
}

class Transaction {
    varname: String = ""
    varamount: Float = 0
    varcategory: Category
    
    init(name: String, amount: Float, category: Category){
        self.name = name
        self.amount = amount
        self.category = category
    }
}

class Income: Transaction {

}

class Discharge: Transaction {
    
}

let account = Account(amount: 27_500, name: "Santander")

var me = Person(name: "Ismael", lastName: "Sánchez")
me.account = account

print(me.account!)

account.addTransaction(transaction: Discharge(name:"Jugo de Naranja", amount:15, category: Category(name: "Food")))
account.addTransaction(transaction: Income(name:"Pago de ventilador", amount:680, category: Category(name: "Otro")))

print(me.account!.amount)

for transaction in me.account!.transactions {
    print("\(transaction.category.name) ")
}

Vespaciano Forero Sanchez

student•

Reto:

class Transaction {
    var value: Float
    var name: String
    var category: String
    
    init(value: Float, name: String, category: String) {
        self.value = value
        self.name = name
        self.category = category
    }
}

Las transacciones quedan asi:

me.account?.addTransaction(transaction:
    Debit(value: 20, name: "Cafe con friends", category: "Hobbies"))

me.account?.addTransaction(transaction:
    Debit(value: 100, name: "Juego PS4r", category: "Regalos"))

me.account?.addTransaction(transaction:
    Debit(value: 500, name: "PS4", category: "Regalos"))

me.account?.addTransaction(transaction:
    Gain(value: 1000, name: "Salario", category: "Trabajo"))

Luis Angel Patlani Aguilar

student•

Me surgió la duda de por qué las clases hijas no requieren inicilizadores. ¿Es porque no tienen atributos? o ¿Es porque heredan los inicializadores de Transaction?

Diego Forero

Team Platzi•

Como las clases hijas heredan de su clase padre no necesitan inicializar valores a menos que tenga atributos nuevos, en este caso se debe sobreescribir el inicializador y agregar el atributo nuevo.

Andrew Ortiz

student•

import Foundation

class Person {
    var name:String
    var lastName:String
    
    init(name:String, lastName:String) {
        self.name = name
        self.lastName = lastName
    }
    
    func getFullName() -> String {
        return "\(name) \(lastName)"
    }
}

class Account {
    var person:Person
    var transactions:[Transaction]
    
    init(person:Person, transactions:[Transaction] = []) {
        self.person = person
        self.transactions = transactions;
    }
    
    func getPerson() -> Person {
        return person
    }
    
    func getMount() -> Float {
        if (transactions.count == 0) {
            return 0
        }
        
        let addTransactions:[Float] = transactions.filter( {$0.type == "add" }).map({ return $0.value })
        let sumAddTransactions:Float = addTransactions.map({$0}).reduce(0, +);
        
        let debitTransactions:[Float] = transactions.filter( {$0.type == "debit" }).map({ return $0.value })
        let sumDebitTransactions:Float = debitTransactions.map({$0}).reduce(0, +);
        
        return sumAddTransactions - sumDebitTransactions;
    }
    
    func addTransaction(transaction:Transaction) {
        let currentAccountMount = getMount();
        
        if(transaction.type == "debit" && (currentAccountMount - transaction.value) < 0){
            print("esta transaction no puede ser mayor al monto a \(currentAccountMount) ")
        } else {
            transactions.append(transaction)
        }
    }
    
    func getTransactions() -> [Transaction] {
        return transactions;
    }
}

class Transaction {
    var account:Account
    var value:Float;
    var description:String
    var type:String = "add"
    
    init(account:Account, value:Float, description:String) {
        self.account = account
        self.value = value
        self.description = description
    }
    
    func setAccount(account:Account) {
        self.account = account;
    }
    
    func setValue(value:Float) {
        self.value = value;
    }
    
    func setDescription(description:String) {
        self.description = description;
    }
    
    func setType(type:String) {
        self.type = type;
    }
    
    func getType() -> String {
        return type
    }
    
    func getValue() -> Float {
        return value
    }
}

class Debit: Transaction {
    override init(account: Account, value: Float, description: String) {
        super.init(account: account, value: value, description: description)
        setType(type: "debit")
    }
}

class Add: Transaction {
    override init(account: Account, value: Float, description: String) {
        super.init(account: account, value: value, description: description)
        setType(type: "add")
    }
}

let person:Person = Person(name:"Andrew", lastName:"Ortiz")

let account:Account = Account(person: person);

account.addTransaction(transaction: Add(account: account, value: 2000, description: "Pago por freelance"))

account.addTransaction(transaction: Debit(account: account, value: 450, description: "Mercado para el mes"))

account.addTransaction(transaction: Debit(account: account, value: 500, description: "Pago alquiler mes junio"))

print(account.getPerson().getFullName(), "Tu saldo es \(account.getMount())")

Daniel Alcudia

student•

class Transactions{
    var value: Float
    var name: String
    var category: String
    
    init(value: Float, name: String,category: String) {
        self.value = value
        self.name = name
        self.category = category
    }
}

class Debit: Transactions{

}

class Gain: Transactions{
    
}

class Person{
    var name: String
    var lastName: String
    var account: Account?
    
    var fullName: String {
        get{
            return "\(name) \(lastName)"
        }
        set{
            name = String(newValue.split(separator: " ").first ?? "")
            lastName = String(newValue.split(separator: " ").last ?? "")
        }
    }
    
    init(name: String, lastName: String) {
        self.name = name
        self.lastName = lastName
    }
}

class Account{
    var amount: Float = 0.0 {
        //Disparadores de propiedades
        willSet{
            print("Vamos a cambiar el valor",amount)
        }
        didSet{
            print("Tenemos nuevo valor ", amount)
        }
    }
    var name: String = ""
    var transactions: [Transactions] = []
    
    init(amount: Float, name: String) {
        self.amount = amount
        self.name = name
    }
    
    @discardableResult
    func addTransaction(transaction: Transactions) -> Float{
        if transaction is Debit{
            amount -= transaction.value
        }
        if transaction is Gain{
            if(amount - transaction.value) < 0 {
                return 0
            }
            amount += transaction.value
        }
            transactions.append(transaction)
        return amount
    }
    
    func debits() -> [Transactions] {
        return transactions.filter({$0 is Debit})
    }
    
    func gains() -> [Transactions] {
        return transactions.filter({$0 is Gain})
    }
}

var me = Person(name: "Daniel", lastName: "Alcudia")
var account = Account(amount: 100_000, name: "Citibanamex")

me.account = account

me.account?.addTransaction(transaction: Debit(value: 80, name: "Sandwich", category: "Food"))
me.account?.addTransaction(transaction: Gain(value: 100, name: "Juego Xbox", category: "Entertainment"))
me.account?.addTransaction(transaction: Gain(value: 500, name: "XBOX ONE", category: "Entertainment"))

print(me.account!.amount)

for transaction in me.account!.transactions {
    print("\nValor de la transacción: \(transaction.value) \nNombre de la transacción: \(transaction.name) \nCategoría de la transacción: \(transaction.category)")
}

Wilzon Mariño

student•

y no compates guardas el ejemplo de cada clase?

Josue Zafra

student•

import UIKit

class Transaction {
    var value: Float
    var name: String
    var category: String
    
    init(value: Float, name: String, category: String) {
        self.value = value
        self.name = name
        self.category = category
    }
}

class Debit: Transaction {
    
}

class Gain: Transaction {
    
}

class Account {
    var amount: Float = 0 {
        willSet (nextValue){
            print("Vamos a cambiar el valor", amount, nextValue)
        }
        didSet {
            print("tenemos nuevo valor", amount)
        }
    }
    var name: String = ""
    var transactions: [Transaction] = []
    
    init(amount: Float, name: String) {
        self.amount = amount
        self.name = name
    }
    
    @discardableResult
    func addTransaction(transaction: Transaction) -> Float {
        if transaction is Gain {
            amount -= transaction.value
        }
        if transaction is Debit {
            if (amount - transaction.value) < 0 {
                return 0
            }
            
            amount -= transaction.value
        }
        
        
        
        transactions.append(transaction)
        return amount
    }
    
    func debits() -> [Transaction] {
        return transactions.filter({$0 is Debit})
    }
    
    func gains() -> [Transaction] {
        return transactions.filter({$0 is Gain})
    }
}

class Person {
    var fullName: String {
        get {
            return "\(name) \(lastName)"
        }
        set {
            name = String(newValue.split(separator: " ").first ?? "")
            lastName = "\(newValue.split(separator: " ").last ?? "")"
        }
    }
    
    var name: String = ""
    var lastName: String = ""
    var account: Account?
    
    init(name: String, lastName: String) {
        self.name = name
        self.lastName = lastName
    }
}



var me = Person(name: "Josue", lastName: "Zafra")

var account = Account(amount: 100_000, name: "X bank")

me.account = account

//print(me.account!)

Transaction(value: 20, name: "Cafe con amigos", category: "Food")

me.account?.addTransaction(
    transaction: Debit(value: 20, name: "Cafe con amigos", category: "Food")
)

me.account?.addTransaction(
    transaction: Debit(value: 100, name: "Juego PS4", category: "games")
)

me.account?.addTransaction(
    transaction: Debit(value: 500, name: "PS4", category: "games")
)

me.account?.addTransaction(
    transaction: Gain(value: 500, name: "Salario", category: "Gain")
)

print(me.account!.amount)

print(me.fullName)
print(me.lastName)
print(me.name)

print(me.account!.amount)

Horacio Cantu Garcia

student•

Lo que no me gusta del curso es que no dejas nada documentado sobre escribes cada parte que vas explicado y no dejas una manera de hacer las cosas como ejemplo

Herencia

Bienvenida e Introducción

Introducción a Swift

Apple Swift Playgrounds

Conoce el proyecto de este curso

Variables, Constantes y Tipos de Datos

Constantes y Variables

Tipos de datos básicos

Manejo y manipulación de Strings

Manejo y manipulación de Números

Uso de valores boleanos

Tipos de datos Complejos

Arrays en Swift 4

Matrices

Diccionarios

Estructuras de control

If, else, else if, Inline If

Switch

For

Opcionales, Guard, If guard

For Where

Manejo de Arrays

Funciones

Definicion

Parámetros en las funciones

Tuplas

@discardableResult

Objetos

Estructuras vs Clases

Funciones

Propiedades

Manejo de propiedades

Herencia

Enums

Enums Básicos

Enums representativos

Enums con parámetros

Protocolos

Definición

Usando protocolos

Delegados

Advanced Topics

Extensions

Clousures

Typealias

ARC, Retain cycles, Strong, Weak y unowned

Caso práctico de ARC y Retain cycles

Caso práctico de Retain Cycle con Closures

Excepciones

Generics

Completar el proyecto

Organizar nuestro proyecto en clases independientes

Agregar transacciones repetibles

Calcular Lifetime Value

Conclusiones

Finalización del curso

Reto final

Bonus

Primer proyecto en iOS