Polymorfi i Java

Hej! I dag afslutter vi en række lektioner om principperne for OOP. I denne lektion vil vi tale om Java-polymorfi. Polymorfi er evnen til at arbejde med flere typer, som om de var den samme type. Desuden vil objekternes adfærd være forskellig afhængig af deres type. Lad os se nærmere på denne udtalelse. Lad os starte med den første del: 'evnen til at arbejde med flere typer, som om de var den samme type'. Hvordan kan forskellige typer være ens? Det lyder lidt mærkeligt :/ Faktisk er det hele meget simpelt. For eksempel opstår denne situation ved almindelig brug af arv. Lad os se, hvordan det virker. Antag, at vi har en simpel Cat forældreklasse med en enkelt run() metode:

public class Cat {

   public void run() {
       System.out.println("Run!");
   }
}

Nu vil vi oprette tre klasser, der arver Cat : Lion , Tiger og Cheetah .

public class Lion extends Cat {

   @Override
   public void run() {
       System.out.println("Lion runs at 80 km/h");
   }
}

public class Tiger extends Cat {

   @Override
   public void run() {
       System.out.println("Tiger runs at 60 km/h");
   }
}

public class Cheetah extends Cat {

   @Override
   public void run() {
       System.out.println("Cheetah runs at up to 120 km/h");
   }
}

Så vi har 3 klasser. Lad os modellere situationen, hvor vi kan arbejde med dem, som om de var samme klasse. Forestil dig, at en af ​​vores katte er syg og har brug for hjælp fra Dr. Dolittle. Lad os prøve at skabe en Dolittle- klasse, der kan helbrede løver, tigre og geparder.

public class Dolittle {

   public void healLion(Lion lion) {

       System.out.println("Lion is healthy!");
   }

   public void healTiger(Tiger tiger) {

       System.out.println("Tiger is healthy!");
   }

   public void healCheetah(Cheetah cheetah) {

       System.out.println("Cheetah is healthy!");
   }
}

Det ser ud til, at problemet er løst: klassen er skrevet og klar til at gå. Men hvad vil vi gøre, hvis vi vil forlænge vores program? Vi har i øjeblikket kun 3 typer: løver, tigre og geparder. Men der er mere end 40 typer katte i verden. Forestil dig, hvad der ville ske, hvis vi tilføjede separate klasser for manuler, jaguarer, Maine Coons, huskatte og alt det andet. Selve programmet vil selvfølgelig fungere, men vi er nødt til hele tiden at tilføje nye metoder til Dolittle -klassen for at heale hver type kat. Som et resultat vil det vokse til hidtil usete størrelser. Det er her polymorfi - "evnen til at arbejde med flere typer, som om de var den samme type" - kommer ind. Vi behøver ikke skabe utallige metoder til at gøre det samme - helbrede en kat. En metode er nok til dem alle:

public class Dolittle {

   public void healCat(Cat cat) {

       System.out.println("The patient is healthy!");
   }
}

healCat () metoden kan acceptere Lion , Tiger og Cheetah objekter - de er alle forekomster af Cat :

public class Main {

   public static void main(String[] args) {

       Dolittle dolittle = new Dolittle();

       Lion simba = new Lion();
       Tiger shereKhan = new Tiger();
       Cheetah chester = new Cheetah();

       dolittle.healCat(simba);
       dolittle.healCat(shereKhan);
       dolittle.healCat(chester);
   }
}

Konsoludgang: Patienten er rask! Patienten er rask! Patienten er rask! Så vores Dolittleklasse arbejder med forskellige typer, som om de var den samme type. Lad os nu tage fat på den anden del: "desuden vil genstandenes adfærd være forskellig afhængig af deres type". Det hele er meget enkelt. I naturen løber hver kat på en anden måde. Som minimum kører de med forskellige hastigheder. Blandt vores tre kattedyr er geparden den hurtigste, mens tigeren og løven løber langsommere. Med andre ord er deres adfærd anderledes. Polymorfi gør mere end blot at lade os bruge forskellige typer som én. Det lader os også huske deres forskelle, og bevarer den adfærd, der er specifik for hver af dem. Det følgende eksempel illustrerer dette. Antag, at vores katte efter en vellykket bedring besluttede at nyde en lille løbetur. Vi tilføjer dette til vores Dolittle- klasse:

public class Dolittle {

   public void healCat(Cat cat) {

       System.out.println("The patient is healthy!");
       cat.run();
   }
}

Lad os prøve at køre den samme kode til at behandle tre dyr:

public static void main(String[] args) {

   Dolittle dolittle = new Dolittle();

   Lion simba = new Lion();
   Tiger shereKhan = new Tiger();
   Cheetah chester = new Cheetah();

   dolittle.healCat(simba);
   dolittle.healCat(shereKhan);
   dolittle.healCat(chester);
}

Og sådan ser resultaterne ud: Patienten er rask! Lion løber med 80 km/t. Patienten er rask! Tiger kører med 60 km/t. Patienten er rask! Geparden løber med op til 120 km/t Her ser vi tydeligt, at genstandes specifikke adfærd er bevaret, selvom vi overdrog alle tre dyr til metoden efter at have 'generaliseret' dem til Cat . På grund af polymorfi husker Java godt, at disse ikke blot er hvilke som helst tre katte. De er en løve, en tiger og en gepard, som hver løber forskelligt. Dette illustrerer polymorfis vigtigste fordel: fleksibilitet. Når vi skal implementere en funktionalitet, der deles af mange typer, så bliver løver, tigre og geparder simpelthen "katte". Alle dyr er forskellige, men i nogle situationer er en kat en kat, uanset dens art :) Her er en videobekræftelse til dig. Når denne 'generalisering' er uønsket, og vi i stedet har brug for, at hver art opfører sig forskelligt, gør hver type sin egen ting. Takket være polymorfi kan du oprette en enkelt grænseflade (sæt af metoder) til en bred vifte af klasser. Dette gør programmer mindre komplicerede. Selvom vi udvider programmet til at understøtte 40 typer katte, ville vi stadig have den enkleste grænseflade: en enkelt run()- metode for alle 40 katte.