Polymorfisme in Java: methoden overbelasten of negeren

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' betekent veel en 'morph' betekent vorm. 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:

class Arithmetic{
int cube(int x){
return x*x*x;
}
double cube(double x){
return x*x*x;
}
float cube(float x){
return x*x*x;
}
public static void main(String[] args){
Arithmetic myMultiplication = new Arithmetic();
System.out.println('The cube of 5 is ' + myMultiplication.cube(5));
System.out.println('The cube of 5.0 is ' + myMultiplication.cube(5.0));
System.out.println('The cube of 0.5 is ' + myMultiplication.cube(0.5));
}
}

Uitgang:





The cube of 5 is 125
The cube of 5.0 is 125.0
The cube of 0.5 is 0.125

De bovenstaande code laat zien hoe je een kubus van verschillende typen kunt krijgen ( int , dubbele , vlot ) 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.

class Account{
public void message() {
System.out.println('
Thank you for opening an account with us!');
}
public static void main(String args[]) {
Account myAccount = new Account();
Savings mySavings = new Savings();
FixedDeposit myFixedDepo = new FixedDeposit();
myAccount.message();
mySavings.message();
myFixedDepo.message();
}
}
class Savings extends Account {
public void message() {
System.out.println('
Thank you for opening a Savings account with us!');
}
}
class FixedDeposit extends Account {
public void message() {
System.out.println('
Thank you for opening a Fixed Deposit account with us!');
}
}

Uitgang:

Thank you for opening an account with us!
Thank you for opening a Savings account with us!
Thank you for opening a Fixed Deposit account with us!

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 .

final void message (){
System.out.println('
Thank you for opening an account with us!');
}

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 .

class Animal{
public void move() {
System.out.println('
I can move.');
}
}

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

class Fish extends Animal {
public void move() {
System.out.println('
I can swim.');
super.move();
}
public static void main(String args[]){
Fish Tilapia = new Fish();
Tilapia.move();
}
}

Uitgang:

mijn amazon-bestelling is niet aangekomen
I can swim.
I can move.

Wanneer u een methode overschrijft, moet u ook rekening houden met de gebruikte toegangsmodifier. De modifier in de subklasse moet hetzelfde niveau van zichtbaarheid hebben of hoger zijn 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 verwoestend insect je harde werk voor je eigen ogen begint te vernietigen. U moet de bron van de infectie isoleren en u moet dit snel doen.

Veel 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.

Deel Deel Tweeten E-mail Bewerkingen maken en uitvoeren op arrays in Java

Java leren? Laat arrays uw gegevens gemakkelijk verwerken.

Lees volgende
Gerelateerde onderwerpen
  • Programmeren
  • Java
  • Codeerhandleidingen
Over de auteur Jerome Davidson(22 artikelen gepubliceerd)

Jerome is een stafschrijver bij MakeUseOf. Hij behandelt artikelen over programmeren en Linux. Hij is ook een crypto-enthousiasteling en houdt de crypto-industrie altijd in de gaten.

Meer van Jerome Davidson

Abonneer op onze nieuwsbrief

Word lid van onze nieuwsbrief voor technische tips, recensies, gratis e-boeken en exclusieve deals!

Klik hier om je te abonneren