Полиморфизъм в Java

здрасти Днес приключваме поредица от уроци за принципите на ООП. В този урок ще говорим за полиморфизма на Java. Полиморфизмът е способността да се работи с няколко типа, сякаш са от един и същи тип. Освен това поведението на обектите ще бъде различно в зависимост от вида им. Нека разгледаме по-отблизо това твърдение. Нека започнем с първата част: „способността да работите с няколко типа, сякаш са от един и същи тип“. Как различните типове могат да бъдат еднакви? Звучи малко странно :/ Всъщност всичко е много просто. Например, тази ситуация възниква при обикновено използване на наследство. Нека да видим How работи това. Да предположим, че имаме прост родителски клас Cat с един метод run() :

public class Cat {

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

Сега ще създадем три класа, които наследяват Cat : Lion , Tiger и 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");
   }
}

Така че имаме 3 класа. Нека моделираме ситуацията, в която можем да работим с тях, сякаш са от един клас. Представете си, че една от нашите котки е болна и се нуждае от помощ от д-р Дулитъл. Нека се опитаме да създадем клас Dolittle , който може да лекува лъвове, тигри и гепарди.

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!");
   }
}

Изглежда, че проблемът е решен: класът е написан и готов за работа. Но Howво ще направим, ако искаме да разширим нашата програма? В момента имаме само 3 вида: лъвове, тигри и гепарди. Но в света има повече от 40 вида котки. Представете си Howво ще стане, ако добавим отделни класове за манули, ягуари, мейн кууни, домашни котки и всички останали. Самата програма, разбира се, ще функционира, но трябва непрекъснато да добавяме нови методи към класа Dolittle , за да лекуваме всеки тип котка. В резултат на това ще нарасне до безпрецедентни размери. Тук се появява полиморфизмът — „способността да се работи с няколко типа, сякаш са от един и същи тип“ — не е необходимо да създаваме безброй методи, за да направим едно и също нещо — да излекуваме котка. Един метод е достатъчен за всички тях:

public class Dolittle {

   public void healCat(Cat cat) {

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

Методът healCat() може да приема обекти Lion , Tiger и Cheetah — всички те са екземпляри на 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);
   }
}

Изход от конзолата: Пациентът е здрав! Пациентът е здрав! Пациентът е здрав! И така, нашият Дулитълclass работи с различни типове, сякаш са от един и същи тип. Сега нека се заемем с втората част: "освен това, поведението на обектите ще бъде различно в зависимост от техния тип". Всичко е много просто. В природата всяка котка тича по различен начин. Като минимум те работят с различни скорости. Сред нашите три котки гепардът е най-бързият, докато тигърът и лъвът тичат по-бавно. С други думи поведението им е различно. Полиморфизмът прави нещо повече от това просто да ни позволи да използваме различни типове като един. Също така ни позволява да запомним техните различия, запазвайки поведението, специфично за всеки от тях. Следният пример илюстрира това. Да предположим, че нашите котки, след успешно възстановяване, са решor да се насладят на малко тичане. Ще добавим това към нашия клас Dolittle :

public class Dolittle {

   public void healCat(Cat cat) {

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

Нека опитаме да изпълним същия code за лечение на три животни:

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);
}

А ето How изглеждат резултатите: Пациентът е здрав! Лъвът тича с 80 км/ч. Пациентът е здрав! Тигърът тича с 60 км/ч. Пациентът е здрав! Гепардът тича с до 120 км/ч. Тук ясно виждаме, че специфичното поведение на обектите е запазено, въпреки че предадохме и трите животни на метода, след като ги „обобщихме“ на Cat . Благодарение на полиморфизма Java помни добре, че това не са просто три котки. Те са лъв, тигър и гепард, всеки от които тича по различен начин. Това илюстрира основното предимство на полиморфизма: гъвкавост. Когато трябва да приложим няHowва функционалност, споделена от много типове, тогава лъвовете, тигрите и гепардите просто стават „котки“. Всички животни са различни, но в някои ситуации котката си е котка, независимо от вида си :) Ето малко видео потвърждение за вас. Когато това „обобщаване“ е нежелано и instead of това имаме нужда всеки вид да се държи по различен начин, всеки тип прави своето. Благодарение на полиморфизма можете да създадете единичен интерфейс (набор от методи) за широк набор от класове. Това прави програмите по-малко сложни. Дори ако разширим програмата, за да поддържа 40 типа котки, пак ще имаме най-простия интерфейс: един метод run() за всичките 40 котки.