W Javie przeciążanie metod pozwala różnym metodom mieć tę samą nazwę, ale różne podpisy, przy czym podpis może różnić się liczbą parametrów wejściowych lub typem parametrów wejściowych, albo kombinacją obu.
Przeciążanie metod w Javie jest również znane jako Polimorfizm w czasie kompilacji , Polimorfizm statyczny lub Wczesne wiązanie . W przypadku przeciążenia metody w porównaniu z argumentem nadrzędnym argument podrzędny otrzyma najwyższy priorytet.
Przykład przeciążania metod
Jawa
// 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>));> >}> }> |
>
ciąg.podciąg Java
>Wyjście
30 60 31.0>
Różne sposoby przeciążania metod w Javie
- Zmiana liczby parametrów.
- Zmiana typów danych argumentów.
- Zmiana kolejności parametrów metod
1. Zmiana liczby parametrów
Przeciążanie metod można osiągnąć poprzez zmianę liczby parametrów podczas przechodzenia do różnych metod.
Poniżej implementacja powyższej metody:
Jawa
// 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);> >}> }> |
>
>Wyjście
Product of the two integer value :2 Product of the three integer value :6>
2. Zmiana typów danych argumentów
W wielu przypadkach metody można uznać za przeciążone, jeśli mają tę samą nazwę, ale mają różne typy parametrów. Metody uważa się za przeciążone.
Poniżej implementacja powyższej metody:
Jawa
// 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);> >}> }> |
>
>Wyjście
Product of the three integer value :6 Product of the three double value :6.0>
3. Zmiana kolejności parametrów metod
Przeciążanie metod można również wdrożyć poprzez zmianę parametrów dwóch lub większej liczby przeciążonych metod. Na przykład, jeśli parametry metody 1 to (String name, int roll_no), a drugiej metody to (int roll_no, String name), ale obie mają tę samą nazwę, wówczas te 2 metody są uważane za przeciążone różnymi sekwencjami parametrów .
Poniżej implementacja powyższej metody:
Jawa
// 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'>);> >}> }> |
>
>Wyjście
Name :Spyd3r Roll-No :1 Roll-No :2 Name :Kamlesh>
Co się stanie, jeśli dokładny prototyp nie będzie zgodny z argumentami?
Jeśli chodzi o priorytety, kompilator wykonuje następujące kroki:
- Konwersja typu, ale na wyższy typ (pod względem zakresu) w tej samej rodzinie.
- Konwersja typu do następnej wyższej rodziny (załóżmy, że jeśli nie jest dostępny typ danych long dla typu danych int, wówczas zostanie wyszukany typ danych float).
Weźmy przykład, aby wyjaśnić tę koncepcję:
Jawa
// 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>);> >}> }> |
>
>
Wyjście
./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>
Zalety przeciążania metod
- Przeciążanie metod poprawia czytelność i możliwość ponownego użycia programu.
- Przeciążanie metod zmniejsza złożoność programu.
- Stosując przeciążanie metod, programiści mogą wydajnie i efektywnie wykonywać zadania.
- Dzięki przeciążaniu metod można uzyskać dostęp do metod wykonujących powiązane funkcje z nieco innymi argumentami i typami.
- Obiekty klasy można także inicjować na różne sposoby, korzystając z konstruktorów.
Ważne pytania w Javie
Pytanie 1. Czy możemy przeciążać metody statyczne?
Odpowiedź:
Odpowiedź to ' Tak ’. Możemy mieć dwie lub więcej metod statycznych o tej samej nazwie, ale różniących się parametrami wejściowymi. Rozważmy na przykład następujący program Java. Więcej na ten temat znajdziesz w artykule – Czy możemy przeciążać lub zastępować metody statyczne w Javie?
Pytanie 2. Czy możemy przeciążać metody, które różnią się jedynie statycznymi słowami kluczowymi?
Odpowiedź:
My Nie mogę przeciążać dwie metody w Javie, jeśli różnią się one jedynie statycznym słowem kluczowym (liczba parametrów i typy parametrów są takie same). Zobacz na przykład następujący program Java. Aby uzyskać szczegółowe informacje, zobacz to.
Pytanie 3. Czy możemy przeciążać funkcję main() w Javie?
Odpowiedź:
Podobnie jak inne metody statyczne, my Móc przeciążyć funkcję main() w Javie.
Jawa
// 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);>>}>}>>>WyjścieHi Geek (from main) Hi, Geek Hi, Dear Geek, My Geek>
Pytanie 4. Czy Java obsługuje przeciążanie operatorów?
Odpowiedź:
W przeciwieństwie do C++, Java nie pozwala na przeciążone operatory zdefiniowane przez użytkownika. Wewnętrznie Java przeciąża operatory, na przykład + jest przeciążany w celu konkatenacji.
Pytanie 5. Czy możemy przeciążać metody typu zwracanego?
Odpowiedź:
Nie możemy przeciążać według typu zwracanego. To zachowanie jest takie samo w C++. Aby uzyskać szczegółowe informacje, zobacz to.
Jawa
/*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[]) {}>}>>>Błąd
./Main.java:8: error: method foo() is already defined in class Main public char foo() { return 'a'; } ^ 1 error>Jednakże metody przeciążające typ zwracany są możliwe w przypadkach, gdy typ danych wywoływanej funkcji jest jawnie określony. Spójrz na poniższe przykłady:
Jawa
// 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>));>>}>}>wyrównaj obraz za pomocą CSS>>Wyjście10 a>Jawa
// 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>));>>}>}>>>Wyjście10 a>
Pytanie 6. Jaka jest różnica między przeciążaniem a zastępowaniem?
Odpowiedź:
Przeciążanie dotyczy tej samej funkcji z różnymi podpisami. Nadrzędny dotyczy tej samej funkcji i tej samej sygnatury, ale różnych klas połączonych poprzez dziedziczenie.
Przeciążenie jest przykładem polimorfizmu czasu kompilatora, a przesłonięcie jest przykładem polimorfizmu czasu wykonywania.
Powiązane artykuły
- Różne sposoby przeciążania metod w Javie
- Przeciążenie metody i błąd zerowy w Javie
- Czy możemy przeciążać lub zastępować metody statyczne w Javie?