Java Academy · Lektion

Varargs-parametre

Definér metoder, der accepterer argumentlister med variabel længde, og kombinér dem med arrays.

Lektion 2 af 413 trin

Varargs-parametre er en gratis Java Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Java Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Java Academy-kurset indeholder 4 lektioner i alt.

Varargs-parametre

Varargs (argumentlister med variabel længde) giver dig mulighed for at definere metoder, der accepterer et vilkårligt antal argumenter af samme type, som internt behandles som et array.

Deklaration af varargs

Brug Type... name til en varargs-parameter. Den skal være den sidste parameter, og der kan kun være én pr. metode.

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

Varargs internt

Varargs er syntaktisk sukker. Kompileren omskriver kaldet til oprettelse af et array på kaldestedet.

// 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

Blandede parametre med varargs

Varargs skal være den sidste parameter. Du kan blande dem med normale parametre før dem.

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

Varargs med generiske typer

Brug af varargs med generiske typer medfører en advarsel om heap-forurening. Undertryk den med @SafeVarargs, når det kan bevises, at metoden er sikker.

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]

Varargs og overbelastning

Når en varargs-metode er overbelastet med et eksakt match, foretrækkes det eksakte match. Varargs er sidste udvej.

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 bruger varargs

System.out.printf bruger varargs — den accepterer en formatstreng og et vilkårligt antal argumenter af enhver 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

Oprettelse af en logningskomponent med varargs

Implementering af en simpel struktureret logningskomponent, der accepterer nøgleværdi-par ved hjælp af varargs.

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

Overvejelser om ydeevne

Hvert varargs-kald opretter et nyt array på heapen. For hjælpeværktøjsmetoder, der kaldes ofte, bør du levere overbelastninger med fast antal parametre for at undgå allokering.

// 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); }

Varargs og null

Det er tvetydigt at sende null til en varargs-metode — Java kan fortolke det som et null-array. Brug en eksplicit typekonvertering for at undgå advarslen.

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)

Praktisk: Hjælper til String-formattering

En sikker wrapper omkring printf, der returnerer den formatterede streng og bruger varargs for at matche format-argumentstilen.

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' ...]

Hurtigt tjek

Hvilken type har en varargs-parameter inde i metodens krop?

Besvar den i den interaktive lektion

Opsummering: Varargs-parametre

Vigtigste pointer:

Varargs (Type... name) accepterer 0 eller flere argumenter, som internt behandles som et array
Skal være den sidste parameter — der kan kun være én varargs-parameter pr. metode
Den kaldende kode kan sende individuelle værdier eller et array
Brug @SafeVarargs til at undertrykke advarsler om heap-forurening for generiske varargs
Overbelastninger med eksakt match foretrækkes frem for varargs-overbelastninger
Lever overbelastninger med fast antal parametre til metoder, der kaldes ofte, for at undgå allokering af arrays

Gratis at komme i gang

Lær Java med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 104
Lektioner: 374

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Varargs-parametre” gratis?

Ja — hele teksten til “Varargs-parametre” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Java Academy-kurset, skal du opgradere til CoddyKit PRO. Java Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Varargs-parametre”?

Definér metoder, der accepterer argumentlister med variabel længde, og kombinér dem med arrays. Du øver dig i Java Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Java Academy?

Der kræves ingen tidligere erfaring. Java Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Varargs-parametre”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Java Academy-lektion?

Ja. Alle Java Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Regler for method overloading
Varargs-parametre
Statiske felter og konstanter
Hjælpeklasser og statiske factory-metoder

← Tilbage til Java Academy