Parametry varargs
Definiuj metody przyjmujące listy argumentów o zmiennej długości i łącz je z tablicami.
Parametry varargs to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.
Parametry varargs
Varargs (listy argumentów o zmiennej długości) pozwalają definiować metody przyjmujące dowolną liczbę argumentów tego samego typu, traktowanych wewnętrznie jako tablica.
Deklarowanie parametrów varargs
Użyj Type... name jako parametru varargs. Musi on być ostatnim parametrem, a w każdej metodzie może wystąpić tylko jeden taki parametr.
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)); // 30Varargs wewnętrznie
Varargs to cukier składniowy. Kompilator zamienia wywołanie na utworzenie tablicy w miejscu wywołania.
// 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 arrayParametry mieszane z varargs
Parametr varargs musi być ostatnim parametrem. Można umieścić przed nim zwykłe parametry.
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.00Varargs z typami generycznymi
Używanie varargs z typami generycznymi powoduje ostrzeżenie o zanieczyszczeniu sterty. Użyj @SafeVarargs, jeśli można dowieść, że metoda jest bezpieczna.
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 a przeciążanie metod
Jeśli metoda varargs ma przeciążenie z dokładnym dopasowaniem, preferowane jest to dokładne dopasowanie. Varargs są wybierane w ostateczności.
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: 0printf używa varargs
System.out.printf korzysta z varargs — przyjmuje napis formatujący oraz dowolną liczbę argumentów dowolnego typu.
// 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 FoundTworzenie loggera z użyciem varargs
Implementacja prostego loggera strukturalnego, który przyjmuje pary klucz-wartość za pomocą 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=trueKwestie wydajności
Każde wywołanie varargs tworzy nową tablicę na stercie. W przypadku często wywoływanych metod narzędziowych udostępnij przeciążenia o stałej liczbie parametrów, aby uniknąć alokacji.
// 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 i null
Przekazanie null do metody varargs jest niejednoznaczne — Java może zinterpretować tę wartość jako pustą tablicę. Użyj jawnego rzutowania, aby uniknąć ostrzeżenia.
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)Praktycznie: pomocnicza metoda formatowania String
Bezpieczny wrapper dla printf, który zwraca sformatowany napis i korzysta z varargs, aby zachować styl argumentów formatowania.
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' ...]Szybki test
Jaki typ ma parametr varargs wewnątrz treści metody?
Podsumowanie: parametry varargs
Najważniejsze informacje:
- Varargs (Type... name) przyjmuje zero lub więcej argumentów, traktowanych wewnętrznie jako tablica
- Musi być ostatnim parametrem — w każdej metodzie może wystąpić tylko jeden parametr varargs
- Wywołujący może przekazać pojedyncze wartości albo tablicę
- Użyj @SafeVarargs, aby wyciszyć ostrzeżenia o zanieczyszczeniu sterty dla generycznych parametrów varargs
- Przeciążenia z dokładnym dopasowaniem mają pierwszeństwo przed przeciążeniami varargs
- W przypadku często wywoływanych metod udostępniaj przeciążenia o stałej liczbie parametrów, aby uniknąć alokacji tablicy
Często zadawane pytania
Czy lekcja „Parametry varargs” jest bezpłatna?
Tak — pełny tekst „Parametry varargs” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Parametry varargs”?
Definiuj metody przyjmujące listy argumentów o zmiennej długości i łącz je z tablicami. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Java Academy?
Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.
Ile czasu zajmuje lekcja „Parametry varargs”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?
Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Zasady przeciążania metod
- Parametry varargs
- Pola statyczne i stałe
- Klasy narzędziowe i statyczne metody fabrykujące