In Java zorgt Method Overloading ervoor dat verschillende methoden dezelfde naam kunnen hebben, maar verschillende handtekeningen, waarbij de handtekening kan verschillen door het aantal invoerparameters of het type invoerparameters, of een combinatie van beide.
Overbelasting van methoden in Java wordt ook wel Compile-time polymorfisme , Statisch polymorfisme, of Vroege binding . Bij overbelasting van de methode in vergelijking met het bovenliggende argument krijgt het onderliggende argument de hoogste prioriteit.
Voorbeeld van overbelasting van de methode
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>));> >}> }> |
>
substring-methode in Java
>Uitvoer
30 60 31.0>
Verschillende manieren van methode-overbelasting in Java
- Het aantal parameters wijzigen.
- Gegevenstypen van de argumenten wijzigen.
- De volgorde van de parameters van methoden wijzigen
1. Het aantal parameters wijzigen
Overbelasting van de methode kan worden bereikt door het aantal parameters te wijzigen terwijl u overgaat op verschillende methoden.
Hieronder vindt u de implementatie van de bovenstaande methode:
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);> >}> }> |
>
>Uitvoer
Product of the two integer value :2 Product of the three integer value :6>
2. Gegevenstypen van de argumenten wijzigen
In veel gevallen kunnen methoden als overbelast worden beschouwd als ze dezelfde naam hebben maar verschillende parametertypen hebben. Methoden worden als overbelast beschouwd.
Hieronder vindt u de implementatie van de bovenstaande methode:
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);> >}> }> |
>
>Uitvoer
Product of the three integer value :6 Product of the three double value :6.0>
3. De volgorde van de parameters van methoden wijzigen
Overbelasting van methoden kan ook worden geïmplementeerd door de parameters van twee of meer overbelaste methoden te herschikken. Als de parameters van methode 1 bijvoorbeeld (String name, int roll_no) zijn en de andere methode (int roll_no, String name) maar beide dezelfde naam hebben, worden deze twee methoden geacht overbelast te zijn met verschillende reeksen parameters .
Hieronder vindt u de implementatie van de bovenstaande methode:
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'>);> >}> }> |
>
>Uitvoer
Name :Spyd3r Roll-No :1 Roll-No :2 Name :Kamlesh>
Wat als het exacte prototype niet overeenkomt met de argumenten?
Wat de prioriteit betreft, voert de compiler de volgende stappen uit:
- Typeconversie maar naar een hoger type (qua bereik) in dezelfde familie.
- Typeconversie naar de volgende hogere familie (stel dat als er geen long-gegevenstype beschikbaar is voor een int-gegevenstype, er wordt gezocht naar het float-gegevenstype).
Laten we een voorbeeld nemen om het concept te verduidelijken:
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>);> >}> }> |
>
>
Uitvoer
./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>
Voordelen van overbelasting van methoden
- Overbelasting van methoden verbetert de leesbaarheid en herbruikbaarheid van het programma.
- Overbelasting van methoden vermindert de complexiteit van het programma.
- Door gebruik te maken van method overloading kunnen programmeurs een taak efficiënt en effectief uitvoeren.
- Door methode-overbelasting te gebruiken, is het mogelijk toegang te krijgen tot methoden die gerelateerde functies uitvoeren met enigszins verschillende argumenten en typen.
- Objecten van een klasse kunnen ook op verschillende manieren worden geïnitialiseerd met behulp van de constructors.
Belangrijke vragen op Java
Q1. Kunnen we statische methoden overbelasten?
Antwoord:
Het antwoord is ' Ja ’. We kunnen twee of meer statische methoden hebben met dezelfde naam, maar met verschillen in invoerparameters. Beschouw bijvoorbeeld het volgende Java-programma. Als u hier meer over wilt weten, raadpleegt u het artikel – Kunnen we statische methoden in Java overbelasten of overschrijven?
Vraag 2. Kunnen we methoden overbelasten die alleen verschillen door statische trefwoorden?
Antwoord:
Wij kan niet overbelast twee methoden in Java als ze alleen verschillen door een statisch trefwoord (het aantal parameters en de typen parameters zijn hetzelfde). Zie bijvoorbeeld het volgende Java-programma. Raadpleeg dit voor meer informatie.
Q3. Kunnen we main() in Java overbelasten?
Antwoord:
Net als andere statische methoden zijn wij kan overbelast main() in 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);>>}>}>>css-rand>UitvoerHi Geek (from main) Hi, Geek Hi, Dear Geek, My Geek>
Q4. Ondersteunt Java Operator Overloading?
Antwoord:
In tegenstelling tot C++ staat Java geen door de gebruiker gedefinieerde overbelaste operators toe. Intern overbelast Java operators, + wordt bijvoorbeeld overbelast voor aaneenschakeling.
Vraag 5. Kunnen we methoden overbelasten op het retourtype?
Antwoord:
We kunnen niet overbelasten per retourtype. Dit gedrag is hetzelfde in C++. Raadpleeg dit voor meer informatie.
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[]) {}>}>>>Fout
./Main.java:8: error: method foo() is already defined in class Main public char foo() { return 'a'; } ^ 1 error>Overbelastingsmethoden voor het retourtype zijn echter mogelijk in gevallen waarin het gegevenstype van de aangeroepen functie expliciet is gespecificeerd. Bekijk de onderstaande voorbeelden:
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>));>>}>}>>>Uitvoer10 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>));>>}>}>>>Uitvoer10 a>
Vraag 6. Wat is het verschil tussen overbelasting en overschrijven?
Antwoord:
Overbelasting gaat over dezelfde functie met verschillende handtekeningen. Overschrijven gaat over dezelfde functie en dezelfde signatuur, maar verschillende klassen verbonden door overerving.
Overbelasting is een voorbeeld van compilertijdpolymorfisme en overschrijven is een voorbeeld van runtimepolymorfisme.
gerelateerde artikelen
- Verschillende manieren van methode-overbelasting in Java
- Methode Overbelasting en nulfout in Java
- Kunnen we statische methoden in Java overbelasten of overschrijven?