I Java tillader Method Overloading, at forskellige metoder har samme navn, men forskellige signaturer, hvor signaturen kan variere med antallet af inputparametre eller typen af inputparametre eller en blanding af begge.
Metodeoverbelastning i Java er også kendt som Kompileringstidspolymorfi , statisk polymorfi eller Tidlig binding . I metodeoverbelastning sammenlignet med det overordnede argument, vil det underordnede argument få den højeste prioritet.
Eksempel på metodeoverbelastning
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 læse csv-fil
>Produktion
30 60 31.0>
Forskellige måder til metodeoverbelastning i Java
- Ændring af antallet af parametre.
- Ændring af datatyper for argumenterne.
- Ændring af rækkefølgen af metodernes parametre
1. Ændring af antallet af parametre
Metodeoverbelastning kan opnås ved at ændre antallet af parametre, mens man går over til forskellige metoder.
Nedenfor er implementeringen af ovenstående metode:
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. Ændring af datatyper for argumenterne
I mange tilfælde kan metoder betragtes som overbelastede, hvis de har samme navn, men har forskellige parametertyper, metoder anses for at være overbelastede.
Nedenfor er implementeringen af ovenstående metode:
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. Ændring af rækkefølgen af metodernes parametre
Metodeoverbelastning kan også implementeres ved at omarrangere parametrene for to eller flere overbelastede metoder. For eksempel, hvis parametrene for metode 1 er (String name, int roll_no) og den anden metode er (int roll_no, String name), men begge har samme navn, så anses disse 2 metoder for at være overbelastet med forskellige sekvenser af parametre .
Nedenfor er implementeringen af ovenstående metode:
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>
Hvad hvis den nøjagtige prototype ikke stemmer overens med argumenter?
Prioritetsmæssigt tager compileren disse trin:
- Typekonvertering, men til en højere type (i forhold til rækkevidde) i samme familie.
- Typekonvertering til den næste højere familie (antag, at hvis der ikke er nogen lang datatype tilgængelig for en int-datatype, så vil den søge efter float-datatypen).
Lad os tage et eksempel for at tydeliggøre begrebet:
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>
Fordele ved metodeoverbelastning
- Metodeoverbelastning forbedrer programmets læsbarhed og genbrugelighed.
- Metodeoverbelastning reducerer programmets kompleksitet.
- Ved at bruge metodeoverbelastning kan programmører udføre en opgave effektivt og effektivt.
- Ved at bruge metodeoverbelastning er det muligt at få adgang til metoder, der udfører relaterede funktioner med lidt forskellige argumenter og typer.
- Objekter i en klasse kan også initialiseres på forskellige måder ved hjælp af konstruktørerne.
Vigtige spørgsmål i Java
Q1. Kan vi overbelaste statiske metoder?
Svar:
Svaret er ' Ja ’. Vi kan have to eller flere statiske metoder med samme navn, men forskelle i inputparametre. Overvej for eksempel følgende Java-program. For at vide mere om dette, se artiklen - Kan vi overbelaste eller tilsidesætte statiske metoder i Java?
Q2. Kan vi overbelaste metoder, der kun adskiller sig ved statiske søgeord?
Svar:
Vi kan ikke overbelast to metoder i Java, hvis de kun adskiller sig ved statisk nøgleord (antallet af parametre og typer af parametre er de samme). Se f.eks. følgende Java-program. Se dette for detaljer.
Q3. Kan vi overbelaste main() i Java?
Svar:
Ligesom andre statiske metoder har vi kan overbelast 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);>>}>}>>>ProduktionHi Geek (from main) Hi, Geek Hi, Dear Geek, My Geek>
Q4. Understøtter Java Operator Overloading?
Svar:
I modsætning til C++ tillader Java ikke brugerdefinerede overbelastede operatører. Internt overbelaster Java operatører, for eksempel er + overbelastet til sammenkædning.
Q5. Kan vi overbelaste metoder på returtype?
Svar:
Vi kan ikke overbelaste efter returtype. Denne adfærd er den samme i C++. Se dette for 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[]) {}>}>>>Fejl
./Main.java:8: error: method foo() is already defined in class Main public char foo() { return 'a'; } ^ 1 error>Overbelastningsmetoder på returtype er dog mulige i tilfælde, hvor datatypen for den funktion, der kaldes, er eksplicit angivet. Se eksemplerne nedenfor:
Java
heltal til streng i 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>
Q6. Hvad er forskellen mellem overbelastning og tilsidesættelse?
Svar:
Overbelastning handler om den samme funktion med forskellige signaturer. Tilsidesættende handler om den samme funktion og samme signatur, men forskellige klasser forbundet gennem arv.
Overbelastning er et eksempel på kompilertidspolymorfi og tilsidesættelse er et eksempel på runtimepolymorfi.
relaterede artikler
- Forskellige måder til metodeoverbelastning i Java
- Metodeoverbelastning og nul-fejl i Java
- Kan vi overbelaste eller tilsidesætte statiske metoder i java?