Переменные параметры (Varargs) в Java

В этой статье вы узнаете, как использовать примеры для изучения переменных параметров (Varargs) в Java. Вы также узнаете, когда использовать varargs, а когда нет.

Что такое varargs в Java?

Предположим, что вы создаетеJava методыНо вы не уверены, сколько параметров принимает ваш метод. Чтобы решить эту проблему, в Java 1.5 был введен varargs.

Varargs - это аббревиатура от variable arguments. В Java параметры метода могут принимать любое количество значений. Параметр, принимающий переменное количество значений, называется varargs.

Синтаксис реализации varargs следующий:

accessModifier methodName(datatype… arg) {
　　　　// Основной метод
{}

Чтобы определить vararg, в списке параметров метода используется ...(три точки).

Методы, принимающие переменное количество параметров, называются методами с переменными аргументами или сокращенно varargs.

Сначала давайте посмотрим на пример без использования varargs:

class NoVararg {
　　　　public int sumNumber(int a, int b) {
　　　　　　　　return a + b;
　　　　{}
　　　　public int sumNumber(int a, int b, int c) {
　　　　　　　　return a + b + c;
　　　　{}
　　　　public static void main(String[] args) {
　　　　　　　　NoVararg obj = new NoVararg();
　　　　　　　　System.out.println(obj.sumNumber(1, 2));
　　　　　　　　System.out.println(obj.sumNumber(1, 2, 3));
　　　　{}
{}

Когда вы запустите программу, вывод будет следующим:

3
6

Как вы видите, необходимо перегрузить метод sumNumber() для работы с тремя параметрами.

Что если пользователь хочет добавить 5 чисел или 10 или 100?

Использование varargs позволяет решать эту проблему в более простом виде. Давайте посмотрим на пример кода:

Пример: демонстрация работы с переменными аргументами

class VarargExample {
　　　　public int sumNumber(int ... args) {
　　　　　　　　System.out.println("Длина параметров: " + args.length);
　　　　　　　　int sum = 0;
　　　　　　　　for (int x : args) {
　　　　　　　　　　　　sum += x;
　　　　　　　　{}
　　　　　　　　return sum;
　　　　{}
　　　　public static void main(String[] args) {
　　　　　　　　VarargExample ex = new VarargExample();
　　　　　　　　int sum2 = ex.sumNumber(2, 4);
　　　　　　　　System.out.println("sum2 = " + sum2);
　　　　　　　　int sum3 = ex.sumNumber(1, 3, 5);
　　　　　　　　System.out.println("sum3 = " + sum3);
　　　　　　　　int sum4 = ex.sumNumber(1, 3, 5, 7);
　　　　　　　　System.out.println("sum4 = " + sum4);
　　　　{}
{}

При выполнении программы вывод будет следующим:

Длина параметров: 2
sum2 = 6
Длина параметров: 3
sum3 = 9
Длина параметров: 4
sum4 = 16

В этом случае метод sumNumber() возвращает сумму переданных ему int параметров (независимо от количества переданных параметров).

Как вы видите, переменные аргументы очень полезны в некоторых случаях. Однако, если вы уверены в количестве передаваемых методу параметров, лучше использовать перегрузку методов. Например, если вы уверены, что метод sumNumber() используется только для вычисления суммы 2 или 3 параметров, как в первом примере, используйте перегрузку.

Давайте рассмотрим еще один пример. Метод format(), определенный в библиотеке Java, принимает переменные аргументы. В JDK метод format() определен следующим образом:

public static String format(Locale l, String format, Object... args) {
　　　　// тело
{}

Пример: метод format()

class Company {
　　　　public static void main(String[] args) {
　　　　　　　　String siteName = "oldtoolbag.com";
　　　　　　　　int empCount = 6;
　　　　　　　　String type = "веб-сайт с учебными материалами";
　　　　　　　　System.out.println(
　　　　　　　　　　　　　　　　String.format(
　　　　　　　　　　　　　　　　　　　　　　　　"Название сайта: %s, Количество сотрудников: %d Тип: %s",
　　　　　　　　　　　　　　　　　　　　　　　　siteName, empCount, type
　　　　　　　　　　　　　　　　)
　　　　　　　　);
　　　　{}
{}

При выполнении программы вывод будет следующим:

Название сайта: oldtoolbag.com, Количество сотрудников: 6 Тип: веб-сайт с учебными материалами

Как работают переменные аргументы в фоновом режиме?

Давайте посмотрим на следующий пример кода:

public int sumNumber(int ... nums) {
　　　　// Основной метод
{}

Синтаксис ... сообщает компилятору Java, что метод может быть вызван с нуля или несколькими параметрами. В результате переменная nums имплицитно объявляется как int [].МассивСледовательно, в методе используйте синтаксис массива для доступа к переменной nums.

Если нет параметров, длина nums равна 0.

Перегрузка методов с переменным количеством аргументов

Как и в случае с типичными методами, вы можете перегружать методы с переменным количеством аргументов.

Пример: перегрузка методов с переменным количеством аргументов

class VarargOverload {
　　　　private void test(int ... args){
　　　　　　　　int sum = 0;
　　　　　　　　for (int i: args) {
　　　　　　　　　　　　sum += i;
　　　　　　　　{}
　　　　　　　　System.out.println("sum = " + sum);
　　　　{}
　　　　private void test(boolean p, String ... args){
　　　　　　　　boolean negate = !p;
　　　　　　　　System.out.println("negate = " + negate);
　　　　　　　　System.out.println("args.length = " + args.length);
　　　　{}
　　　　public static void main(String[] args) {
　　　　　　　　VarargOverload obj = new VarargOverload();
　　　　　　　　obj.test(1, 2, 3);
　　　　　　　　obj.test(true, "hello", "world");
　　　　{}
{}

При выполнении программы вывод будет следующим:

sum = 6
negate = false
args.length = 2

В вышеуказанном программном обеспечении метод test() перегружен за счет изменения количества передаваемых параметров.

Вещи, которые нужно помнить при использовании Varargs

Вот несколько вещей, которые нужно помнить при использовании Java Varargs:

1. При определении подписи метода务必:СохранениеВ конце varargs.

Параметры varargs должны быть переданы в качестве последнего параметра метода. Рассмотрим, например, вызов метода doSomething() следующим образом:

doSomething(1, 2, 3, 4);

И кроме того, ваше doSomething() метод определено как:

// Некорректное объявление метода
public void doSomething(int ... nums, int p){
　　　　// тело метода
{}

В этом случае компилятор не может определить количество параметров, переданных nums.

Но если определить метод как:

public void doSomething(int p, int ... nums) {
　　　　// тело метода
{}

Java компилятор назначает первый параметр p,其余 int параметры назначаются nums.

2. Один метод может иметь только один параметр varargs.

Например, это声明是不正确的:

int doSomething(int p, float ... floatNums, double ... doubleNums) {
　　　　// код
{}

Неясность в перегрузке методов varargs

Давайте рассмотрим такой перегруженный метод test():

class Demo {　
　　
　　　　static void test(int ... vargs) {
　　　　　　　　// тело метода
　　　　{}
　　　　
　　　　static void test(int n, int ... vargs) {
　　　　　　　　// тело метода
　　　　{}
{}

В приведенном выше примере программы, даже если вы пытаетесь вызвать метод test(), несмотря на то, что метод уже перегружен и принимает разное количество параметров, компилятор может быть смущен.

Компилятор не знает,哪个 метод вызывается. Компилятор может думать, что вы пытаетесь вызвать test(int ... vargs) с использованием varargs параметра. Также, компилятор может думать, что вы пытаетесь вызвать test(int n, int ... vargs) с параметрами, переданными для первого параметра, а второй параметр пуст.

Так как существует две возможности, это может вызвать неясность. Поэтому, иногда вам может потребоваться использовать два разных имени методов,而不是 перегружать методы varargs.