‫Dans cette leçon, vous apprendrez à créer et implémenter vos propres interfaces avec un exemple concret, et vous aurez
‫une idée de pourquoi les interfaces sont utilisées, en particulier lorsque nos classes n'ont pas de relation entre elles et donc
‫qu'elles n'ont pas de relation. t partager une classe de base.
‫L'héritage en tant que tel n'est donc pas une option.
‫Imaginez que nous travaillons sur un jeu vidéo où le joueur peut détruire des trucs, mais tout ce
‫que nous détruisons aura un comportement différent selon ce qui est détruit.
‫Par exemple, détruire une chaise jouera un son de destruction et engendrera des parties de chaise détruites.
‫Mais détruire une voiture produira un bruit d'explosion, créera un incendie et détruira d'autres objets à proximité.
‫Pour notre jeu, nous avons les classes suivantes, une chaise qui hérite du mobilier de classe et la voiture qui
‫hérite du véhicule de classe.
‫Voyons donc ces cours très rapidement.
‫On a donc cette chaise qui hérite du meuble, et la chaise a juste un constructeur simple ici où
‫on fixe la couleur ainsi que la matière en fonction de ce qui est donné à l'objet qui est créé.
‫Mais maintenant, bien sûr, cette classe hérite des meubles, c'est pourquoi nous avons ici les propriétés, la couleur et
‫le matériau que nous venons d'utiliser dans la classe des chaises.
‫Et puis nous avons le constructeur ici, qui est le constructeur par défaut, où ces valeurs seront
‫définies par défaut.
‫Donc la couleur et la matière seront blanches et le seraient par défaut.
‫Et puis nous avons aussi un constructeur simple qui utilise la couleur ainsi que le matériau pour les définir
‫par défaut.
‫OK, donc il n'y a rien d'extraordinaire, mais bien sûr nous avons aussi une voiture et nous voulons pouvoir détruire la chaise et la
‫voiture, comme je l'ai dit plus tôt.
‫Alors regardons la voiture très rapidement.
‫Nous avons donc ici la même histoire, une sous-classe de voiture qui étend le véhicule où nous définissons la vitesse de la voiture ainsi que
‫la couleur.
‫Alors maintenant, nous utilisons, en passant, un constructeur simple comme nous le faisons ici.
‫Mais bien sûr, nous aurions pu utiliser des bases ici aussi, en passant la vitesse ainsi que la couleur.
‫OK, donc c'est aussi une option valide et nous n'aurions pas à l'utiliser ici.
‫Il y a donc bien sûr deux manières de procéder.
‫OK, et puis cette voiture hérite d'un véhicule où bien sûr, la vitesse et la couleur doivent être définies.
‫Regardons donc la classe de véhicule.
‫Et nous pouvons voir ici que ce véhicule de classe de base a une vitesse, une couleur, un constructeur par défaut, qui
‫fixe ces deux valeurs vitesse à 120 kilomètres par heure et la couleur avec du blanc.
‫Et puis nous avons le constructeur simple qui définirait la vitesse et la couleur en fonction
‫des valeurs qui sont données à l'objet véhicule.
‫Egalement, bien entendu, à l'objet héritier, comme une voiture par exemple.
‫OK, alors maintenant que nous avons toutes ces différentes classes et que nous avons vu comment elles sont
‫structurées, examinons la fonction de destruction réelle.
‫Alors, quelle est la meilleure approche pour créer une telle fonctionnalité de destruction ?
‫Si nous y réfléchissons, nous ne pouvons pas ajouter une classe pour en faire hériter nos classes car il s'agit
‫d'un langage à héritage unique et non d'un langage à héritage multiple que nous héritons déjà d'une classe.
‫Ainsi la voiture hérite déjà du véhicule et la chaise hérite déjà du mobilier.
‫Il ne peut donc pas hériter d'autre chose.
‫Comme, par exemple, le véhicule ici que vous voyez C Sharp ne le permet pas car il ne peut pas avoir plusieurs
‫classes de base.
‫Une classe ne peut pas avoir plusieurs classes de base en C dièse.
‫Donc, en plus, il n'y a pas de relation concrète entre une voiture et une chaise pour partager une classe de base de toute façon, car
‫ils sont complètement différents de deux choses, n'est-ce pas ?
‫Si nous implémentons des méthodes normales appelées méthode destroy, par exemple, dans chacune de ces classes que nous
‫avons ici, ce sera difficile à maintenir.
‫Et si nous décidons de changer complètement le système de destruction ou d'ajouter des effets visuels à nos
‫objets destructibles à l'avenir, il sera difficile de parcourir chaque classe et de la modifier.
‫Parce que dans ce cas, nous n'avons que deux sous-classes, pour ainsi dire, n'est-ce pas, mais imaginez que vous
‫ayez 50 ou même 100 classes différentes, 100 types d'objets différents dans votre jeu, alors vous devriez passer
‫par chacune d'entre elles et ajustez le code en conséquence.
‫C'est donc vraiment un fardeau et nous ne voulons pas subir cela.
‫C'est pourquoi nous devons trouver une meilleure solution.
‫Ce dont nous avons besoin, c'est d'un moyen d'imposer notre comportement destructible à chaque classe qui l'utilise, tout comme un
‫contrat.
‫Et si vous avez regardé notre vidéo sur les interfaces, vous savez que ce sont des contrats que nous pouvons créer.
‫La meilleure approche dans ce cas est donc d'utiliser une interface et nous l'appellerons I destructible.
‫Et toute classe qui implémente cette interface sera obligée de suivre nos exigences de destruction et de
‫la personnaliser en même temps, en fonction de la classe elle-même.
‫Alors allons-y et créons une telle interface, donc vous pouvez aller ici dans votre projet, ajouter un nouvel
‫élément, puis sélectionner l'interface ici et lui donner un nom.
‫Je vais donc appeler celui-ci I.
‫D stroy Elbo pour que vous puissiez voir lorsque vous utilisez des interfaces, vous ajoutez l'IA au début du nom
‫du fichier pour indiquer qu'il s'agira d'une interface.
‫Ajoutons donc cette interface.
‫Donc, cette interface aura juste une propriété pour stocker le fichier audio qui sera exécuté une fois que nous aurons
‫exécuté la destruction, qui sera le son de destruction, puis nous aurons juste une méthode qui détruira un objet
‫et nous allons l'appeler méthode détruire.
‫Il ne rendra rien.
‫Cela va juste détruire quelque chose.
‫Ainsi pourrait, par exemple, retourner les graphiques que vous avez.
‫Ainsi, les objets AI que vous souhaitez afficher une fois que l'élément est détruit, par exemple, la voiture est détruite ou la chaise
‫est détruite et ainsi de suite.
‫Assurons-nous donc maintenant que nos classes vont bien implémenter cette interface et bien sûr, implémenter le contenu de l'interface,
‫c'est-à-dire le son de destruction ainsi que la méthode destroy.
‫Comment peut-on faire ça?
‫Bon, passons à notre voiture, par exemple.
‫Et ici, notre voiture devra ajouter une virgule ici en haut de la classe, la définition en haut
‫et utiliser cette interface destructible comme.
‫Alors maintenant, si vous ajoutez cela, vous pouvez voir que vous obtenez une erreur qui dit que la voiture n'implémente pas le son
‫de destruction des membres de l'interface ainsi que la destruction.
‫Ainsi, nous pouvons montrer des correctifs potentiels et implémenter tous les membres.
‫Par exemple, cela créera ce code automatique pour nous.
‫Donc, cela créera le vide destructible, et cela créera le son de la destruction pour nous.
‫Ce serait donc la version générée automatiquement.
‫Mais on peut aussi le faire manuellement.
‫Il n'y a pas de problème avec ça.
‫Donc ici, par exemple, nous pouvons mettre en œuvre le son de destruction.
‫Et puis ce que je veux pouvoir faire, c'est avoir une propriété pour stocker les objets destructibles à
‫proximité.
‫Ainsi, lorsqu'une voiture est détruite, elle devrait également détruire l'objet à proximité.
‫Et cette liste sera également de type I destructible, ce qui signifie qu'elle peut stocker n'importe quel objet qui implémente cette interface et
‫que nous ne pouvons accéder qu'aux propriétés et aux méthodes de cette interface.
‫Donc, pour créer cela, je vais créer une liste publique d'objets hautement destructibles et je
‫vais les appeler destructibles à proximité.
‫Alors maintenant, nous pouvons aller de l'avant et étendre notre constructeur, donc d'une part, nous voulons nous assurer que nous
‫initialisons le son afin de nous assurer que nous avons un son d'explosion.
‫Par exemple, disons que nous avons ce son appelé bruit d'explosion de voiture et trois, puis nous voulons
‫initialiser la liste des objets destructibles.
‫Il s'agira donc par exemple d'une nouvelle liste d'objets destructibles.
‫Et puis nous avons juste besoin d'implémenter également la méthode destroy.
‫Donc ça je destructible ici en haut, vous pouvez voir que c'est toujours pas content.
‫Il attend toujours que nous implémentions la méthode destroy.
‫Donc, vous voyez, lorsque vous implémentez une interface, vous devez implémenter ses membres car l'interface
‫ici a deux membres.
‫Nous devons mettre en œuvre les deux.
‫OK, cela signifie donc que nous devons revenir ici et que nous devons réellement implémenter la méthode destroy.
‫Alors faisons ça très vite pour le faire.
‫Ce que je veux ajouter ici va être, tout d'abord, deux déclarations.
‫Je vais juste utiliser les bonnes déclarations de ligne.
‫Je vais rester simple car nous ne créons pas de jeu ici, mais nous essayons simplement de
‫comprendre les concepts d'interfaces.
‫Ainsi, lorsqu'une voiture est détruite, nous devons jouer le son de destruction et créer un effet de feu.
‫Donc ici, nous imitons juste comme s'il jouait réellement le son et il dira simplement, OK, jouant
‫l'explosion de la voiture et trois sons, puis nous créons le feu.
‫Donc tout est sur le feu.
‫Tout brûle car la voiture est détruite.
‫Alors maintenant, passons en revue chaque objet destructible à proximité et détruisons-le réellement.
‫Donc, ici, nous allons passer en revue chaque objet destructible I qui se trouve à l'intérieur de notre liste de murs détruits
‫à proximité.
‫Nous l'appelons destructible afin que chaque élément soit destructible, ce qui n'est en fait qu'un nom
‫de variable locale.
‫Nous disons donc, OK, l'objet destructible qui implémentera l'interface destructible sera simplement appelé destructible dans notre
‫boucle for each.
‫Nous l'itérons donc, ce qui signifie que nous parcourons la collection destructible à proximité, qui
‫est une liste d'objets destructibles par l'IA, essentiellement des objets qui l'implémentent, l'interface destructible par
‫l'IA, puis nous appelons simplement la méthode de destruction.
‫Donc, fondamentalement, nous créons une réaction en chaîne ici, détruisant tout autour de tout ce qui est détruit et qui est aussi
‫une voiture et ainsi de suite.
‫Donc dans ce cas, disons que nous avons deux voitures l'une à côté de l'autre et qu'elles ont un tas de chaises l'une à côté
‫de l'autre.
‫Donc les voitures appelleront cette méthode de destruction où elles détruiront les objets à proximité parce que, eh bien, c'est une énorme
‫explosion, n'est-ce pas ?
‫Il y a un son qui monte et chaque élément crée un son.
‫Maintenant, vous pouvez, bien sûr, créer une minuterie dont il a besoin jusqu'à ce que l'explosion réelle se produise après que quelque
‫chose ait pris feu.
‫Mais nous allons rester simple ici.
‫OK, donc nous détruisons les autres voitures, mais aussi les autres acclamations afin que chaque voiture infecte d'autres objets qui l'entourent et
‫qui se trouvent à proximité.
‫Et cela pourrait être, disons, tout ce qui se trouve à 10 mètres ou à cinq mètres ou
‫à quelques centimètres si vous voulez prendre le système américain ici.
‫Mais c'est essentiellement ce qui va se passer.
‫Maintenant, regardons les chaises, parce que les chaises vont devoir passer par une approche similaire parce que nous
‫voulons aussi nous assurer qu'une chaise est destructible, mais la destruction d'une chaise sera très
‫différente.
‫OK, donc ici, nous allons également ajouter l'interface.
‫Donc, l'interface destructible de l'IA et bien sûr, nous devons implémenter le son de destruction et ce
‫sera une destruction très différente parce que la chaise va juste s'effondrer et ce sera du bois brisé
‫que vous entendez.
‫Ce sera donc un son très différent ici.
‫OK, et bien sûr, nous voulons également définir le son de destruction à l'intérieur de notre constructeur.
‫Je vais donc dire que le son de destruction de chaise doit être joué.
‫Ce sera toujours pareil.
‫C'est pourquoi je ne l'ajoute pas ici dans la déclaration du président.
‫Donc je reste simple ici.
‫Bien sûr, vous pourriez avoir différentes chaises qui ont des sons d'explosion différents, puis
‫vous l'ajouteriez ici en haut en tant que paramètre pour votre constructeur.
‫OK, implémentons maintenant la méthode destroy.
‫Et dans ce cas, ce qui se passera, c'est que nous détruirons quelque chose et que nous détruirons tout d'abord la chaise colorée
‫en fonction de la couleur de la chaise, écrirons cela.
‫Ensuite, nous jouerons le son de destruction et enfin nous allons créer des parties de chaise.
‫OK, donc dans notre cas, nous l'écrivons simplement sur la console.
‫Mais imaginez simplement comment vous feriez cela dans un jeu réel, car la meilleure façon de détruire quelque chose dans un jeu
‫vidéo n'est pas de faire la chose physique où vous faites toute la destruction, ce qui
‫est très difficile à construire, surtout si.
‫Si vous n'avez pas une grande équipe qui fait toutes sortes de choses, vous feriez
‫simplement une grosse explosion ou une animation de destruction, puis vous feriez apparaître les parties détruites des parties individuelles qui
‫traînent.
‫Donc, vous voyez ici qu'il n'y a pas de réaction en chaîne provenant de cette méthode de destruction.
‫Ainsi, l'implémentation de la méthode de destruction pour la chaise est très différente de celle du véhicule,
‫mais les deux héritent de l'interface destructible de l'IA et doivent implémenter la méthode de destruction et ils peuvent le
‫faire à leur manière.
‫Donc, fondamentalement, les interfaces nous permettent une sorte d'héritage multiple, même si ce n'est pas vraiment un héritage
‫multiple.
‫OK, alors maintenant allons-y et passons à nos programmes.
‫Oui.
‫Et utilisez réellement nos classes nouvellement créées parce que.
‫Eh bien, sinon c'est ennuyeux.
‫Droit.
‫Alors allons-y et créons deux chaises.
‫Nous avons donc une chaise de bureau qui sera marron et en plastique, puis nous avons une chaise de jeu
‫qui sera rouge et bois.
‫Et puis créons aussi une nouvelle voiture.
‫Donc cette voiture aura une vitesse de 80 et elle sera bleue et sera une voiture endommagée.
‫Et puis on va ajouter les deux chaises à côté de cette voiture accidentée.
‫Nous les ajoutons donc comme destructibles à proximité de notre voiture endommagée.
‫Donc la chaise de bureau ainsi que la chaise gamer le seront désormais, si on la regarde ici car destructible est à proximité, car
‫lors de la création d'une voiture, cette liste sera vide.
‫Mais alors nous pouvons, bien sûr, parce que c'est une liste publique ici, nous pouvons y ajouter des éléments, ce que nous faisons.
‫Nous y ajoutons des objets destructibles.
‫Et pourquoi pouvons-nous ajouter des chaises à nos destructibles à proximité ?
‫Eh bien, parce qu'une chaise implémente cette interface.
‫Que nous ayons appelé I destructible, cela signifie qu'une chaise va maintenant être acceptée comme un objet de type II destructible, ce
‫qui signifie que nous pouvons maintenant l'ajouter comme notre destructible à proximité.
‫Alors maintenant, nous pouvons aller de l'avant et détruire la voiture.
‫Alors appelons simplement la méthode de destruction pour notre voiture endommagée afin que l'explosion puisse participer, le son de l'explosion
‫puisse commencer et toutes les bonnes choses.
‫Alors exécutons ceci.
‫Et bien sûr, ce sera plus un jeu d'aventure et pas tellement un jeu où vous voyez des graphismes 3D réels ou quoi
‫que ce soit.
‫Alors nous jouons le son de la destruction, le son de l'explosion de la voiture.
‫Nous créons le feu.
‫La chaise brune a été détruite.
‫Nous jouons le son de destruction de la chaise, le son de destruction et B3.
‫Ensuite, nous filons les pièces de la chaise pour notre chaise marron.
‫Puis la chaise rouge a été détruite.
‫Nous jouons le son de destruction de la chaise, la destruction, le son et la fureur, puis nous répondons aux parties
‫de la chaise pour notre chaise rouge.
‫Alors vous voyez, c'est à peu près tout.
‫C'est ainsi que vous pouvez créer vos propres interfaces et comment vous pouvez les utiliser.
‫Et j'espère que vous comprenez maintenant ce que les interfaces peuvent faire pour vous et les avantages des interfaces.
‫Ainsi, un nœud important ici par interfaces est utilisé pour la communication entre deux classes similaires ou non similaires qui
‫ne se soucient pas d'un type de classe implémentant l'interface, tout comme la façon dont notre voiture a communiqué avec la chaise
‫pour appeler la méthode destroy, tout cela parce qu'elles implémenté la même interface que je l'ai
‫dit plus tôt.
‫Ainsi, même si les interfaces peuvent sembler difficiles à comprendre, à première vue, elles nous offrent de grands avantages.
‫Ces avantages sont appelés lisibilité.
‫Ainsi, une interface constitue une déclaration d'intentions, elle définit donc la capacité de votre classe.
‫Alors, qu'est-ce que votre classe est capable de faire ?
‫Si vous implémentez le triable I, par exemple, vous indiquez clairement que les objets de votre classe
‫peuvent être triés, puis codez la sémantique.
‫En fournissant des interfaces et en les implémentant, vous séparez activement les concepts et l'interface définit un modèle
‫comportemental, une définition de ce qu'un objet peut faire.
‫Et séparer ces concepts permet de garder la sémantique de votre code beaucoup plus claire.
‫Ensuite, vous avez le code.
‫Les interfaces de maintenabilité aident à réduire le couplage et vous permettent d'échanger facilement des implémentations pour le
‫même concept sans que le code sous-jacent soit affecté.
‫Et puis nous avons des modèles de conception.
‫C'est l'ensemble de l'utilisation des contrats, de l'abstraction et des interfaces essentielles pour la programmation orientée
‫objet.
‫Donc compréhension humaine et architecture système complexe.
‫Donc, il s'agit simplement de mieux le comprendre en tant qu'être humain, puis d'un héritage multiple.
‫Les interfaces peuvent donc être notre passerelle pour utiliser l'héritage multiple en C sharp.
‫Supposons donc que vous écriviez une bibliothèque et que vous souhaitiez qu'elle soit modifiable par les utilisateurs.
‫Vous écrivez l'interface et son implémentation de classe.
‫Les autres développeurs qui utiliseront votre bibliothèque peuvent toujours écrire leur propre classe d'implémentation, qui
‫peut utiliser différentes technologies ou algorithmes pour obtenir le même résultat.
‫C'est aussi pourquoi on rencontre autant d'interfaces dans les bibliothèques.
‫Nous utilisons, mais ressentons rarement le besoin d'écrire nos propres interfaces car nous n'écrivons pas de bibliothèques nous-mêmes.
‫Sur une note finale, l'important est de comprendre comment les interfaces sont implémentées à ce stade.
‫Bien sûr, au fur et à mesure que nous passerons en revue différentes technologies telles que WP et AP dot
‫net et la master class C, nous commencerons à utiliser davantage les interfaces, ce qui vous aidera à mieux les comprendre à l'avenir.
‫D'accord.
‫Alors merci beaucoup d'avoir regardé cette vidéo.
‫Rendez-vous dans le prochain.