Menu

Hvad er polymorfisme i Java - vejledning med eksempler

  • Vigtigste
  • Andet
  • Hvad er polymorfisme i Java - vejledning med eksempler

what is polymorphism java tutorial with examples

Prøv Vores Instrument Til At Fjerne Problemer

Denne vejledning forklarer, hvad der er polymorfisme i Java, typer polymorfisme, og hvordan man implementerer kompileringstidspolymorfisme med eksempler:

Ordet 'polymorfisme' stammer fra to ord, dvs. “Poly” hvilket betyder mange og “ morphs ”Betyder former. Polymorfisme betyder således mange former. På et programmeringssprog kan vi sige, at et objekt kan tage mange former, og derfor er objektet polymorf.

Polymorfisme er et af de vigtigste træk ved OOP, og det giver os mulighed for at udtrykke en funktion (et objekt eller en besked eller metode eller en operator) i forskellige former.

=> Se på Java Beginners Guide her.

Hvad er polymorfisme i Java

Hvad du lærer:

Introduktion til polymorfisme i Java

Den polymorfe enhed opfører sig forskelligt under forskellige scenarier.

For eksempel, overvej en '+' (tilføjelse) operatør i Java. Dette er en binær operatør og tager to operander. Når operanderne, der sendes til '+' operatoren, er tal, udføres en tilføjelsesoperation, der returnerer summen af ​​to tal.

Når operander skifter til strengtype, tilføjer '+' operatoren ikke strengobjekterne, men sammenkædes eller sammenføjes indholdet af strengen for at danne en resulterende tredje streng.

For eksempel, hvis “ en ”Og“ to ”Er indholdet af to strengobjekter da “En” + “to” vil medføre ' en to ”. Dette er sammenkædning.

I Java er alle objekter polymorfe, da de alle er afledt af 'Objekt' -klassen og således opfylder 'IS-A '-forholdet med Objektklassen.

Der er altid adgang til et objekt via en referencevariabel af den pågældende klassetype. Når en referencevariabel af en bestemt type er erklæret, kan den ikke ændres. Men hvis referencevariablen ikke erklæres som 'endelig', kan vi tildele den igen til at pege på andre objekter.

Typen af ​​denne objektreference bestemmer de klassemetoder eller funktioner, der skal kaldes.

For eksempel,hvis der er en ABC-klasse og klasse XYZ afledt af ABC, har begge klasser en polymorf metode func ().

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

Lad os oprette en reference af typen ABC.

obj = new XYZ ();

Når vi nu kalder func () -metoden, da objektet, som objektet påpeges, er af klasse XYZ, kaldes func () -metoden fra klasse XYZ.

Som vi har set i eksemplet ovenfor, har metoden func () forskellige implementeringer, men den samme prototype. Afhængigt af det objekt, der er peget på med referenceobjektet, har vi den relevante implementering i dette scenario påberåbt. Dette er polymorfisme.

Lad os diskutere polymorfisme i Java detaljeret.

Java polymorfisme Eksempel

Lad os forstå et simpelt eksempel på polymorfisme i Java med tilføjelsesoperationen som diskuteret tidligere.

Her bruger vi to metoder med samme navn, men forskellige parametre. Den første funktion accepterer to heltalsparametre, og den anden metode accepterer to strengparametre.

Afhængig af typen af ​​parametre, der sendes, kaldes den relevante metode og tilføjer enten to heltal og udskriver resultatet eller sammenkædes af de to strenge og udskriver den resulterende streng.

Java-programmet er angivet 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 } }

Produktion:

Output - eksempel på polymorfisme

Her har vi set, at når den første gang vi sender to heltalsparametre til addition_func, kaldes den første metode. I det andet funktionsopkald videregiver vi to strengtypeparametre, og derfor kaldes den anden overbelastede metode.

Typer af polymorfisme

Java understøtter to typer polymorfisme:

  • Kompileringstid polymorfisme
  • Kørselstidspolymorfisme

Typer af polymorfisme i Java

Som navnet antyder, udføres kompileringstidspolymorfismen ved kompileringstid, og polymorfisme under kørselstid udføres ved kørselstid.

Som vist i ovenstående figur implementeres kompileringstidspolymorfisme gennem overbelastning. Vi kan overbelaste enten metoden eller operatøren. Runtime polymorfisme opnås gennem Overriding.

I denne vejledning vil vi diskutere polymorfisme i kompileringstid i detaljer. Vi vil tage runtime polymorfisme op i den næste vejledning.

Kompileringstidspolymorfisme i Java

Kompileringstidspolymorfisme er også kendt som 'Statisk polymorfisme'. Som en del af kompileringstidspolymorfisme, uanset polymorfisme, der skal udføres, udføres på kompileringstidspunktet.

I Java udføres polymorfismen med kompileringstid ved hjælp af “ Metode Overbelastning ”. Ved hjælp af metodeoverbelastning kan vi have en eller flere metoder med samme navn og kun differentieret på tal eller type eller rækkefølge af parametre.

Metodeoverbelastning er den mest almindelige implementering af kompileringstidspolymorfisme i Java. Java understøtter også overbelastning af operatører.

Hvad er overbelastning generelt i Java?

Overbelastning i Java er en proces med at have mere end en metode med samme navn og returneringstype, men forskelligt på rækkefølgen, antallet og typerne af argumenter. Det kaldes også metodeoverbelastning generelt.

Metodeoverbelastning i Java

Metodeoverbelastning er en implementering af kompil-time polymorfisme i Java. Når vi har en eller flere metoder med samme navn og / eller returneringstyper, men forskellige parameterlister, siger vi, at vi har 'overbelastet' metoderne.

Så i en given klasse kan vi have forskellige metoder med samme navn, men forskellige argumentlister.

Hvordan påberåber vi os overbelastede metoder? Eller hvordan ved compileren hvilken metode der skal kaldes?

Påkaldelsen af ​​den nøjagtige metode, der matcher opkaldet, udføres afhængigt af parameterlisten.

Vi har allerede set, at en klasse i Java kan have mere end en konstruktør. I tilfælde af konstruktører er argumentlisten eller de argumenter, som konstruktøren accepterer, forskellige i alle konstruktører. Dette er et eksempel på overbelastning. Så konstruktøroverbelastning er en grundlæggende form for metodeoverbelastning i Java.

Lad os nu se, hvordan man overbelaster en metode i Java?

Java giver tre måder til overbelastning af metoder afhængigt af variationerne i parameter- / argumentlisten.

# 1) Parametertype

Vi kan overbelaste metoder i Java afhængigt af parameterdatatypen.

Overvej følgende eksempel, hvor vi har givet prototyper af tre metoder.

tilføjelse (int, int);
tilføjelse (int, flyde);
tilføjelse (String, String);

Som set ovenfra har vi det samme metodenavn i alle de tre tilfælde og det samme antal parametre, men hver metodeopkald har forskellige typer parametre.

Så så længe metoder har forskellige typer parametre, kan vi sige, at metoderne er overbelastede. Når vi påkalder metoden, bestemmer kompilatoren datatypen for parameteren, og afhængigt af datatypen på parameterlisten, der følger med metodekaldet, kaldes den relevante metode.

For eksempel,hvis vi har en metodeopkald som nedenfor:

tilsætning (3, 3,5);

I ovennævnte metodeopkald kan vi se, at den første parameter er int-type, mens den anden parameter er float-type. Når ovenstående opkald er stødt, løser kompilatoren parameterlisten og påkalder derefter den relevante metode, som er den anden metode ovenfor.

Lad os nu implementere et komplet Java-program for at demonstrere metodeoverbelastning baseret på datatypen af ​​parametre.

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:

Type parametre - output

# 2) Antal parametre

En anden implementering af metodeoverbelastning er ved overbelastning af metoder med et andet antal parametre i funktionsopkaldet.

For eksempel,lad os overveje følgende metodedeklarationer:

forskel mellem port forwarding og triggering

addnum (int, int);

addnum (int, int, int);

I ovenstående metodedeklarationer har den første metadeklaration to parametre, og den anden erklæring har tre parametre. Når en funktion påberåbes, inspicerer compileren antallet af parametre og løser derefter metodekaldet korrekt.

Nedenstående eksempel viser det program, der bruger metodeoverbelastning baseret på antallet af parametre.

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 parametre - output

I dette eksempel har vi to overbelastede metoder baseret på antallet af parametre. Den første metode tager en parameter, og den anden metode tager to parametre. I hovedmetoden kalder vi begge metoderne efter hinanden, og compileren løser funktionsopkaldet afhængigt af antallet af angivne parametre.

# 3) Sekvens af parametre

Den tredje tilgang til implementering af metodeoverbelastning er baseret på rækkefølgen af ​​parametre i overbelastede metoder.

Overvej følgende eksempel på metodedeklarationen,

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

Her har vi en overbelastet metodesum. I den første erklæring er parametrene int og float. Også i den anden erklæring er parametrene int og flyder, men deres rækkefølge i parameterlisten ændres.

Nu vises float-parameteren først, mens int-parameteren er anden. Vi kan opnå metodeoverbelastning ved at ændre parameterrækkefølgen.

Det under Java-programmet demonstrerer 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) } }

Produktion:

Sekvens af parametre - output

I ovenstående program har vi en printParam overbelastet metode, der har int og char parametre, hvis rækkefølge ændres i to metodedeklarationer.

Ugyldige tilfælde af overbelastning af metoder

Indtil videre har vi diskuteret metodeoverbelastning ved hjælp af parameterlisten. Vi har endnu ikke overvejet returtypen af ​​metode. Bemærk, at vi ikke overbelaster metoder baseret på returtyper.

For eksempel, hvis to metoder har samme navn og samme parameterlister, men forskellige returtyper, siger vi ikke, at disse to metoder er overbelastede. Denne sag bliver ugyldig for overbelastning.

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

I int (int, int);
Strengsum (int, int);

I dette tilfælde udsender compileren en fejl, da to metoder ikke er overbelastede. Derfor er metoderne ikke udelukkende baseret på returtyperne.

Lad os demonstrere denne ugyldige sag ved hjælp af 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 ovenstående program har metoden myMethod to prototyper. En prototype tager to int-parametre og returnerer dobbelt. Den anden metode prototype tager to int-parametre og returnerer en int.

Så når vi kompilerer dette program, får vi nedenstående output.

Produktion:

Ugyldigt tilfælde af metodeoverbelastning

Ovenstående kompileringsfejl angiver, at metoden er deklareret to gange. Dette betyder, at kompilatoren ikke betragter disse metoder som overbelastede kun baseret på returtypen.

Operatør Overbelastning

Operatøroverbelastning er en overbelastningsmekanisme, hvor en eksisterende operatør får en anden betydning.

Som vi har diskuteret i introduktionsafsnittet i denne vejledning, er en tilføjelsesoperator '+' et klassisk eksempel på operatøroverbelastning.

Når operandørens operander er numeriske, returnerer operatoren + det samlede antal af to værdier. Men når operanderne er af streng-type, så er resultatet af tilføjelsesoperationen den sammenkædede streng. Bemærk, at I Java kan vi kun overbelaste + (tilføjelse) operatør.

Denne operatør udfører to funktioner:

  • Tilføjelse af heltal eller numeriske værdier.
  • Sammenkædende strenge

Derfor er understøttelse af operatøroverbelastning begrænset i Java i modsætning til i C ++, hvor vi kan overbelaste næsten alle operatører, der spærrer nogle få som størrelse af, prikoperator osv.

Nedenstående program demonstrerer overbelastning af 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:

Operatøroverbelastning - output

I ovenstående program har vi overbelastet '+' operatøren. Når vi videregiver to heltalsværdier til den overbelastede metode, returneres en sum af to heltal, og når to strenge sendes, er resultatet den sammenkædede streng.

Visse punkter, der skal bemærkes med hensyn til overbelastning og kompileringstidspolymorfisme.

  1. Metodeoverbelastning er måden at implementere polymorfisme på kompileringstid, der også er kendt som statisk polymorfisme.
  2. Statisk polymorfisme er også kendt som tidlig binding eller kompileringstid-binding.
  3. Da binding af parametre og funktionsopkald sker ved kompileringstid, kaldes overbelastning kompileringstidsbinding.
  4. Vi kan kun overbelaste '+' operatøren i Java, og den udfører tilføjelsen af ​​to heltal eller sammenkædning af to strenge.

Ofte stillede spørgsmål

Q # 1) Hvorfor har vi brug for polymorfisme i Java?

Svar: Polymorfisme tillader os at have mange implementeringer til et objekt. Gennem overbelastning af metoder behøver vi ikke have for mange metoder med forskellige navne, som er vanskelige at huske. Vi kan i stedet have overbelastede metoder, så vi kan få en klar implementering af metoderne, der udfører lignende funktioner.

Overordnede hjælpemidler til korrekt implementering af arv, der giver os mulighed for at tilføje mere funktionalitet til de eksisterende klasser på en lettere måde.

Q # 2) Hvad er polymorfisme OOP?

Svar: Den objektorienterede programmeringsdefinition af polymorfisme refererer til programmeringssprogens evne til at implementere et objekt i forskellige former. Polymorfisme defineres også som et programs evne til at tilsidesætte metoderne fra den overordnede klasse til den afledte klasse for at have yderligere funktionalitet.

Q # 3) Kan vi overbelaste og tilsidesætte hovedmetoden?

Svar: Nej. Vi kan ikke tilsidesætte den statiske hovedmetode. Selvom vi kan overbelaste hovedmetoden, vil JVM aldrig kalde den overbelastede hovedmetode. Så det bedste svar er ikke at overbelaste eller tilsidesætte hovedmetoden.

Q # 4) Kan konstruktører overbelastes?

Svar: Ja, vi kan overbelaste konstruktørerne i Java på samme måde som vi overbelaster Java-metoderne. Konstruktører har normalt det samme navn, men et andet antal argumenter.

Spørgsmål nr. 5) Hvorfor er metodeoverbelastning nyttig?

Svar: Vi kan skrive ren kode ved hjælp af metodeoverbelastning, og det bliver også læsbart, da vi har metoder med samme navn. Så hvis vi implementerer funktionalitet til forskellige datatyper, kan vi overbelaste metoderne, og det bliver lettere at adskille koden.

Konklusion

Polymorfisme i Java betyder, at et objekt kan have mange former. Polymorfisme i Java har to typer, dvs. kompileringstidspolymorfisme og Runtime-polymorfisme. Kompileringstidspolymorfisme udføres på kompileringstidspunktet. Kompileringstidspolymorfisme er statisk og implementeres gennem metodeoverbelastning og operatøroverbelastning.

Runtime polymorfisme udføres ved kørsel og er dynamisk. Det implementeres ved hjælp af metode tilsidesættelse.

I denne vejledning har vi set måder at implementere metodeoverbelastning på. Vi har også diskuteret operatøroverbelastning i detaljer. Java understøtter kun overbelastning af '+' operatøren.

=> Læs gennem Easy Java Training Series.

Anbefalet læsning

^