I Java tillåter Method Overloading att olika metoder har samma namn, men olika signaturer där signaturen kan skilja sig åt med antalet ingångsparametrar eller typen av ingångsparametrar, eller en blandning av båda.
Metodöverbelastning i Java är också känd som Polymorfism vid kompilering , statisk polymorfism, eller Tidig bindning . I metodöverbelastning jämfört med det överordnade argumentet kommer det underordnade argumentet att få högsta prioritet.
Exempel på metodöverbelastning
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>));> >}> }> |
>
java annat
>Produktion
30 60 31.0>
Olika sätt för metodöverbelastning i Java
- Ändra antalet parametrar.
- Ändra datatyper för argumenten.
- Ändra ordningen för parametrarna för metoder
1. Ändra antalet parametrar
Metodöverbelastning kan uppnås genom att ändra antalet parametrar samtidigt som man övergår till olika metoder.
Nedan är implementeringen av ovanstående metod:
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);> >}> }> |
>
>Produktion
Product of the two integer value :2 Product of the three integer value :6>
2. Ändra datatyper för argumenten
I många fall kan metoder anses överbelastade om de har samma namn men har olika parametertyper, metoder anses vara överbelastade.
Nedan är implementeringen av ovanstående metod:
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);> >}> }> |
>
>Produktion
Product of the three integer value :6 Product of the three double value :6.0>
3. Ändra ordningen för parametrarna för metoder
Metodöverbelastning kan också implementeras genom att omarrangera parametrarna för två eller flera överbelastade metoder. Till exempel, om parametrarna för metod 1 är (String name, int roll_no) och den andra metoden är (int roll_no, String name) men båda har samma namn, så anses dessa 2 metoder vara överbelastade med olika sekvenser av parametrar .
Nedan är implementeringen av ovanstående metod:
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'>);> >}> }> |
>
>Produktion
Name :Spyd3r Roll-No :1 Roll-No :2 Name :Kamlesh>
Vad händer om den exakta prototypen inte stämmer överens med argument?
Prioritetsmässigt tar kompilatorn dessa steg:
- Typkonvertering men till en högre typ (i termer av räckvidd) i samma familj.
- Typkonvertering till nästa högre familj (antag att om det inte finns någon lång datatyp tillgänglig för en int-datatyp, så kommer den att söka efter flytdatatypen).
Låt oss ta ett exempel för att förtydliga konceptet:
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>);> >}> }> |
>
>
Produktion
./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>
Fördelar med metodöverbelastning
- Metodöverbelastning förbättrar programmets läsbarhet och återanvändbarhet.
- Metodöverbelastning minskar programmets komplexitet.
- Genom att använda metodöverbelastning kan programmerare utföra en uppgift effektivt och effektivt.
- Genom att använda metodöverbelastning är det möjligt att komma åt metoder som utför relaterade funktioner med lite olika argument och typer.
- Objekt i en klass kan också initieras på olika sätt med hjälp av konstruktörerna.
Viktiga frågor i Java
Q1. Kan vi överbelasta statiska metoder?
Svar:
Svaret är ' Ja ’. Vi kan ha två eller flera statiska metoder med samma namn, men skillnader i indataparametrar. Tänk till exempel på följande Java-program. För att veta mer om detta, se artikeln - Kan vi överbelasta eller åsidosätta statiska metoder i Java?
Q2. Kan vi överbelasta metoder som bara skiljer sig med statiska sökord?
Svar:
Vi kan inte överbelasta två metoder i Java om de bara skiljer sig från statiskt nyckelord (antalet parametrar och typer av parametrar är desamma). Se till exempel följande Java-program. Se detta för detaljer.
Q3. Kan vi överbelasta main() i Java?
Svar:
Liksom andra statiska metoder, vi burk överbelasta main() i 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);>>}>}>sortera en array java>>ProduktionHi Geek (from main) Hi, Geek Hi, Dear Geek, My Geek>
Q4. Stöder Java Operator Overloading?
Svar:
Till skillnad från C++ tillåter inte Java användardefinierade överbelastade operatörer. Internt överbelastar Java operatörer, till exempel är + överbelastad för sammanlänkning.
F5. Kan vi överbelasta metoder för returtyp?
Svar:
Vi kan inte överbelasta efter returtyp. Detta beteende är detsamma i C++. Se detta för detaljer.
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[]) {}>}>>>Fel
./Main.java:8: error: method foo() is already defined in class Main public char foo() { return 'a'; } ^ 1 error>Överbelastningsmetoder på returtyp är dock möjliga i de fall då datatypen för den funktion som anropas är explicit specificerad. Titta på exemplen nedan:
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>));>>}>}>>>Produktion10 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>));>>}>}>>>Produktion10 a>
F6. Vad är skillnaden mellan överbelastning och överstyrning?
Svar:
Överbelastning handlar om att samma funktion har olika signaturer. Åsidosättande handlar om samma funktion och samma signatur men olika klasser kopplade genom arv.
Överbelastning är ett exempel på kompilatortidspolymorfism och åsidosättande är ett exempel på körtidspolymorfism.
relaterade artiklar
- Olika sätt för metodöverbelastning i Java
- Metodöverbelastning och nollfel i Java
- Kan vi överbelasta eller åsidosätta statiska metoder i java?