1
00:00:00,480 --> 00:00:05,200
Hola. Hoy vamos a examinar
una sutileza muy interesante

2
00:00:05,360 --> 00:00:07,720
que puedes aplicar en sus programas.

3
00:00:07,880 --> 00:00:11,640
Para comenzar, revisaremos rápidamente
el programa de dados

4
00:00:11,800 --> 00:00:16,520
Si recuerdas, en este ejercicio
definimos la clase Dice

5
00:00:16,680 --> 00:00:20,840
para definir instancias de esta clase
y representan varias caras de dados.

6
00:00:21,000 --> 00:00:24,920
Definimos una clase llamada DiceHandle.

7
00:00:25,360 --> 00:00:29,440
Luego implementamos
el método "plus"

8
00:00:29,600 --> 00:00:31,320
en la clase DiceHandle,

9
00:00:31,480 --> 00:00:34,840
para agregar DiceHandles
y construir un nuevo DiceHandle.

10
00:00:35,000 --> 00:00:37,600
Este es el código para esta clase.

11
00:00:37,760 --> 00:00:40,680
Tenemos DiceHandle new.

12
00:00:40,840 --> 00:00:42,920
Creamos un nuevo DiceHandle,

13
00:00:43,080 --> 00:00:46,680
al que agregamos los dados
de la clase receptora

14
00:00:46,840 --> 00:00:48,200
y la configuración,

15
00:00:48,360 --> 00:00:52,040
y devolvemos este handle
al final del método. ¿Bueno?

16
00:00:53,280 --> 00:00:57,960
En esta secuencia veremos
la diferencia,

17
00:00:58,120 --> 00:01:02,200
en este método "+",
entre escribir DiceHandle new

18
00:01:02,360 --> 00:01:04,840
y self class new.

19
00:01:05,000 --> 00:01:07,560
Y veremos por qué.
una técnica es mejor.

20
00:01:08,160 --> 00:01:09,840
Este es el problema.

21
00:01:10,200 --> 00:01:15,440
Si creo una subclase DiceHandle
llamada MemoDiceHandle,

22
00:01:16,080 --> 00:01:20,720
y quiero agregar MemoDiceHandles,

23
00:01:20,880 --> 00:01:24,280
con el método "+"
que se hereda de DiceHandle,

24
00:01:24,440 --> 00:01:28,600
el resultado es una instancia
de la clase DiceHandle.

25
00:01:28,760 --> 00:01:30,880
No de la clase MemoDiceHandle.

26
00:01:31,040 --> 00:01:33,840
Esto es un problema
porque cuando agregamos elementos,

27
00:01:34,000 --> 00:01:36,720
queremos obtener
el mismo tipo de elemento de nuevo.

28
00:01:36,880 --> 00:01:38,400
¿Cómo lo hacemos?

29
00:01:38,560 --> 00:01:40,080
Solución N° 1.

30
00:01:40,480 --> 00:01:42,960
Cambio la implementación

31
00:01:43,120 --> 00:01:46,080
del método "+"
en la clase DiceHandle.

32
00:01:46,560 --> 00:01:48,080
El método "+", ¿de acuerdo?

33
00:01:48,240 --> 00:01:53,280
Y simplemente agrego este método:
self handleClass.

34
00:01:53,440 --> 00:01:58,320
En lugar de definir
la variable de instancia que deseo obtener,

35
00:01:58,480 --> 00:02:02,160
uso un método
que llamo handleClass.

36
00:02:02,320 --> 00:02:05,160
En DiceHandle,
se devuelve la clase DiceHandle,

37
00:02:05,320 --> 00:02:09,800
y en la subclase MemoDiceHandle,
se devuelve MemoDiceHandle.

38
00:02:10,160 --> 00:02:14,480
Entonces simplemente
redefiniendo el método handleClass,

39
00:02:14,640 --> 00:02:19,720
obtenemos la instancia correcta
cuando agregamos elementos.

40
00:02:21,120 --> 00:02:25,280
Si ejecutamos el mismo código,

41
00:02:25,440 --> 00:02:30,520
usando MemoDiceHandle en su lugar,
obtenemos una instancia de MemoDiceHandle,

42
00:02:30,680 --> 00:02:33,680
porque redefiní
el método handleClass

43
00:02:33,840 --> 00:02:38,280
en la clase MemoDiceHandle.
Tenemos una instancia de la subclase.

44
00:02:38,440 --> 00:02:42,160
Entonces alcanzamos nuestro objetivo.

45
00:02:42,760 --> 00:02:46,200
El problema es que

46
00:02:46,360 --> 00:02:51,680
cada vez que agregamos una subclase
a DiceHandle,

47
00:02:51,840 --> 00:02:54,240
debemos redefinir
el método handleClass.

48
00:02:54,400 --> 00:02:59,600
Si no lo haces, el método "+" nunca
devuelve la instancia de clase correcta.

49
00:02:59,760 --> 00:03:03,720
Esto es tedioso.
Debes constantemente redefinir el método.

50
00:03:03,880 --> 00:03:05,080
Hay formas mejores.

51
00:03:05,600 --> 00:03:09,000
Aquí está la solución N° 2.

52
00:03:09,160 --> 00:03:13,200
Usando el método "+" en DiceHandle,
esta vez escribiremos:

53
00:03:13,360 --> 00:03:16,160
self class new.

54
00:03:17,000 --> 00:03:20,680
Le preguntaré al receptor actual
por su clase,

55
00:03:20,840 --> 00:03:22,640
para obtener una instancia.

56
00:03:22,800 --> 00:03:27,240
De hecho, la self class siempre retorna
la clase del receptor.

57
00:03:27,400 --> 00:03:29,360
Si es la instancia de una subclase,

58
00:03:29,520 --> 00:03:33,520
devolverá la clase correcta.
Por ejemplo, MemoDiceHandle.

59
00:03:33,680 --> 00:03:37,840
Obtenemos instancias del mismo tipo
del receptor.

60
00:03:38,520 --> 00:03:40,480
Como conclusión,

61
00:03:40,640 --> 00:03:42,400
como viste,

62
00:03:42,800 --> 00:03:47,040
cuando envíe el mensaje "+"
a un DiceHandle,

63
00:03:47,200 --> 00:03:52,080
si fijas el nombre de la clase
que quieres para una instancia,

64
00:03:52,240 --> 00:03:56,760
en cierto sentido te previenes a ti mismo
de la creación de subclases.

65
00:03:56,920 --> 00:04:01,400
Pero con self class new, "+" retorna
una instancia del receptor.

66
00:04:01,560 --> 00:04:03,280
De la subclase potencial.

67
00:04:03,440 --> 00:04:06,920
Entonces es mucho mejor usar
self class new,

68
00:04:07,080 --> 00:04:09,480
para obtener directamente

69
00:04:10,120 --> 00:04:14,720
una instancia de la clase
de acuerdo al tipo de receptor.