Menú

Què és el polimorfisme a Java: tutorial amb exemples

what is polymorphism java tutorial with examples

Proveu El Nostre Instrument Per Eliminar Problemes

Aquest tutorial explica què és el polimorfisme a Java, els tipus de polimorfisme i com implementar el polimorfisme en temps de compilació amb exemples:

La paraula 'Polimorfisme' deriva de dues paraules i.e. 'Poly' que vol dir molts i ' morfes ”Que significa formes. Així, el polimorfisme significa moltes formes. En un llenguatge de programació, podem dir que un objecte pot adoptar moltes formes i, per tant, l'objecte és polimorf.

El polimorfisme és una de les característiques més importants de l'OOP i ens permet expressar una característica (un objecte o un missatge o mètode o un operador) de diverses formes.

=> Feu una ullada a la guia per a principiants de Java aquí

Què és el polimorfisme a Java

Què aprendreu:

Introducció al polimorfisme a Java

L'entitat polimòrfica es comporta de manera diferent en diferents escenaris.

Per exemple, tingueu en compte un operador ‘+’ (addició) a Java. Aquest és un operador binari i pren dos operands. Quan els operands que es passen a l’operador ‘+’ són números, es realitza una operació d’addició que retorna la suma de dos números.

Quan els operands canvien al tipus de cadena, l’operador ‘+’ no afegeix els objectes de cadena, sinó que concatena o uneix el contingut de la cadena per formar una tercera cadena resultant.

Per exemple, si ' un 'I' dos ”Són el contingut de dos objectes String 'Un' + 'dos' donarà lloc a ' un dos ”. Això és la concatenació.

A Java, tots els objectes són polimòrfics ja que tots es deriven de la classe “Object” i compleixen així la relació ‘IS-A” amb la classe Object.

Sempre s’accedeix a un objecte mitjançant una variable de referència d’aquest tipus de classe en particular. Un cop es declara una variable de referència d'un tipus concret, no es podrà modificar. Tanmateix, si la variable de referència no es declara com a 'Final', podem reassignar-la per apuntar a altres objectes.

El tipus d’aquesta referència d’objecte decidirà els mètodes o funcions de classe que s’han de cridar.

Per exemple,si hi ha una classe ABC i una classe XYZ derivades d'ABC, les dues classes tenen un mètode polimòrfic func ().

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

Creem una referència del tipus ABC.

obj = new XYZ ();

Ara, quan anomenem el mètode func (), atès que l'objecte assenyalat per obj és de la classe XYZ, s'invocarà el mètode func () de la classe XYZ.

Com hem vist a l'exemple anterior, el mètode func () té implementacions diferents però el mateix prototip. Depenent de l'objecte assenyalat per l'objecte de referència, es requereix la implementació adequada en aquest escenari. Això és polimorfisme.

Analitzem detalladament el polimorfisme a Java.

Exemple de polimorfisme de Java

Comprenguem un exemple senzill de polimorfisme a Java amb l’operació d’addició tal com s’ha comentat anteriorment.

Aquí fem servir dos mètodes amb el mateix nom però paràmetres diferents. La primera funció accepta dos paràmetres enters i el segon mètode accepta dos paràmetres de cadena.

Depenent del tipus de paràmetres aprovats, es crida el mètode adequat i afegeix dos enters i imprimeix el resultat o concatena les dues cadenes i imprimeix la cadena resultant.

El programa Java es presenta a continuació:

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

Sortida:

Sortida: exemple de polimorfisme

Aquí hem vist que quan la primera vegada que passem dos paràmetres enters a l’addició_func, aleshores s’anomena el primer mètode. A la segona trucada de funció, passem dos paràmetres de tipus String i, per tant, es diu el segon mètode sobrecarregat.

Tipus de polimorfisme

Java admet dos tipus de polimorfisme:

  • Polimorfisme en temps de compilació
  • Polimorfisme en temps d'execució

Tipus de polimorfisme a Java

Com el seu nom indica, el polimorfisme en temps de compilació es realitza en temps de compilació i el polimorfisme en temps d'execució es realitza en temps d'execució.

Com es mostra a la figura anterior, el polimorfisme en temps de compilació s’implementa mitjançant la sobrecàrrega. Podem sobrecarregar el mètode o l’operador. El polimorfisme en temps d’execució s’aconsegueix mitjançant Overriding.

En aquest tutorial, parlarem detalladament del polimorfisme en temps de compilació. Prendrem polimorfisme en temps d'execució al proper tutorial.

Polimorfisme de temps de compilació a Java

El polimorfisme en temps de compilació també es coneix com a 'polimorfisme estàtic'. Com a part del polimorfisme en temps de compilació, qualsevol polimorfisme que es realitzi es realitza en temps de compilació.

A Java, el polimorfisme en temps de compilació es realitza mitjançant “ Sobrecàrrega del mètode ”. Mitjançant la sobrecàrrega de mètodes, podem tenir un o més mètodes amb el mateix nom i només diferenciats per números o tipus o ordre de paràmetres.

La sobrecàrrega de mètodes és la implementació més comuna del polimorfisme en temps de compilació a Java. Java també admet la sobrecàrrega de l'operador.

què és la clau de seguretat de la xarxa al router

Què és la sobrecàrrega a Java en general?

La sobrecàrrega a Java és un procés de tenir més d’un mètode amb el mateix nom i el mateix tipus de retorn, però que difereix en la seqüència, nombre i tipus d’arguments. També s’anomena sobrecàrrega de mètodes en general.

Mètode de sobrecàrrega a Java

La sobrecàrrega de mètodes és una implementació de polimorfisme en temps de compilació a Java. Quan tenim un o més mètodes amb el mateix nom i / o tipus de retorn, però llistes de paràmetres diferents, diem que hem 'sobrecarregat' els mètodes.

Així doncs, en una classe determinada, podem tenir diversos mètodes amb el mateix nom però diferents llistes d’arguments.

Com invocem mètodes sobrecarregats? O com sap el compilador a quin mètode s’anomena?

La invocació del mètode exacte que coincideix amb la trucada es realitza en funció de la llista de paràmetres.

Ja hem vist que una classe a Java pot tenir més d’un constructor. En el cas dels constructors, la llista d’arguments o els arguments que accepta el constructor són diferents en tots els constructors. Aquest és un exemple de sobrecàrrega. Per tant, la sobrecàrrega del constructor és una forma bàsica de sobrecàrrega de mètodes a Java.

Ara veurem com sobrecarregar un mètode a Java?

Java proporciona tres maneres de sobrecarregar mètodes en funció de les variacions de la llista de paràmetres / arguments.

# 1) Tipus de paràmetres

Podem sobrecarregar mètodes a Java en funció del tipus de dades dels paràmetres.

Penseu en el següent exemple en què hem donat prototips de tres mètodes.

addició (int, int);
addició (int, float);
addició (String, String);

Com es veu a la part superior, tenim el mateix nom de mètode en els tres casos i el mateix nombre de paràmetres, però cada trucada de mètode té diferents tipus de paràmetres.

Per tant, sempre que els mètodes tinguin diferents tipus de paràmetres, podem dir que els mètodes estan sobrecarregats. Quan invocem el mètode, el compilador decideix el tipus de dades del paràmetre i, segons el tipus de dades de la llista de paràmetres que es proporciona amb la crida al mètode, es crida al mètode adequat.

Per exemple,si tenim un mètode de trucada com a continuació:

addició (3, 3,5);

A la trucada del mètode anterior, podem veure que el primer paràmetre és de tipus int mentre que el segon és de tipus flotant. Quan es troba la trucada anterior, el compilador resol la llista de paràmetres i després invoca el mètode adequat que és el segon mètode anterior.

Ara implementem un programa Java complet per demostrar la sobrecàrrega del mètode basat en els tipus de dades de paràmetres.

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

Sortida:

Tipus de paràmetres: sortida

# 2) Nombre de paràmetres

Una altra implementació de la sobrecàrrega de mètodes consisteix en sobrecarregar mètodes amb un nombre diferent de paràmetres a la trucada de funció.

Per exemple,considerem les declaracions de mètodes següents:

addnum (int, int);

addnum (int, int, int);

A les declaracions de mètodes anteriors, la primera declaració de mètode té dos paràmetres i la segona declaració té tres paràmetres. Quan s'invoca una funció, el compilador inspecciona el nombre de paràmetres i, a continuació, resol la trucada del mètode adequadament.

L'exemple següent mostra el programa que utilitza la sobrecàrrega del mètode en funció del nombre de paràmetres.

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

Sortida:

nombre de paràmetres: sortida

En aquest exemple, tenim dos mètodes sobrecarregats en funció del nombre de paràmetres. El primer mètode pren un paràmetre i el segon mètode pren dos paràmetres. Al mètode principal, anomenem els dos mètodes un darrere l’altre i el compilador resol la trucada de funció en funció del nombre de paràmetres especificats.

# 3) Seqüència de paràmetres

El tercer enfocament d’implementació de la sobrecàrrega del mètode es basa en la seqüència de paràmetres dels mètodes sobrecarregats.

Penseu en l'exemple següent de la declaració del mètode,

suma (int, float);
suma (float, int);

Aquí tenim una suma de mètode sobrecarregada. A la primera declaració, els paràmetres són int i float. A la segona declaració també, els paràmetres són int i float, però es canvia el seu ordre a la llista de paràmetres.

Ara el paràmetre float apareix primer mentre el paràmetre int és segon. Podem aconseguir una sobrecàrrega de mètode canviant l’ordre dels paràmetres.

fer una còpia de la matriu java

El a continuació, el programa Java ho demostra.

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

Sortida:

Seqüència de paràmetres - sortida

Al programa anterior, tenim un mètode sobrecarregat printParam que té paràmetres int i char l'ordre dels quals es modifica en dues declaracions de mètode.

Casos no vàlids de sobrecàrrega del mètode

Fins ara hem parlat de la sobrecàrrega de mètodes mitjançant la llista de paràmetres. Encara no hem considerat el tipus de mètode de retorn. Tingueu en compte que no sobrecarreguem els mètodes basats en els tipus de retorn.

Per exemple, si dos mètodes tenen el mateix nom i les mateixes llistes de paràmetres però diferents tipus de retorn, no diem que aquests dos mètodes estiguin sobrecarregats. Aquest cas no és vàlid per sobrecàrrega.

Per tant, si tenim les declaracions següents:

I int (int, int);
Suma de cadena (int, int);

En aquest cas, el compilador produirà un error ja que dos mètodes no estan sobrecarregats. Per tant, basant-se únicament en els tipus de devolució, els mètodes no es diferencien.

Demostrem aquest cas no vàlid mitjançant un programa Java.

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

Al programa anterior, el mètode myMethod té dos prototips. Un prototip pren dos paràmetres int i retorna el doble. El segon prototip de mètode pren dos paràmetres int i retorna un int.

Així, quan compilem aquest programa, obtenim la sortida següent.

Sortida:

Cas no vàlid de sobrecàrrega del mètode

L'error de compilació anterior indica que el mètode es declara dues vegades. Això significa que el compilador no considera aquests mètodes sobrecarregats només basant-se en el tipus de retorn.

Sobrecàrrega de l’operador

La sobrecàrrega de l’operador és un mecanisme de sobrecàrrega en què es dóna un significat diferent a un operador existent.

Com hem comentat a la secció d’introducció d’aquest tutorial, un operador d’addició ‘+’ és un exemple clàssic de sobrecàrrega de l’operador.

Quan els operands d'aquest operador són numèrics, l'operador + retorna el total de dos valors. Però quan els operands són de tipus String, el resultat de l'operació d'addició és la cadena concatenada. Tingueu en compte que a Java, només podem sobrecarregar l’operador + (addició).

Aquest operador realitza dues funcions:

  • Afegir números enters o valors numèrics.
  • Concatenació de cordes

Per tant, el suport de la sobrecàrrega de l’operador és limitat a Java, a diferència de C ++, en el qual podem sobrecarregar gairebé tots els operadors excepte alguns, com sizeof, operador de punts, etc.

El programa següent mostra una sobrecàrrega de l'operador a 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 } }

Sortida:

Sobrecàrrega de l

Al programa anterior, hem sobrecarregat l’operador ‘+’. Quan passem dos valors enters al mètode sobrecarregat, es retorna una suma de dos enters i quan es passen dues cadenes el resultat és la cadena concatenada.

Alguns punts a destacar sobre la sobrecàrrega i el polimorfisme en temps de compilació.

  1. La sobrecàrrega de mètodes és la manera d'implementar un polimorfisme en temps de compilació que també es coneix com polimorfisme estàtic.
  2. El polimorfisme estàtic també es coneix com a unió primerenca o en temps de compilació.
  3. A mesura que la vinculació de paràmetres i de trucades a funcions es produeix en temps de compilació, la sobrecàrrega s’anomena vinculació de temps de compilació.
  4. Només podem sobrecarregar l’operador ‘+’ a Java i realitza l’addició de dos enters o la concatenació de dues cadenes.

Preguntes freqüents

P # 1) Per què necessitem polimorfisme a Java?

Resposta: El polimorfisme ens permet tenir moltes implementacions per a un objecte. Mitjançant la sobrecàrrega de mètodes, no necessitem tenir massa mètodes amb noms diferents i difícils de recordar. En canvi, podem tenir mètodes sobrecarregats de manera que puguem tenir una implementació clara dels mètodes que realitzen funcions similars.

També s’han d’ajudar a implementar correctament l’herència que ens permet afegir més funcionalitat a les classes existents d’una manera més senzilla.

Q # 2) Què és el polimorfisme OOP?

Resposta: La definició de polimorfisme de programació orientada a objectes fa referència a la capacitat dels llenguatges de programació per implementar un objecte de diverses formes. El polimorfisme també es defineix com la capacitat d’un programa d’anul·lar els mètodes de la classe pare a la classe derivada per tenir una funcionalitat addicional.

P # 3) Podem sobrecarregar i anul·lar el mètode principal?

Resposta: No, no podem anul·lar el mètode estàtic principal. Tot i que podem sobrecarregar el mètode principal, JVM mai trucarà al mètode principal sobrecarregat. Per tant, la millor resposta és no sobrecarregar ni anul·lar el mètode principal.

P # 4) Es poden sobrecarregar els constructors?

Resposta: Sí, podem sobrecarregar els constructors a Java de la mateixa manera que els mètodes Java. Els constructors solen tenir el mateix nom però un nombre diferent d’arguments.

P # 5) Per què és útil la sobrecàrrega de mètodes?

Resposta: Podem escriure codi net mitjançant la sobrecàrrega del mètode i també es pot llegir, ja que tenim mètodes amb el mateix nom. Per tant, si implementem funcionalitats per a diversos tipus de dades, podem sobrecarregar els mètodes i serà més fàcil separar el codi.

Conclusió

El polimorfisme a Java significa que un objecte pot tenir moltes formes. El polimorfisme a Java té dos tipus, és a dir, el polimorfisme en temps de compilació i el polimorfisme en temps d'execució. El polimorfisme en temps de compilació es fa en temps de compilació. El polimorfisme en temps de compilació és estàtic i s’implementa mitjançant la sobrecàrrega de mètodes i la sobrecàrrega de l’operador.

El polimorfisme en temps d'execució es realitza en temps d'execució i és dinàmic. S’implementa mitjançant mètode d’anul·lació.

En aquest tutorial, hem vist les maneres d'implementar la sobrecàrrega del mètode. També hem debatut detalladament sobre la sobrecàrrega de l’operador. Java només admet la sobrecàrrega de l’operador ‘+’.

=> Llegiu la sèrie de formació Java fàcil.

Lectura recomanada

^