Polymorfism i Java (Statisk och dynamisk)

Vad är polymorfism i Java?

Polymorfism i Java inträffar när en eller flera klasser eller objekt är relaterade till varandra genom arv. Det är ett objekts förmåga att anta många former. Arv låter användare ärva attribut och metoder, och polymorfism använder dessa metoder för att utföra olika uppgifter. Målet är kommunikation, medan tillvägagångssättet kan variera.

Till exempel används en smartphone för kommunikation. Kommunikationssättet kan vara ett samtal, ett textmeddelande, ett bildmeddelande eller ett e-postmeddelande. Målet är gemensamt, det vill säga kommunikation, men tillvägagångssättet är annorlunda. Detta beteende är essensen av polymorfismNu ska vi lära oss polymorfism i Java med exempelkod, diagram och steg-för-steg-förklaringar.

Klicka här. om videon inte är tillgänglig

Varför använda polymorfism i Java?

Polymorfism i Java används eftersom det gör kod flexibel, återanvändbar och enklare att underhålla. En enda referensvariabel av en föräldertyp kan peka på flera underobjekt, så samma anrop anpassar sig till vilken underklass som helst som anges. Detta mönster håller testad kod orörd medan nytt beteende läggs till genom specialiserade underklasser, vilket är just därför ramverk som Spring och Jakarta EE är beroende av det.

Java Polymorfism i OOPs med exempel

Betrakta en förälderklass som heter Min sida med funktioner för insättning och uttag. Klassen Konto har två underklasser. Funktionen för insättning och uttag är densamma för spar- och checkkonton, så de ärvda metoderna från klassen Konto kommer att fungera.

Java Exempel på polymorfism

Ändring av mjukvarukrav

Det sker en förändring i kravspecifikationen, något som är vanligt inom mjukvaruindustrin. Funktionalitet för ett privilegierat bankkonto med övertrassering måste läggas till. Övertrassering är en möjlighet där en kund kan ta ut ett belopp som är större än det tillgängliga saldot på kontot. Uttagsmetoden för det privilegierade kontot behöver en ny implementering, medan den testade koden i spar- och checkkonton lämnas orörd. Den isoleringen är fördelen med HOPPSAN.

Steg 1) När uttagsmetoden för sparkontot anropas, körs metoden som definierats i den överordnade klassen Konto.

Steg 2) När uttagsmetoden för det privilegierade kontot (övertrasseringen) anropas, utförs uttagsmetoden som definierats i den privilegierade klassen. Denna avsändning är Polymorfism i OOP:er.

Metod Åsidosättande in Java

Metodöverstyrning är processen att omdefiniera en superklassmetod inuti en underklass. Underklassen behåller samma bestämmelser.tract, men tillhandahåller en ny implementering som väljs när programmet körs.

Regler för metodöverstyrning

• Metodsignaturen, det vill säga metodnamnet, parameterlistan och returtypen, måste matcha exakt.
• Den åsidosatta metoden kan bredda tillgängligheten, men den kan inte begränsa den. Om metoden är privat i basklassen kan underklassen göra den publik men inte tvärtom.

Exempelvis

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

Skillnaden mellan metodöverbelastning och metodöverstyrning

Metodöverbelastning sker inom samma klass med samma metodnamn men olika signaturer. Metodöverstyrning sker över en förälder-barn-klassrelation, där underklassen omdefinierar en metod som deklarerats i superklassen.

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

Vad är dynamisk polymorfism?

Dynamisk polymorfism i OOP:er är den mekanism genom vilken flera metoder kan definieras med samma namn och signatur i superklassen och underklassen. Anropet till en åsidosatt metod löses vid körning genom dynamisk bindning inuti JVM:n.

Exempel på dynamisk polymorfism

En referensvariabel i superklassen kan referera till ett underklassobjekt:

 Doctor obj = new Surgeon();

Betrakta påståendet:

obj.treatPatient();

Här är referensvariabeln obj är av förälderklassen, men objektet den pekar på är av underklassen, som visas i diagrammet för polymorfism.

Samtalet obj.treatPatient() kommer att köra metoden treatPatient() från underklassen Surgeon. När en basklassreferens används för att anropa en metod, bestäms vilken metod som anropas av JVM:n baserat på det faktiska objektet som referensen pekar på. Även om obj är en referens till Doktor, kallar den metoden Surgeon, eftersom den pekar på ett Surgeon-objekt. Beslutet fattas under körning, vilket är anledningen till att det kallas Dynamisk polymorfism eller runtime-polymorfism.

Skillnaden mellan statisk och dynamisk polymorfism

Statisk polymorfism i Java är en typ av polymorfism som samlar in informationen för att anropa en metod vid kompileringstid, medan dynamisk polymorfism är en typ av polymorfism som samlar in informationen för att anropa en metod vid körning.

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

Super sökord i Java

Vad händer om metoden treatPatient i Surgeon-klassen vill utföra den funktionalitet som definierats i Doctor-klassen och sedan utföra sitt eget specifika beteende? I det här fallet är nyckelordet super kan användas för att komma åt metoder för föräldraklassen från barnklassen. Behandlingspatientmetoden i klassen Surgeon kan skrivas som:

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

Nyckelordet super kan användas för att komma åt valfri datamedlem eller metod i superklassen inom underklassen. Härnäst ska vi lära oss om nyckelordet super, Arvoch polymorfism i Java med exempelprogram.

Exempel: För att lära sig arv, polymorfism och supernyckelordet

Steg 1) Kopiera följande kod till en editor.

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

Steg 2) Spara, kompilera och kör koden. Observera utdata.

Steg 3) Avkommentera raderna 6 till 9. Spara, kompilera och kör koden. Observera utdata.

Steg 4) Avkommentera rad 10. Spara och kompilera koden.

Steg 5) Fel = ? Detta beror på att underklassen inte kan komma åt privata medlemmar i superklassen.

Vanliga frågor