‫In deze les leer je hoe je je eigen interfaces kunt maken en implementeren met een
‫concreet voorbeeld, en je krijgt een idee waarom interfaces worden gebruikt, vooral wanneer onze klassen geen relatie met
‫elkaar hebben en daarom niet' t delen een basisklasse.
‫Erfelijkheid als zodanig is dus geen optie.
‫Stel je voor dat we aan een videogame werken waarin de speler dingen kan vernietigen, maar dat alles
‫wat we vernietigen zich anders gedraagt, afhankelijk van wat er wordt vernietigd.
‫Als u bijvoorbeeld een stoel vernietigt, wordt er een vernietigingsgeluid afgespeeld en worden vernietigde stoelonderdelen voortgebracht.
‫Maar als je een auto vernietigt, hoor je een explosiegeluid, creëer je vuur en vernietig je andere objecten in de buurt.
‫Voor ons spel hebben we de volgende klassen, een stoel die erft van klasmeubilair en de auto
‫die erft van klasvoertuig.
‫Dus laten we eens kijken naar die klassen heel snel.
‫Dus we hebben deze stoel die is geërfd van meubels, en de stoel heeft hier gewoon een eenvoudige constructor
‫waar we zowel de kleur als het materiaal instellen op basis van wat wordt gegeven aan het object dat wordt gemaakt.
‫Maar nu is deze klasse natuurlijk geërfd van meubels, daarom hebben we hier die eigenschappen, kleur
‫en materiaal die we net in de stoelklasse hebben gebruikt.
‫En dan hebben we hier de constructor, de standaardconstructor, waar die waarden standaard
‫worden ingesteld.
‫Dus de kleur en het materiaal zullen wit zijn en zouden standaard zijn.
‫En dan hebben we ook nog een simpele constructor die zowel de kleur als het materiaal gebruikt om ze standaard in
‫te stellen.
‫OK, er is dus niets bijzonders, maar we hebben natuurlijk ook een auto en we willen de stoel en de auto kunnen
‫vernietigen, zoals ik eerder al zei.
‫Dus laten we de auto heel snel bekijken.
‫Dus hier hebben we hetzelfde verhaal, een subklasse auto die het voertuig uitbreidt waar we zowel de autosnelheid als de kleur
‫instellen.
‫Dus nu gebruiken we trouwens een eenvoudige constructor zoals we die hier doen.
‫Maar natuurlijk hadden we hier ook kunnen gebruiken, zowel de snelheid als de kleur doorgeven.
‫OK, dus dat is ook een geldige optie en we zouden dit hier niet hoeven te gebruiken.
‫Dus er zijn natuurlijk twee verschillende manieren om het aan te pakken.
‫OK, en dan erft deze auto van een voertuig waar natuurlijk snelheid en kleur gedefinieerd moeten worden.
‫Laten we dus eens kijken naar de voertuigklasse.
‫En we kunnen hier zien dat dit voertuig uit de basisklasse een snelheid heeft, een kleur, een standaardconstructor, die die
‫twee waarden snelheid instelt op 120 kilometer per uur en de kleur op wit.
‫En dan hebben we de eenvoudige constructor die de snelheid en de kleur zou instellen op basis
‫van de waarden die aan het voertuigobject worden gegeven.
‫Ook natuurlijk aan het ervende object, zoals bijvoorbeeld een auto.
‫Oké, dus nu we al die verschillende klassen hebben en we hebben gezien hoe ze gestructureerd zijn, laten
‫we eens kijken naar de eigenlijke vernietigingsfunctie.
‫Dus wat is de beste aanpak om zo'n vernietigingsfunctie te creëren?
‫Als we erover nadenken, kunnen we geen klasse toevoegen om onze klassen ervan te laten erven, omdat dit een
‫enkele overervingstaal is en niet een taal met meerdere overervingen die we al van één klasse erven.
‫Dus de auto erft al van het voertuig en de stoel erft al van meubels.
‫Het kan dus niet van iets anders erven.
‫Zoals bijvoorbeeld het voertuig dat je hier ziet C Sharp staat dit niet toe omdat het niet meerdere basisklassen
‫kan hebben.
‫Een klasse kan niet meerdere basisklassen hebben in C sharp.
‫Dus plus er is geen concrete relatie tussen een auto en een stoel om toch één basisklasse te delen, omdat
‫ze totaal verschillend zijn van twee dingen, toch?
‫Als we normale methoden, bijvoorbeeld de vernietigingsmethode, implementeren in elk van de klassen die we hier hebben,
‫zal het moeilijk te onderhouden zijn.
‫Wat als we besluiten om het vernietigingssysteem in de toekomst volledig te veranderen of visuele effecten toe te voegen aan onze
‫vernietigbare objecten, dan zal het lastig zijn om elke klasse daadwerkelijk te doorlopen en aan te passen.
‫Omdat we in dit geval maar twee subklassen hebben, om zo te zeggen, juist, maar stel je voor dat
‫je 50 of zelfs 100 verschillende klassen, 100 verschillende soorten objecten in je spel hebt, dan zou je
‫ze allemaal moeten doorlopen en pas de code hierop aan.
‫Dat is dus echt een last en daar willen we niet doorheen.
‫Daarom moeten we een betere oplossing vinden.
‫Wat we nodig hebben is een manier om ons vernietigbare gedrag op te leggen aan elke klas die het gebruikt, net als
‫een contract.
‫En als je onze video over interfaces hebt bekeken, weet je dat het contracten zijn die we kunnen maken.
‫Dus de beste benadering in dit geval is om een interface te gebruiken en we zullen het I vernietigbaar noemen.
‫En elke klasse die deze interface implementeert, wordt gedwongen onze vernietigingsvereisten te volgen en deze
‫tegelijkertijd aan te passen, afhankelijk van de klasse zelf.
‫Dus laten we doorgaan en zo'n interface maken, daarom kun je hier naar je project gaan, een nieuw item
‫toevoegen en dan hier de interface selecteren en het een naam geven.
‫Dus ik ga deze I noemen.
‫D stroy Elbo zodat je kunt zien wanneer je interfaces gebruikt, je voegt de AI toe aan het begin van de naam van het
‫bestand om aan te geven dat dit een interface gaat worden.
‫Dus laten we deze interface toevoegen.
‫Dus deze interface heeft alleen een eigenschap om het audiobestand op te slaan dat wordt uitgevoerd zodra we de vernietiging
‫uitvoeren, wat het vernietigingsgeluid zal zijn, en dan hebben we gewoon een methode die een object zal vernietigen en
‫we gaan dit noemen methode vernietigen.
‫Het zal niets teruggeven.
‫Het zal gewoon iets vernietigen.
‫Dus zou bijvoorbeeld de afbeeldingen kunnen retourneren die u heeft.
‫Dus de AI-objecten die u wilt weergeven zodra het item is vernietigd, bijvoorbeeld de auto
‫of de stoel, enzovoort.
‫Dus laten we er nu voor zorgen dat onze klassen deze interface daadwerkelijk gaan implementeren en dan natuurlijk de inhoud van
‫de interface implementeren, wat zowel het vernietigingsgeluid als de vernietigingsmethode betekent.
‫Hoe kunnen we dat doen?
‫Laten we bijvoorbeeld naar onze auto gaan.
‫En hier moet onze auto een komma toevoegen hier bovenaan de klasse, definitie bovenaan en
‫deze I-vernietigbare interface gebruiken.
‫Dus als je dat nu toevoegt, kun je zien dat je een foutmelding krijgt die zegt dat de auto geen
‫vernietigingsgeluid voor interface-leden implementeert en ook niet vernietigt.
‫Zodat we mogelijke oplossingen kunnen laten zien en alle leden kunnen implementeren.
‫Dit zal bijvoorbeeld deze automatische code voor ons maken.
‫Dus het zal de leegte vernietigbare vernietiging creëren en het zal het vernietigingsgeluid voor ons creëren.
‫Dus dat zou de automatisch gegenereerde versie zijn.
‫Maar we kunnen het ook handmatig doen.
‫Daar is geen probleem mee.
‫Dus hier kunnen we bijvoorbeeld het vernietigingsgeluid implementeren.
‫En wat ik dan wil kunnen doen, is dat ik een eigendom wil hebben om de vernietigbare objecten in de buurt op te
‫slaan.
‫Dus wanneer een auto wordt vernietigd, moet deze ook het nabijgelegen object vernietigen.
‫En deze lijst zal ook van Type I vernietigbaar zijn, wat betekent dat het elk object kan opslaan dat deze interface implementeert
‫en we hebben alleen toegang tot eigenschappen en methoden in die interface.
‫Dus om dat te creëren, ga ik een openbare lijst maken van zeer vernietigbare objecten en
‫ik noem ze vernietigbaar in de buurt.
‫Dus nu kunnen we doorgaan en onze constructor uitbreiden, dus aan de ene kant willen we ervoor zorgen dat we
‫het geluid initialiseren, zodat we zeker weten dat we een explosiegeluid hebben.
‫Laten we bijvoorbeeld zeggen dat we dit geluid hebben dat auto-explosiegeluid wordt genoemd en drie, en dan willen
‫we de lijst met vernietigbare objecten initialiseren.
‫Dit wordt bijvoorbeeld gewoon een nieuwe lijst met vernietigbare objecten.
‫En dan hoeven we alleen nog maar de vernietigingsmethode te implementeren.
‫Dus dit vernietig ik hier aan de bovenkant, je kunt zien dat het nog steeds niet gelukkig is.
‫Het verwacht nog steeds dat we de vernietigingsmethode implementeren.
‫Dus je ziet dat wanneer je een interface implementeert, je de leden ervan moet implementeren, omdat de
‫interface hier twee leden heeft.
‫We moeten ze allebei uitvoeren.
‫OK, dus dat betekent dat we hier terug moeten gaan en de vernietigingsmethode daadwerkelijk moeten implementeren.
‫Dus laten we dat heel snel doen om het te doen.
‫Wat ik hier wil toevoegen, zijn in de eerste plaats twee uitspraken.
‫Ik ga gewoon de juiste regelverklaringen gebruiken.
‫Ik ga het simpel houden, want we maken hier geen spel, maar we proberen alleen de concepten
‫van interfaces te begrijpen.
‫Dus wanneer een auto wordt vernietigd, moeten we het vernietigingsgeluid spelen en een vuureffect creëren.
‫Dus hier bootsen we gewoon na alsof het het geluid zou spelen en het zal gewoon zeggen, OK,
‫het spelen van de auto-explosie en drie geluiden, en dan creëren we het vuur.
‫Dus alles staat op het vuur.
‫Alles staat in brand omdat de auto is vernield.
‫Dus laten we nu alle vernietigbare dingen in de buurt doornemen en het daadwerkelijk vernietigen.
‫Dus hier gaan we door elk vernietigbaar object gaan dat in onze lijst met vernietigde muren in de
‫buurt staat.
‫We noemen het vernietigbaar, zodat elk afzonderlijk item vernietigbaar wordt, wat in feite gewoon een
‫lokale variabelenaam is.
‫Dus we zeggen, OK, het vernietigbare object dat de vernietigbare interface zal implementeren, zal gewoon vernietigbaar worden genoemd in
‫onze voor elke lus.
‫Dus we itereren er doorheen, wat betekent dat we de verzameling vernietigbaar dichtbij doorlopen,
‫wat een lijst is van AI-vernietigbare objecten, in feite objecten die het implementeren, AI-vernietigbare
‫interface en dan noemen we gewoon de vernietigingsmethode.
‫Dus eigenlijk creëren we hier een kettingreactie, vernietigen we alles rond alles wat vernietigd is en dat
‫is ook een auto, enzovoort.
‫Dus in dit geval, laten we zeggen dat we twee auto's naast elkaar hebben en dat ze een stel stoelen naast elkaar
‫hebben.
‫Dus de auto's zullen deze vernietigingsmethode noemen, waarbij ze de items in de buurt zullen vernietigen, want, nou ja, het is
‫een enorme explosie, toch?
‫Er komt een geluid aan en elk item maakt een geluid.
‫Nu kun je natuurlijk een timer maken die nodig is totdat de daadwerkelijke explosie plaatsvindt nadat er iets in
‫brand is gevlogen.
‫Maar we gaan het hier simpel houden.
‫Oké, dus we vernietigen de andere auto's, maar ook het gejuich van de andere auto's, zodat elke auto andere voorwerpen eromheen
‫in de buurt zal besmetten.
‫En dit kan, laten we zeggen, alles zijn dat 10 meter of vijf meter verwijderd is, of hoeveel inches
‫er ook zijn als je het Amerikaanse systeem hier wilt nemen.
‫Maar dat is in wezen wat er gaat gebeuren.
‫Laten we nu naar de stoelen kijken, want de stoelen zullen een soortgelijke aanpak moeten ondergaan, omdat we er ook zeker
‫van willen zijn dat een stoel vernietigbaar is, maar de vernietiging van een stoel zal heel
‫anders zijn.
‫OK, dus hier zullen we ook de interface toevoegen.
‫Dus de AI-vernietigbare interface en natuurlijk moeten we het vernietigingsgeluid implementeren en dat zal
‫een heel andere vernietiging zijn omdat de stoel gewoon uit elkaar valt en het hout dat
‫je hoort verbrijzelen.
‫Het zal hier dus een heel ander geluid zijn.
‫OK, en dan willen we natuurlijk ook het vernietigingsgeluid in onze constructor definiëren.
‫Dus ik ga zeggen dat het stoelvernietigingsgeluid moet worden gespeeld.
‫Het zal altijd hetzelfde zijn.
‫Daarom voeg ik het hier niet toe in de verklaring van de voorzitter.
‫Dus ik hou het hier simpel.
‫Je kunt natuurlijk verschillende stoelen hebben met verschillende explosiegeluiden, dan zou je
‫deze hier bovenaan als parameter voor je constructor toevoegen.
‫OK, dus laten we nu de vernietigingsmethode implementeren.
‫En in dit geval, wat er zal gebeuren, is dat we iets vernietigen en we zullen allereerst de gekleurde stoel vernietigen op basis
‫van de kleur die de stoel heeft, zullen dat opschrijven.
‫Dan spelen we het vernietigingsgeluid en dan gaan we eindelijk stoelonderdelen spawnen.
‫OK, dus in ons geval schrijven we het gewoon op de console.
‫Maar stel je eens voor hoe je dat in een echte game zou doen, want de beste manier om iets in een videogame
‫te vernietigen, is niet om het fysieke ding te doen waarbij je alle vernietiging doet, wat erg
‫moeilijk is om te bouwen, vooral als.
‫Heb je geen groot team dat allerlei dingen doet, dan zou je eigenlijk gewoon
‫een grote explosie- of vernietigingsanimatie maken en dan zou je de vernietigde delen van de afzonderlijke delen die eromheen lagen spawnen.
‫Dus je ziet hier dat er geen kettingreactie voortkomt uit deze vernietigingsmethode.
‫Dus de implementatie van de vernietigingsmethode voor de stoel is heel anders dan die van het
‫voertuig, maar ze erven allebei van de AI-vernietigbare interface en moeten de vernietigingsmethode implementeren en ze kunnen het op
‫hun eigen manier doen.
‫Dus eigenlijk laten interfaces ons een soort van multi-overerving toe, ook al is het niet echt
‫multi-overerving.
‫Oké, laten we nu doorgaan en naar onze programma's gaan.
‫Ja.
‫En gebruik eigenlijk onze nieuw gemaakte klassen omdat.
‫Nou ja, anders is het saai.
‫Rechts.
‫Dus laten we doorgaan en twee stoelen maken.
‫Dus we hebben een bureaustoel die bruin en plastic wordt, en dan hebben we een gamestoel die
‫rood en hout wordt.
‫En laten we dan ook een nieuwe auto maken.
‫Deze auto zal dus een snelheid van 80 hebben en hij zal blauw zijn en een beschadigde auto zijn.
‫En dan gaan we de twee stoelen bij deze beschadigde auto toevoegen.
‫Dus voegen we ze als vernietigbaar in de buurt toe aan onze beschadigde auto.
‫Dus zowel de bureaustoel als de gamestoel zullen nu zijn, als we het hier bekijken als vernietigbaar in de buurt, want bij
‫het maken van een auto zal deze lijst leeg zijn.
‫Maar dan kunnen we natuurlijk, omdat het hier een openbare lijst is, er items aan toevoegen, wat we doen.
‫We voegen er vernietigbare items aan toe.
‫En waarom kunnen we stoelen toevoegen aan onze vernietigbare omgeving?
‫Nou, omdat een stoel deze interface implementeert.
‫Dat we I vernietigbaar hebben genoemd, betekent dat een stoel nu wordt geaccepteerd als een object van Type II vernietigbaar, wat betekent dat
‫we het nu kunnen toevoegen als ons vernietigbare object in de buurt.
‫Dus nu kunnen we doorgaan en de auto vernietigen.
‫Dus laten we gewoon de vernietigingsmethode voor onze beschadigde auto noemen, zodat de explosie kan deelnemen, het explosiegeluid
‫kan beginnen en al het goede.
‫Dus laten we dit uitvoeren.
‫En natuurlijk zal dit meer een avonturenspel zijn en niet zozeer een spel waarin je echte 3D-graphics of iets
‫dergelijks ziet.
‫Dus we spelen het vernietigingsgeluid, het auto-explosiegeluid.
‫Wij creëren het vuur.
‫De bruine stoel is vernield.
‫We spelen het vernietigingsgeluid van de stoel, vernietigingsgeluid en B3.
‫Dan draaien we de stoeldelen voor onze bruine stoel.
‫Toen werd de rode stoel vernietigd.
‫We spelen het vernietigingsgeluid van de stoel, vernietiging, geluid en woede en reageren vervolgens stoeldelen
‫voor onze rode stoel.
‫Dus je ziet, dat is het zo'n beetje.
‫Zo kunt u dus uw eigen interfaces maken en gebruiken.
‫En ik hoop dat u nu begrijpt wat interfaces voor u kunnen doen en wat de voordelen van interfaces zijn.
‫Dus een belangrijk knooppunt hier door interfaces wordt gebruikt voor communicatie tussen twee vergelijkbare of niet-vergelijkbare klassen die
‫zich niets aantrekken van een type klasse dat de interface implementeert, net zoals onze auto met de stoel communiceerde
‫om de vernietigingsmethode aan te roepen, allemaal omdat ze gewoon implementeerde dezelfde interface als ik
‫eerder zei.
‫Dus hoewel interfaces misschien moeilijk te begrijpen lijken, bieden ze ons op het eerste gezicht geweldige voordelen.
‫Die voordelen worden leesbaarheid genoemd.
‫Dus een interface vormt een verklaring over intenties, dus het definieert de mogelijkheden van je klas.
‫Dus waartoe jouw klas in staat is?
‫Als u bijvoorbeeld de I sortable implementeert, geeft u duidelijk aan dat objecten van uw klasse
‫kunnen worden gesorteerd, en vervolgens codesemantiek.
‫Door interfaces te bieden en deze te implementeren, scheid je actief concepten en interface definieert een gedragsmodel,
‫een definitie van wat een object kan doen.
‫En door die concepten te scheiden, blijft de semantiek van je code een stuk duidelijker.
‫Dan heb je de code.
‫Onderhoudsinterfaces helpen de koppeling te verminderen en stellen u in staat eenvoudig implementaties voor hetzelfde concept uit te
‫wisselen zonder dat de onderliggende code wordt aangetast.
‫En dan hebben we ontwerppatronen.
‫Het is het grotere plaatje van het gebruik van contracten, abstractie en interfaces die cruciaal zijn voor objectgeoriënteerd
‫programmeren.
‫Dus menselijk begrip en complexe systeemarchitectuur.
‫Dus het is eigenlijk gewoon om het als mens beter te begrijpen en dan meervoudige overerving.
‫Dus interfaces kunnen onze toegangspoort zijn om meervoudige overerving in C sharp te gebruiken.
‫Dus stel dat u een bibliotheek schrijft en wilt dat deze door gebruikers kan worden gewijzigd.
‫Je schrijft de interface en de implementatie ervan.
‫Andere ontwikkelaars die uw bibliotheek zullen gebruiken, kunnen nog steeds hun eigen implementatieklasse schrijven, die
‫verschillende technologieën of algoritmen kan gebruiken die hetzelfde resultaat bereiken.
‫Dit is ook de reden waarom we zoveel interfaces in bibliotheken tegenkomen.
‫We gebruiken, maar hebben zelden de behoefte om onze eigen interfaces te schrijven, omdat we zelf geen bibliotheken schrijven.
‫Tot slot, het belangrijkste is om te begrijpen hoe interfaces op dit punt worden geïmplementeerd.
‫Natuurlijk, als we verschillende technologieën doorlopen, zoals WP en AP dot net en de
‫C-masterclass, zullen we interfaces meer gaan gebruiken, waardoor je ze in de toekomst beter zult begrijpen.
‫Oke.
‫Dus heel erg bedankt voor het kijken naar deze video.
‫Tot ziens in de volgende.