Polymorfisme eenvoudig uitgelegd!

De vier basis concepten van OOP (Object Oriented Programming) zijn Inheritance, Abstraction, Polymorphism en Encapsulation. Voor iemand die nieuw is in OOP kan het in het begin een beetje moeilijk zijn om de laatste 3 van de basis concepten van OOP te begrijpen (omdat Inheritance een beetje gemakkelijk te begrijpen is).

Polymorfisme is het vermogen van een object om vele vormen aan te nemen.

Elk Java object dat meer dan één IS-A test kan doorstaan wordt beschouwd als een polymorf- leerpunt. Dit betekent dat elk object van een child class elke vorm kan aannemen van een class in zijn parent hierarchy en natuurlijk ook van zichzelf. Wat dit in feite betekent is dat het kind klasse object kan worden toegewezen aan elke klasse verwijzing in zijn ouder hiërarchie en natuurlijk zichzelf ook.

Eg: Laten we zeggen Student klasse is een kind van de klasse Persoon

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

Het meest voorkomende gebruik van polymorfisme in OOP doet zich voor wanneer een ouder klasse verwijzing wordt gebruikt om te verwijzen naar een kind klasse object. Eigenlijk is hier sprake van Dynamisch Polymorfisme (dat ik hierna zal beschrijven).

Er zijn 2 soorten polymorfisme die vaak worden genoemd.

1. Dynamisch polymorfisme
2. Statisch polymorfisme

Dynamisch polymorfisme

Dit wordt ook wel Run-Time polymorfisme, Dynamische binding, Run-Time binding, Late binding en Methode overriding genoemd. Hier zijn vele vormen in verschillende klassen.

Dit is wat algemeen bekend staat als het zogenaamde “polymorfisme”. Laat het me heel eenvoudig uitleggen –

Laten we aannemen dat er in klassen in een klasse-hiërarchie (ouder-kind relaties) methoden zijn met dezelfde methodesignatuur, deze methoden zijn in verschillende vormen (dit staat bekend als method overriding).

Wanneer een object wordt toegewezen aan een klasse-referentie en wanneer een methode van het object wordt aangeroepen, wordt de methode in de klasse van het object uitgevoerd. Niet de methode van de referentieklasse (als de referentie een bovenliggende klasse is).

Wat hier gebeurt is dat, omdat het maken van het object op run-time gebeurt, de vorm van de methode die moet worden uitgevoerd (de methode in het object) pas op run-time kan worden bepaald.

Eg: 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
}
}

Statisch polymorfisme

Dit wordt ook wel Compile-Time polymorfisme, Static binding, Compile-Time binding, Early binding en Method overloading. Hier is het hebben van vele vormen gebeurt in dezelfde klasse.

Als ik dit EENVOUDIG uitleg..

Dit is eigenlijk methode overloading. Methode-overloading is het hebben van meer dan één methode met dezelfde methode-naam, maar met verschillende argumenten (het terugkeertype kan al dan niet hetzelfde zijn). Hier kiest de compiler bij het aanroepen van de methoden welke methode moet worden aangeroepen, afhankelijk van de parameters die bij het aanroepen worden doorgegeven. Dit gebeurt tijdens compile-time.

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
}
}

Sommigen zeggen dat method overloading niet echt polymorfisme is. Maar ik denk dat het gecategoriseerd kan worden als een soort polymorfisme, omdat in method overloading er een methode is in vele vormen.

Hoop dat dit geholpen heeft in het eenvoudig begrijpen van polymorfisme.

Cheeers! 😀

Hier zijn enkele nuttige links

• Method overriding
• Method overloading
• Typen polymorfisme
• Verschil tussen Runtime Polymorfisme en Compileer-tijd Polymorfisme