V Javě metoda Method Overloading umožňuje různým metodám mít stejný název, ale různé signatury, kde se signatura může lišit počtem vstupních parametrů nebo typem vstupních parametrů, nebo kombinací obojího.
Přetížení metod v Javě je také známé jako Polymorfismus v době kompilace , Statický polymorfismus, popř Včasná vazba . Při přetížení metody ve srovnání s nadřazeným argumentem bude mít podřízený argument nejvyšší prioritu.
Příklad přetížení metody
Jáva
// 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 null check
>Výstup
30 60 31.0>
Různé způsoby přetížení metod v Javě
- Změna počtu parametrů.
- Změna datových typů argumentů.
- Změna pořadí parametrů metod
1. Změna počtu parametrů
Přetížení metod lze dosáhnout změnou počtu parametrů při přechodu na různé metody.
Níže je uvedena implementace výše uvedené metody:
Jáva
// 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);> >}> }> |
>
>Výstup
Product of the two integer value :2 Product of the three integer value :6>
2. Změna datových typů argumentů
V mnoha případech lze metody považovat za přetížené, pokud mají stejný název, ale mají různé typy parametrů, metody jsou považovány za přetížené.
Níže je uvedena implementace výše uvedené metody:
Jáva
// 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);> >}> }> |
>
>Výstup
Product of the three integer value :6 Product of the three double value :6.0>
3. Změna pořadí parametrů metod
Přetížení metod lze také implementovat přeskupením parametrů dvou nebo více přetížených metod. Pokud jsou například parametry metody 1 (název řetězce, int roll_no) a druhá metoda je (int roll_no, název řetězce), ale obě mají stejný název, pak se tyto 2 metody považují za přetížené různými sekvencemi parametrů. .
Níže je uvedena implementace výše uvedené metody:
Jáva
// 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'>);> >}> }> |
>
>Výstup
Name :Spyd3r Roll-No :1 Roll-No :2 Name :Kamlesh>
Co když se přesný prototyp neshoduje s argumenty?
Prioritně kompilátor provede tyto kroky:
- Zadejte Konverze, ale na vyšší typ (z hlediska rozsahu) ve stejné rodině.
- Převod typu na další vyšší rodinu (předpokládejme, že pokud pro datový typ int není k dispozici žádný dlouhý datový typ, bude hledat datový typ float).
Vezměme si příklad pro objasnění konceptu:
Jáva
// 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>);> >}> }> |
>
>
Výstup
./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>
Výhody přetížení metody
- Přetížení metod zlepšuje čitelnost a znovupoužitelnost programu.
- Přetížení metod snižuje složitost programu.
- Pomocí přetížení metod mohou programátoři provádět úkol efektivně a efektivně.
- Pomocí přetěžování metod je možné přistupovat k metodám vykonávajícím související funkce s mírně odlišnými argumenty a typy.
- Objekty třídy lze také inicializovat různými způsoby pomocí konstruktorů.
Důležité otázky v Javě
Q1. Můžeme přetížit statické metody?
Odpovědět:
Odpověď je ' Ano '. Můžeme mít dvě nebo více statických metod se stejným názvem, ale rozdíly ve vstupních parametrech. Zvažte například následující program Java. Chcete-li se o tom dozvědět více, podívejte se na článek - Můžeme přetížit nebo přepsat statické metody v Javě?
Q2. Můžeme přetížit metody, které se liší pouze statickými klíčovými slovy?
Odpovědět:
My nemůže přetížit dvě metody v Javě, pokud se liší pouze statickým klíčovým slovem (počet parametrů a typy parametrů jsou stejné). Viz například následující program Java. Podrobnosti naleznete zde.
Q3. Můžeme přetížit main() v Javě?
Odpovědět:
Stejně jako ostatní statické metody jsme umět přetížení main() v Javě .
Jáva
// 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);>>}>}>>>VýstupHi Geek (from main) Hi, Geek Hi, Dear Geek, My Geek>
Q4. Podporuje Java přetížení operátorů?
Odpovědět:
Na rozdíl od C++ Java neumožňuje uživatelem definované přetížené operátory. Interně Java přetěžuje operátory, například + je přetíženo zřetězením.
Q5. Můžeme přetížit metody na návratovém typu?
Odpovědět:
Nemůžeme přetížit návratovým typem. Toto chování je stejné v C++. Podrobnosti naleznete zde.
Jáva
co je uživatelské jméno
/*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[]) {}>}>>>Chyba
./Main.java:8: error: method foo() is already defined in class Main public char foo() { return 'a'; } ^ 1 error>Metody přetížení na návratovém typu jsou však možné v případech, kdy je explicitně specifikován datový typ volané funkce. Podívejte se na příklady níže:
Jáva
// 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>));>>}>}>>>Výstup10 a>Jáva
// 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>));>>}>}>>>Výstup10 a>
Q6. Jaký je rozdíl mezi přetížením a přepsáním?
Odpovědět:
Přetížení je přibližně stejná funkce s různými podpisy. Přepisování je přibližně stejná funkce a stejný podpis, ale různé třídy spojené prostřednictvím dědičnosti.
Přetížení je příkladem polymorfismu v čase kompilátoru a přepisování je příkladem polymorfismu v době běhu.
Související články
- Různé způsoby přetížení metod v Javě
- Metoda přetížení a chyba Null v Javě
- Můžeme přetížit nebo přepsat statické metody v jazyce Java?