Polymorphismus einfach erklärt!

Die vier Grundkonzepte der OOP (Objektorientierte Programmierung) sind Vererbung, Abstraktion, Polymorphismus und Kapselung. Für jemanden, der neu in der OOP ist, kann es anfangs etwas schwierig sein, die letzten 3 der grundlegenden Konzepte der OOP zu verstehen (da Vererbung etwas einfacher zu verstehen ist).

Polymorphie ist die Fähigkeit eines Objekts, viele Formen anzunehmen.

Jedes Java-Objekt, das mehr als einen IS-A-Test bestehen kann, wird als polymorph betrachtet – Tutorialpunkt. Das bedeutet, dass jedes Objekt einer Kindklasse jede Form einer Klasse in seiner Elternhierarchie annehmen kann und natürlich auch sich selbst. Das bedeutet, dass das Objekt einer Kindklasse jede Klassenreferenz in seiner Elternhierarchie und natürlich auch sich selbst annehmen kann.

Z.B.: Nehmen wir an, die Klasse Student ist ein Kind der Klasse Person

Student student = new Student()
Person person = new Student()

Die häufigste Verwendung von Polymorphie in der OOP tritt auf, wenn eine Elternklassenreferenz verwendet wird, um auf ein Objekt einer Kindklasse zu verweisen. Genau genommen handelt es sich hier um dynamischen Polymorphismus (den ich als nächstes beschreiben werde).

Es gibt 2 Arten von Polymorphismus, die allgemein bekannt sind.

1. Dynamischer Polymorphismus
2. Statischer Polymorphismus

Dynamischer Polymorphismus

Dieser wird auch als Run-Time Polymorphismus, Dynamische Bindung, Run-Time Bindung, Late Bindung und Method Overriding bezeichnet. Hier gibt es viele Formen, die in verschiedenen Klassen vorkommen.

Das ist das, was gemeinhin als sogenannter „Polymorphismus“ bekannt ist. Lassen Sie es mich SEHR EINFACH erklären –

Angenommen, es gibt Methoden mit gleicher Methodensignatur in Klassen in einer Klassenhierarchie (Eltern-Kind-Beziehungen), diese Methoden haben unterschiedliche Formen (dies ist als Methodenüberschreibung bekannt).

Wenn dann ein Objekt einer Klassenreferenz zugewiesen wird und wenn eine Methode des Objekts aufgerufen wird, wird die Methode in der Klasse des Objekts ausgeführt. Nicht die Methode der Referenzklasse (wenn die Referenz eine Elternklasse ist).

Da die Objekterzeugung zur Laufzeit erfolgt, kann erst zur Laufzeit entschieden werden, welche Methode ausgeführt werden soll (die Methode im Objekt).

Beispiel: Java-Code

class Person { 
public void teach(){
System.out.println("Person can teach");
}
}
class Teacher extends Person {
public void teach() {
System.out.println("Teacher can teach in a school");
}
}
public class TestTeacher {
public static void main(String args) {
Person person = new Person(); //Person reference and object
Person another_person = new Teacher(); //Person reference, Teacher object
Teacher teacher = new Teacher(); //Teacher reference and obj. person.teach();//output: Person can teach // Here you can see Teacher object's method is executed even-
// -though the Person reference was used 
another_person.teach();//output: Teacher can teach in a school teacher.teach();//output: Teacher can teach in a school
}
}

Statischer Polymorphismus

Dieser wird auch als Compile-Time-Polymorphismus bezeichnet, Statische Bindung, Compile-Time-Bindung, Frühe Bindung und Methodenüberladung. Hier gibt es viele Formen in der gleichen Klasse.

Wenn ich das mal ganz einfach erkläre.

Das ist eigentlich Methodenüberladung. Methodenüberladung bedeutet, mehr als eine Methode mit demselben Methodennamen, aber mit unterschiedlichen Argumenten zu haben (der Rückgabetyp kann, muss aber nicht derselbe sein). Hier wählt der Compiler beim Aufruf der Methoden je nach den beim Aufruf übergebenen Parametern die aufzurufende Methode aus. Dies geschieht zur Compile-Zeit.

Eg: Java-Code

class Calculator {
void add(int a, int b) {
System.out.println(a+b);
}
void add(int a, int b, int c) {
System.out.println(a+b+c);
}
}public class Demo {
public static void main(String args) {
Calculator calculator = new Calculator(); // method with 2 parameters is called
calculator.add(10, 20); //output: 30 // method with 3 parameters is called
calculator.add(10, 20, 30); //output: 60
}
}

Einige Leute sagen, dass Methodenüberladung nicht wirklich Polymorphismus ist. Aber ich denke, es kann als eine Art von Polymorphismus kategorisiert werden, da es bei der Methodenüberladung eine Methode in vielen Formen gibt.

Hoffentlich hat das geholfen, Polymorphismus einfach zu verstehen.

Cheeers! 😀

Hier sind einige nützliche Links

• Methodenüberschreibung
• Methodenüberladung
• Arten von Polymorphismus
• Unterschied zwischen Laufzeit-Polymorphismus und Kompilierzeit-Polymorphismus