Ya conocemos los tipos de variables o constantes y cómo funcionan, también hemos visto los controles de flujo y las variables opcionales, y con esta información podemos montar fácilmente un proyecto con un Playground y trabajar con él.
Con todo ello podemos experimentar y hacer mucho, pero si queremos hacer un programa más complejo (un proyecto completo) nos queda una última cosa que ver: las clases y métodos en Swift. Esas partes esenciales que organizar y que dividen nuestra aplicación en diferentes archivos y dentro de estos en diferentes llamadas (métodos) que nos permiten estructurar todo.
La clase es la parte más esencial en que se divide un programa, pudiendo contener una por fichero o varias en uno solo si nos resulta mejor.
Como cualquier lenguaje orientado a objetos, en Swift además podemos utilizar la herencia para estructurar nuestro programa. De esta forma, si hacemos un juego y vamos a tener diferentes tipos de enemigos como un troll, un orco o un espectro, tendremos una clase enemigo que a su vez podrá tener los hijos (o subclases) troll, orco y espectro.
De esta forma, podemos definir métodos que sean comunes a todos los enemigos y que podremos ejecutar en el contexto de cada uno de ellos, aunque luego incluyamos nuevos enemigos.
A su vez, si enemigo es un personaje del juego, también podríamos crear una clase personaje y que enemigo fuera subclase de esta, con lo que aquello común de un personaje, como por ejemplo, saber si está vivo o no, puede ser controlado desde la clase principal e invocado, gestionado o sobrescrito desde cualquiera de sus subclases.
class Enemigo {
let nombre: String
var fuerza: Int
var vida: Int
}
class Orco: Enemigo {
}
Así de simple hemos definido una clase. Por supuesto, aun nos falta inicializar Enemigo y nos dará error, pero por ahora, de esta forma tenemos una visión clara de lo que estamos hablando. Tenemos un Enemigo con tres propiedades y un Orco, subclase de enemigo, que heredará todos las propiedades de su padre por lo que también tendrá nombre, fuerza y vida.
Una clase y un struct son muy similares, de hecho, en Swift son casi iguales. Su única diferencia es que mientras una actúa en paso por referencia (la clase) la otra se copia a sí misma en cada nueva asignación (el struct). Los structs, por otro lado, permiten declarar una estructura de datos que no requiere inicializar ninguna de sus variables. Luego, cuando queremos crear una instancia del struct, se nos permite usar un constructor por defecto que nos obliga a dar valor a todos los valores del mismo.
Vamos a crear un struct que represente los valores de fuerza y vida como valores vitales y lo sustituimos en nuestra clase Enemigo.
struct valoresVitales {
var fuerza: Int
var vida: Int
}
Ahora sustituimos en la clase los valores y, ahora sí, inicializamos la clase:
class Enemigo {
let nombre: String
let vital: valoresVitales
init(nombre: String, vital: valoresVitales) {
self.nombre = nombre
self.vital = vital
}
}
Debido a cómo Swift maneja las variables y las constantes en objetos, cuando definimos una instancia de una clase como constante (en let) podremos cambiar las propiedades de esta sin problema, aunque no podremos re-asignar la constante a una nueva clase.
Sin embargo, un struct constante no permite alterar las propiedades de la misma ni tampoco, como pasa con las clases, re-asignar dicha constante a un nuevo struct.
Como vemos, la inicialización de una clase se basa en la palabra clave init, donde pedimos aquellos parámetros que consideremos necesarios para la inicialización. Si tras crear nuestro inicializador, alguna propiedad de la clase no quedara asignada, nos daría error, pues recordemos que en Swift todo ha de ser inicializado con valor en el momento de su creación, incluso las opcionales que llevan un valor vacío y wrapeado que se asigna en el momento de la creación del mismo opcional.
Ya hemos creado nuestra clase Enemigo, y para inicializarla tenemos que pasarle el nombre del mismo como parámetro, pero también tenemos pasarle la iniciación de un struct que corresponda con sus valores vitales. Esto supondría que tendríamos que crear previamente una variable o constante del struct valoresVitales y luego pasarlo al inicializador de Enemigo.
var vitalUruk = valoresVitales(fuerza: 30,vida: 50) let UrukHai = Enemigo (nombre: "Shagrat", vital: vitalUruk)
Esto puede hacerse más simplemente, usando un concepto llamado inicializador de conveniencia. Podemos crear nuevos tipos de inicializadores que nos permitan recibir otros parámetros diferentes que los que la clase requiere de por sí, y que nos permitan construir más cómodamente la instancia.
convenience init (name:String, fuerza:Int, vida:Int) {
let vitalUruk = valoresVitales(fuerza: fuerza, vida: vida)
self.init (nombre: name, vital: vitalUruk)
}
El concepto es simple: creamos inicializadores alternativos que invoquen al init principal, pero pudiendo pre-procesar los datos. En nuestro caso, creando el struct desde los dos valores Int aislados. De esta forma, cuando queramos crear una nueva clase enemigo como la creada anteriormente, solo tendremos que hacer una única llamada:
let UrukHai = Enemigo (name: "Shagrat", fuerza: 30, vida: 50)
Sin duda, una herramienta tremendamente útil pues nos permite inicializar una clase de diferentes formas, en función de los parámetros que queramos y, en este caso concreto, nos ahorra tener que dar pasos intermedios como la creación del struct previo a la creación de la clase donde vamos a usarlo.
Imaginemos que queremos crear una nueva clase que extienda por herencia la funcionalidad de una clase padre. Por ejemplo, en el ejemplo que ya hemos trabajo tenemos la clase Enemigo que es padre del Orco, pero queremos que Orco a su vez pueda definir a qué clan pertenece el nuestro. Esta es una característica propia de los orcos, que son enemigos pero que otros enemigos no tienen por qué tener.
class Orco: Enemigo {
let clan: String
init(nombre: String, vital: valoresVitales, clan: String) {
self.clan = clan
super.init(nombre: nombre, vital: vital)
}
convenience init (nombre: String, fuerza:Int, vida:Int, clan:String) {
let vitalOrco = valoresVitales(fuerza: fuerza, vida: vida)
self.init (nombre: nombre, vital: vitalOrco, clan: clan)
}
}
Estamos creando una clase Orco que hereda de Enemigo pero extiende sus propiedades añadiendo un nuevo valor clan. Ese valor forma parte de la inicialización de la clase al que luego añadimos uno nuevo de conveniencia que nos permite enviar la fuerza y la vida que conforman los valores vitales por separado.
En uno de los trucos ya publicados aquí en AppleCoding, teníamos una forma de extender la funcionalidad de una clase String para conseguir que esta nos devolvería lo que se llaman propiedades computadas o calculadas. Valores que se calculan en tiempo real en el momento de la consulta y que depende o tienen que ver con los valores que alberga la propia clase. Estas extensiones alteran y extienden el funcionamiento de cualquiera de ellas a nuestra voluntad, desde una que hayamos creado, hasta cualquiera del sistema.
En nuestro caso vamos a suponer que queremos obtener el valor de valía de un enemigo, que es el resultado de multiplicar su fuerza por su vida.
extension Enemigo {
var valia: Int {
return (self.vital.fuerza * self.vital.vida)
}
}
Sencillamente definimos una extensión de Enemigo, con una nueva propiedad computada (o calculada). Una propiedad que recupera el valor de fuerza y vida de los valores propios de la clase (self) y devuelve la multiplicación de estos valores.
Ahora solo tenemos que ver el valor de nuestro Enemigo UrukHai que definimos más arriba. Si miramos UrukHai.valia veremos que nos devuelve 1.500, que es la multiplicación de sus valores de fuerza 30 y vida 50.
Vamos ahora a crear un Orco:
let orcoFeo = Orco (nombre: "Thrum", fuerza: 20, vida: 15, clan: "Skullsplitter")
Creamos nuestro orco, que a su vez hereda de la clase enemigo y usamos para ello el inicializador de conveniencia que nos permite dar los valores de fuerza y vida por separado. Si ahora preguntamos por su valor de valia, con orcoFeo.valia, nos dirá que es 300.
Como vemos, la extensión de valia para la clase Enemigo ha sido heredada igualmente por el Orco (que es su hijo) y cualquier Orco que creemos desde ese momento tendrá esta extensión, así como cualquier nuevo enemigo que queramos crear, siempre que sea hijo o subclase de Enemigo.
Hemos visto como en esta nueva lección hemos dado una noción básica de las clases y las estructuras (o structs), como extender la funcionalidad de una clase de una manera sencilla y las formas en que la herencia de clases funciona.
Próximamente veremos qué es y cómo funciona el polimorfismo, la sobreescritura de clases o cómo funcionan los controles de acceso de Swift y podemos acceder a los métodos y propiedades de otras clases definidas en otros ficheros desde cualquiera nuevo.
Recordar practicar mucho, hacer vuestras propias modificaciones y usar los Playground de los que ya os hemos dado una guía de trabajo. Y recordad, Good Apple Coding.