Polymorfisme in Java: methoden overbelasten of negeren

Overbelasting en overschrijven van methoden zijn de twee manieren waarop Java polymorfisme demonstreert. Polymorfisme komt van een combinatie van twee Griekse woorden: "poly" wat veel betekent en "morph" wat vorm betekent. Daarom maakt polymorfisme het mogelijk dat methoden vele vormen aannemen.

Volg deze handleiding om te leren hoe u methoden in Java kunt overbelasten of overschrijven.

Wat is methode-overbelasting?

"Methode overloading" verwijst naar het definiëren van verschillende methoden in een klasse met dezelfde naam. De methoden moeten verschillende handtekeningen hebben. Een methodehandtekening is de combinatie van de naam van een methode en de parameterlijst. Het bevat niet het retourtype.

De compiler weet welke methode hij moet gebruiken door het type, het aantal parameters en de volgorde waarin ze zijn geplaatst te controleren.

Verwant: Overerving onderzoeken in de programmeertaal Java

Overbelasting van de methode toont polymorfisme tijdens compileren aan. Compile-time polymorfisme betekent dat de Java-compiler tijdens runtime een object aan zijn functionaliteit bindt. De compiler controleert methodehandtekeningen om dit te bereiken.

Dit type polymorfisme staat ook bekend als statische of vroege binding.

Zie het voorbeeld van overbelasting van de methode hieronder:

klas rekenen{
int kubus (int x){
retourneer x*x*x;
}
dubbele kubus (dubbele x){
retourneer x*x*x;
}
zwevende kubus (zweven x){
retourneer x*x*x;
}
public static void main (String[] args){
Rekenen myMultiplication = nieuwe Rekenen();
System.out.println("De kubus van 5 is " + myMultiplication.cube (5));
System.out.println("De kubus van 5.0 is " + myMultiplication.cube (5.0));
System.out.println("De kubus van 0,5 is " + myMultiplication.cube (0,5));
}
}

Uitgang:

De kubus van 5 is 125
De kubus van 5.0 is 125,0
De kubus van 0,5 is 0,125

De bovenstaande code laat zien hoe je een kubus van verschillende typen kunt krijgen (int, dubbele, vlotter) met dezelfde methode.

Over het algemeen wordt methode-overbelasting gebruikt om vergelijkbare methoden met verschillende parametertypen te definiëren.

Wat is methode overschrijven?

Dit verwijst naar een andere implementatie van een methode in een subklasse. De methode moet al gedefinieerd zijn in de bovenliggende klasse.

De overschrijvende methode (d.w.z. die in de subklasse) moet dezelfde methodehandtekening hebben als die in de superklasse. Het retourtype van de overschrijvende methode kan hetzelfde zijn of een subtype van dat in de superklasse.

Overschrijven wordt over het algemeen gebruikt om een ​​specifieke implementatie van het gedrag van een object in de subklasse op te nemen.

klasse-account{
openbaar ongeldig bericht() {
Systeem.uit.println("
Bedankt voor het openen van een account bij ons!");
}
public static void main (String args[]) {
Account myAccount = nieuw account();
Besparingen mySavings = nieuwe Besparingen();
FixedDeposit myFixedDepo = nieuwe FixedDeposit();
mijnAccount.bericht();
mijnSavings.bericht();
mijnFixedDepo.bericht();
}
}
klasse Sparen verlengt Rekening {
openbaar ongeldig bericht() {
Systeem.uit.println("
Bedankt voor het openen van een Spaarrekening bij ons!");
}
}
klasse FixedDeposit verlengt rekening {
openbaar ongeldig bericht() {
Systeem.uit.println("
Bedankt voor het openen van een vast deposito-account bij ons!");
}
}

Uitgang:

Bedankt voor het openen van een account bij ons!
Bedankt voor het openen van een Spaarrekening bij ons!
Bedankt voor het openen van een Fixed Deposit-rekening bij ons!

Het bovenstaande voorbeeld laat zien hoe de methode bericht() wordt overschreven in de subklassen Besparingen en Vaste aanbetaling. Voor bankrekeninghouders met een Spaarrekening en die met een Vast Deposito worden verschillende berichten weergegeven.

Verwant: Wat u moet weten over het gebruik van strings in Java

Het is ook vermeldenswaard dat het overschrijven van methodes runtime-polymorfisme of dynamische methodeverzending aantoont. Dit betekent dat de aan te roepen methode tijdens runtime wordt opgelost in plaats van bij compilatie.

Om te voorkomen dat een methode wordt overschreven, gebruikt u het sleutelwoord laatste.

laatste ongeldig bericht (){
Systeem.uit.println("
Bedankt voor het openen van een account bij ons!");
}

Wanneer een subklasse deze probeert te overschrijven, treedt er een compilatiefout op.

Idealiter zouden alle methoden die binnen een constructor worden aangeroepen moeten zijn: laatste. Dit is om onbedoelde wijzigingen te voorkomen die door de subklassen kunnen worden veroorzaakt.

Soms moet u mogelijk toegang krijgen tot een overschreven methode binnen de overschrijvende methode. U kunt het trefwoord gebruiken: super gevolgd door de puntoperator (.) en de naam van de methode in dat geval.

Overweeg de superklasse Dier.

klasse Dier{
public void move() {
Systeem.uit.println("
Ik kan bewegen.");
}
}

Hieronder is een subklasse, genaamd Vis, dat overheerst Actie():

klasse Vis breidt Dier uit {
public void move() {
Systeem.uit.println("
Ik kan zwemmen.");
super.verplaats();
}
public static void main (String args[]){
Vis Tilapia = nieuwe Vis();
Tilapia.move();
}
}

Uitgang:

Ik kan zwemmen.
Ik kan bewegen.

Wanneer u een methode overschrijft, moet u ook rekening houden met de gebruikte toegangsmodifier. De modifier in de subklasse moet hetzelfde niveau van zichtbaarheid of hoger hebben dan in de basisklasse. Als de methode in de basisklasse bijvoorbeeld is gedefinieerd als beschermd, dan kan de overschrijvende methode ofwel zijn: beschermd of openbaar.

Eenvoudige code met polymorfisme

Overriding en overbelasting van methoden zijn belangrijk voor vereenvoudiging van de code, en eenvoudige code is een goede gewoonte.

Waarom? Stel je een complexe codebase voor met meer ins en outs dan Grand Central Station. Stel je nu voor dat een verwoestende bug je harde werk voor je eigen ogen begint te vernietigen. U moet de bron van de infectie isoleren en u moet dit snel doen.

Succes, je hebt je code niet vereenvoudigd... Nu ga je een echte les in cryptografie krijgen. Het gebruik van effectieve datastructuren en doen wat je kunt om code in te korten (zoals DRY in gedachten houden) is je beste verdediging tegen een situatie als deze.

De volgende op uw Java-leerlijst zou moeten werken met arrays. Het zijn belangrijke gegevensstructuren die worden gebruikt om batches gegevenspunten op te slaan.

Bewerkingen maken en uitvoeren op arrays in Java

Java leren? Laat arrays uw gegevens gemakkelijk verwerken.

Lees volgende

Over de auteur

Uitvouwen om het volledige verhaal te lezen