Meny

Hva er polymorfisme i Java - Veiledning med eksempler

  • Hoved
  • Annen
  • Hva er polymorfisme i Java - Veiledning med eksempler

what is polymorphism java tutorial with examples

Prøv Instrumentet Vårt For Å Eliminere Problemer

Denne opplæringen forklarer hva som er polymorfisme i Java, typer polymorfisme og hvordan man implementerer kompileringstidspolymorfisme med eksempler:

Ordet 'polymorfisme' stammer fra to ord, dvs. “Poly” som betyr mange og “ morphs ”Som betyr former. Dermed betyr polymorfisme mange former. På et programmeringsspråk kan vi si at et objekt kan ha mange former, og dermed er objektet polymorf.

Polymorfisme er en av de viktigste funksjonene i OOP, og den lar oss uttrykke en funksjon (et objekt eller en melding eller metode eller en operatør) i forskjellige former.

=> Ta en titt på Java Beginners Guide her.

Hva er polymorfisme i Java

Hva du vil lære:

Introduksjon til polymorfisme i Java

Den polymorfe enheten oppfører seg annerledes under forskjellige scenarier.

For eksempel, vurdere en ‘+’ (tillegg) operatør i Java. Dette er en binær operatør og tar to operander. Når operandene som sendes til ‘+’ operatoren er tall, utføres en tilleggsoperasjon som returnerer summen av to tall.

Når operander skifter til strengtype, legger ikke '+' - operatoren til strengobjektene, men sammenkobles eller blir sammen med innholdet i strengen for å danne en resulterende tredje streng.

For eksempel, hvis “ en ”Og“ to ”Er innholdet i to strengobjekter da “En” + “to” vil resultere i “ en to ”. Dette er sammenkobling.

I Java er alle objektene polymorfe ettersom de alle er avledet fra 'Object' -klassen og dermed oppfyller 'IS-A '-forholdet til Object-klassen.

Du får alltid tilgang til et objekt gjennom en referansevariabel av den aktuelle klassetypen. Når en referansevariabel av en bestemt type er erklært, kan den ikke endres. Imidlertid, hvis referansevariabelen ikke blir erklært som 'Endelig', kan vi tildele den på nytt til å peke på andre objekter.

Typen av denne objektreferansen bestemmer klassemetodene eller funksjonene som skal kalles.

For eksempel,hvis det er en ABC-klasse og klasse XYZ avledet fra ABC, har begge klassene en polymorf metode func ().

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

La oss lage en referanse av typen ABC.

obj = new XYZ ();

Nå når vi kaller func () -metoden, siden objektet påpekt av obj er av klasse XYZ, vil func () -metoden fra klasse XYZ påberopes.

Som vi har sett i eksemplet ovenfor, har metoden func () forskjellige implementeringer, men den samme prototypen. Avhengig av objektet som pekes av referanseobjekt, har vi riktig implementering i det scenariet påkalt. Dette er polymorfisme.

La oss diskutere polymorfisme i Java i detalj.

Java Polymorphism Eksempel

La oss forstå et enkelt eksempel på polymorfisme i Java med tilleggsoperasjonen som diskutert tidligere.

Her bruker vi to metoder med samme navn, men forskjellige parametere. Den første funksjonen godtar to heltallsparametere, og den andre metoden godtar to strengparametere.

Avhengig av hvilken type parametere som sendes, blir den riktige metoden kalt og legger til to heltall og skriver ut resultatet eller sammenkobler de to strengene og skriver ut den resulterende strengen.

Java-programmet er gitt nedenfor:

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

Produksjon:

Output - eksempel på polymorfisme

Her har vi sett at når første gang vi sender to heltallsparametere til addition_func, kalles den første metoden. I den andre funksjonsanropet passerer vi to strengtypeparametere, og dermed kalles den andre overbelastede metoden.

Typer polymorfisme

Java støtter to typer polymorfisme:

  • Kompileringstidspolymorfisme
  • Kjøretids polymorfisme

Typer polymorfisme i Java

Som navnet antyder, utføres kompileringstidspolymorfismen på kompileringstid og kjøretidspolymorfisme utføres ved kjøretid.

Som vist i figuren ovenfor implementeres polymorfisme med kompileringstid gjennom overbelastning. Vi kan overbelaste enten metoden eller operatøren. Runtime polymorfisme oppnås gjennom Overriding.

I denne veiledningen vil vi diskutere polymorfisme i kompilering i detalj. Vi tar opp polymorfismen i løpet av neste opplæring.

Kompileringstidspolymorfisme i Java

Kompileringstidspolymorfisme er også kjent som “Statisk polymorfisme”. Som en del av kompileringstidspolymorfisme, uansett polymorfisme som skal utføres, utføres på kompileringstidspunktet.

I Java utføres polymorfismen med kompileringstid ved bruk av “ Metode Overbelastning ”. Ved å bruke metodeoverbelastning kan vi ha en eller flere metoder med samme navn og bare differensiert på tall eller type eller rekkefølge av parametere.

Metodeoverbelastning er den vanligste implementeringen av kompileringstidspolymorfisme i Java. Java støtter også overbelastning av operatører.

Hva er overbelastning generelt i Java generelt?

Overbelastning i Java er en prosess med å ha mer enn én metode med samme navn og returstype, men som er forskjellig fra rekkefølge, antall og typer argumenter. Det kalles også metodeoverbelastning generelt.

Metodeoverbelastning i Java

Metodeoverbelastning er en implementering av kompileringstidspolymorfisme i Java. Når vi har en eller flere metoder med samme navn og / eller returtyper, men forskjellige parameterlister, så sier vi at vi har 'overbelastet' metodene.

Så i en gitt klasse kan vi ha forskjellige metoder med samme navn, men forskjellige argumentlister.

Hvordan påberoper vi oss overbelastede metoder? Eller hvordan vet kompilatoren hvilken metode som skal kalles?

Påkallingen av den nøyaktige metoden som samsvarer med samtalen utføres avhengig av parameterlisten.

Vi har allerede sett at en klasse i Java kan ha mer enn en konstruktør. Når det gjelder konstruktører, er argumentlisten eller argumentene som konstruktøren aksepterer forskjellig i alle konstruktører. Dette er et eksempel på overbelastning. Så konstruktøroverbelastning er en grunnleggende form for metodeoverbelastning i Java.

La oss nå se hvordan du overbelaster en metode i Java?

Java gir tre måter å overbelaste metoden på, avhengig av variasjonene i parameter- / argumentlisten.

# 1) Type parametere

Vi kan overbelaste metoder i Java, avhengig av parameterdatatypen.

Tenk på følgende eksempel der vi har gitt prototyper av tre metoder.

tillegg (int, int);
tillegg (int, float);
tillegg (String, String);

Som sett ovenfra, har vi samme metodenavn i alle de tre tilfellene og samme antall parametere, men hver metodeanrop har forskjellige typer parametere.

Så så lenge metodene har forskjellige typer parametere, kan vi si at metodene er overbelastede. Når vi påkaller metoden, bestemmer kompilatoren datatypen til parameteren, og avhengig av datatypen til parameterlisten som følger med metodeanropet, kalles den riktige metoden.

For eksempel,hvis vi har en metodeanrop som nedenfor:

tillegg (3, 3,5);

I ovennevnte metodeanrop kan vi se at den første parameteren er int-type mens den andre parameteren er flottørtype. Når ovennevnte samtale oppstår, løser kompilatoren parameterlisten og påkaller deretter riktig metode som er den andre metoden ovenfor.

La oss nå implementere et komplett Java-program for å demonstrere metodeoverbelastning basert på parameterdatatypene.

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

Produksjon:

Type parametere - utdata

# 2) Antall parametere

En annen implementering av metodeoverbelastning er ved overbelastning av metoder med et annet antall parametere i funksjonsanropet.

For eksempel,la oss vurdere følgende metodedeklarasjoner:

addnum (int, int);

addnum (int, int, int);

I metodedeklarasjonene ovenfor har den første metadeklarasjonen to parametere og den andre deklarasjonen har tre parametere. Når en funksjon påkalles, inspiserer kompilatoren antall parametere og løser deretter metodeanropet på riktig måte.

Eksemplet nedenfor viser programmet som bruker metodeoverbelastning basert på antall parametere.

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

Produksjon:

antall parametere - utgang

I dette eksemplet har vi to metoder som er overbelastet basert på antall parametere. Den første metoden tar en parameter og den andre metoden tar to parametere. I hovedmetoden kaller vi begge metodene etter hverandre, og kompilatoren løser funksjonsanropet avhengig av antall parametere som er spesifisert.

# 3) Sekvens av parametere

Den tredje tilnærmingen til implementering av metodeoverbelastning er basert på rekkefølgen av parametere i overbelastede metoder.

Tenk på følgende eksempel på metodedeklarasjonen,

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

Her har vi en overbelastet metodesum. I den første erklæringen er parametrene int og float. I den andre erklæringen er også parameterne int og flyter, men rekkefølgen i parameterlisten endres.

Nå vises float-parameteren først mens int-parameteren er andre. Vi kan oppnå metodeoverbelastning ved å endre parameterrekkefølgen.

De under Java-programmet viser dette.

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

Produksjon:

Sekvens av parametere - utdata

I det ovennevnte programmet har vi en printParam overbelastet metode som har int og char parametere hvis rekkefølge endres i to metodedeklarasjoner.

Ugyldige tilfeller av overbelastning av metoden

Så langt har vi diskutert overbelastning av metoder ved hjelp av parameterliste. Vi har ennå ikke vurdert returtypen av metode. Merk at vi ikke overbelaster metoder basert på returtyper.

For eksempel, hvis to metoder har samme navn og samme parameterlister, men forskjellige returtyper, så sier vi ikke at disse to metodene er overbelastet. Denne saken blir ugyldig for overbelastning.

Så hvis vi har følgende erklæringer:

Jeg int (int, int);
Strengsum (int, int);

I dette tilfellet vil kompilatoren gi en feil da to metoder ikke er overbelastet. Derfor, basert på returtypene, er ikke metodene differensiert.

La oss demonstrere denne ugyldige saken ved hjelp av et 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 programmet ovenfor har metoden myMethod to prototyper. En prototype tar to int-parametere og returnerer dobbelt. Den andre metoden prototypen tar to int-parametere og returnerer en int.

Så når vi kompilerer dette programmet, får vi utdataene nedenfor.

Produksjon:

Ugyldig tilfelle av overbelastning av metoden

Ovennevnte kompileringsfeil indikerer at metoden er erklært to ganger. Dette betyr at kompilatoren ikke anser disse metodene som overbelastet bare basert på returtypen.

Overbelastning av operatør

Operatøroverbelastning er en overbelastningsmekanisme der en annen betydning blir gitt til en eksisterende operatør.

Som vi har diskutert i innledningsdelen av denne opplæringen, er en tilleggsoperatør ‘+’ et klassisk eksempel på operatøroverbelastning.

Når operandene til denne operatøren er numeriske, returnerer + -operatøren totalt to verdier. Men når operandene er av streng-type, er resultatet av tilleggsoperasjonen den sammenkoblede strengen. Merk at i Java kan vi bare overbelaste + (tillegg) operatør.

Denne operatøren utfører to funksjoner:

  • Legge til heltall eller numeriske verdier.
  • Sammenkobling av strenger

Derfor er støtte for overbelastning av operatører begrenset i Java i motsetning til i C ++, hvor vi kan overbelaste nesten alle operatørene som sperrer noen som størrelse, prikkoperatør, etc.

Programmet nedenfor viser overbelastning 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 } }

Produksjon:

Operatøroverbelastning - utgang

I programmet ovenfor har vi overbelastet ‘+’ operatøren. Når vi overfører to heltallverdier til den overbelastede metoden, returneres en sum av to heltall, og når to strenger sendes, blir resultatet den sammenkoblede strengen.

Visse punkter som skal bemerkes angående overbelastning og kompileringstidspolymorfisme.

  1. Metodeoverbelastning er måten å implementere kompileringstidspolymorfisme som også er kjent som Statisk polymorfisme.
  2. Statisk polymorfisme er også kjent som tidlig binding eller kompileringstid binding.
  3. Når binding av parametere og funksjonsanrop skjer ved kompileringstid, kalles overbelastning kompileringstidbinding.
  4. Vi kan bare overbelaste ‘+’ operatøren i Java, og den utfører tillegg av to heltall eller sammenkobling av to strenger.

ofte stilte spørsmål

Q # 1) Hvorfor trenger vi polymorfisme i Java?

Svar: Polymorfisme tillater oss å ha mange implementeringer for ett objekt. Gjennom overbelastning av metoder trenger vi ikke ha for mange metoder med forskjellige navn som er vanskelig å huske. Vi kan i stedet ha overbelastede metoder slik at vi kan få en klar implementering av metodene som utfører lignende funksjoner.

test nettstedet ditt i forskjellige nettlesere

Også overordnede hjelpemidler i riktig implementering av arv som gjør at vi kan legge til mer funksjonalitet i de eksisterende klassene på en enklere måte.

Q # 2) Hva er polymorfisme OOP?

Svar: Den objektorienterte programmeringsdefinisjonen av polymorfisme refererer til evnen til programmeringsspråkene til å implementere ett objekt i forskjellige former. Polymorfisme er også definert som et programs evne til å overstyre metodene fra foreldreklassen til den avledede klassen for å ha tilleggsfunksjonalitet.

Sp # 3) Kan vi overbelaste og overstyre hovedmetoden?

Svar: Nei. Vi kan ikke overstyre den statiske hovedmetoden. Selv om vi kan overbelaste hovedmetoden, vil JVM aldri kalle den overbelastede hovedmetoden. Så det beste svaret er ikke å overbelaste eller overstyre hovedmetoden.

Q # 4) Kan konstruktører overbelastes?

Svar: Ja, vi kan overbelaste konstruktørene i Java på samme måte som vi overbelaster Java-metodene. Konstruktører har vanligvis samme navn, men et annet antall argumenter.

Sp # 5) Hvorfor er metodeoverbelastning nyttig?

Svar: Vi kan skrive ren kode ved bruk av metodeoverbelastning, og den blir også lesbar ettersom vi har metoder med samme navn. Så hvis vi implementerer funksjonalitet for forskjellige datatyper, kan vi overbelaste metodene, og det blir lettere å skille koden.

Konklusjon

Polymorfisme i Java betyr at et objekt kan ha mange former. Polymorfisme i Java har to typer, dvs. polymorfisme og Runtime-polymorfisme. Kompileringstidspolymorfisme gjøres på kompileringstidspunktet. Kompileringstidspolymorfisme er statisk og implementeres gjennom metodeoverbelastning og operatøroverbelastning.

Runtime polymorfisme utføres ved kjøretid og er dynamisk. Det er implementert ved hjelp av metodeoverstyring.

I denne veiledningen har vi sett måtene å implementere overbelastning av metoder på. Vi har også diskutert operatørens overbelastning i detalj. Java støtter bare overbelastning av '+' operatør.

=> Les gjennom Easy Java Training Series.

Anbefalt lesing

^