what is polymorphism java tutorial with examples
In diesem Tutorial wird anhand von Beispielen erläutert, was Polymorphismus in Java ist, welche Arten von Polymorphismus es gibt und wie Polymorphismus zur Kompilierungszeit implementiert wird:
Das Wort 'Polymorphismus' leitet sich von zwei Wörtern ab, d.h. 'Poly' was bedeutet viele und “ verwandelt sich Bedeutet Formen. Polymorphismus bedeutet also viele Formen. In einer Programmiersprache können wir sagen, dass ein Objekt viele Formen annehmen kann und daher das Objekt polymorph ist.
Polymorphismus ist eines der wichtigsten Merkmale von OOP und ermöglicht es uns, ein Merkmal (ein Objekt oder eine Nachricht oder Methode oder einen Operator) in verschiedenen Formen auszudrücken.
=> Schauen Sie sich hier den Java Beginners Guide an.
Was du lernen wirst:
Einführung in den Polymorphismus in Java
Die polymorphe Entität verhält sich unter verschiedenen Szenarien unterschiedlich.
Beispielsweise, Betrachten Sie einen '+' (Additions-) Operator in Java. Dies ist ein binärer Operator und benötigt zwei Operanden. Wenn die Operanden, die an den Operator '+' übergeben werden, Zahlen sind, wird eine Additionsoperation ausgeführt, die die Summe von zwei Zahlen zurückgibt.
Wenn Operanden in den String-Typ geändert werden, fügt der Operator '+' die String-Objekte nicht hinzu, sondern verkettet oder verbindet den Inhalt des Strings, um einen resultierenden dritten String zu bilden.
Beispielsweise, wenn ' einer ' und ' zwei ”Sind dann der Inhalt von zwei String-Objekten 'Eins' + 'zwei' wird darin enden, dass ' eins zwei ”. Dies ist eine Verkettung.
In Java sind alle Objekte polymorph, da sie alle von der Klasse 'Object' abgeleitet sind und somit die Beziehung 'IS-A' zur Object-Klasse erfüllen.
Auf ein Objekt wird immer über eine Referenzvariable dieses bestimmten Klassentyps zugegriffen. Sobald eine Referenzvariable eines bestimmten Typs deklariert ist, kann sie nicht mehr geändert werden. Wenn die Referenzvariable jedoch nicht als 'Final' deklariert ist, können wir sie neu zuweisen, um auf andere Objekte zu verweisen.
Der Typ dieser Objektreferenz bestimmt die Klassenmethoden oder -funktionen, die aufgerufen werden sollen.
Beispielsweise,Wenn es eine ABC-Klasse und eine von ABC abgeleitete Klasse XYZ gibt, haben beide Klassen eine polymorphe Methode func ().
class ABC{ void func(){} } class XYZ extends ABC{ void func() {} }
Erstellen wir eine Referenz vom Typ ABC.
obj = new XYZ ();
Wenn wir nun die Methode func () aufrufen, wird die Methode func () aus der Klasse XYZ aufgerufen, da das Objekt, auf das obj zeigt, der Klasse XYZ angehört.
Wie wir im obigen Beispiel gesehen haben, hat die Methode func () unterschiedliche Implementierungen, aber denselben Prototyp. Abhängig von dem Objekt, auf das das Referenzobjekt zeigt, wird die entsprechende Implementierung in diesem Szenario aufgerufen. Das ist Polymorphismus.
Lassen Sie uns den Polymorphismus in Java im Detail diskutieren.
Java Polymorphism Beispiel
Lassen Sie uns ein einfaches Beispiel für Polymorphismus in Java mit der zuvor beschriebenen Additionsoperation verstehen.
Hier verwenden wir zwei Methoden mit demselben Namen, aber unterschiedlichen Parametern. Die erste Funktion akzeptiert zwei ganzzahlige Parameter und die zweite Methode akzeptiert zwei Zeichenfolgenparameter.
Abhängig von der Art der übergebenen Parameter wird die entsprechende Methode aufgerufen und fügt entweder zwei Ganzzahlen hinzu und druckt das Ergebnis oder verkettet die beiden Zeichenfolgen und druckt die resultierende Zeichenfolge.
Das Java-Programm ist unten angegeben:
class Addition_operation{ //method to add two integers void addition_func(int num1,int num2){ System.out.println('ABC::addition_func:' + (num1+num2)); } //overloaded method to add two strings void addition_func(String str1, String str2){ String result = str1 + ' ' + str2; System.out.println('XYZ::addition_func:' + result); } } public class Main { public static void main(String[] args) { Addition_operation abc = new Addition_operation(); //create a class object abc.addition_func (3,4); //calls 1st method abc.addition_func ('Hello' , 'World!'); //calls 2nd method } }
Ausgabe:
Hier haben wir gesehen, dass, wenn wir zum ersten Mal zwei ganzzahlige Parameter an die Addition_Func übergeben, die erste Methode aufgerufen wird. Im zweiten Funktionsaufruf übergeben wir zwei Parameter vom Typ String, und daher wird die zweite überladene Methode aufgerufen.
Arten von Polymorphismus
Java unterstützt zwei Arten von Polymorphismus:
- Polymorphismus zur Kompilierungszeit
- Laufzeitpolymorphismus
Wie der Name schon sagt, wird der Polymorphismus zur Kompilierungszeit zur Kompilierungszeit und der Laufzeitpolymorphismus zur Laufzeit durchgeführt.
Wie in der obigen Abbildung gezeigt, wird der Polymorphismus zur Kompilierungszeit durch Überladen implementiert. Wir können entweder die Methode oder den Operator überladen. Laufzeitpolymorphismus wird durch Überschreiben erreicht.
In diesem Tutorial werden wir den Polymorphismus zur Kompilierungszeit im Detail diskutieren. Wir werden den Laufzeitpolymorphismus im nächsten Tutorial aufgreifen.
Polymorphismus zur Kompilierungszeit in Java
Der Polymorphismus zur Kompilierungszeit wird auch als 'statischer Polymorphismus' bezeichnet. Als Teil des Polymorphismus zur Kompilierungszeit wird jeder Polymorphismus, der ausgeführt werden soll, zur Kompilierungszeit ausgeführt.
In Java wird der Polymorphismus zur Kompilierungszeit mit „ Methodenüberladung ”. Mit der Methodenüberladung können wir eine oder mehrere Methoden mit demselben Namen haben und nur nach Zahlen, Typ oder Reihenfolge der Parameter unterscheiden.
Das Überladen von Methoden ist die häufigste Implementierung des Polymorphismus zur Kompilierungszeit in Java. Java unterstützt auch das Überladen von Operatoren.
Was ist Überladen in Java im Allgemeinen?
Wie öffne ich eine MKV-Datei unter Windows?
Beim Überladen in Java werden mehr als eine Methode mit demselben Namen und Rückgabetyp verwendet, die sich jedoch in der Reihenfolge, Anzahl und Art der Argumente unterscheiden. Es wird im Allgemeinen auch als Methodenüberladung bezeichnet.
Methodenüberladung in Java
Das Überladen von Methoden ist eine Implementierung des Polymorphismus zur Kompilierungszeit in Java. Wenn wir eine oder mehrere Methoden mit demselben Namen und / oder Rückgabetypen, aber unterschiedlichen Parameterlisten haben, sagen wir, dass wir die Methoden „überladen“ haben.
In einer bestimmten Klasse können wir also verschiedene Methoden mit demselben Namen, aber unterschiedlichen Argumentlisten haben.
Wie rufen wir überladene Methoden auf? Oder woher weiß der Compiler, welche Methode aufgerufen werden soll?
Der Aufruf der genauen Methode, die dem Aufruf entspricht, erfolgt abhängig von der Parameterliste.
Wir haben bereits gesehen, dass eine Klasse in Java mehr als einen Konstruktor haben kann. Bei Konstruktoren unterscheiden sich die Argumentliste oder die vom Konstruktor akzeptierten Argumente in allen Konstruktoren. Dies ist ein Beispiel für Überlastung. Das Überladen von Konstruktoren ist also eine Grundform des Überladens von Methoden in Java.
Nun wollen wir sehen, wie eine Methode in Java überladen wird.
Java bietet drei Möglichkeiten zum Überladen von Methoden, abhängig von den Variationen in der Parameter- / Argumentliste.
# 1) Art der Parameter
Wir können Methoden in Java abhängig vom Datentyp der Parameter überladen.
Betrachten Sie das folgende Beispiel, in dem wir Prototypen von drei Methoden angegeben haben.
Addition (int, int);
Addition (int, float);
Addition (String, String);
Wie von oben gesehen, haben wir in allen drei Fällen den gleichen Methodennamen und die gleiche Anzahl von Parametern, aber jeder Methodenaufruf hat unterschiedliche Parametertypen.
Solange Methoden unterschiedliche Arten von Parametern haben, können wir sagen, dass die Methoden überladen sind. Wenn wir die Methode aufrufen, entscheidet der Compiler über den Datentyp des Parameters, und abhängig vom Datentyp der mit dem Methodenaufruf bereitgestellten Parameterliste wird die entsprechende Methode aufgerufen.
Beispielsweise,Wenn wir einen Methodenaufruf wie unten haben:
Addition (3, 3,5);
Im obigen Methodenaufruf können wir sehen, dass der erste Parameter vom Typ int ist, während der zweite Parameter vom Typ float ist. Wenn der obige Aufruf auftritt, löst der Compiler die Parameterliste auf und ruft dann die entsprechende Methode auf, die die zweite Methode oben ist.
Implementieren wir nun ein vollständiges Java-Programm, um die Methodenüberladung basierend auf den Datentypen der Parameter zu demonstrieren.
class MethodOverload { //overloaded method - char parameter public void printParam(char ch) { System.out.println('Input character:' + ch); } //overloaded method - int parameter public void printParam(int num) { System.out.println('Input Number:' + num); } } class Main { public static void main(String args[]) { MethodOverload obj = new MethodOverload(); obj.printParam('A'); //call overloaded method (char ) obj.printParam(10); //call overloaded method (int ) } }
Ausgabe:
# 2) Anzahl der Parameter
Eine andere Implementierung der Methodenüberladung besteht darin, Methoden mit einer anderen Anzahl von Parametern im Funktionsaufruf zu überladen.
Beispielsweise,Betrachten wir die folgenden Methodendeklarationen:
addnum (int, int);
addnum (int, int, int);
In den obigen Methodendeklarationen hat die erste Methodendeklaration zwei Parameter und die zweite Deklaration drei Parameter. Wenn eine Funktion aufgerufen wird, überprüft der Compiler die Anzahl der Parameter und löst den Methodenaufruf entsprechend auf.
Das folgende Beispiel zeigt das Programm, das eine Methodenüberladung basierend auf der Anzahl der Parameter verwendet.
class MethodOverload { //overloaded method - 1 parameter public void printParam(char ch) { System.out.println(ch); } //overloaded method - 2 parameters public void printParam(char ch, int num) { System.out.println('Character: ' + ch + ' ; '+ 'Number:' +num); } } class Main { public static void main(String args[]) { MethodOverload obj = new MethodOverload(); obj.printParam('A'); //call overloaded method (1 ) obj.printParam('A',10); //call overloaded method (2 ) } }
Ausgabe:
In diesem Beispiel sind zwei Methoden basierend auf der Anzahl der Parameter überladen. Die erste Methode verwendet einen Parameter und die zweite Methode zwei Parameter. In der Hauptmethode rufen wir beide Methoden nacheinander auf und der Compiler löst den Funktionsaufruf in Abhängigkeit von der Anzahl der angegebenen Parameter auf.
# 3) Reihenfolge der Parameter
Der dritte Ansatz zur Implementierung der Methodenüberladung basiert auf der Reihenfolge der Parameter in überladenen Methoden.
Betrachten Sie das folgende Beispiel der Methodendeklaration:
Summe (int, float);
sum (float, int);
Hier haben wir eine überladene Methodensumme. In der ersten Deklaration sind die Parameter int und float. Auch in der zweiten Deklaration sind die Parameter int und float, aber ihre Reihenfolge in der Parameterliste wird geändert.
Jetzt erscheint zuerst der Parameter float, während der Parameter int an zweiter Stelle steht. Wir können eine Methodenüberladung erreichen, indem wir die Parameterreihenfolge ändern.
Das Das folgende Java-Programm demonstriert dies.
intelligente Identifikation in QTP mit Beispiel
class MethodOverload { //overloaded method - char,int parameter public void printParam(char ch, int num) { System.out.println('Input character:' + ch + ' ; ' + 'Input Number:' + num); } //overloaded method - int,char parameter public void printParam(int num, char ch) { System.out.println('Input Number:' + num + ' ; ' + 'Input Character:' + ch); } } class Main { public static void main(String args[]) { MethodOverload obj = new MethodOverload(); obj.printParam('A', 100); //call overloaded method (char,int) obj.printParam(100, 'A'); //call overloaded method (int,char) } }
Ausgabe:
Im obigen Programm haben wir eine überladene printParam-Methode mit int- und char-Parametern, deren Reihenfolge in zwei Methodendeklarationen geändert wird.
Ungültige Fälle von Methodenüberladung
Bisher haben wir das Überladen von Methoden mithilfe der Parameterliste erörtert. Wir haben den Rückgabetyp der Methode noch nicht berücksichtigt. Beachten Sie, dass wir Methoden, die auf Rückgabetypen basieren, nicht überladen.
Wenn beispielsweise zwei Methoden denselben Namen und dieselben Parameterlisten, aber unterschiedliche Rückgabetypen haben, sagen wir nicht, dass diese beiden Methoden überladen sind. Dieser Fall wird wegen Überlastung ungültig.
Wenn wir also die folgenden Erklärungen haben:
I int (int, int);
Stringsumme (int, int);
In diesem Fall gibt der Compiler einen Fehler aus, da zwei Methoden nicht überladen sind. Daher werden die Methoden nicht nur anhand der Rückgabetypen unterschieden.
Lassen Sie uns diesen ungültigen Fall mit einem Java-Programm demonstrieren.
class OverloadDemo { public double myMethod(int num1, int num2) { System.out.println('OverloadDemo::myMethod returns double'); return num1+num2; } public int myMethod(int var1, int var2) { System.out.println('OverloadDemo::myMethod returns int'); return var1-var2; } } class Main { public static void main(String args[]) { OverloadDemo obj2= new OverloadDemo(); obj2.myMethod(10,10); obj2.myMethod(20,12); } }
Im obigen Programm hat die Methode myMethod zwei Prototypen. Ein Prototyp akzeptiert zwei int-Parameter und gibt double zurück. Der zweite Methodenprototyp verwendet zwei int-Parameter und gibt ein int zurück.
Wenn wir dieses Programm kompilieren, erhalten wir die folgende Ausgabe.
Ausgabe:
Der obige Kompilierungsfehler zeigt an, dass die Methode zweimal deklariert wurde. Dies bedeutet, dass der Compiler diese Methoden nicht nur aufgrund des Rückgabetyps als überladen betrachtet.
Überlastung des Bedieners
Das Überladen von Operatoren ist ein Überladungsmechanismus, bei dem einem vorhandenen Operator eine andere Bedeutung gegeben wird.
Wie wir im Einführungsabschnitt dieses Tutorials besprochen haben, ist ein Additionsoperator '+' ein klassisches Beispiel für das Überladen von Operatoren.
Wenn die Operanden dieses Operators numerisch sind, gibt der Operator + die Summe von zwei Werten zurück. Wenn die Operanden jedoch vom Typ String sind, ist das Ergebnis der Additionsoperation die verkettete Zeichenfolge. Beachten Sie, dass wir in Java nur den Operator + (Addition) überladen können.
Dieser Operator führt zwei Funktionen aus:
- Ganzzahlen oder numerische Werte hinzufügen.
- Verketten von Zeichenfolgen
Daher ist die Unterstützung für das Überladen von Operatoren in Java im Gegensatz zu C ++ begrenzt, wo wir fast alle Operatoren überladen können, mit Ausnahme einiger weniger wie sizeof, dot operator usw.
Das folgende Programm demonstriert das Überladen von Operatoren in Java.
class OperatorOverload { //overloaded method for concatenating two strings void operator(String str1, String str2) { String resultStr = str1 + str2; System.out.println('Concatenated String: ' + resultStr); } //overloaded method for adding two numbers void operator(int num1, int num2) { int result = num1 + num2; System.out.println('Sum of two numbers : ' + result); } } class Main { public static void main(String[] args) { OperatorOverload obj = new OperatorOverload(); obj.operator(10, 15); //add two numbers obj.operator('Hello ', 'World!!'); //concatenate two strings } }
Ausgabe:
Im obigen Programm haben wir den Operator '+' überladen. Wenn wir zwei ganzzahlige Werte an die überladene Methode übergeben, wird eine Summe von zwei Ganzzahlen zurückgegeben, und wenn zwei Zeichenfolgen übergeben werden, ist das Ergebnis die verkettete Zeichenfolge.
Bestimmte Punkte, die in Bezug auf Überladung und Polymorphismus zur Kompilierungszeit zu beachten sind.
- Das Überladen von Methoden ist der Weg, um einen Polymorphismus zur Kompilierungszeit zu implementieren, der auch als statischer Polymorphismus bezeichnet wird.
- Statischer Polymorphismus wird auch als frühe Bindung oder Bindung zur Kompilierungszeit bezeichnet.
- Da die Bindung von Parametern und Funktionsaufrufen zur Kompilierungszeit erfolgt, wird Überladung als Bindung zur Kompilierungszeit bezeichnet.
- Wir können den Operator '+' in Java nur überladen und er fügt zwei ganze Zahlen hinzu oder verkettet zwei Zeichenfolgen.
Häufig gestellte Fragen
F # 1) Warum brauchen wir Polymorphismus in Java?
Antworten: Polymorphismus ermöglicht es uns, viele Implementierungen für ein Objekt zu haben. Durch das Überladen von Methoden müssen wir nicht zu viele Methoden mit unterschiedlichen Namen haben, die schwer zu merken sind. Wir können stattdessen überladene Methoden haben, damit wir eine klare Implementierung der Methoden haben, die ähnliche Funktionen ausführen.
Das Überschreiben hilft auch bei der ordnungsgemäßen Implementierung der Vererbung, wodurch wir den vorhandenen Klassen auf einfachere Weise mehr Funktionen hinzufügen können.
F # 2) Was ist Polymorphismus OOP?
Antworten: Die objektorientierte Programmierdefinition des Polymorphismus bezieht sich auf die Fähigkeit der Programmiersprachen, ein Objekt in verschiedenen Formen zu implementieren. Polymorphismus ist auch definiert als die Fähigkeit eines Programms, die Methoden von der übergeordneten Klasse in die abgeleitete Klasse zu überschreiben, um zusätzliche Funktionen zu erhalten.
F # 3) Können wir die Hauptmethode überladen und überschreiben?
Antworten: Nein, wir können die statische Hauptmethode nicht überschreiben. Obwohl wir die Hauptmethode überladen können, wird JVM die überladene Hauptmethode niemals aufrufen. Die beste Antwort ist also, die Hauptmethode nicht zu überladen oder zu überschreiben.
F # 4) Können Konstruktoren überlastet werden?
Antworten: Ja, wir können die Konstruktoren in Java genauso überladen wie die Java-Methoden. Konstruktoren haben normalerweise den gleichen Namen, aber eine andere Anzahl von Argumenten.
F # 5) Warum ist das Überladen von Methoden nützlich?
Antworten: Wir können sauberen Code mithilfe von Methodenüberladung schreiben und er wird auch lesbar, da wir Methoden mit demselben Namen haben. Wenn wir also Funktionen für verschiedene Datentypen implementieren, können wir die Methoden überladen und es wird einfacher sein, den Code zu trennen.
Fazit
Polymorphismus in Java bedeutet, dass ein Objekt viele Formen haben kann. Polymorphismus in Java hat zwei Arten, d. H. Polymorphismus zur Kompilierungszeit und Laufzeitpolymorphismus. Der Polymorphismus zur Kompilierungszeit wird zur Kompilierungszeit durchgeführt. Der Polymorphismus zur Kompilierungszeit ist statisch und wird durch Methodenüberladung und Operatorüberladung implementiert.
Der Laufzeitpolymorphismus wird zur Laufzeit ausgeführt und ist dynamisch. Es wird mithilfe der Methodenüberschreibung implementiert.
In diesem Tutorial haben wir gesehen, wie Methodenüberladung implementiert werden kann. Wir haben auch die Überlastung des Bedieners ausführlich erörtert. Java unterstützt nur das Überladen des Operators '+'.
=> Lesen Sie die Easy Java Training Series durch.
Literatur-Empfehlungen
- Java String enthält () Method Tutorial mit Beispielen
- Java String length () -Methode mit Beispielen
- Java substring () -Methode - Tutorial mit Beispielen
- Java Float Tutorial mit Programmierbeispielen
- JAVA-Tutorial für Anfänger: Über 100 praktische Java-Video-Tutorials
- TreeMap in Java - Tutorial mit Java TreeMap-Beispielen
- Java String Tutorial | Java-String-Methoden mit Beispielen
- Java Double - Tutorial mit Programmierbeispielen