0Pricing
Java Academy · Lektion

Varargs-Parameter

Definieren Sie Methoden, die Argumentlisten variabler Länge akzeptieren, und kombinieren Sie diese mit Arrays.

Varargs-Parameter ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Varargs-Parameter

Varargs (Argumentlisten variabler Länge) ermöglichen es, Methoden zu definieren, die eine beliebige Anzahl von Argumenten desselben Typs akzeptieren und diese intern als Array behandeln.

Varargs deklarieren

Verwenden Sie Type... name für einen Varargs-Parameter. Er muss der letzte Parameter sein, und pro Methode ist nur einer zulässig.

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 im Inneren

Varargs sind syntaktischer Zucker. Der Compiler wandelt den Aufruf an der Aufrufstelle in die Erstellung eines Arrays um.

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

Gemischte Parameter mit Varargs

Varargs müssen der letzte Parameter sein. Sie können davor normale Parameter verwenden.

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 mit generischen Typen

Die Verwendung von Varargs mit Generics führt zu einer heap pollution-Warnung. Unterdrücken Sie sie mit @SafeVarargs, wenn die Methode nachweislich sicher ist.

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 und Überladung

Wenn eine Varargs-Methode mit einer exakten Übereinstimmung überladen ist, wird die exakte Übereinstimmung bevorzugt. Varargs sind das letzte Mittel.

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 verwendet Varargs

System.out.printf verwendet Varargs – die Methode akzeptiert eine Formatzeichenkette und eine beliebige Anzahl von Argumenten beliebigen Typs.

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

Einen Logger mit Varargs erstellen

Implementierung eines einfachen strukturierten Loggers, der mithilfe von Varargs Schlüssel-Wert-Paare akzeptiert.

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

Überlegungen zur Performance

Jeder Aufruf mit Varargs erstellt ein neues Array auf dem Heap. Stellen Sie für Hilfsmethoden, die sehr häufig aufgerufen werden, Überladungen mit fester Parameteranzahl bereit, um die Allokation zu vermeiden.

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

Die Übergabe von null an eine Varargs-Methode ist mehrdeutig – Java kann den Wert als null-Array interpretieren. Verwenden Sie einen expliziten Cast, um die Warnung zu vermeiden.

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)

Praxis: String-Format-Hilfsmethode

Eine sichere printf-Wrapper-Methode, die den formatierten String zurückgibt und Varargs verwendet, um dem Format-Argument-Stil zu entsprechen.

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

Schnelltest

Welchen Typ hat ein Varargs-Parameter innerhalb des Methodenrumpfs?

Zusammenfassung: Varargs-Parameter

Die wichtigsten Erkenntnisse:

  • Varargs (Type... name) akzeptieren 0 oder mehr Argumente und behandeln sie intern als Array
  • Sie müssen der letzte Parameter sein – pro Methode ist nur ein Varargs-Parameter zulässig
  • Der Aufrufer kann einzelne Werte oder ein Array übergeben
  • Verwenden Sie @SafeVarargs, um Heap-Pollution-Warnungen bei generischen Varargs zu unterdrücken
  • Überladungen mit exakter Übereinstimmung werden gegenüber Varargs-Überladungen bevorzugt
  • Stellen Sie für häufig aufgerufene Methoden Überladungen mit fester Parameteranzahl bereit, um die Array-Allokation zu vermeiden

Häufig gestellte Fragen

Ist die Lektion „Varargs-Parameter“ kostenlos?

Ja — der vollständige Text von „Varargs-Parameter“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Varargs-Parameter“?

Definieren Sie Methoden, die Argumentlisten variabler Länge akzeptieren, und kombinieren Sie diese mit Arrays. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Varargs-Parameter“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Regeln für Methodenüberladung
  2. Varargs-Parameter
  3. Statische Felder und Konstanten
  4. Utility-Klassen und statische Factory-Methoden
← Zurück zu Java Academy