Polymorfisme (Polymorphism)

Polymorfisme betekent veelvormigheid. In object georiënteerd denken wordt hier gelijkvormigheid van uiterlijk bedoeld, maar een verschil in implementatie. Vertaald naar OOP kun je hierdoor objecten gebruiken zonder iets te weten over de daadwerkelijke implementatie.

Over inheritance heb je geleerd dat een object Hond en een object Kat een “implementatie” zijn van een object Huisdier. Ze zijn specifieker dan de generieke superclass Huisdier en overschrijven mogelijk zelfs methodes.

Als we kijken naar het uiterlijk van een object Hond en een object Kat, zijn ze door het gebruik van Huisdier “gelijkvormig van uiterlijk”. Huisdier heeft bijvoorbeeld een methode maakGeluid(), dus Hond en Kat hebben die ook. Alleen maakt een Hond een ander geluid (“Woef”) dan een Kat (“Miauw”).

Polymorfisme is een eigenschap van OOP die je eigenlijk niet altijd bewust toepast, het is er gewoon. Soms is het belangrijker een object te gebruiken, dan precies te weten welke implementatie het is. Verder zul je zien dat door deze eigenschap het uitbreiden van code makkelijker wordt.

Voorbeelden van Polymorfisme in TypeScript en Python:

TypescriptPython

/**
 * Musician super-class (or parent-class)
 */
class Musician {
    public play() {
        console.log("Play instrument");
    }
}
/**
 * Guitarist sub-class (or child-class)
 */
class Guitarist extends Musician {
    // The Guitarist class extends the Musician class.
    // The play method has a different outcome and/or behavior.
    public play() {
        console.log("Play guitar");
        this.activateDistortion();
    }
    private activateDistortion() {
        console.log("Put foot on distortion pedal");
    }
}
/**
 * Drummer sub-class (or child-class)
 */
class Drummer extends Musician {
    public play() {
        // The Drummer class extends the Musician class.
        // The play method has a different outcome and/or behavior.
        this.hitCymbal();
        console.log("Play drums");
    }
    private hitCymbal() {
        console.log("Cymbal sound");
    }
}

const musician: Musician = new Musician();
musician.play(); // Logs "Play instrument"

const guitarist: Guitarist = new Guitarist();
guitarist.play(); // Logs "Play guitar" and "Put foot on distortion pedal"

const drummer: Drummer = new Drummer();
drummer.play(); // Logs "Cymbal sound" and "Play drums"

# super-class (or parent-class)
class Musician:
def __init__(self, artistName):
    self.artistName = artistName

def play(self):
    print(self.artistName + " starts playing a instrument" )


# sub-class (or child-class)
class Guitarist(Musician):
def __init__(self, artistName):
    # pass the artistName variable to the super-class via the 'super' function
    super().__init__(artistName)

def play(self):
    # Guitarist play method has a different outcome and/or behavior.
    print(self.artistName + " starts playing a guitar")
    self.activateDistortion()

def activateDistortion(self):
    print("Put foot on distortion pedal")

# sub-class (or child-class)
class Drummer(Musician):
def __init__(self, artistName):
    # pass the artistName variable to the super-class via the 'super' function
    super().__init__(artistName)

def play(self):
    # Drummer play method has a different outcome and/or behavior.
    self.hitCymbal()
    print(self.artistName + " starts playing the drums")


def hitCymbal(self):
    print("Cymbal sound")

musician = Musician("Ray Manzarek")
musician.play()

guitarist = Guitarist("John Mayer")
guitarist.play()

drummer = Drummer("Animal")
drummer.play()