what is polymorphism java tutorial with examples
Този урок обяснява какво е полиморфизъм в Java, видове полиморфизъм и как да приложите полиморфизъм по време на компилация с примери:
Думата „Полиморфизъм“ произлиза от две думи, т.е. „Поли“ което означава много и „ морфи ”Смислови форми. По този начин полиморфизмът означава много форми. В език за програмиране можем да кажем, че обектът може да приеме много форми и следователно обектът е полиморфен.
Полиморфизмът е една от най-важните характеристики на ООП и ни позволява да изразим характеристика (обект или съобщение или метод или оператор) в различни форми.
=> Погледнете тук ръководството за начинаещи Java.
Какво ще научите:
Въведение в полиморфизма в Java
Полиморфната същност се държи различно при различни сценарии.
Например, помислете за оператор ‘+’ (добавяне) в Java. Това е двоичен оператор и отнема два операнда. Когато операндите, които се предават на оператора ‘+’ са числа, се извършва операция за събиране, която връща сумата от две числа.
Когато операндите се променят на тип String, операторът ‘+’ не добавя String обектите, а обединява или обединява съдържанието на низа, за да образува резултатния трети низ.
Например, ако „ един ' и ' две ”Са съдържанието на два String обекта тогава „Едно“ + „две“ ще доведе до „ едно две ”. Това е конкатенация.
В Java всички обекти са полиморфни, тъй като всички са получени от класа „Object“ и по този начин изпълняват връзката ‘IS-A’ с класа Object.
До обекта винаги се осъществява достъп чрез референтна променлива от този конкретен тип клас. След като се декларира референтна променлива от определен тип, тя не може да бъде модифицирана. Ако обаче референтната променлива не е декларирана като „Крайна“, тогава можем да я преназначим, за да сочи към други обекти.
Типът на тази препратка към обект ще реши методите или функциите на класа, които трябва да бъдат извикани.
Например,ако има ABC клас и клас XYZ, получени от ABC, двата класа имат полиморфен метод func ().
class ABC{ void func(){} } class XYZ extends ABC{ void func() {} }
Нека създадем референция от тип ABC.
obj = new XYZ ();
Сега, когато извикаме метода func (), тъй като обектът, посочен от obj, е от клас XYZ, ще бъде извикан методът func () от класа XYZ.
Както видяхме в горния пример, методът func () има различни реализации, но един и същ прототип. В зависимост от обекта, посочен от референтен обект, имаме подходящо изпълнение в този сценарий. Това е полиморфизъм.
Нека обсъдим подробно полиморфизма в Java.
Пример за полиморфизъм на Java
Нека разберем един прост пример за полиморфизъм в Java с операцията за добавяне, както беше обсъдено по-рано.
Тук използваме два метода със същото име, но различни параметри. Първата функция приема два целочислени параметъра, а вторият метод приема два низови параметъра.
В зависимост от вида на предадените параметри се извиква подходящият метод и или добавя две цели числа и отпечатва резултата, или обединява двата низа и отпечатва резултантния низ.
Програмата Java е дадена по-долу:
class Addition_operation{ //method to add two integers void addition_func(int num1,int num2){ System.out.println('ABC::addition_func:' + (num1+num2)); } //overloaded method to add two strings void addition_func(String str1, String str2){ String result = str1 + ' ' + str2; System.out.println('XYZ::addition_func:' + result); } } public class Main { public static void main(String[] args) { Addition_operation abc = new Addition_operation(); //create a class object abc.addition_func (3,4); //calls 1st method abc.addition_func ('Hello' , 'World!'); //calls 2nd method } }
Изход:
Тук видяхме, че когато за първи път предаваме два целочислени параметъра на add_func, тогава се извиква първият метод. Във второто извикване на функция предаваме два параметъра тип String и следователно се извиква вторият претоварен метод.
Видове полиморфизъм
Java поддържа два вида полиморфизъм:
- Полиморфизъм по време на компилация
- Полиморфизъм по време на изпълнение
Както подсказва името, полиморфизмът по време на компилация се извършва по време на компилация, а полиморфизмът по време на изпълнение се извършва по време на изпълнение.
Както е показано на горната фигура, полиморфизмът по време на компилация се реализира чрез претоварване. Можем да претоварим или метода, или оператора. Полиморфизмът по време на изпълнение се постига чрез заместване.
В този урок ще обсъдим подробно полиморфизма по време на компилация. Ще разгледаме полиморфизма по време на изпълнение в следващия урок.
Полиморфизъм по време на компилация в Java
Полиморфизмът по време на компилация е известен още като „статичен полиморфизъм“. Като част от полиморфизма по време на компилация, какъвто и да е полиморфизъм, който се изпълнява, се извършва по време на компилация.
В Java полиморфизмът по време на компилация се извършва с помощта на „ Метод Претоварване ”. Използвайки претоварване на метод, можем да имаме един или повече методи с едно и също име и само диференцирани по числа или тип или ред на параметрите.
qa въпроси и отговори за интервю за инженер
Претоварването на метода е най-честото изпълнение на полиморфизма по време на компилация в Java. Java също поддържа претоварване на оператора.
Какво е претоварването в Java като цяло?
Претоварването в Java е процес на наличие на повече от един метод с едно и също име и тип на връщане, но различен в последователността, броя и видовете аргументи. Той също така се нарича метод за претоварване като цяло.
Претоварване на метод в Java
Претоварването на метода е изпълнение на полиморфизъм по време на компилация в Java. Когато имаме един или повече методи с едно и също име и / или върнати типове, но различни списъци с параметри, тогава казваме, че сме „претоварили“ методите.
Така че в даден клас можем да имаме различни методи с едно и също име, но различни списъци с аргументи.
Как да извикаме претоварени методи? Или как компилаторът знае кой метод трябва да бъде извикан?
Извикването на точния метод, който съответства на повикването, се извършва в зависимост от списъка с параметри.
Вече видяхме, че клас в Java може да има повече от един конструктор. В случай на конструктори, списъкът с аргументи или аргументите, които конструкторът приема, е различен във всички конструктори. Това е пример за претоварване. Така че претоварването на конструктора е основна форма на претоварване на метода в Java.
Сега да видим как да претоварим метод в Java?
Java предоставя три начина за претоварване на метода в зависимост от вариациите в списъка с параметри / аргументи.
# 1) Тип параметри
Можем да претоварим методи в Java в зависимост от типа данни на параметрите.
Да разгледаме следния пример, в който сме дали прототипи на три метода.
добавяне (int, int);
добавяне (int, float);
добавяне (String, String);
Както се вижда по-горе, имаме едно и също име на метода във всичките три случая и еднакъв брой параметри, но всяко извикване на метод има различни видове параметри.
Така че, докато методите имат различни видове параметри, можем да кажем, че методите са претоварени. Когато извикаме метода, компилаторът взема решение за типа данни на параметъра и в зависимост от типа данни на списъка с параметри, предоставен с извикването на метода, се извиква подходящият метод.
Например,ако имаме извикване на метод като по-долу:
добавяне (3, 3.5);
В горното извикване на метод можем да видим, че първият параметър е тип int, докато вторият параметър е тип float. Когато се срещне горното повикване, компилаторът разрешава списъка с параметри и след това извиква подходящия метод, който е вторият метод по-горе.
Сега нека приложим пълна Java програма, за да покажем претоварването на метода въз основа на типовете данни на параметрите.
class MethodOverload { //overloaded method - char parameter public void printParam(char ch) { System.out.println('Input character:' + ch); } //overloaded method - int parameter public void printParam(int num) { System.out.println('Input Number:' + num); } } class Main { public static void main(String args[]) { MethodOverload obj = new MethodOverload(); obj.printParam('A'); //call overloaded method (char ) obj.printParam(10); //call overloaded method (int ) } }
Изход:
# 2) Брой параметри
Друго изпълнение на претоварването на метода е чрез претоварване на методи с различен брой параметри в извикването на функция.
Например,нека разгледаме следните декларации на методи:
addnum (int, int);
addnum (int, int, int);
В горните декларации на методите първата декларация на метод има два параметъра, а втората декларация има три параметъра. Когато се извика функция, компилаторът проверява броя на параметрите и след това разрешава извикването на метода по подходящ начин.
Примерът по-долу показва програмата, която използва претоварване на метода въз основа на броя на параметрите.
class MethodOverload { //overloaded method - 1 parameter public void printParam(char ch) { System.out.println(ch); } //overloaded method - 2 parameters public void printParam(char ch, int num) { System.out.println('Character: ' + ch + ' ; '+ 'Number:' +num); } } class Main { public static void main(String args[]) { MethodOverload obj = new MethodOverload(); obj.printParam('A'); //call overloaded method (1 ) obj.printParam('A',10); //call overloaded method (2 ) } }
Изход:
В този пример имаме два метода, претоварени в зависимост от броя на параметрите. Първият метод взема един параметър, а вторият метод взема два параметъра. В основния метод извикваме двата метода един след друг и компилаторът разрешава извикването на функцията в зависимост от броя на зададените параметри.
# 3) Последователност на параметрите
Третият подход за внедряване на претоварване на метода се основава на последователността на параметрите в претоварените методи.
Да разгледаме следния пример за декларация на метода,
сума (int, float);
сума (float, int);
Тук имаме претоварена сума от метода. В първата декларация параметрите са int и float. Във втората декларация параметрите са int и float, но техният ред в списъка с параметри се променя.
Сега параметърът float се появява първи, докато параметърът int е втори. Можем да постигнем претоварване на метода, като променим реда на параметрите.
The отдолу Java програмата демонстрира това.
class MethodOverload { //overloaded method - char,int parameter public void printParam(char ch, int num) { System.out.println('Input character:' + ch + ' ; ' + 'Input Number:' + num); } //overloaded method - int,char parameter public void printParam(int num, char ch) { System.out.println('Input Number:' + num + ' ; ' + 'Input Character:' + ch); } } class Main { public static void main(String args[]) { MethodOverload obj = new MethodOverload(); obj.printParam('A', 100); //call overloaded method (char,int) obj.printParam(100, 'A'); //call overloaded method (int,char) } }
Изход:
В горната програма имаме претоварен метод printParam, който има параметри int и char, чийто ред се променя в две декларации на методи.
Невалидни случаи на претоварване на метода
Досега обсъждахме претоварването на метода, използвайки списък с параметри. Все още не сме обмисляли метода за връщане. Имайте предвид, че не претоварваме методи, базирани на типове връщане.
Например, ако два метода имат едно и също име и едни и същи списъци с параметри, но различни типове връщане, тогава не казваме, че тези два метода са претоварени. Този случай става невалиден за претоварване.
Така че, ако имаме следните декларации:
Аз int (int, int);
Струнна сума (int, int);
В този случай компилаторът ще издаде грешка, тъй като два метода не са претоварени. Следователно, само въз основа на типовете връщане, методите не са диференцирани.
Нека демонстрираме този невалиден случай с помощта на Java програма.
class OverloadDemo { public double myMethod(int num1, int num2) { System.out.println('OverloadDemo::myMethod returns double'); return num1+num2; } public int myMethod(int var1, int var2) { System.out.println('OverloadDemo::myMethod returns int'); return var1-var2; } } class Main { public static void main(String args[]) { OverloadDemo obj2= new OverloadDemo(); obj2.myMethod(10,10); obj2.myMethod(20,12); } }
В горната програма методът myMethod има два прототипа. Един прототип взема два int параметъра и връща double. Прототипът на втория метод взема два int параметъра и връща int.
Така че, когато компилираме тази програма, получаваме изхода по-долу.
Изход:
Горната грешка при компилацията показва, че методът е деклариран два пъти. Това означава, че компилаторът не счита тези методи претоварени само въз основа на типа връщане.
Претоварване на оператора
Претоварването на оператора е механизъм за претоварване, при който на съществуващ оператор се придава различно значение.
Както обсъдихме в раздела за въвеждане на този урок, добавящият оператор ‘+’ е класически пример за претоварване на оператора.
Когато операндите на този оператор са числови, тогава + операторът връща общо две стойности. Но когато операндите са от тип String, резултатът от операцията за добавяне е конкатенираният низ. Имайте предвид, че в Java можем да претоварим само оператора + (добавяне).
Този оператор изпълнява две функции:
- Добавяне на цели числа или числови стойности.
- Обединяване на низове
Следователно поддръжката на претоварване на оператора е ограничена в Java, за разлика от C ++, където можем да претоварим почти всички оператори, като изключим няколко като sizeof, dot оператор и т.н.
Програмата по-долу демонстрира претоварване на оператора в Java.
class OperatorOverload { //overloaded method for concatenating two strings void operator(String str1, String str2) { String resultStr = str1 + str2; System.out.println('Concatenated String: ' + resultStr); } //overloaded method for adding two numbers void operator(int num1, int num2) { int result = num1 + num2; System.out.println('Sum of two numbers : ' + result); } } class Main { public static void main(String[] args) { OperatorOverload obj = new OperatorOverload(); obj.operator(10, 15); //add two numbers obj.operator('Hello ', 'World!!'); //concatenate two strings } }
Изход:
В горната програма сме претоварили оператора ‘+’. Когато предаваме две целочислени стойности на претоварения метод, се връща сума от две цели числа и когато са предадени два низа, резултатът е конкатенираният низ.
Трябва да се отбележат някои точки относно претоварването и полиморфизма по време на компилация.
- Претоварването на метода е начинът за внедряване на полиморфизъм по време на компилация, който е известен също като статичен полиморфизъм.
- Статичният полиморфизъм е известен също като ранно свързване или свързване по време на компилация.
- Тъй като обвързването на параметри и извикване на функция се случва по време на компилация, претоварването се нарича обвързване на времето на компилиране.
- В Java можем да претоварим само оператор ‘+’ и той извършва добавяне на две цели числа или конкатенация на два низа.
често задавани въпроси
В # 1) Защо се нуждаем от полиморфизъм в Java?
Отговор: Полиморфизмът ни позволява да имаме много реализации за един обект. Чрез претоварване на метода не е необходимо да имаме твърде много методи с различни имена, които са трудни за запомняне. Вместо това можем да имаме претоварени методи, за да можем да имаме ясна реализация на методите, изпълняващи подобни функции.
Също така заместващи помощни средства за правилното изпълнение на наследяването, което ни позволява да добавим повече функционалност към съществуващите класове по-лесно.
В # 2) Какво е полиморфизъм ООП?
Отговор: Дефиницията за полиморфизъм на обектно-ориентирано програмиране се отнася до способността на програмните езици да реализират един обект в различни форми. Полиморфизмът също се дефинира като способността на програмата да замени методите от родителския клас в производния клас, за да има допълнителна функционалност.
В # 3) Можем ли да претоварим и заменим основния метод?
Отговор: Не. Не можем да заменим статичния основен метод. Въпреки че можем да претоварим основния метод, JVM никога няма да извика претоварения основен метод. Така че най-добрият отговор е да не се претоварва или отменя основния метод.
В # 4) Може ли конструкторите да бъдат претоварени?
Отговор: Да, можем да претоварим конструкторите в Java по същия начин, по който претоварваме Java методите. Конструкторите обикновено имат едно и също име, но различен брой аргументи.
В # 5) Защо е полезно претоварването на метода?
Отговор: Можем да напишем чист код, използвайки претоварване на метода и той също става четим, тъй като имаме методи със същото име. Така че, ако внедряваме функционалност за различни типове данни, тогава можем да претоварим методите и ще бъде по-лесно да отделим кода.
Заключение
Полиморфизмът в Java означава, че обектът може да има много форми. Полиморфизмът в Java има два типа, т.е.полиморфизъм по време на компилация и полиморфизъм по време на изпълнение. Полиморфизмът по време на компилация се извършва по време на компилация. Полиморфизмът по време на компилация е статичен и се реализира чрез претоварване на метода и претоварване на оператора.
Полиморфизмът по време на изпълнение се изпълнява по време на изпълнение и е динамичен. Той се изпълнява с използване на метода за отмяна.
В този урок видяхме начините за прилагане на претоварване на метода. Също така обсъдихме подробно претоварването на оператора. Java поддържа претоварване само на оператор „+“.
=> Прочетете серията Easy Training Training.
Препоръчително четене
- Java String съдържа () Урок за метод с примери
- Дължина на низа на Java () Метод с примери
- Метод на Java substring () - Урок с примери
- Урок за Java Float с примери за програмиране
- Урок за JAVA за начинаещи: 100+ практически ръководства за Java видео
- TreeMap в Java - Урок с примери за TreeMap на Java
- Java урок за низове | Низови методи на Java с примери
- Java Double - Урок с примери за програмиране