Java Polymorfisme

Verken Java polymorfisme door duidelijke uitleg en praktische codevoorbeelden, en begrijp hoe het codeflexibiliteit en herbruikbaarheid verbetert.

Polymorfisme – een essentiële pijler van objectgeoriënteerd programmeren – betekent dat een enkele entiteit meerdere vormen kan aannemen.

Dat wil zeggen, dezelfde entiteit (methode, operator of object) kan verschillende operaties uitvoeren afhankelijk van de context.

Voorbeeld: Java Polymorfisme

class Polygon { // methode om een vorm te renderen public void render() { System.out.println("Polygon renderen..."); } } class Vierkant extends Polygon { // rendert Vierkant public void render() { System.out.println("Vierkant renderen..."); } } class Cirkel extends Polygon { // rendert cirkel public void render() { System.out.println("Cirkel renderen..."); } } class Main { public static void main(String[] args) { // creeer een object van Vierkant Vierkant v1 = new Vierkant(); v1.render(); // creeer een object van Cirkel Cirkel c1 = new Cirkel(); c1.render(); } }

Uitvoer

Vierkant renderen... Cirkel renderen...

In het bovenstaande voorbeeld maken we een superklasse: Polygon en twee subklassen: Vierkant en Cirkel. De render() methode wordt geërfd door beide subklassen, maar elk overrided het om vorm-specifieke renderlogica te bieden.

De kern is dat render() zich anders gedraagt afhankelijk van het daadwerkelijke objecttype, wat de essentie is van polymorfisme.

Waarom polymorfisme?

Polymorfisme stelt ontwikkelaars in staat schone, consistente code te schrijven. In plaats van aparte methoden te definiëren zoals renderVierkant() of renderCirkel(), past een enkele render() methode zich aan aan elke vorm, wat redundantie vermindert en onderhoudbaarheid verbetert.

Hoewel aparte methoden zouden werken, leiden ze snel tot code-duplicatie en een gefragmenteerde API. Polymorfisme verenigt gedrag onder een gemeenschappelijk contract, zodat elke nieuwe vorm geïntegreerd kan worden door simpelweg render() te overriden.

Let op: De print() methode demonstreert ook polymorfisme – het kan char, int, String, en meer uitvoeren zonder meerdere overloads te vereisen.

We kunnen polymorfisme in Java bereiken met de volgende technieken:

1. Methode Overriding
2. Methode Overladen
3. Operator Overladen

Java Methode Overriding

Wanneer een subklasse een methode definieert met dezelfde handtekening als een methode in zijn superklasse, overrided de subklasse-methode de superklasse-methode. Dit stelt dezelfde methodenaam in staat verschillende operaties uit te voeren gebaseerd op het runtime-type van het object.

Voorbeeld 1: Polymorfisme via methode overriding

class Taal { public void toonInfo() { System.out.println("Gemeengschap Engels Taal"); } } class Java extends Taal { @Override public void toonInfo() { System.out.println("Java Programmeertaal"); } } class Main { public static void main(String[] args) { // creeer een object van Java klasse Java j1 = new Java(); j1.toonInfo(); // creeer een object van Taal klasse Taal t1 = new Taal(); t1.toonInfo(); } }

Uitvoer:

Java Programmeertaal Gemeengschap Engels Taal

Hier fungeert Taal als basisklasse en Java als subklasse. De toonInfo() methode is gedefinieerd in beide klassen, maar elke implementatie levert context-geschikte informatie.

De methode die uitgevoerd wordt, wordt tijdens runtime bepaald, weshalb dit patroon runtime polymorfisme heet.

Let op: De methode die aangeroepen wordt, wordt bepaald tijdens de uitvoering van het programma. Dus method overriding is run-time polymorfisme.

2. Java Methode Overladen

Methode overladen stelt een klasse in staat meerdere methoden met dezelfde naam maar verschillende parameterlijsten te hebben. De compiler lost op welke methode aangeroepen moet worden gebaseerd op de meegeleverde argumenten.

void func() { ... } void func(int a) { ... } float func(double a) { ... } float func(int a, float b) { ... }

Deze techniek maakt het mogelijk dat dezelfde logische operatie gevarieerde inputs accepteert.

Voorbeeld 3: Polymorfisme via methode overladen

class Patroon { // methode zonder parameter public void toon() { for (int i = 0; i < 10; i++) { System.out.print("*"); } } // methode met enkele parameter public void toon(char symbool) { for (int i = 0; i < 10; i++) { System.out.print(symbool); } } } class Main { public static void main(String[] args) { Patroon d1 = new Patroon(); // roep methode zonder argument aan d1.toon(); System.out.println("\n"); // roep methode met een enkel argument aan d1.toon('#'); } }

Uitvoer:

********** ##########

In dit voorbeeld bevat de Patroon klasse twee overgeladen toon() methoden. De versie zonder parameters print tien asterisks, terwijl de ene die een char accepteert tien kopieën van het meegeleverde symbool print.

Omdat de compiler de methode tijdens compile-time selecteert, wordt deze vorm van polymorfisme vaak compile-time polymorfisme genoemd.

Let op: De methode die aangeroepen wordt, wordt bepaald door de compiler. Dus het is ook bekend als compile-time polymorfisme.

3. Java Operator Overladen

Java's operators kunnen verschillende gedragingen vertonen gebaseerd operand types. Bijvoorbeeld, de + operator voert numerieke optelling uit bij getallen en string-concatenatie bij strings.

• + kan getallen optellen of strings concateneren.
• Logische en bitwise operators zoals &, |, en ! gedragen zich ook anders afhankelijk van operand types.

Hieronder illustreren hoe + zich aanpast aan zijn operanden.

1. Met getallen:

int a = 5; int b = 6; // + met getallen int som = a + b; // Uitvoer = 11

2. Met strings:

String eerste = "Java "; String tweede = "Programmeren"; // + met strings String naam = eerste + tweede; // Uitvoer = Java Programmeren

Dus, + is in Java overgeladen om zowel optelling als concatenatie uit te voeren.

Let op: Hoewel talen zoals C++ user-defined operator overloading toestaan, beperkt Java operator overloading tot built-in operators alleen.

Polymorfische variabelen

Een variabele wordt polymorfisch genoemd wanneer het tijdens programma-uitvoering kan refereren naar objecten van verschillende typen. In Java maken object-referenties dit gedrag mogelijk, waardoor een referentie van een basistype kan wijzen naar instanties van subklassen.

Voorbeeld: Polymorfische variabelen

class ProgrammeerTaal { public void toon() { System.out.println("Ik ben een Programmeertaal."); } } class Java extends ProgrammeerTaal { @Override public void toon() { System.out.println("Ik ben een Objectgeoriënteerde Programmeertaal."); } } class Main { public static void main(String[] args) { // declareer een objectvariabele ProgrammeerTaal pt; // creeer object van ProgrammeerTaal pt = new ProgrammeerTaal(); pt.toon(); // creeer object van Java klasse pt = new Java(); pt.toon(); } }

Uitvoer:

Ik ben een Programmeertaal. Ik ben een Objectgeoriënteerde Programmeertaal.

In deze illustratie is de referentie pt gedeclareerd met het basistype ProgrammeerTaal maar toegewezen aan objecten van zowel de basisklasse als zijn subklasse. Dit demonstreert upcasting en runtime polymorfisme.