Meny

Vad är polymorfism i Java - Handledning med exempel

  • Huvud
  • Övrig
  • Vad är polymorfism i Java - Handledning med exempel

what is polymorphism java tutorial with examples

Prova Vårt Instrument För Att Eliminera Problem

Denna handledning förklarar vad som är polymorfism i Java, typer av polymorfism och hur man implementerar sammanställningstidspolymorfism med exempel:

Ordet 'polymorfism' härstammar från två ord, dvs. “Poly” vilket betyder många och morphs ”Meningsformer. Således betyder polymorfism många former. I ett programmeringsspråk kan vi säga att ett objekt kan ta många former, och därmed är objektet polymorf.

Polymorfism är en av de viktigaste funktionerna i OOP och det låter oss uttrycka en funktion (ett objekt eller ett meddelande eller en metod eller en operatör) i olika former.

=> Ta en titt på Java-nybörjarguiden här.

Vad är polymorfism i Java

Vad du kommer att lära dig:

Introduktion till polymorfism i Java

Den polymorfa enheten beter sig annorlunda under olika scenarier.

Till exempel, överväga en '+' (tillägg) operatör i Java. Detta är en binär operatör och tar två operander. När operanderna som skickas till '+' operatören är nummer utförs en tilläggsoperation som returnerar summan av två nummer.

När operander ändras till strängtyp lägger operatören '+' inte till strängobjekten utan sammanfogar eller sammanfogar strängens innehåll för att bilda en resulterande tredje sträng.

Till exempel, om ' ett ”Och” två ”Är innehållet i två strängobjekt då 'En' + 'två' kommer att resultera i “ ett två ”. Detta är sammankoppling.

I Java är alla objekt polymorfa, eftersom de alla härrör från 'Object' -klassen och därmed uppfyller 'IS-A' -relationen med Object-klassen.

Ett objekt nås alltid via en referensvariabel av den specifika klasstypen. När en referensvariabel av en viss typ deklareras kan den inte ändras. Men om referensvariabeln inte deklareras som 'Final' kan vi tilldela den till att peka på andra objekt.

Typen av denna objektreferens avgör de klassmetoder eller funktioner som ska kallas.

Till exempel,om det finns en ABC-klass och klass XYZ härledd från ABC, har båda klasserna en polymorf metod func ().

class ABC{ void func(){} } class XYZ extends ABC{ void func() {} }

Låt oss skapa en referens av typen ABC.

obj = new XYZ ();

Nu när vi kallar func () -metoden, eftersom objektet som objekt pekas på är av klass XYZ, kommer func () -metoden från klassen XYZ att åberopas.

Som vi har sett i exemplet ovan har metoden func () olika implementeringar men samma prototyp. Beroende på objektet som pekas av referensobjekt har vi rätt implementering i det scenariot åberopat. Detta är polymorfism.

Låt oss diskutera polymorfism i Java i detalj.

Java Polymorphism Exempel

Låt oss förstå ett enkelt exempel på polymorfism i Java med tilläggsoperationen som diskuterats tidigare.

Här använder vi två metoder med samma namn men olika parametrar. Den första funktionen accepterar två heltalsparametrar och den andra metoden accepterar två strängparametrar.

Beroende på vilken typ av parametrar som skickas, anropas lämplig metod och antingen lägger till två heltal och skriver ut resultatet eller sammanfogar de två strängarna och skriver ut den resulterande strängen.

Java-programmet ges nedan:

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

Produktion:

Output - Polymorfism exempel

Här har vi sett att när vi första gången skickar två heltalsparametrar till addition_func, så kallas den första metoden. I det andra funktionsanropet skickar vi två parametrar av strängtyp och därmed kallas den andra överbelastade metoden.

Typer av polymorfism

Java stöder två typer av polymorfism:

  • Sammanställningstidspolymorfism
  • Körtidspolymorfism

Typer av polymorfism i Java

Som namnet antyder utförs polymorfism med kompileringstid vid sammanställningstid och polymorfism under körning utförs vid körning.

Som visas i figuren ovan implementeras polymorfism med kompileringstid genom överbelastning. Vi kan överbelasta antingen metoden eller operatören. Runtime polymorfism uppnås genom Overriding.

I denna handledning kommer vi att diskutera polymorfism i kompileringstid i detalj. Vi tar upp runtime polymorfism i nästa handledning.

Kompileringstidspolymorfism i Java

Kompileringstidspolymorfism kallas också ”Statisk polymorfism”. Som en del av sammanställningstidspolymorfism, oavsett polymorfism som ska utföras, utförs vid sammanställningstid.

I Java utförs polymorfism med kompileringstid med hjälp av “ Metod överbelastning ”. Med hjälp av metodöverbelastning kan vi ha en eller flera metoder med samma namn och endast differentierade på nummer eller typ eller ordning på parametrar.

Metodöverbelastning är den vanligaste implementeringen av kompileringstidspolymorfism i Java. Java stöder också överbelastning av operatörer.

Vad är överbelastning i Java i allmänhet?

Överbelastning i Java är en process med att ha mer än en metod med samma namn och returtyp men som skiljer sig åt i följd, antal och typer av argument. Det kallas också metodöverbelastning i allmänhet.

Metodöverbelastning i Java

Metodöverbelastning är en implementering av kompileringstidspolymorfism i Java. När vi har en eller flera metoder med samma namn och / eller returtyper men olika parameterlistor, säger vi att vi har 'överbelastat' metoderna.

Så i en given klass kan vi ha olika metoder med samma namn men olika argumentlistor.

Hur åberopar vi överbelastade metoder? Eller hur vet kompilatorn vilken metod som ska kallas?

Anropet av den exakta metoden som matchar samtalet utförs beroende på parameterlistan.

Vi har redan sett att en klass i Java kan ha mer än en konstruktör. När det gäller konstruktörer är argumentlistan eller argumenten som konstruktören accepterar olika i alla konstruktörer. Detta är ett exempel på överbelastning. Så konstruktöröverbelastning är en grundläggande form av metodöverbelastning i Java.

Låt oss nu se hur man överbelastar en metod i Java?

Java ger tre sätt att överbelasta metod beroende på variationerna i parameter- / argumentlistan.

# 1) Typ av parametrar

Vi kan överbelasta metoder i Java beroende på parametrarnas datatyp.

Tänk på följande exempel där vi har gett prototyper av tre metoder.

addition (int, int);
addition (int, float);
addition (String, String);

Som sett ovan har vi samma metodnamn i alla tre fall och samma antal parametrar men varje metodanrop har olika typer av parametrar.

Så så länge som metoder har olika typer av parametrar kan vi säga att metoderna är överbelastade. När vi åberopar metoden bestämmer kompilatorn datatypen för parametern, och beroende på datatypen i parameterlistan som medföljer metodanropet kallas lämplig metod.

Till exempel,om vi har ett metodanrop som nedan:

tillsats (3, 3,5);

I ovanstående metodanrop kan vi se att den första parametern är int-typ medan den andra parametern är flottörtyp. När ovanstående samtal påträffas löser kompilatorn parameterlistan och anropar sedan lämplig metod som är den andra metoden ovan.

Låt oss nu implementera ett komplett Java-program för att demonstrera metodöverbelastning baserat på parametrarnas datatyper.

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

Produktion:

Typ av parametrar - utdata

# 2) Antal parametrar

En annan implementering av metodöverbelastning är genom överbelastning av metoder med ett annat antal parametrar i funktionsanropet.

Till exempel,låt oss överväga följande metoddeklarationer:

addnum (int, int);

addnum (int, int, int);

I ovanstående metoddeklarationer har den första metoddeklarationen två parametrar och den andra deklarationen har tre parametrar. När en funktion anropas inspekterar kompilatorn antalet parametrar och löser sedan metodanropet på lämpligt sätt.

Nedanstående exempel visar programmet som använder metodöverbelastning baserat på antalet parametrar.

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

Produktion:

antal parametrar - utdata

I det här exemplet har vi två överbelastade metoder baserat på antalet parametrar. Den första metoden tar en parameter och den andra metoden tar två parametrar. I huvudmetoden kallar vi båda metoderna efter varandra och kompilatorn löser funktionsanropet beroende på antalet angivna parametrar.

# 3) Sekvens av parametrar

Det tredje tillvägagångssättet för implementering av metodöverbelastning baseras på sekvensen av parametrar i överbelastade metoder.

Tänk på följande exempel på metoddeklarationen,

sum (int, float);
summa (float, int);

Här har vi en överbelastad metodsumma. I den första deklarationen är parametrarna int och float. Även i den andra deklarationen är parametrarna int och float men deras ordning i parameterlistan ändras.

Nu visas float-parametern först medan int-parametern är den andra. Vi kan uppnå metodöverbelastning genom att ändra parameterordning.

De nedan visar Java-programmet detta.

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

Produktion:

Sekvens av parametrar - utdata

I ovanstående program har vi en printParam-överbelastad metod som har int- och char-parametrar vars ordning ändras i två metoddeklarationer.

Ogiltiga fall av metodöverbelastning

Hittills har vi diskuterat metodöverbelastning med hjälp av parameterlistan. Vi har ännu inte övervägt returtypen av metod. Observera att vi inte överbelastar metoder baserade på returtyper.

Till exempel, om två metoder har samma namn och samma parameterlistor men olika returtyper, säger vi inte att dessa två metoder är överbelastade. Detta ärende blir ogiltigt för överbelastning.

Så om vi har följande deklarationer:

I int (int, int);
Strängsumma (int, int);

I detta fall kommer kompilatorn att ge ett fel eftersom två metoder inte är överbelastade. Följaktligen, baserat på returtyperna, är metoderna inte differentierade.

Låt oss visa detta ogiltiga fall med hjälp av ett Java-program.

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

I ovanstående program har metoden myMethod två prototyper. En prototyp tar två int-parametrar och returnerar dubbelt. Den andra metodprototypen tar två int-parametrar och returnerar en int.

Så när vi sammanställer det här programmet får vi utdata nedan.

Produktion:

Ogiltigt fall av metodöverbelastning

Ovanstående kompileringsfel indikerar att metoden deklareras två gånger. Detta innebär att kompilatorn inte anser att dessa metoder är överbelastade bara baserat på returtypen.

Överbelastning av operatören

Operatörsöverbelastning är en överbelastningsmekanism där en annan innebörd ges till en befintlig operatör.

Som vi har diskuterat i introduktionsavsnittet i denna handledning är en tilläggsoperatör '+' ett klassiskt exempel på operatörsöverbelastning.

När operandernas operander är numeriska, returnerar + -operatorn totalt två värden. Men när operanderna är av strängtyp är resultatet av tilläggsoperationen den sammanhängande strängen. Observera att i Java kan vi bara överbelasta + (tillägg) operatör.

Denna operatör utför två funktioner:

  • Lägga till heltal eller numeriska värden.
  • Sammankopplande strängar

Därför är stöd för överbelastning av operatörer begränsat i Java till skillnad från i C ++, där vi kan överbelasta nästan alla operatörer som spärrar några som storlek, punktoperator etc.

Programmet nedan visar överbelastning av operatörer i 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 } }

Produktion:

Överbelastning av operatören - utdata

I ovanstående program har vi överbelastat '+' operatören. När vi skickar två heltal till den överbelastade metoden returneras en summa av två heltal och när två strängar skickas är resultatet den sammanhängande strängen.

Vissa punkter som bör noteras när det gäller överbelastning och polymorfism med kompileringstid.

  1. Metodöverbelastning är sättet att implementera sammanställningstidspolymorfism som också kallas statisk polymorfism.
  2. Statisk polymorfism är också känd som tidig bindning eller kompileringstidbindning.
  3. Eftersom bindning av parametrar och funktionsanrop sker vid kompileringstid kallas överbelastning kompileringstidbindning.
  4. Vi kan bara överbelasta '+' -operatören i Java och den utför tillägget av två heltal eller sammankoppling av två strängar.

Vanliga frågor

F # 1) Varför behöver vi polymorfism i Java?

Svar: Polymorfism tillåter oss att ha många implementeringar för ett objekt. Genom metodöverbelastning behöver vi inte ha för många metoder med olika namn som är svåra att komma ihåg. Vi kan istället ha överbelastade metoder så att vi kan få en tydlig implementering av metoderna som utför liknande funktioner.

Övergripande hjälpmedel för korrekt implementering av arv som gör att vi kan lägga till mer funktionalitet till de befintliga klasserna på ett enklare sätt.

F # 2) Vad är polymorfism OOP?

Svar: Den objektorienterade programmeringsdefinitionen av polymorfism hänvisar till programmeringsspråkens förmåga att implementera ett objekt i olika former. Polymorfism definieras också som förmågan hos ett program att åsidosätta metoderna från moderklassen till den härledda klassen för att ha ytterligare funktionalitet.

testa din webbplats i olika webbläsare

F # 3) Kan vi överbelasta och åsidosätta huvudmetoden?

Svar: Nej. Vi kan inte åsidosätta den statiska huvudmetoden. Även om vi kan överbelasta huvudmetoden kommer JVM aldrig att ringa den överbelastade huvudmetoden. Så det bästa svaret är att inte överbelasta eller åsidosätta huvudmetoden.

F # 4) Kan konstruktörer överbelastas?

Svar: Ja, vi kan överbelasta konstruktörerna i Java på samma sätt som vi överbelastar Java-metoderna. Konstruktörer har vanligtvis samma namn men ett annat antal argument.

F # 5) Varför är metodöverbelastning användbart?

Svar: Vi kan skriva ren kod med metodöverbelastning och den blir också läsbar eftersom vi har metoder med samma namn. Så om vi implementerar funktioner för olika datatyper kan vi överbelasta metoderna och det blir lättare att separera koden.

Slutsats

Polymorfism i Java innebär att ett objekt kan ha många former. Polymorfism i Java har två typer, dvs sammanställningstidspolymorfism och Runtime-polymorfism. Sammanställningstidspolymorfism görs vid sammanställningstid. Kompileringstidspolymorfism är statisk och implementeras genom metodöverbelastning och operatörsöverbelastning.

Runtime-polymorfism utförs vid körning och är dynamisk. Det implementeras med metodöverstyrning.

I denna handledning har vi sett sätten att implementera metodöverbelastning. Vi har också diskuterat operatörens överbelastning i detalj. Java stöder endast överbelastning av '+' -operatören.

=> Läs igenom Easy Java Training Series.

Rekommenderad läsning

^