Java Academy · Les

Varargs-parameters

Definieer methoden die lijsten met een variabel aantal argumenten accepteren en combineer deze met arrays.

Les 2 van 413 stappen

Varargs-parameters is een gratis Java Academy-les op CoddyKit. Dit is les 2 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.

Varargs-parameters

Met varargs (argumentlijsten met variabele lengte) kun je methoden definiëren die een willekeurig aantal argumenten van hetzelfde type accepteren en intern als een array worden behandeld.

Variabele argumenten declareren

Gebruik Type... name voor een parameter met variabele lengte. Deze moet de laatste parameter zijn en per methode is er maar één toegestaan.

static int sum(int... numbers) {
    int total = 0;
    for (int n : numbers) total += n;
    return total;
}

System.out.println(sum());           // 0 (empty array)
System.out.println(sum(1));          // 1
System.out.println(sum(1, 2, 3));    // 6
System.out.println(sum(1, 2, 3, 4)); // 10

// Can also pass an array
int[] arr = {5, 10, 15};
System.out.println(sum(arr));        // 30

Variabele argumenten intern

Variabele argumenten zijn syntactische suiker. De compiler zet de aanroep op de aanroepplaats om in het maken van een array.

// Calling: sum(1, 2, 3)
// Compiler generates: sum(new int[]{1, 2, 3})

static void printAll(String label, String... items) {
    System.out.println(label + ":");
    for (String item : items) System.out.println("  - " + item);
}

printAll("Fruits", "Apple", "Banana", "Cherry");
// Fruits:
//   - Apple
//   - Banana
//   - Cherry

printAll("Empty"); // varargs is empty array

Gemengde parameters met variabele argumenten

Variabele argumenten moeten de laatste parameter zijn. Je kunt ervoor normale parameters combineren.

static double average(String label, double... values) {
    if (values.length == 0) return 0.0;
    double sum = 0;
    for (double v : values) sum += v;
    double avg = sum / values.length;
    System.out.printf("%s average: %.2f%n", label, avg);
    return avg;
}

average("Math scores", 92.0, 85.5, 78.0, 95.0);
// Math scores average: 87.62

average("Single value", 100.0);
// Single value average: 100.00

Variabele argumenten met generieke typen

Het gebruik van variabele argumenten met generieke typen veroorzaakt een waarschuwing voor heapvervuiling. Onderdruk die met @SafeVarargs wanneer de methode aantoonbaar veilig is.

import java.util.Arrays;
import java.util.List;

@SafeVarargs  // suppresses heap pollution warning
static <T> List<T> listOf(T... elements) {
    return Arrays.asList(elements); // safe: we don't store to the array
}

List<String> names = listOf("Alice", "Bob", "Charlie");
System.out.println(names); // [Alice, Bob, Charlie]

List<Integer> scores = listOf(95, 87, 73);
System.out.println(scores); // [95, 87, 73]

Variabele argumenten en overladen

Wanneer een methode met variabele argumenten is overladen met een exacte overeenkomst, krijgt de exacte overeenkomst de voorkeur. Variabele argumenten zijn het laatste redmiddel.

static void log(String msg)         { System.out.println("1-arg: " + msg); }
static void log(String m1, String m2) { System.out.println("2-arg: " + m1 + ", " + m2); }
static void log(String... msgs)        { System.out.println("varargs: " + msgs.length); }

log("hello");          // 1-arg: hello
log("a", "b");         // 2-arg: a, b
log("a", "b", "c");   // varargs: 3
log();                  // varargs: 0

printf gebruikt variabele argumenten

System.out.printf gebruikt variabele argumenten — de methode accepteert een opmaakreeks en een willekeurig aantal argumenten van elk type.

// printf signature: printf(String format, Object... args)
System.out.printf("%s ordered %d items for $%.2f%n",
    "Alice", 3, 59.97);
// Alice ordered 3 items for $59.97

// String.format is also varargs
String msg = String.format("Error %d: %s", 404, "Not Found");
System.out.println(msg); // Error 404: Not Found

Een logger bouwen met variabele argumenten

Een eenvoudige gestructureerde logger implementeren die sleutel-waardeparen accepteert met behulp van variabele argumenten.

static void logEvent(String event, Object... keyValues) {
    if (keyValues.length % 2 != 0)
        throw new IllegalArgumentException("Key-value pairs required");
    StringBuilder sb = new StringBuilder(event);
    for (int i = 0; i < keyValues.length; i += 2)
        sb.append(" ").append(keyValues[i]).append("=").append(keyValues[i+1]);
    System.out.println(sb);
}

logEvent("user.login",  "userId", 42, "ip", "192.168.1.1", "success", true);
// user.login userId=42 ip=192.168.1.1 success=true

Aandachtspunt voor prestaties

Elke aanroep met variabele argumenten maakt een nieuwe array op de heap. Bied voor hulpprogrammamethoden die vaak worden aangeroepen overbelaste varianten met een vast aantal parameters aan om geheugentoewijzing te voorkomen.

// Java's own EnumSet does this:
static <E extends Enum<E>> EnumSet<E> of(E e)              { ... }
static <E extends Enum<E>> EnumSet<E> of(E e1, E e2)       { ... }
static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3) { ... }
static <E extends Enum<E>> EnumSet<E> of(E e1, E... rest)  { ... }
// Avoids array creation for 1-3 args (most common case)

// Apply the same pattern to your own hot-path APIs:
static void report(String msg)             { log(new String[]{msg}); }
static void report(String m1, String m2)   { log(new String[]{m1, m2}); }
static void report(String... msgs)         { log(msgs); }

Variabele argumenten en null

Het doorgeven van null aan een methode met variabele argumenten is dubbelzinnig — Java kan dit interpreteren als een null-array. Gebruik een expliciete cast om de waarschuwing te voorkomen.

static void printItems(String... items) {
    if (items == null) {
        System.out.println("null array passed");
        return;
    }
    for (String item : items)
        System.out.println(item != null ? item : "(null element)");
}

printItems((String[]) null); // null array passed
printItems(null, "valid");   // (null element), valid
printItems();                 // empty array (0 items)

Praktisch: helper voor String-opmaak

Een veilige wrapper voor printf die de opgemaakte tekenreeks retourneert en variabele argumenten gebruikt om aan te sluiten bij de stijl van opmaakargumenten.

static String fmt(String pattern, Object... args) {
    try {
        return String.format(pattern, args);
    } catch (java.util.IllegalFormatException e) {
        return "[FORMAT ERROR: " + e.getMessage() + "]";
    }
}

System.out.println(fmt("User %s has %d orders", "Alice", 5));
// User Alice has 5 orders

System.out.println(fmt("Invalid %z format", "arg"));
// [FORMAT ERROR: Conversion = 'z' ...]

Korte test

Wat is het type van een parameter met variabele argumenten binnen de methodebody?

Beantwoord dit in de interactieve les

Samenvatting: parameters met variabele lengte

Belangrijkste punten:

Variabele argumenten (Type... name) accepteren nul of meer argumenten en behandelen die intern als een array
Ze moeten de laatste parameter zijn — per methode is er maar één parameter met variabele lengte toegestaan
De aanroeper kan afzonderlijke waarden of een array doorgeven
Gebruik @SafeVarargs om waarschuwingen over heapvervuiling bij generieke variabele argumenten te onderdrukken
Overbelaste methoden met een exacte overeenkomst krijgen de voorkeur boven overbelaste methoden met variabele argumenten
Bied voor methoden die vaak worden aangeroepen overbelaste varianten met een vast aantal parameters aan om het maken van arrays te voorkomen

Gratis beginnen

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

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Varargs-parameters” gratis?

Ja — de volledige tekst van “Varargs-parameters” 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 “Varargs-parameters”?

Definieer methoden die lijsten met een variabel aantal argumenten accepteren en combineer deze met arrays. 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 2 van 4.

Hoe lang duurt de les “Varargs-parameters”?

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

← Terug naar Java Academy