From 452b0e0403f56eede5a61555d3b70c13b6b06275 Mon Sep 17 00:00:00 2001
From: Ekaitz Zarraga <ekaitz@elenq.tech>
Date: Sat, 30 Nov 2019 18:51:17 +0100
Subject: Final structure in oop

---
 src/05_oop.md | 84 ++++++++++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 74 insertions(+), 10 deletions(-)

(limited to 'src')

diff --git a/src/05_oop.md b/src/05_oop.md
index dd42cb1..2f59066 100644
--- a/src/05_oop.md
+++ b/src/05_oop.md
@@ -154,8 +154,8 @@ class Dog:
     def bark(self):
         print("Woof! My name is " + self.name)
 
-bobby  = Dog("Bobby")
-beltza = Dog("Beltza")
+bobby  = Dog("Bobby")   # New Dog called Bobby
+beltza = Dog("Beltza")  # New Dog called Beltza
 
 bobby.name    # Bobby
 beltza.name   # Beltza
@@ -167,15 +167,37 @@ bobby.bark()  # Prints "Woof! My name is Bobby"
 beltza.bark() # Prints "Woof! My name is Beltza"
 ```
 
+### Creación de objetos
+
+El ejemplo muestra cómo crear nuevos *objetos* de la clase `Dog`. Las llamadas
+a `Dog("Bobby")` y `Dog("Beltza")` crean las diferentes instancias de la clase.
+
+Llamar a los nombres de clase como si de funciones se tratara crea una
+instancia de éstas. Los argumentos de entrada de la llamada se envían como
+argumentos de la función `__init__` declarada también en el propio ejemplo.
+Entiende de momento que los argumentos posicionales se introducen a partir de
+la segunda posición, dejando el argumento llamado `self` en el ejemplo para un
+concepto que más adelante entenderás.
+
+En el ejemplo, por tanto, se introduce el nombre (`name`) de cada `Dog` en su
+creación y la función `__init__` se encarga de asignárselo a la instancia
+recién creada mediante una metodología que se explica más adelante en este
+mismo capítulo. De momento no es necesario comentar en más profundidad estos
+detalles, con lo que sabes es suficiente para entender el funcionamiento
+general.
+
 Queda por aclarar, sin embargo, qué es la función `__init__` y por qué tiene un
 nombre tan extraño y qué es `type = canine`, que lo trataremos en próximos
 apartados de este capítulo.
 
-Antes de entrar en esos dos puntos, que tratan conceptos algo más avanzados, es
-interesante ver cómo definir clases mediante la herencia. Basta con introducir
-una lista de clases de las que heredar en la definición de la clase, entre
-paréntesis, como si de argumentos de entrada de una función se tratara, tal y
-como se muestra en la clase `Dog` del siguiente ejemplo ejecutado en la REPL:
+### Herencia
+
+Antes de entrar en los detalles propuestos en el apartado anterior, que tratan
+conceptos algo más avanzados, es interesante ver cómo definir clases mediante
+la herencia. Basta con introducir una lista de clases de las que heredar en la
+definición de la clase, entre paréntesis, como si de argumentos de entrada de
+una función se tratara, tal y como se muestra en la clase `Dog` del siguiente
+ejemplo ejecutado en la REPL:
 
 ``` python
 >>> class Animal:
@@ -218,9 +240,9 @@ perro, caminando.
 
 ### Métodos de objeto o funciones de clase: `self`
 
-Te habrás fijado que los métodos reciben un parámetro de entrada llamado `self`
-que no se utiliza a la hora de llamarlos: al hacer `bobby.bark()` no se
-introduce ningún argumento de entrada a la función `bark`.
+Los métodos reciben un parámetro de entrada llamado `self` que no se utiliza a
+la hora de llamarlos: al hacer `bobby.bark()` no se introduce ningún argumento
+de entrada a la función `bark`.
 
 Sin embargo, si no se añade el argumento de entrada a la definición del método
 `bark` y se llama a `bobby.bark()` pasa lo siguiente:
@@ -412,3 +434,45 @@ supone que deberías estar usando las clases.
 
 ### Acceso a la superclase
 
+A pesar de la herencia, no siempre se desea eliminar por completo la
+funcionalidad de un método o pisar una propiedad. A veces es interesante
+simplemente añadir funcionalidad sobre un método o recordar algún valor
+definido en la superclase.
+
+Python soporta la posibilidad de llamar a la superclase mediante la función
+`super`, que permite el acceso a cualquier campo definido en la superclase.
+
+``` python
+class Clase( SuperClase ):
+    def metodo(self, arg):
+        super().metodo(arg)     # Llama a la definición de
+                                # `metodo` de `SuperClase`
+```
+
+> NOTA: `super` busca la clase previa por preferencia, si usas herencias
+> múltiples y pisas los campos puede complicarse. No se trata en este documento
+> porque es un caso muy concreto.
+
+
+## Interfaces estándar
+
+### *Creables*: `__init__`
+
+### *Iterables*: `__next__` e `__iter__`
+
+### *Abribles* y *cerrables*
+
+Que funcionen con el `with`
+
+### *Llamables*: `__call__`
+
+Queda pendiente desde el capítulo sobre funciones, responder a lo que es un
+*callable* o *llamable*.
+
+https://stackoverflow.com/questions/111234/what-is-a-callable
+
+
+## Lo que has aprendido
+
+En el último apartado has aprendido colateralmente a abrir archivos, crearlos y
+a editarlos!
-- 
cgit v1.2.3