Meerdere interfaces overerven

"Hallo, Amigo! We zijn eindelijk tot iets echt interessants gekomen. Vandaag ga ik je vertellen over meervoudige overerving . Meervoudige overerving is inderdaad een heel fascinerend en krachtig hulpmiddel. En als er niet meerdere problemen waren, dan zou Java zou meerdere overerving van klassen ondersteunen. Maar dat doet het niet, dus we moeten tevreden zijn met meervoudige overerving van interfaces . Dat is ook best gaaf."

Stel je voor dat je een computerspel aan het schrijven bent. En zijn personages (jouw objecten) moeten zich op zeer complexe manieren gedragen: over een kaart lopen, items verzamelen, missies uitvoeren, met andere personages communiceren, iemand doden, iemand anders redden. Laten we zeggen dat je alle objecten in 20 categorieën hebt kunnen verdelen. Dit betekent dat je, als je geluk hebt, kunt rondkomen met slechts 20 klassen om je objecten te definiëren. Maar hier zit het addertje onder het gras: hoeveel unieke vormen van interactie zullen deze objecten hebben? Elk type object kan unieke interacties hebben met 20 andere soorten objecten (we tellen ook interacties met objecten van hetzelfde type). Met andere woorden, u moet code schrijven voor 20 x 20 = 400 interacties! En als het aantal unieke objecttypes niet 20, maar 100 is, dan kan het aantal interacties wel 10.000 zijn!

"Ho! Nu begrijp ik waarom programmeren zo'n moeilijk werk is."

"Het is eenvoudig. Dankzij veel abstracties. En niet in de laatste plaats dankzij meerdere overerving van interfaces."

We kunnen objectinteractie vaak vereenvoudigen als rollen en/of vaardigheden op elkaar inwerken in plaats van de objecten zelf. En zoals we al weten, kunnen vaardigheden eenvoudig aan een klasse worden toegevoegd wanneer deze een interface implementeert.

Bij het schrijven van een groot programma doen ontwikkelaars dit meestal vanaf het allereerste begin:

1) Identificeer alle vaardigheden/rollen.

2) Definieer de interactie tussen deze rollen.

3) Wijs vervolgens gewoon rollen toe aan alle klassen.

"Misschien een voorbeeld?"

"Natuurlijk. Laten we eens kijken naar rollen in de tekenfilm «Tom en Jerry»."

interface Moveable
{}

interface Eatable
{}

interface Eat
{}

class Tom extends Cat implements Moveable, Eatable, Eat
{}

class Jerry extends Mouse implements Moveable, Eatable
{}

class Killer extends Dog implements Moveable, Eat
{}

Als je alleen deze drie rollen (interfaces) kent, kun je een programma schrijven en de juiste interactie tussen deze rollen beschrijven. Een object jaagt bijvoorbeeld (via de Moveable-interface) achter de «one you can eat» aan en rent weg van de «one who can eat you». En dit alles zonder kennis van specifieke objecten. Als u meer objecten (klassen) aan het programma toevoegt en deze rollen behoudt, zal het nog steeds prachtig werken en het gedrag van uw objecten regelen.