1
00:00:00,500 --> 00:00:02,750
Bonjour. On va voir
ensemble dans cette séquence une

2
00:00:02,950 --> 00:00:06,000
subtilité extrêmement
intéressante que vous pouvez

3
00:00:06,200 --> 00:00:08,710
appliquer dans vos
 programmes, et donc on va revenir sur

4
00:00:08,910 --> 00:00:11,450
l'exemple du programme de dé.

5
00:00:11,840 --> 00:00:14,600
Donc on avait défini,
souvenez-vous, dans l'exercice des

6
00:00:14,800 --> 00:00:18,050
dés, donc la classe dés ici
qui permettait de définir des

7
00:00:18,250 --> 00:00:20,660
instances de cette classe pour
représenter des dés de plusieurs faces.

8
00:00:21,020 --> 00:00:24,670
Et on avait défini une classe
DiceHandle, donc une poignée de dés.

9
00:00:26,280 --> 00:00:31,080
On avait implémenté la
méthode "+" sur la classe poignée

10
00:00:31,280 --> 00:00:33,310
de dés pour additionner
des poignées de dés, et

11
00:00:33,510 --> 00:00:35,150
construire une
nouvelle poignée de dés.

12
00:00:35,350 --> 00:00:37,290
Je vous remontre ici
le code de cette classe.

13
00:00:37,920 --> 00:00:42,770
On a " DiceHandleNew" ici,
on crée une nouvelle poignée

14
00:00:43,000 --> 00:00:46,950
de dés dans laquelle on va
ajouter les dés du receveur et

15
00:00:47,150 --> 00:00:49,570
les dés du paramètre, et on
va retourner cette poignée de

16
00:00:49,770 --> 00:00:50,580
dés à la fin de la méthode.

17
00:00:53,300 --> 00:00:56,680
Donc maintenant on va
voir dans cette séquence la

18
00:00:56,880 --> 00:01:00,710
différence entre écrire
dans cette méthode "+",

19
00:01:00,910 --> 00:01:03,020
"DiceHandle new" et
écrire "Self class new".

20
00:01:05,100 --> 00:01:07,060
Et pourquoi une technique
est meilleure que l'autre.

21
00:01:08,400 --> 00:01:09,800
Je vous montre le problème.

22
00:01:10,360 --> 00:01:13,320
Le problème c'est que si
je crée une sous-classe de

23
00:01:13,520 --> 00:01:16,420
"DiceHandle" qui
s'appelle "MemoDiceHandle", et que

24
00:01:16,620 --> 00:01:20,000
maintenant je veux
additionner des poignées de dés de

25
00:01:20,200 --> 00:01:23,340
type "Memo", donc avec la
méthode "+" qui héritait de

26
00:01:23,540 --> 00:01:26,320
"DiceHandle", on voit que le
résultat que j'obtiens c'est

27
00:01:26,520 --> 00:01:29,000
une instance de la
 classe "DiceHandle" et pas une

28
00:01:29,200 --> 00:01:30,040
instance de la
 classe "MemoDiceHandle".

29
00:01:31,080 --> 00:01:31,840
Donc ça c'est un problème.

30
00:01:32,040 --> 00:01:33,760
En fait, on aimerait quand
on additionne des éléments

31
00:01:34,000 --> 00:01:35,810
obtenir le même type d'éléments.

32
00:01:36,410 --> 00:01:38,740
Comment faire pour implémenter ça ?

33
00:01:38,940 --> 00:01:43,280
Solution 1, je vais
changer l'implémentation de la

34
00:01:43,480 --> 00:01:48,420
méthode "+" sur la
 classe "DiceHandle", et on

35
00:01:48,620 --> 00:01:53,510
va juste modifier ici,
rajouter cette méthode-là.

36
00:01:53,760 --> 00:01:56,650
Donc, au lieu de fixer la
 classe que je veux instancier

37
00:01:57,010 --> 00:02:00,740
comme étant "DiceHandle", je
vais prévoir une méthode que

38
00:02:00,940 --> 00:02:03,380
j'appelle "HandleClass".
Dans "DiceHandle", elle va

39
00:02:03,580 --> 00:02:05,930
retourner la classe
"DiceHandle", et dans la sous-classe

40
00:02:06,130 --> 00:02:08,910
"MemoDiceHandle" ça va
retourner la classe "MemoDiceHandle".

41
00:02:10,500 --> 00:02:14,880
Juste en redéfinissant cette
méthode "HandleClass", ça va

42
00:02:15,080 --> 00:02:19,170
me permettre d'obtenir la bonne
instance au moment où j'additionne

43
00:02:19,440 --> 00:02:20,200
des éléments.

44
00:02:21,750 --> 00:02:25,750
On a bien ici, si j'exécute
le même sniped de code mais

45
00:02:25,950 --> 00:02:29,650
avec des MemoDiceHandle,
une instance de MemoDiceHandle

46
00:02:30,720 --> 00:02:34,230
parce que j'ai redéfini
HandleClass, la méthode

47
00:02:34,430 --> 00:02:35,870
HandleClass dans la
 classe MemoDiceHandle.

48
00:02:36,070 --> 00:02:37,880
Donc on bien une
instance de la sous-classe.

49
00:02:38,460 --> 00:02:43,040
Donc on a bien atteint
l'objectif qu'on s'était fixé, le

50
00:02:43,240 --> 00:02:48,130
problème c'est qu'il va
falloir à chaque fois qu'on

51
00:02:48,330 --> 00:02:52,920
ajoute une sous-classe à
DiceHandle, redéfinir cette

52
00:02:53,120 --> 00:02:53,880
méthode HandleClass.

53
00:02:54,080 --> 00:02:57,060
Il ne faut pas oublier de
la redéfinir sinon la méthode

54
00:02:57,260 --> 00:02:59,140
"+" ne va jamais retourner
l'instance de la bonne classe.

55
00:03:00,280 --> 00:03:02,590
C'est quelque chose qui est
un peu contraignant, il faut

56
00:03:02,790 --> 00:03:05,100
toujours redéfinir la méthode,
on pourrait faire beaucoup mieux.

57
00:03:05,650 --> 00:03:06,930
Je vous montre la solution 2.

58
00:03:07,460 --> 00:03:08,750
La solution 2 c'est la suivante.

59
00:03:09,230 --> 00:03:12,610
La méthode "+" dans
DiceHandle, cette fois on va écrire

60
00:03:12,810 --> 00:03:13,830
directement "SelfClass new".

61
00:03:17,160 --> 00:03:21,770
Je vais demander au receveur
courant sa classe et je vais l'instancier.

62
00:03:22,810 --> 00:03:27,170
Et en fait cette classe va toujours
retourner la classe du receveur courant.

63
00:03:27,590 --> 00:03:29,890
Si c'est une instance
d'une sous-classe, ça va bien

64
00:03:30,090 --> 00:03:33,000
retourner la bonne classe,
"MemoDiceHandle" par exemple.

65
00:03:33,740 --> 00:03:36,270
Et on va bien obtenir des
instances qui sont du même type

66
00:03:36,470 --> 00:03:37,390
que celui du receveur.

67
00:03:38,680 --> 00:03:41,830
En conclusion, dans cette
séquence, vous avez vu que

68
00:03:42,790 --> 00:03:47,720
quand on envoie le message
"+" à un "DiceHandle", si on a

69
00:03:47,920 --> 00:03:51,170
fixé dans cette méthode
"+" le nom de la classe à

70
00:03:51,370 --> 00:03:54,050
instancier, quelque part on
s'interdit la redéfinition,

71
00:03:54,250 --> 00:03:57,260
on s'interdit le fait de
créer des sous-classes et que ça

72
00:03:57,510 --> 00:04:01,350
marche toujours en
instanciant le bon objet du bon type

73
00:04:01,550 --> 00:04:02,330
d'une des
sous-classes potentiellement.

74
00:04:03,480 --> 00:04:07,260
Donc il vaut mieux vraiment
utiliser "SelfClass new" pour

75
00:04:07,460 --> 00:04:12,300
instancier directement la classe

76
00:04:12,500 --> 00:04:14,240
en fonction du type
courant du receveur.