Inleiding
Overriding en overloading zijn de kernconcepten in Java-programmering. Ze zijn de manieren om polymorfisme te implementeren in onze Java-programma’s. Polymorfisme is een van de OOPS-concepten.
Wanneer de methodehandtekening (naam en parameters) hetzelfde zijn in de superklasse en de subklasse, wordt het overriding genoemd. Wanneer twee of meer methoden in dezelfde klasse dezelfde naam hebben maar verschillende parameters, wordt het overloading genoemd.
Vergelijking tussen overriding en overloading
| Overriding | Overloading |
|---|---|
| Implements “runtime polymorphism” | Implements “compile time polymorphism” |
| The method call is determined at runtime based on the object type | The method call is determined at compile time |
| Occurs between superclass and subclass | Occurs between the methods in the same class |
| Have the same signature (name and method arguments) | Have the same name, but the parameters are different |
| On error, the effect will be visible at runtime | On error, it can be caught at compile time |
Voorbeeld van overriding en overloading
Hier is een voorbeeld van overloading en overriding in een Java-programma:
package com.journaldev.examples;
import java.util.Arrays;
public class Processor {
public void process(int i, int j) {
System.out.printf("Processing two integers:%d, %d", i, j);
}
public void process(int[] ints) {
System.out.println("Adding integer array:" + Arrays.toString(ints));
}
public void process(Object[] objs) {
System.out.println("Adding integer array:" + Arrays.toString(objs));
}
}
class MathProcessor extends Processor {
@Override
public void process(int i, int j) {
System.out.println("Sum of integers is " + (i + j));
}
@Override
public void process(int[] ints) {
int sum = 0;
for (int i : ints) {
sum += i;
}
System.out.println("Sum of integer array elements is " + sum);
}
}
Overriding
De process() methode en de parameters int i, int j in Processor worden overschreven in de subklasse MathProcessor. Regels 7 en 23:
public class Processor {
public void process(int i, int j) { /* ... */ }
}
/* ... */
class MathProcessor extends Processor {
@Override
public void process(int i, int j) { /* ... */ }
}
En de process() methode en int[] ints in Processor worden ook overschreven in de subklasse. Regels 11 en 28:
public class Processor {
public void process(int[] ints) { /* ... */ }
}
/* ... */
class MathProcessor extends Processor {
@Override
public void process(Object[] objs) { /* ... */ }
}
Overloading
De process() methode wordt overbelast in de klasse Processor. Regels 7, 11 en 15:
public class Processor {
public void process(int i, int j) { /* ... */ }
public void process(int[] ints) { /* ... */ }
public void process(Object[] objs) { /* ... */ }
}
Conclusie
In dit artikel hebben we het gehad over overschrijven en overladen in Java. Overschrijven vindt plaats wanneer de methodehandtekening hetzelfde is in de superklasse en de kindklasse. Overladen vindt plaats wanneer twee of meer methoden in dezelfde klasse dezelfde naam hebben maar verschillende parameters.
Source:
https://www.digitalocean.com/community/tutorials/overriding-vs-overloading-in-java