În Java, Method Overloading permite diferitelor metode să aibă același nume, dar semnături diferite în care semnătura poate diferi prin numărul de parametri de intrare sau tipul parametrilor de intrare sau un amestec al ambelor.
Supraîncărcarea metodei în Java este cunoscută și ca Polimorfism în timp de compilare , Polimorfism static sau Legarea timpurie . În supraîncărcarea metodei în comparație cu argumentul părinte, argumentul copil va primi cea mai mare prioritate.
Exemplu de supraîncărcare a metodei
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>));> >}> }> |
>
char și int java
>Ieșire
30 60 31.0>
Diferite moduri de supraîncărcare a metodelor în Java
- Modificarea numărului de parametri.
- Modificarea tipurilor de date ale argumentelor.
- Modificarea ordinii parametrilor metodelor
1. Modificarea numărului de parametri
Supraîncărcarea metodei poate fi realizată prin modificarea numărului de parametri trecând la diferite metode.
Mai jos este implementarea metodei de mai sus:
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);> >}> }> |
>
>Ieșire
Product of the two integer value :2 Product of the three integer value :6>
2. Modificarea tipurilor de date ale argumentelor
În multe cazuri, metodele pot fi considerate supraîncărcate dacă au același nume, dar au tipuri diferite de parametri, metodele sunt considerate a fi supraîncărcate.
Mai jos este implementarea metodei de mai sus:
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);> >}> }> |
>
>Ieșire
Product of the three integer value :6 Product of the three double value :6.0>
3. Modificarea ordinii parametrilor metodelor
Supraîncărcarea metodelor poate fi implementată și prin rearanjarea parametrilor a două sau mai multe metode supraîncărcate. De exemplu, dacă parametrii metodei 1 sunt (String name, int roll_no) și cealaltă metodă este (int roll_no, String name) dar ambele au același nume, atunci aceste 2 metode sunt considerate a fi supraîncărcate cu secvențe diferite de parametri .
Mai jos este implementarea metodei de mai sus:
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'>);> >}> }> |
>
>Ieșire
Name :Spyd3r Roll-No :1 Roll-No :2 Name :Kamlesh>
Ce se întâmplă dacă prototipul exact nu se potrivește cu argumentele?
Din punct de vedere prioritar, compilatorul face acești pași:
- Conversie de tip, dar la un tip superior (în termeni de interval) în aceeași familie.
- Conversia tipului la următoarea familie superioară (să presupunem că dacă nu există un tip de date lung disponibil pentru un tip de date int, atunci va căuta tipul de date float).
Să luăm un exemplu pentru a clarifica conceptul:
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>);> >}> }> |
>
>
Actrița Rakul Preet Singh
Ieșire
./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>
Avantajele supraîncărcării metodei
- Supraîncărcarea metodei îmbunătățește lizibilitatea și reutilizarea programului.
- Supraîncărcarea metodei reduce complexitatea programului.
- Folosind supraîncărcarea metodelor, programatorii pot efectua o sarcină eficient și eficient.
- Folosind supraîncărcarea metodelor, este posibil să accesați metode care efectuează funcții conexe cu argumente și tipuri ușor diferite.
- Obiectele unei clase pot fi, de asemenea, inițializate în diferite moduri folosind constructori.
Întrebări importante în Java
Î1. Putem supraîncărca metodele statice?
Răspuns:
Raspunsul este ' da ’. Putem avea două sau mai multe metode statice cu același nume, dar diferențe în parametrii de intrare. De exemplu, luați în considerare următorul program Java. Pentru a afla mai multe despre acest lucru, consultați articolul - Putem supraîncărca sau suprascrie metodele statice în Java?
Q2. Putem supraîncărca metode care diferă doar prin cuvinte cheie statice?
Răspuns:
Noi nu poti supraîncărcați două metode în Java dacă diferă doar prin cuvântul cheie static (numărul de parametri și tipurile de parametri sunt aceleași). Vezi, de exemplu, următorul program Java. Consultați aceasta pentru detalii.
Q3. Putem supraîncărca main() în Java?
Răspuns:
Ca și alte metode statice, noi poate sa supraîncărcați main() în 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);>>}>}>>>IeșireHi Geek (from main) Hi, Geek Hi, Dear Geek, My Geek>
Î4. Java acceptă supraîncărcarea operatorului?
Răspuns:
Spre deosebire de C++, Java nu permite operatori supraîncărcați definiți de utilizator. Intern Java supraîncărcă operatorii, de exemplu, + este supraîncărcat pentru concatenare.
Î5. Putem supraîncărca metodele pe tipul de returnare?
Răspuns:
Nu putem supraîncărca după tipul de returnare. Acest comportament este același în C++. Consultați aceasta pentru detalii.
Java
/*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[]) {}>}>>>Eroare
./Main.java:8: error: method foo() is already defined in class Main public char foo() { return 'a'; } ^ 1 error>Cu toate acestea, metodele de supraîncărcare pe tipul returnat sunt posibile în cazurile în care tipul de date al funcției apelate este specificat în mod explicit. Uită-te la exemplele de mai jos:
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>));>>}>}>>>Ieșire10 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>));>>}>}>>>Ieșire10 a>
Î6. Care este diferența dintre supraîncărcare și suprascriere?
Răspuns:
Supraîncărcarea este aproximativ aceeași funcție având semnături diferite. Depășirea este aproximativ aceeași funcție și aceeași semnătură, dar clase diferite legate prin moștenire.
Supraîncărcarea este un exemplu de polimorfism în timp al compilatorului, iar suprascrierea este un exemplu de polimorfism în timpul rulării.
Articole similare
- Diferite moduri de supraîncărcare a metodelor în Java
- Supraîncărcarea metodei și eroare nulă în Java
- Putem supraîncărca sau suprascrie metodele statice în java?