Regels voor method-overloading
Begrijp hoe Java overgeladen methoden oplost en welke veelvoorkomende ambiguïteitsproblemen kunnen ontstaan.
Regels voor method-overloading is een gratis Java Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.
Regels voor het overladen van methoden
Met het overladen van methoden kun je meerdere methoden met dezelfde naam maar verschillende parameterlijsten definiëren. Java selecteert tijdens het compileren de beste overeenkomst met behulp van nauwkeurige resolutieregels.
Wat is overloading?
Overladen methoden hebben dezelfde naam, maar verschillen in aantal, type of volgorde van parameters. Alleen het retourtype is NIET voldoende om een methode te overladen.
class Calculator {
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }
int add(int a, int b, int c) { return a + b + c; }
// compile error — same signature, different return type only:
// long add(int a, int b) { return a + b; }
}
Calculator calc = new Calculator();
System.out.println(calc.add(1, 2)); // 3 (int)
System.out.println(calc.add(1.5, 2.5)); // 4.0 (double)
System.out.println(calc.add(1, 2, 3)); // 6 (3-arg)Resolutie: de meest specifieke overeenkomst
Java kiest de meest specifieke toepasbare methode. Verbreding, autoboxing en varargs worden in volgorde van voorkeur geprobeerd.
static void print(int x) { System.out.println("int: " + x); }
static void print(long x) { System.out.println("long: " + x); }
static void print(Object x) { System.out.println("Object: " + x); }
print(42); // int: 42 (exact match — most specific)
print(42L); // long: 42 (exact match)
print(3.14); // Object: 3.14 (no float match, widening then autoboxing)Verbreding vóór autoboxing
Java geeft de voorkeur aan het verbreden van een primitief type boven het omzetten ervan met autoboxing naar een wrappertype. Dit kan verrassende resultaten opleveren.
static void display(long n) { System.out.println("long: " + n); }
static void display(Integer n) { System.out.println("Integer: " + n); }
int x = 100;
display(x); // long: 100 — widens int to long BEFORE autoboxing to Integer
// This surprises many developers!
static void show(Long n) { System.out.println("Long"); }
static void show(Integer n) { System.out.println("Integer"); }
// show(100); // compile error — ambiguous! Neither is more specificAmbiguïteit bij een null-argument
Het doorgeven van null aan overgeladen methoden kan ambigu zijn als meerdere methoden verwijzingstypen accepteren. Cast null om dit op te lossen.
static void handle(String s) { System.out.println("String: " + s); }
static void handle(Integer i) { System.out.println("Integer: " + i); }
static void handle(Object o) { System.out.println("Object"); }
handle((String) null); // String: null (cast resolves ambiguity)
handle((Integer) null); // Integer: null
// handle(null); // compile error: ambiguous (String vs Integer)Overloading met overerving
Bij de methode-resolutie wordt gekeken naar het gedeclareerde type van de referentievariabele, niet naar het type tijdens runtime — dit is een beslissing tijdens het compileren.
class Animal {}
class Dog extends Animal {}
static void greet(Animal a) { System.out.println("Animal"); }
static void greet(Dog d) { System.out.println("Dog"); }
Animal a = new Dog(); // declared as Animal
greet(a); // Animal — compile-time type is Animal!
Dog d = new Dog();
greet(d); // Dog — compile-time type is DogOverloading tegenover overriding
Overloading is een beslissing tijdens het compileren (statische dispatch). Overriding is een beslissing tijdens runtime (dynamische dispatch), gebaseerd op het werkelijke objecttype.
class Base {
void run() { System.out.println("Base.run"); }
}
class Sub extends Base {
@Override
void run() { System.out.println("Sub.run"); } // overriding
void run(int speed) { System.out.println("Sub.run(" + speed + ")"); } // overloading
}
Base b = new Sub();
b.run(); // Sub.run — override (runtime dispatch)
// b.run(10); // compile error — Base doesn't have run(int)Veelgebruikte patronen voor overloading
Veelgebruikte toepassingen van overloading in API's: gemaksmethoden aanbieden die delegeren naar een variant met alle parameters.
class Connection {
void connect(String host, int port, int timeout) {
System.out.println("Connecting to " + host + ":" + port + " timeout=" + timeout);
}
// Convenience overloads
void connect(String host, int port) {
connect(host, port, 30); // delegate with default timeout
}
void connect(String host) {
connect(host, 5432); // delegate with default port
}
}
new Connection().connect("db.example.com");
// Connecting to db.example.com:5432 timeout=30Overloading en generics
Overloading van generieke methoden vereist zorgvuldigheid — type-erasure kan ervoor zorgen dat twee ogenschijnlijk verschillende handtekeningen na het compileren identiek zijn.
// Type erasure problem: both methods erase to the same signature!
// static void process(List<String> list) {} // compile error
// static void process(List<Integer> list) {} // duplicate after erasure
// Solutions:
// 1. Use different method names: processStrings / processIntegers
// 2. Use a generic method with bounded type:
static <T extends Number> void processNumbers(List<T> list) {
list.forEach(n -> System.out.println(n.doubleValue()));
}
processNumbers(List.of(1, 2, 3));
processNumbers(List.of(1.5, 2.5));Praktisch: builder-achtige overloads
Overloading komt vaak voor in builder- en factory-API's om flexibele objectcreatie mogelijk te maken.
class Notification {
final String title, body;
final String imageUrl;
final boolean urgent;
// Factory overloads for convenience
static Notification simple(String title, String body) {
return new Notification(title, body, null, false);
}
static Notification urgent(String title, String body) {
return new Notification(title, body, null, true);
}
static Notification withImage(String title, String body, String url) {
return new Notification(title, body, url, false);
}
Notification(String title, String body, String imageUrl, boolean urgent) {
this.title = title; this.body = body;
this.imageUrl = imageUrl; this.urgent = urgent;
}
}Valkuilen bij overloading
Vermijd deze veelgemaakte fouten bij overloading:
- Te veel overloads voor dezelfde bewerking — gebruik in plaats daarvan een builder
- Overloads die alleen verschillen in de volgorde van parameters — verwarrend
- Verrassende verbreding: een int kan naar long worden opgelost in plaats van naar Integer
// Confusing: order-based overloads
// void save(String name, int age) {}
// void save(int age, String name) {} // very confusing!
// Better: use a record/DTO
record UserData(String name, int age) {}
void save(UserData data) {}
// Surprising widening
static void m(long x) { System.out.println("long"); }
static void m(Integer x){ System.out.println("Integer"); }
int v = 5;
m(v); // long! widening preferred over autoboxingKorte test
Als een methode is overladen met zowel parameters van het type long als Integer, welke wordt gekozen wanneer je een argument van het type int doorgeeft?
Samenvatting: regels voor het overladen van methoden
Belangrijkste punten:
- Overladen verschilt in het aantal, het type of de volgorde van parameters — NIET alleen in het retourtype
- Java bepaalt tijdens het compileren welke overbelasting wordt gebruikt op basis van het gedeclareerde type van argumenten
- Een primitief type verbreden heeft de voorkeur boven het automatisch verpakken ervan in een wrappertype
- Null-argumenten kunnen dubbelzinnigheid veroorzaken — gebruik een cast om dit op te lossen: handle((String) null)
- Overladen gebeurt tijdens het compileren; overschrijven gebeurt tijdens de uitvoering — het zijn verschillende mechanismen
- Gebruik handige overbelaste methoden die delegeren aan één methode met alle parameters
Leer Java met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 104
- Lessen
- 374
Veelgestelde vragen
Is de les “Regels voor method-overloading” gratis?
Ja — de volledige tekst van “Regels voor method-overloading” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.
Wat leer ik in “Regels voor method-overloading”?
Begrijp hoe Java overgeladen methoden oplost en welke veelvoorkomende ambiguïteitsproblemen kunnen ontstaan. Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Java Academy te beginnen?
Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Regels voor method-overloading”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Java Academy?
Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Regels voor method-overloading
- Varargs-parameters
- Statische velden en constanten
- Utilityklassen en statische factorymethoden