"Hej, Amigo! Vi har äntligen kommit fram till något riktigt intressant. Idag ska jag berätta om multipelarv . Multipelarv är verkligen ett mycket fascinerande och kraftfullt verktyg. Och om det inte vore för flera problem, då Java skulle stödja multipelt arv av klasser. Men det gör det inte, så vi måste nöja oss med multipelt arv av gränssnitt. Vilket också är ganska fantastiskt."

Ärver flera gränssnitt - 1

Föreställ dig att du skriver ett datorspel. Och dess karaktärer (dina föremål) måste bete sig på mycket komplexa sätt: gå runt en karta, samla föremål, utföra uppdrag, kommunicera med andra karaktärer, döda någon, rädda någon annan. Låt oss säga att du har kunnat dela upp alla objekt i 20 kategorier. Det betyder att om du har tur kommer du att kunna klara dig med endast 20 klasser för att definiera dina objekt. Men här är haken: hur många unika former av interaktion kommer dessa objekt att ha? Varje typ av objekt kan ha unika interaktioner med 20 andra typer av objekt (vi räknar också interaktioner med objekt av samma typ). Med andra ord, du måste skriva kod för 20 x 20 = 400 interaktioner! Och om antalet unika objekttyper inte är 20, utan 100, kan antalet interaktioner vara 10 000!

Java university

"Wow! Nu förstår jag varför programmering är så svårt arbete."

"Det är enkelt. Tack vare många abstraktioner. Och utan ett litet tack till flera arv av gränssnitt."

Vi kan ofta förenkla objektinteraktion om roller och/eller förmågor samverkar snarare än själva objekten. Och som vi redan vet kan förmågor enkelt läggas till en klass när den implementerar något gränssnitt.

När man skriver ett stort program gör utvecklare vanligtvis detta från första början:

1) Identifiera alla förmågor/roller.

2) Definiera interaktionen mellan dessa roller.

3) Tilldela sedan helt enkelt roller till alla klasser.

"Kanske ett exempel?"

"Självklart. Låt oss titta på roller i den tecknade filmen "Tom och Jerry"."

Java-kod Beskrivning 
interface Moveable
{}
 — Roll/förmåga att röra sig. 
interface Eatable
{}
 — Roll/förmåga att bli uppäten. 
interface Eat
{}
 — Roll/förmåga att äta någon. 
class Tom extends Cat implements Moveable, Eatable, Eat
{}
 Tom är en katt som har tre roller:
1) Han kan röra sig
2) Han kan äta någon
3) Han kan bli uppäten av någon (en hund)		 
class Jerry extends Mouse implements Moveable, Eatable
{}
 Jerry är en mus som har två roller:
1) Han kan röra sig
2) Han kan bli uppäten av någon		 
class Killer extends Dog implements Moveable, Eat
{}
 Killer är en hund med två roller: 1) Han kan röra sig 2) Han kan äta någon

Genom att bara känna till dessa tre roller (gränssnitt), kan du skriva ett program och beskriva den korrekta interaktionen mellan dessa roller. Till exempel kommer ett objekt att jaga (via det flyttbara gränssnittet) efter «den du kan äta» och fly från «den som kan äta dig». Och allt detta utan att veta om specifika föremål. Om du lägger till fler objekt (klasser) till programmet och behåller dessa roller kommer det fortfarande att fungera vackert och kontrollera dina objekts beteende.