A Java, Method Overloading permet que diferents mètodes tinguin el mateix nom, però diferents signatures on la signatura pot diferir pel nombre de paràmetres d'entrada o tipus de paràmetres d'entrada, o una barreja d'ambdós.
La sobrecàrrega de mètodes a Java també es coneix com Polimorfisme en temps de compilació , Polimorfisme estàtic o Enquadernació primerenca . A la sobrecàrrega de mètodes en comparació amb l'argument principal, l'argument fill tindrà la prioritat més alta.
Exemple de sobrecàrrega de mètodes
Java
// Java program to demonstrate working of method> // overloading in Java> > public> class> Sum {> >// Overloaded sum(). This sum takes two int parameters> >public> int> sum(>int> x,>int> y) {>return> (x + y); }> > >// Overloaded sum(). This sum takes three int parameters> >public> int> sum(>int> x,>int> y,>int> z)> >{> >return> (x + y + z);> >}> > >// Overloaded sum(). This sum takes two double> >// parameters> >public> double> sum(>double> x,>double> y)> >{> >return> (x + y);> >}> > >// Driver code> >public> static> void> main(String args[])> >{> >Sum s =>new> Sum();> >System.out.println(s.sum(>10>,>20>));> >System.out.println(s.sum(>10>,>20>,>30>));> >System.out.println(s.sum(>10.5>,>20.5>));> >}> }> |
>
govinda
>Sortida
30 60 31.0>
Diferents maneres de sobrecàrrega de mètodes a Java
- Canviar el nombre de paràmetres.
- Canvi de tipus de dades dels arguments.
- Canvi de l'ordre dels paràmetres dels mètodes
1. Canviar el nombre de paràmetres
La sobrecàrrega de mètodes es pot aconseguir canviant el nombre de paràmetres mentre es passa a diferents mètodes.
A continuació es mostra la implementació del mètode anterior:
Java
// Java Program to Illustrate Method Overloading> // By Changing the Number of Parameters> > // Importing required classes> import> java.io.*;> > // Class 1> // Helper class> class> Product {> >// Method 1> >// Multiplying two integer values> >public> int> multiply(>int> a,>int> b)> >{> >int> prod = a * b;> >return> prod;> >}> > >// Method 2> >// Multiplying three integer values> >public> int> multiply(>int> a,>int> b,>int> c)> >{> >int> prod = a * b * c;> >return> prod;> >}> }> > // Class 2> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Creating object of above class inside main()> >// method> >Product ob =>new> Product();> > >// Calling method to Multiply 2 numbers> >int> prod1 = ob.multiply(>1>,>2>);> > >// Printing Product of 2 numbers> >System.out.println(> >'Product of the two integer value :'> + prod1);> > >// Calling method to multiply 3 numbers> >int> prod2 = ob.multiply(>1>,>2>,>3>);> > >// Printing product of 3 numbers> >System.out.println(> >'Product of the three integer value :'> + prod2);> >}> }> |
>
>Sortida
Product of the two integer value :2 Product of the three integer value :6>
2. Canvi de tipus de dades dels arguments
En molts casos, els mètodes es poden considerar sobrecarregats si tenen el mateix nom però tenen diferents tipus de paràmetres, els mètodes es consideren sobrecarregats.
A continuació es mostra la implementació del mètode anterior:
Java
// Java Program to Illustrate Method Overloading> // By Changing Data Types of the Parameters> > // Importing required classes> import> java.io.*;> > // Class 1> // Helper class> class> Product {> >// Multiplying three integer values> >public> int> Prod(>int> a,>int> b,>int> c)> >{> >int> prod1 = a * b * c;> >return> prod1;> >}> > >// Multiplying three double values.> >public> double> Prod(>double> a,>double> b,>double> c)> >{> >double> prod2 = a * b * c;> >return> prod2;> >}> }> > class> GFG {> >public> static> void> main(String[] args)> >{> >Product obj =>new> Product();> > >int> prod1 = obj.Prod(>1>,>2>,>3>);> >System.out.println(> >'Product of the three integer value :'> + prod1);> > >double> prod2 = obj.Prod(>1.0>,>2.0>,>3.0>);> >System.out.println(> >'Product of the three double value :'> + prod2);> >}> }> |
>
>Sortida
Product of the three integer value :6 Product of the three double value :6.0>
3. Canvi de l'ordre dels paràmetres dels mètodes
La sobrecàrrega de mètodes també es pot implementar reordenant els paràmetres de dos o més mètodes sobrecarregats. Per exemple, si els paràmetres del mètode 1 són (String name, int roll_no) i l'altre mètode és (int roll_no, String name) però tots dos tenen el mateix nom, es considera que aquests dos mètodes estan sobrecarregats amb diferents seqüències de paràmetres. .
A continuació es mostra la implementació del mètode anterior:
Java
// Java Program to Illustrate Method Overloading> // By changing the Order of the Parameters> > // Importing required classes> import> java.io.*;> > // Class 1> // Helper class> class> Student {> >// Method 1> >public> void> StudentId(String name,>int> roll_no)> >{> >System.out.println(>'Name :'> + name +>' '> >+>'Roll-No :'> + roll_no);> >}> > >// Method 2> >public> void> StudentId(>int> roll_no, String name)> >{> >// Again printing name and id of person> >System.out.println(>'Roll-No :'> + roll_no +>' '> >+>'Name :'> + name);> >}> }> > // Class 2> // Main class> class> GFG {> >// Main function> >public> static> void> main(String[] args)> >{> >// Creating object of above class> >Student obj =>new> Student();> > >// Passing name and id> >// Note: Reversing order> >obj.StudentId(>'Spyd3r'>,>1>);> >obj.StudentId(>2>,>'Kamlesh'>);> >}> }> |
>
>Sortida
Name :Spyd3r Roll-No :1 Roll-No :2 Name :Kamlesh>
Què passa si el prototip exacte no coincideix amb els arguments?
Pel que fa a prioritats, el compilador fa aquests passos:
- Conversió de tipus però a un tipus superior (en termes d'interval) de la mateixa família.
- Conversió de tipus a la següent família superior (suposem que si no hi ha un tipus de dades llarg disponible per a un tipus de dades int, llavors cercarà el tipus de dades flotant).
Posem un exemple per aclarir el concepte:
Java
// Demo Class> class> Demo {> >public> void> show(>int> x)> >{> >System.out.println(>'In int'> + x);> >}> >public> void> show(String s)> >{> >System.out.println(>'In String'> + s);> >}> >public> void> show(>byte> b)> >{> >System.out.println(>'In byte'> + b);> >}> }> > class> UseDemo {> >public> static> void> main(String[] args)> >{> >byte> a =>25>;> >Demo obj =>new> Demo();> > >// it will go to> >// byte argument> >obj.show(a);> > >// String> >obj.show(>'hello'>);> > >// Int> >obj.show(>250>);> > >// Since char is> >// not available, so the datatype> >// higher than char in terms of> >// range is int.> >obj.show(>'A'>);> > >// String> >obj.show(>'A'>);> > >// since float datatype> >// is not available and so it's higher> >// datatype, so at this step their> >// will be an error.> >obj.show(>7.5>);> >}> }> |
>
>
Sortida
./UseDemo.java:46: error: no suitable method found for show(double) obj.show(7.5); ^ method Demo.show(int) is not applicable (argument mismatch; possible lossy conversion from double to int) method Demo.show(String) is not applicable (argument mismatch; double cannot be converted to String) method Demo.show(byte) is not applicable (argument mismatch; possible lossy conversion from double to byte) 1 error>
Avantatges de la sobrecàrrega del mètode
- La sobrecàrrega de mètodes millora la llegibilitat i la reutilització del programa.
- La sobrecàrrega de mètodes redueix la complexitat del programa.
- Mitjançant la sobrecàrrega de mètodes, els programadors poden realitzar una tasca de manera eficient i eficaç.
- Mitjançant la sobrecàrrega de mètodes, és possible accedir a mètodes que realitzen funcions relacionades amb arguments i tipus lleugerament diferents.
- Els objectes d'una classe també es poden inicialitzar de diferents maneres mitjançant els constructors.
Preguntes importants a Java
Q1. Podem sobrecarregar els mètodes estàtics?
Resposta:
La resposta és ' Sí ’. Podem tenir dos o més mètodes estàtics amb el mateix nom, però diferències en els paràmetres d'entrada. Per exemple, considereu el següent programa Java. Per saber més sobre això, consulteu l'article: Podem sobrecarregar o anul·lar mètodes estàtics a Java?
P2. Podem sobrecarregar mètodes que només es diferencien per paraules clau estàtiques?
Resposta:
Nosaltres no pot sobrecarregueu dos mètodes a Java si només difereixen per paraula clau estàtica (el nombre de paràmetres i els tipus de paràmetres són els mateixos). Vegeu el següent programa Java per exemple. Consulteu això per obtenir més informació.
P3. Podem sobrecarregar main() a Java?
Resposta:
Com altres mètodes estàtics, nosaltres llauna sobrecarregueu main() a Java.
Java
// Java program with overloaded main()>import>java.io.*;>>public>class>Test {>>// Normal main()>>public>static>void>main(String[] args)>>{>>System.out.println(>'Hi Geek (from main)'>);>>Test.main(>'Geek'>);>>}>>>// Overloaded main methods>>public>static>void>main(String arg1)>>{>>System.out.println(>'Hi, '>+ arg1);>>Test.main(>'Dear Geek'>,>'My Geek'>);>>}>>>public>static>void>main(String arg1, String arg2)>>{>>System.out.println(>'Hi, '>+ arg1 +>', '>+ arg2);>>}>}>>>SortidaHi Geek (from main) Hi, Geek Hi, Dear Geek, My Geek>
P4. Java admet la sobrecàrrega de l'operador?
Resposta:
A diferència de C++, Java no permet operadors sobrecarregats definits per l'usuari. Internament, Java sobrecarrega els operadors, per exemple, + està sobrecarregat per a la concatenació.
P5. Podem sobrecarregar mètodes en tipus de retorn?
Resposta:
No podem sobrecarregar per tipus de retorn. Aquest comportament és el mateix en C++. Consulteu això per obtenir més informació.
Java
c++ converteix int en cadena
/*package whatever //do not write package name here */>>import>java.io.*;>>public>class>Main {>>public>int>foo() {>return>10>; }>>>// compiler error: foo() is already defined>>public>char>foo() {>return>'a'>; }>>>public>static>void>main(String args[]) {}>}>>>Error
./Main.java:8: error: method foo() is already defined in class Main public char foo() { return 'a'; } ^ 1 error>Tanmateix, els mètodes de sobrecàrrega en el tipus de retorn són possibles en els casos en què s'especifica explícitament el tipus de dades de la funció que es crida. Mireu els exemples següents:
Java
// Java program to demonstrate the working of method>// overloading in static methods>>import>java.io.*;>>public>class>Main {>>>public>static>int>foo(>int>a) {>return>10>; }>>public>static>char>foo(>int>a,>int>b) {>return>'a'>; }>>>public>static>void>main(String args[])>>{>>System.out.println(foo(>1>));>>System.out.println(foo(>1>,>2>));>>}>}>>>Sortida10 a>Java
// Java program to demonstrate working of method>// overloading in methods>class>A {>>public>int>foo(>int>a) {>return>10>; }>>>public>char>foo(>int>a,>int>b) {>return>'a'>; }>}>>public>class>Main {>>>public>static>void>main(String args[])>>{>>A a =>new>A();>>System.out.println(a.foo(>1>));>>System.out.println(a.foo(>1>,>2>));>>}>}>>>Sortida10 a>
P6. Quina diferència hi ha entre sobrecàrrega i anul·lació?
Resposta:
La sobrecàrrega és aproximadament la mateixa funció amb signatures diferents. Anul·lació és aproximadament la mateixa funció i la mateixa signatura, però diferents classes connectades mitjançant l'herència.
La sobrecàrrega és un exemple de polimorfisme en temps del compilador i la substitució és un exemple de polimorfisme en temps d'execució.
Articles relacionats
- Diferents maneres de sobrecàrrega de mètodes a Java
- Sobrecàrrega del mètode i error nul a Java
- Podem sobrecarregar o anul·lar mètodes estàtics a Java?