oop
polymorfism

Introduktion

Polymorfism är ett av de grundläggande begreppen i OOP (Object Oriented Programming) . Huvudtanken med polymorfismen är att ett objekt har förmågan att ta på sig olika former. För att uppnå detta (polymorfism) har vi två huvudsakliga metoder.

1. Metodöverbelastning

   • Händer när det finns två eller flera metoder med samma namn, med olika inmatningsparametrar. Returtypen ska vara densamma för alla metoder med samma namn

2. Överträffande metod

   • Händer när barnobjekt använder samma metoddefinition (samma namn med samma parametrar), men har olika implementationer.

Genom att använda dessa två metoder kan vi använda samma metod / funktion för att bete sig annorlunda. Låt oss se mer information om detta i följande exempel.

Metod överbelastning

Metodöverbelastning är sättet att använda polymorfism i en klass. Vi kan ha två eller flera metoder inom samma klass, med olika inputparametrar.

Skillnaden mellan ingångsparametrar kan vara antingen:

• Antal parametrar
• Typ av parametrar (Datatyp)
• Parternas ordning

Låt oss titta på dem separat (dessa exempel på java, eftersom jag är mer bekant med det - tyvärr det):

1. Antal parametrar

    public class Mathematics { 
        public int add (int a, int b) {
            return (a + b);
        }
   
        public int add (int a, int b, int c) {
            return (a + b + c); 
        }
   
        public int add (int a, int b, int c, int c) {
            return (a + b + c + d);
        }
    }
   

   Titta noga, du kan se metodens returtyp är densamma - int , men där av dessa metoder har olika antal ingångar. Detta kallas som metod över belastning med olika antal parametrar.

   PS: Detta är bara ett exempel , det finns ingen anledning att definiera tilläggsfunktioner som denna.

2. Typ av parametrar

   public class Mathematics { 
       public void display (int a) {
           System.out.println("" + a);
       }
   
       public void display (double a) {
           System.out.println("" + a);
       }
   
       public void display (float a) {
           System.out.println("" + a);
       }
   }
   

   Observera att varje metod har samma namn och samma returtyp, medan de har olika inputdatatyper.

   PS: Detta exempel är endast för att förklara syfte.

3. Parternas ordning

   public class Mathematics {
       public void display (int a, double b) {
           System.out.println("Numbers are " + a + " and " + b);
       }
   
       public void display (double a, int b) {
           System.out.println("Numbers are " + a + " and " + b);
       }
   }
   

   PS: Detta exempel är också endast för att förklara syfte.

Metodöverskridande

Metodöverskridande är sättet att använda polymorfism mellan klasser. om en klass ärvs från en annan kan den förra (underklassen) åsidosätta den sistnämnda (superklassens) metoder och ändra implementeringen.

detta används där superklassen definierar den mer allmänna implementeringen av metoden medan underklassen använder en mer specifik.

Överväg följande exempel:

Vi har en klass för däggdjur:

class Mammal {
  void whoIam () {
    System.out.println("I am a Mammal");
  }
}

Sedan har vi en klass för hund, som är ett däggdjur:

class Dog extends Mammal {
  @Override
  void whoIam () {
    super.whoIam();
    System.out.println("I am a Dog!");
  }
}

I detta exempel definierar whoIam() metoden whoIam() i Mammal , där däggdjuret säger att det är ett däggdjur. Men detta är en allmän term, eftersom det finns många däggdjur där ute. Då kan vi ärva Dog från Mammal , eftersom Hund är ett däggdjur. Men för att vara mer specifik är Dog en hund såväl som ett däggdjur. Därför borde hund säga, I am a Mammal och I am a Dog . Därför kan vi Åsidosätt whoIam() metod super klass ( Mammal klass, alltså) från underklassen (den Dog klass).

Vi kan också kalla superklassens metod med hjälp av super.whoIam() i Java. Sedan kommer Dog att bete sig som en hund, medan han också uppför sig som ett däggdjur.