Polymorfismus v Javě je koncept, pomocí kterého můžeme provádět a jediná akce různými způsoby . Polymorfismus je odvozen ze 2 řeckých slov: poly a morphs. Slovo 'poly' znamená mnoho a 'morphs' znamená formy. Polymorfismus tedy znamená mnoho forem.

V Javě existují dva typy polymorfismu: polymorfismus v době kompilace a polymorfismus za běhu. Polymorfismus v Javě můžeme provést přetížením metody a přepsáním metody.

Pokud přetížíte statickou metodu v Javě, je to příklad polymorfismu doby kompilace. Zde se zaměříme na běhový polymorfismus v Javě.

Runtime Polymorphism v Javě

Runtime polymorfismus nebo Dynamická metoda odeslání je proces, ve kterém je volání přepsané metody vyřešeno za běhu, nikoli během kompilace.

V tomto procesu je přes referenční proměnnou nadtřídy volána přepsaná metoda. Určení metody, která má být volána, je založeno na objektu, na který odkazuje referenční proměnná.

Pojďme nejprve pochopit upcasting před Runtime Polymorphism.

Upcasting

Pokud referenční proměnná třídy Parent odkazuje na objekt třídy Child, nazývá se to upcasting. Například:

 class A{} class B extends A{} 

 A a=new B();//upcasting 

Pro upcasting můžeme použít referenční proměnnou typu třídy nebo typu rozhraní. Například:

 interface I{} class A{} class B extends A implements I{} 

Zde by vztah třídy B byl:

 B IS-A A B IS-A I B IS-A Object 

Protože Object je kořenovou třídou všech tříd v Javě, můžeme psát B IS-A Object.

Příklad Java Runtime Polymorphism

V tomto příkladu vytváříme dvě třídy Bike a Splendor. Třída Splendor rozšiřuje třídu Bike a přepisuje její metodu run(). Voláme metodu run pomocí referenční proměnné třídy Parent. Protože odkazuje na objekt podtřídy a metoda podtřídy přepíše metodu třídy Parent, je metoda podtřídy vyvolána za běhu.

Vzhledem k tomu, že vyvolání metody je určeno JVM, nikoli kompilátorem, nazývá se to runtime polymorfismus.

 class Bike{ void run(){System.out.println('running');} } class Splendor extends Bike{ void run(){System.out.println('running safely with 60km');} public static void main(String args[]){ Bike b = new Splendor();//upcasting b.run(); } } 

Výstup:

 running safely with 60km. 

Java Runtime Polymorphism Příklad: Bank

Zvažte scénář, kde je Banka třídou, která poskytuje metodu, jak získat úrokovou sazbu. Úroková sazba se však může u jednotlivých bank lišit. Například banky SBI, ICICI a AXIS poskytují úrokovou sazbu 8,4 %, 7,3 % a 9,7 %.

Poznámka: Tento příklad je také uveden v přepisování metody, ale nedocházelo k upcastingu.

 class Bank{ float getRateOfInterest(){return 0;} } class SBI extends Bank{ float getRateOfInterest(){return 8.4f;} } class ICICI extends Bank{ float getRateOfInterest(){return 7.3f;} } class AXIS extends Bank{ float getRateOfInterest(){return 9.7f;} } class TestPolymorphism{ public static void main(String args[]){ Bank b; b=new SBI(); System.out.println('SBI Rate of Interest: '+b.getRateOfInterest()); b=new ICICI(); System.out.println('ICICI Rate of Interest: '+b.getRateOfInterest()); b=new AXIS(); System.out.println('AXIS Rate of Interest: '+b.getRateOfInterest()); } } 

Výstup:

 SBI Rate of Interest: 8.4 ICICI Rate of Interest: 7.3 AXIS Rate of Interest: 9.7 

Java Runtime Polymorphism Příklad: Shape

 class Shape{ void draw(){System.out.println('drawing...');} } class Rectangle extends Shape{ void draw(){System.out.println('drawing rectangle...');} } class Circle extends Shape{ void draw(){System.out.println('drawing circle...');} } class Triangle extends Shape{ void draw(){System.out.println('drawing triangle...');} } class TestPolymorphism2{ public static void main(String args[]){ Shape s; s=new Rectangle(); s.draw(); s=new Circle(); s.draw(); s=new Triangle(); s.draw(); } } 

Výstup:

 drawing rectangle... drawing circle... drawing triangle... 

Java Runtime Polymorphism Příklad: Animal

 class Animal{ void eat(){System.out.println('eating...');} } class Dog extends Animal{ void eat(){System.out.println('eating bread...');} } class Cat extends Animal{ void eat(){System.out.println('eating rat...');} } class Lion extends Animal{ void eat(){System.out.println('eating meat...');} } class TestPolymorphism3{ public static void main(String[] args){ Animal a; a=new Dog(); a.eat(); a=new Cat(); a.eat(); a=new Lion(); a.eat(); }} 

Výstup:

 eating bread... eating rat... eating meat... 

Java Runtime Polymorphism s datovým členem

Přepsána je metoda, nikoli datové členy, takže pomocí datových členů nelze dosáhnout polymorfismu za běhu.

V níže uvedeném příkladu mají obě třídy rychlostní limit datového člena. K datovému členu přistupujeme pomocí referenční proměnné třídy Parent, která odkazuje na objekt podtřídy. Protože přistupujeme k datovému členu, který není přepsán, bude tedy vždy přistupovat k datovému členu třídy Parent.

Pravidlo: Datovými členy nelze dosáhnout polymorfismu za běhu.

 class Bike{ int speedlimit=90; } class Honda3 extends Bike{ int speedlimit=150; public static void main(String args[]){ Bike obj=new Honda3(); System.out.println(obj.speedlimit);//90 } } 

Výstup:

 90 

Polymorfismus Java Runtime s víceúrovňovou dědičností

Podívejme se na jednoduchý příklad Runtime Polymorphism s víceúrovňovou dědičností.

jak zkontrolovat blokovaná čísla na android

 class Animal{ void eat(){System.out.println('eating');} } class Dog extends Animal{ void eat(){System.out.println('eating fruits');} } class BabyDog extends Dog{ void eat(){System.out.println('drinking milk');} public static void main(String args[]){ Animal a1,a2,a3; a1=new Animal(); a2=new Dog(); a3=new BabyDog(); a1.eat(); a2.eat(); a3.eat(); } } 

Výstup:

 eating eating fruits drinking Milk 

Zkuste výstup

 class Animal{ void eat(){System.out.println('animal is eating...');} } class Dog extends Animal{ void eat(){System.out.println('dog is eating...');} } class BabyDog1 extends Dog{ public static void main(String args[]){ Animal a=new BabyDog1(); a.eat(); }} 

Výstup:

 Dog is eating 

Protože BabyDog nepřepisuje metodu eat(), je vyvolána metoda eat() třídy Dog.