Polymorfisme i Java

Hei! I dag avslutter vi en serie leksjoner om prinsippene til OOP. I denne leksjonen skal vi snakke om Java-polymorfisme. Polymorfisme er evnen til å jobbe med flere typer som om de var samme type. Dessuten vil gjenstandenes oppførsel være forskjellig avhengig av type. La oss se nærmere på denne uttalelsen. La oss starte med den første delen: 'evnen til å jobbe med flere typer som om de var samme type'. Hvordan kan ulike typer være like? Det høres litt rart ut :/ Faktisk er det hele veldig enkelt. For eksempel oppstår denne situasjonen ved ordinær bruk av arv. La oss se hvordan det fungerer. Anta at vi har en enkel Cat- overordnet klasse med en enkelt run() -metode:

public class Cat {

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

Nå skal vi lage tre klasser som 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. La oss modellere situasjonen der vi kan jobbe med dem som om de var samme klasse. Tenk deg at en av våre katter er syk og trenger hjelp fra Dr. Dolittle. La oss prøve å lage en Dolittle- klasse som 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 ut til at problemet er løst: klassen er skrevet og klar til å gå. Men hva vil vi gjøre hvis vi ønsker å utvide programmet? Vi har for øyeblikket bare 3 typer: løver, tigre og geparder. Men det er mer enn 40 typer katter i verden. Tenk deg hva som ville skje hvis vi la til separate klasser for manuler, jaguarer, Maine Coons, huskatter og alt det andre. Selve programmet vil selvfølgelig fungere, men vi må hele tiden legge til nye metoder til Dolittle -klassen for å helbrede hver type katt. Som et resultat vil den vokse til enestående størrelser. Det er her polymorfisme - "evnen til å jobbe med flere typer som om de var samme type" - kommer inn. Vi trenger ikke lage utallige metoder for å gjøre det samme - helbrede en katt. En metode er nok for dem alle:

public class Dolittle {

   public void healCat(Cat cat) {

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

healCat () -metoden kan godta Lion , Tiger og Cheetah- objekter - de er alle forekomster av 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);
   }
}

Konsollutgang: Pasienten er frisk! Pasienten er frisk! Pasienten er frisk! Så vår Dolittleklasse jobber med ulike typer som om de var samme type. La oss nå takle den andre delen: "Dessuten vil gjenstandenes oppførsel være forskjellig avhengig av deres type". Det hele er veldig enkelt. I naturen løper hver katt på en annen måte. Som et minimum kjører de i forskjellige hastigheter. Blant våre tre kattedyr er geparden den raskeste, mens tigeren og løven løper saktere. Med andre ord er oppførselen deres annerledes. Polymorfisme gjør mer enn bare å la oss bruke forskjellige typer som en. Det lar oss også huske forskjellene deres, og bevare atferden som er spesifikk for hver av dem. Følgende eksempel illustrerer dette. Anta at kattene våre, etter en vellykket bedring, bestemte seg for å nyte en liten løpetur. Vi legger dette til i Dolittle- klassen vår:

public class Dolittle {

   public void healCat(Cat cat) {

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

La oss prøve å kjøre den samme koden for å 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 slik ser resultatene ut: Pasienten er frisk! Lion løper i 80 km/t. Pasienten er frisk! Tiger går i 60 km/t. Pasienten er frisk! Geparden løper i opptil 120 km/t Her ser vi tydelig at objekters spesifikke oppførsel er bevart, selv om vi overførte alle tre dyrene til metoden etter å ha 'generalisert' dem til Cat . På grunn av polymorfisme husker Java godt at dette ikke bare er tre katter. De er en løve, en tiger og en gepard, som hver løper forskjellig. Dette illustrerer polymorfis viktigste fordel: fleksibilitet. Når vi trenger å implementere funksjonalitet som deles av mange typer, blir løver, tigre og geparder ganske enkelt "katter". Alle dyr er forskjellige, men i noen situasjoner er en katt en katt, uansett art :) Her er en videobekreftelse for deg. Når denne 'generaliseringen' er uønsket og vi i stedet trenger at hver art oppfører seg forskjellig, gjør hver type sin egen greie. Takket være polymorfisme kan du lage et enkelt grensesnitt (sett med metoder) for et bredt spekter av klasser. Dette gjør programmer mindre kompliserte. Selv om vi utvider programmet til å støtte 40 typer katter, vil vi fortsatt ha det enkleste grensesnittet: en enkelt kjøring()- metode for alle 40 katter.