Polimorfizmus be Java (Statikus és dinamikus)

Miben rejlik a polimorfizmus? Java?

Polimorfizmus be Java A polimorfizmus akkor fordul elő, amikor egy vagy több osztály vagy objektum öröklődés útján kapcsolódik egymáshoz. Ez egy objektum azon képessége, hogy sokféle formát öltsön. Az öröklődés lehetővé teszi a felhasználók számára, hogy attribútumokat és metódusokat örököljenek, és a polimorfizmus ezeket a metódusokat különböző feladatok végrehajtására használja. A cél a kommunikáció, bár a megközelítés eltérő lehet.

Például egy okostelefont kommunikációra használnak. A kommunikációs mód lehet hívás, szöveges üzenet, képüzenet vagy e-mail. A cél közös, azaz a kommunikáció, de a megközelítés eltérő. Ez a viselkedés a lényege... polimorfizmusMost a polimorfizmust fogjuk tanulni Java példakóddal, ábrákkal és lépésről lépésre bemutatott magyarázatokkal.

Kattints itt ha a videó nem érhető el

Miért használjuk a polimorfizmust? Java?

Polimorfizmus be Java azért használják, mert rugalmassá, újrafelhasználhatóvá és könnyebben karbantarthatóvá teszi a kódot. Egyetlen szülő típusú referenciaváltozó több gyermekobjektumra is mutathat, így ugyanaz a hívás alkalmazkodik a megadott alosztályhoz. Ez a minta érintetlenül hagyja a tesztelt kódot, miközben új viselkedést ad hozzá speciális alosztályokon keresztül, pontosan ezért támaszkodnak rá olyan keretrendszerek, mint a Spring és a Jakarta EE.

Java Polimorfizmus az OOP-ban példával

Tekintsünk egy szülő osztályt, melynek neve Fiók befizetés és kivétel függvényekkel. Az Account osztálynak két gyermekosztálya van. A befizetés és a kivétel működése megegyezik a megtakarítási és folyószámlák esetében, így az Account osztálytól örökölt metódusok fognak működni.

Java Példa a polimorfizmusra

Változás a szoftverkövetelményben

Változás történt a követelményspecifikációban, ami gyakori a szoftveriparban. Hozzá kell adni a kiemelt bankszámla, folyószámlahitel funkcióját. A folyószámlahitel egy olyan lehetőség, ahol az ügyfél a számlán rendelkezésre álló egyenlegnél nagyobb összeget vehet fel. A kiemelt számla kifizetési módszeréhez újra kell implementálni, míg a megtakarítási és folyószámláknál tesztelt kódot érintetlenül kell hagyni. Ez az elszigeteltség a következő előny: Hoppá.

Step 1) Amikor a Takarékszámlához tartozó "withdraw" metódus meghívásra kerül, a szülő Account osztályban definiált metódus hajtódik végre.

Step 2) Amikor a privilegizált számlához (overdraft facility) tartozó withdraw metódus meghívásra kerül, a privilegizált osztályban definiált withdraw metódus végrehajtásra kerül. Ez a diszpécser a következő: Polimorfizmus az OOP-okban.

Módszer felülbírálása be Java

A metódus felülírása egy alosztályon belüli szuperosztály metódus újradefiniálásának folyamata. Az alosztály megtartja ugyanazt a metódust.tract, de egy friss implementációt biztosít, amely a program futtatásakor kerül kiválasztásra.

A módszer felülbírálásának szabályai

• A metódus szignatúrájának, azaz a metódus nevének, a paraméterlistának és a visszatérési típusnak pontosan meg kell egyeznie.
• A felülírt metódus szélesítheti az elérhetőséget, de nem szűkítheti azt. Ha a metódus privát az alaposztályban, akkor a gyermekosztály nyilvánossá teheti, de fordítva nem.

Példa

class Doctor{
  public void treatPatient(){
  // treatPatient method
  
}
class Surgeon extends Doctor{
  public void treatPatient(){
  // treatPatient method
  }
}
class Run{
  public static void main (String args[]){
    Doctor doctorObj = new Doctor();
    // treatPatient method in class Doctor will be executed
    doctorObj.treatPatient();
   
    Surgeon surgeonObj = new Surgeon();
    // treatPatient method in class Surgeon will be executed
    surgeonObj.treatPatient();
  }
}

Különbség a módszer túlterhelése és a módszer felülbírálása között

A metódus túlterhelés ugyanazon osztályon belül történik, ugyanazzal a metódusnévvel, de eltérő szignatúrával. A metódus felülbírálása szülő-gyermek osztálykapcsolaton keresztül történik, ahol az alosztály újradefiniál egy, a szuperosztályban deklarált metódust.

void sum (int a , int b);
void sum (int a , int b, int c);
void sum (float a, double b);

class X{
  public int sum(){
     // some code
  }
}
class Y extends X{
  public int sum(){
    //overridden method
    //signature is same
 }
}

Mi az a dinamikus polimorfizmus?

Az OOP-okban a dinamikus polimorfizmus az a mechanizmus, amellyel több metódus definiálható ugyanazzal a névvel és szignatúrával a szuperosztályban és az alosztályban is. A felülírt metódusok hívása futásidőben, a JVM-en belüli dinamikus kötésen keresztül oldódik fel.

Dinamikus polimorfizmus példa

A szuperosztály referenciaváltozója hivatkozhat egy alosztály objektumra:

 Doctor obj = new Surgeon();

Tekintsük a következő állítást:

obj.treatPatient();

Itt a referencia változó obj a szülő osztályba tartozik, de az objektum, amire mutat, a gyermek osztályba tartozik, ahogy az a polimorfizmus diagramján is látható.

A hívás obj.treatPatient() végrehajtja a Surgeon alosztály treatPatient() metódusát. Amikor egy alaposztály-hivatkozást használunk egy metódus meghívására, a meghívott metódust a JVM dönti el a hivatkozás által mutatott tényleges objektum alapján. Annak ellenére, hogy obj Ha a Doctor objektumra hivatkozik, akkor a Surgeon metódusát hívja meg, mivel az egy Surgeon objektumra mutat. A döntés futásidőben születik meg, ezért nevezik Dinamikus polimorfizmus vagy futásidejű polimorfizmus.

A statikus és a dinamikus polimorfizmus közötti különbség

Statikus polimorfizmus be Java egy olyan polimorfizmus, amely a fordítási időben gyűjti össze a metódus meghívásához szükséges információkat, míg a dinamikus polimorfizmus egy olyan polimorfizmus, amely futási időben gyűjti össze a metódus meghívásához szükséges információkat.

void sum (int a , int b);
void sum (float a, double b);
int sum (int a, int b); //compiler gives error.

//reference of parent pointing to child object
 Doctor obj = new Surgeon();
// method of child called
obj.treatPatient();

Szuper kulcsszó be Java

Mi van akkor, ha a Surgeon osztály treatPatient metódusa végre akarja hajtani a Doctor osztályban definiált funkciókat, majd a saját specifikus viselkedését szeretné végrehajtani? Ebben az esetben a kulcsszó super használható a szülő osztály metódusainak eléréséhez a gyermekosztályból. A Sebész osztály kezelési páciens módszere a következőképpen írható fel:

treatPatient(){
   super.treatPatient();
     //add code specific to Surgeon
}

A „super” kulcsszóval a szuperosztály bármely adattagját vagy metódusát elérhetjük az alosztályon belül. Ezután megismerkedünk a „super” kulcsszóval, Öröklés, és a polimorfizmus a Java példaprogramokkal.

Példa: Az öröklődés, a polimorfizmus és a szuper kulcsszó megtanulása

Step 1) Másolja be a következő kódot egy szerkesztőbe.

public class Test{
     public static void main(String args[]){
        X x= new X();
        Y y = new Y();
        y.m2();
        //x.m1();
        //y.m1();
        //x = y;// parent pointing to object of child
        //x.m1() ;
        //y.a=10;
   }
}
class X{
   private int a;
   int b;
      public void m1(){
       System.out.println("This is method m1 of class X");
     }
}
class Y extends X{
      int c; // new instance variable of class Y
         public void m1(){
            // overridden method
            System.out.println("This is method m1 of class Y");
        }
       public void m2(){
           super.m1();
           System.out.println("This is method m2 of class Y");
      }
}

Step 2) Mentsd el, fordítsd le és futtasd a kódot. Figyeld meg a kimenetet.

Step 3) Töröld ki a kommenteket a 6–9. sorokból. Mentsd el, fordítsd le és futtasd a kódot. Figyeld meg a kimenetet.

Step 4) Töröld ki a 10. sort a megjegyzésből. Mentsd el és fordítsd le a kódot.

Step 5) Hiba = ? Ez azért van, mert az alosztály nem férhet hozzá a szuperosztály privát tagjaihoz.

GYIK