In Java ermöglicht das Überladen von Methoden, dass verschiedene Methoden denselben Namen, aber unterschiedliche Signaturen haben, wobei sich die Signatur durch die Anzahl der Eingabeparameter oder den Typ der Eingabeparameter oder eine Mischung aus beidem unterscheiden kann.
Methodenüberladung wird in Java auch als Methodenüberladung bezeichnet Polymorphismus zur Kompilierungszeit , Statischer Polymorphismus oder Frühe Bindung . Bei der Methodenüberladung im Vergleich zum übergeordneten Argument erhält das untergeordnete Argument die höchste Priorität.
Beispiel für Methodenüberladung
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-Swing-Tutorial
>Ausgabe
30 60 31.0>
Verschiedene Arten der Methodenüberladung in Java
- Ändern der Anzahl der Parameter.
- Datentypen der Argumente ändern.
- Ändern der Reihenfolge der Parameter von Methoden
1. Ändern der Anzahl der Parameter
Eine Methodenüberladung kann erreicht werden, indem die Anzahl der Parameter bei der Übergabe an verschiedene Methoden geändert wird.
Nachfolgend finden Sie die Implementierung der oben genannten 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);> >}> }> |
>
>Ausgabe
Product of the two integer value :2 Product of the three integer value :6>
2. Datentypen der Argumente ändern
In vielen Fällen können Methoden als überladen betrachtet werden, wenn sie denselben Namen, aber unterschiedliche Parametertypen haben. Methoden gelten als überladen.
Nachfolgend finden Sie die Implementierung der oben genannten 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);> >}> }> |
>
>Ausgabe
Product of the three integer value :6 Product of the three double value :6.0>
3. Ändern der Reihenfolge der Parameter von Methoden
Eine Methodenüberladung kann auch durch Neuanordnen der Parameter von zwei oder mehr überladenen Methoden implementiert werden. Wenn beispielsweise die Parameter von Methode 1 (String-Name, int roll_no) und die der anderen Methode (int roll_no, String-Name) lauten, beide jedoch denselben Namen haben, gelten diese beiden Methoden als mit unterschiedlichen Parametersequenzen überladen .
Nachfolgend finden Sie die Implementierung der oben genannten 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'>);> >}> }> |
>
>Ausgabe
Name :Spyd3r Roll-No :1 Roll-No :2 Name :Kamlesh>
Was passiert, wenn der genaue Prototyp nicht mit den Argumenten übereinstimmt?
In Bezug auf die Priorität führt der Compiler die folgenden Schritte aus:
- Typkonvertierung, jedoch zu einem höheren Typ (in Bezug auf den Bereich) in derselben Familie.
- Typkonvertierung in die nächsthöhere Familie (angenommen, wenn für einen int-Datentyp kein langer Datentyp verfügbar ist, wird nach dem float-Datentyp gesucht).
Nehmen wir ein Beispiel, um das Konzept zu verdeutlichen:
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>);> >}> }> |
>
>
Ausgabe
./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>
Vorteile der Methodenüberladung
- Das Überladen von Methoden verbessert die Lesbarkeit und Wiederverwendbarkeit des Programms.
- Durch Methodenüberladung wird die Komplexität des Programms verringert.
- Mithilfe der Methodenüberladung können Programmierer eine Aufgabe effizient und effektiv ausführen.
- Mithilfe der Methodenüberladung ist es möglich, auf Methoden zuzugreifen, die verwandte Funktionen mit leicht unterschiedlichen Argumenten und Typen ausführen.
- Objekte einer Klasse können mit den Konstruktoren auch auf unterschiedliche Weise initialisiert werden.
Wichtige Fragen in Java
Q1. Können wir statische Methoden überladen?
Antwort:
Die Antwort ist ' Ja '. Wir können zwei oder mehr statische Methoden mit demselben Namen, aber unterschiedlichen Eingabeparametern haben. Betrachten Sie beispielsweise das folgende Java-Programm. Weitere Informationen hierzu finden Sie im Artikel – Können wir statische Methoden in Java überladen oder überschreiben?
Q2. Können wir Methoden überladen, die sich nur durch statische Schlüsselwörter unterscheiden?
Antwort:
Wir kann nicht Überladen Sie zwei Methoden in Java, wenn sie sich nur durch das statische Schlüsselwort unterscheiden (die Anzahl der Parameter und Parametertypen sind gleich). Sehen Sie sich zum Beispiel das folgende Java-Programm an. Weitere Informationen finden Sie hier.
Q3. Können wir main() in Java überladen?
Antwort:
Wie andere statische Methoden auch wir dürfen main() in Java überladen.
Java
10 Millionen
// 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);>>}>}>>>AusgabeHi Geek (from main) Hi, Geek Hi, Dear Geek, My Geek>
Q4. Unterstützt Java das Überladen von Operatoren?
Antwort:
Im Gegensatz zu C++ erlaubt Java keine benutzerdefinierten überladenen Operatoren. Intern überlädt Java Operatoren, zum Beispiel wird + für die Verkettung überladen.
F5. Können wir Methoden für den Rückgabetyp überladen?
Antwort:
Wir können keine Überladung nach Rückgabetyp durchführen. Dieses Verhalten ist in C++ dasselbe. Weitere Informationen finden Sie hier.
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[]) {}>}>>>Fehler
./Main.java:8: error: method foo() is already defined in class Main public char foo() { return 'a'; } ^ 1 error>Das Überladen von Methoden für den Rückgabetyp ist jedoch in Fällen möglich, in denen der Datentyp der aufgerufenen Funktion explizit angegeben wird. Schauen Sie sich die folgenden Beispiele an:
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>));>>}>}>>>Ausgabe10 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>));>>}>}>>>Ausgabe10 a>
F6. Was ist der Unterschied zwischen Überladen und Überschreiben?
Antwort:
Beim Überladen geht es um dieselbe Funktion mit unterschiedlichen Signaturen. Überschreiben handelt von der gleichen Funktion und der gleichen Signatur, aber unterschiedlichen Klassen, die durch Vererbung verbunden sind.
Überladen ist ein Beispiel für Compilerzeitpolymorphismus und Überschreiben ist ein Beispiel für Laufzeitpolymorphismus.
In Verbindung stehende Artikel
- Verschiedene Arten der Methodenüberladung in Java
- Methodenüberladung und Nullfehler in Java
- Können wir statische Methoden in Java überladen oder überschreiben?