что такое varargs какие есть ограничения при написании
Varargs: аргументы переменной длины
В JDK 5 была добавлена новая функциональная возможность, которая упрощает создание методов, принимающих переменное количество аргументов. Эта функциональная возможность получила название varargs (сокращение термина variable-length arguments — аргументы переменной длины). Метод, который принимает переменное число аргументов, называют методом переменной арности, или просто методом varargs.
Ситуации, в которых методу нужно передавать переменное количество аргументов, встречаются не так уж редко. Например, метод, который открывает подключение к Internet, может принимать имя пользователя, пароль, имя файла, протокол и тому подобное, но применять значения, заданные по умолчанию, если какие-либо из этих сведений опущены. В этой ситуации было бы удобно передавать только те аргументы, для которых заданные по умолчанию значения не применимы. Еще один пример — метод printf (), входящий в состав библиотеки ввода-вывода Java. Как будет показано в главе 19, он принимает переменное число аргументов, которые форматирует, а затем выводит.
До появления версии J2SE 5 обработка аргументов переменной длины могла выполняться двумя способами, ни один из которых не был особенно удобным. Во-первых, если максимальное количество аргументов было небольшим и известным, можно было создавать перегруженные версии метода — по одной для каждого возможного способа вызова метода. Хотя этот способ подходит для ряда случаев, он применим только к узкому классу ситуаций.
В тех случаях, когда максимальное число возможных аргументов было большим или неизвестным, применялся второй подход, при котором аргументы помещались в массив, а затем массив передавался методу. Следующая программа иллюстрирует этот подход.
// Использование массива для передачи методу переменного
// количества аргументов. Это старый стиль подхода
// к обработке аргументов переменной длины.
class PassArray <
static void vaTest(int v[]) <
System.out.print(«Количество аргументов: » + v.length + » Содержимое: «);
for (int x : v)
System.out.print(x + » «) ;
System.out.println ();
>
public static void main(String args[]) <
// Обратите внимание на способ создания массива
// для хранения аргументов.
int nl[] = < 10 >;
int п2[] = < 1, 2, 3 >;
int пЗ []=<>;
vaTest(nl); // 1 аргумент
vaTest(n2); // 3 аргумента
vaTest(nЗ); // без аргументов
Эта программа создает следующий вывод:
Количество аргументов: 1
Содержимое: 10
Количество аргументов: 3
Содержимое: 1 2 3
Количество аргументов: 0
Содержимое:
В программе методу vaTest () аргументы передаются через массив v. Этот старый подход к обработке аргументов переменной длины позволяет методу vaTest () принимать любое число аргументов. Однако он требует, чтобы эти аргументы были вручную помещены в массив до вызова метода vaTest (). Создание массива при каждом вызове метода vaTest () не только трудоемкая, но и чреватая ошибками задача. Функциональная возможность использования методов varargs обеспечивает более простой и эффективный подход.
Для указания аргумента переменной длины используют три точки (. ). Например, вот как метод vaTest () можно записать с использованием аргумента Переменной длины:
Эта синтаксическая конструкция указывает компилятору, что метод vaTest () может вызываться с нулем или более аргументов. В результате v неявно объявляется как массив типа int []. Таким образом, внутри метода vaTest () доступ к v осуществляется с использованием синтаксиса обычного массива. Предыдущая программа с применением метода vararg приобретает следующий вид:
Вывод этой программы совпадает с выводом исходной версии.
Наряду с параметром переменной длины массив может содержать «нормальные» параметры. Однако параметр переменной длины должен быть последним параметром, объявленным методом. Например, следующее объявление метода вполне допустимо:
В данном случае первые три аргумента, указанные в обращении к методу dolt (), соответствуют первым трем параметрам. Все остальные аргументы считаются принадлежащими параметру vals.
Помните, что параметр vararg должен быть последним. Например, следующее объявление записано неправильно:
В этом примере предпринимается попытка объявления обычного параметра после параметра типа vararg, что недопустимо.
Существует еще одно ограничение, о котором следует знать: метод должен содержать только одни параметр типа varargs. Например, следующее объявление также неверно:
Попытка объявления второго параметра типа vararg недопустима. Рассмотрим измененную версию метода vaTest (), которая принимает обычный аргумент и аргумент переменной длины:
Вывод это программы имеет вид:
Один параметр vararg: 1
Содержимое: 10
Три параметра vararg: 3
Содержимое: 12 3
Вез параметров vararg: 0
Содержимое:
Java Varargs
В этой статье вы узнаете о varargs в Java с помощью примеров. Вы также узнаете, когда использовать varargs, а когда нет.
Что такое varargs в Java?
Предположим, вы создаете метод Java. Однако вы не уверены, сколько аргументов будет принимать ваш метод. Для решения этой проблемы в Java 1.5 были введены varargs.
Синтаксис для реализации varargs следующий:
Чтобы определить vararg, … (три точки) используются в формальном параметре метода.
Метод, который принимает переменное количество аргументов, называется методом переменной арности или просто методом varargs.
Для начала посмотрим на пример без использования varargs:
Когда вы запустите эту программу, вывод будет:
Как вы можете ясно видеть, вам пришлось перегрузить sumNumber() метод, чтобы он работал с 3 аргументами.
Что, если пользователь хочет сложить 5 чисел, 10 или 100?
С этим можно аккуратно справиться с помощью varargs. Давайте посмотрим на пример кода:
Пример: работа varargs
Когда вы запустите программу, вывод будет:
Здесь sumNumber() метод возвращает сумму int переданных ему параметров (не имеет значения количество переданных аргументов).
Как видите, в некоторых ситуациях varargs может быть действительно полезен. Однако, если вы уверены в количестве аргументов, переданных методу, вместо этого используйте перегрузку метода. Например, если вы уверены, что этот sumNumber() метод будет использоваться только для вычисления суммы 2 или 3 аргументов, используйте перегрузку, как в первом примере.
Возьмем другой пример. Метод format (), определенный в библиотеке Java, принимает varargs. В JDK format() метод определяется следующим образом:
Пример: метод format ()
Когда вы запустите программу, вывод будет:
Как varargs работает за сценой?
Рассмотрим следующий псевдокод:
В случае отсутствия аргументов длина числа равна 0.
Перегрузка методов Varargs
Подобно обычным методам, вы можете перегрузить методы vararg.
Рекомендуемая литература: Перегрузка методов Java
Пример: перегрузка метода Varargs
Когда вы запустите программу, вывод будет:
В приведенной выше программе test() метод перегружается за счет изменения количества принимаемых аргументов.
Что нужно помнить при использовании Varargs
Вот несколько вещей, которые вы должны помнить при работе с варгарами Java:
1. При определении сигнатуры метода всегда сохраняйте наконец-то varargs.
Аргумент переменной должен быть последним аргументом, переданным методу. Предположим, вы вызвали doSomething() такой метод:
И ваш doSomething() метод определяется как:
В этом случае компилятор не может определить количество аргументов, переданных в nums.
Однако, если вы определяете свой метод как:
2. Метод может иметь только один параметр varargs.
Например, это объявление метода неверно:
Неоднозначность в перегрузке метода Вараргса
Давайте рассмотрим ваш перегруженный test() метод следующим образом:
В приведенной выше программе компилятор запутается, если вы попытаетесь вызвать test() метод, даже если test() методы перегружены и принимают различное количество аргументов.
Компилятор не знает, какой метод вызвать. Компилятор может подумать, что вы пытаетесь вызвать test(int… vargs) с одним аргументом varargs. Кроме того, компилятор может подумать, что вы пытаетесь вызвать test(int n, int… vargs) с аргументом, переданным первому параметру, с пустым вторым параметром.
Поскольку есть две возможности, это вызывает двусмысленность. Из-за этого иногда может потребоваться использовать два разных имени метода вместо перегрузки метода varargs.
Java, 3 точки в параметрах
что означают 3 точки в следующем методе?
9 ответов
это означает, что ноль или более строковых объектов (или массив из них) могут быть переданы в качестве аргумента(ов) для этого метода.
в вашем примере вы можете назвать его любым из следующих:
Важное Замечание: аргумент(ы), переданный таким образом, всегда является массивом-даже если есть только один. Убедитесь, что вы относитесь к нему таким образом в теле метода.
спасибо Ваш за разъяснения в своем комментарии.
эта функция называется С varargs, и это функция, представленная в Java 5. Это означает, что функция может получить несколько String аргументы:
тогда вы можете использовать String VAR как массив:
этот ответ сильно заимствует у Кисвы и Лоренцо. а также из замечания Graphain по.
это способ Java пройти С varargs (аргументы с переменным числом).
но безопасным способом: каждый аргумент должен соответствовать указанному типу (в вашем примере они должны быть все String ).
это простой пример того, как можно использовать С varargs:
это с varargs 🙂
varargs short для Аргументов переменной длины-это функция, которая позволяет методу принимать переменное количество аргументов (ноль или более). С varargs стало просто создавать методы, которые должны принимать переменное количество аргументов. Функция аргумента переменной была добавлена в Java 5.
синтаксис varargs
С переменным числом аргументов является secified тремя точками (три точки) после типа данных его общая форма
потребность в varargs
до Java 5, в случае необходимости переменного количества аргументов, было два способа обработать его
если максимальное число аргументов, которое может принимать метод, было небольшим и известным, то могут быть созданы перегруженные версии метода. Если максимальное количество аргументов, которые может принять метод, было большим или / и неизвестным, то подход состоял в том, чтобы поместить эти аргументы в массив и передать их в метод, который принимает массив в качестве параметра. Эти 2 подхода были подвержены ошибкам-построение массива параметров каждый раз и трудно поддерживать, поскольку добавление нового аргумента может привести к написанию нового перегруженного метода.
преимущества varargs
предлагает гораздо более простой вариант. Меньше кода, так как нет необходимости писать перегруженные методы.
пример с varargs
из программы видно, что длина используется здесь, чтобы найти количество аргументов, переданных методу. Это возможно, потому что varargs неявно передаются как массив. Любые аргументы, передаваемые как varargs, хранятся в массиве, который ссылается на имя, данное varargs. В этой программе имя массива значений. Также обратите внимание, что метод вызывается с разным количеством аргументов, сначала вызов с четырьмя аргументами, затем три аргумента и тогда с нулевыми аргументами. Все эти вызовы обрабатываются тем же методом, который принимает varargs.
ограничение с varargs
в методе можно иметь другие параметры с параметром varargs, однако в этом случае параметр varargs должен быть последним параметром, объявленным методом.
другое ограничение с varargs заключается в том, что должен быть только один varargs параметр.
перегрузка методов varargs
типы его параметра vararg могут быть разными. Путем добавления других параметров. Пример перегрузки метода varargs
varargs и перегрузки двусмысленность
в некоторых случаях вызов может быть неоднозначным, а мы перегруженного метода varargs. Давайте посмотрим пример
эти два перегруженных метода, всегда будет неопределенность.
также, чтобы пролить свет, важно знать, что параметры var-arg ограничены одним, и вы не можете иметь несколько параметров var-art. Например, это illigal:
просто подумайте об этом как о ключевом слове params В C#, если вы исходите из этого фона:)
String. это то же самое, что String[]
VarArgs в Java
Привет! Это статья про VarArgs в Java.
Что такое VarArgs
Наверняка, если Вы читаете эту статью, Вы уже написали не один метод и даже не десять. И, конечно, Вам известно, что для каждого метода мы задаем типы параметров, которые требуются для работы метода. Например:
void myMethod(String s)
требует для работы одну переменную типа String, или
int findMax(int a, int b)
просит две переменные типа int.
Тем не менее, в Java есть еще одна «специальная» возможность работы с аргументами. Давайте приведем пример.
Представим, что нам нужно создать метод, который складывает переменные типа int.
Назовем этот метод addAll(). Сначала представим, что у нас два аргумента. Пишем такой код:
Отлично! А что если мы хотим получить сумму трех чисел? Добавим еще один метод, только уже с тремя аргументами:
Замечательно. И запустим:
Получим корректный результат:
Но а что, если мы хотим сложить четыре int-а? Пять int-ов? Шесть int-ов. Что, писать для каждого свой метод? Нет, это не выход. Именно тут нам и поможет VarArgs.
Переменные аргументы (Varargs) в Java
В JDK 5 Java включила функцию, которая упрощает создание методов, которые должны принимать переменное число аргументов. Эта функция называется varargs и является краткой для аргументов переменной длины. Метод, который принимает переменное число аргументов, является методом varargs.
До JDK 5 аргументы переменной длины могли обрабатываться двумя способами. Один использует перегруженный метод (по одному для каждого), а другой помещает аргументы в массив, а затем передает этот массив методу. Оба они потенциально подвержены ошибкам и требуют больше кода. Функция varargs предлагает более простой и лучший вариант.
Синтаксис varargs:
Аргумент переменной длины задается тремя точками (…). Например,
Этот синтаксис сообщает компилятору, что fun () может вызываться с нулевым или большим количеством аргументов. В результате здесь a неявно объявляется как массив типа int []. Ниже приведен фрагмент кода для иллюстрации вышеуказанной концепции:
// Java-программа для демонстрации varargs
// Метод, который принимает переменное число целого числа
System.out.println( «Number of arguments: » + a.length);
// используем для каждого цикла отображение содержимого
public static void main(String args[])
// Вызов метода varargs с другим номером
fun( 100 ); // один параметр
fun(); // без параметра
Объяснение вышеуказанной программы:
Примечание: метод может иметь параметры переменной длины и с другими параметрами, но следует убедиться, что существует только один параметр varargs, который должен быть записан последним в списке параметров объявления метода.
В этом случае первые два аргумента сопоставляются с первыми двумя параметрами, а остальные аргументы принадлежат c.
// Java-программа для демонстрации varargs с нормальным
// аргументы
// Принимает строку в качестве аргумента, за которой следует varargs
System.out.println( «String: » + str);
System.out.println( «Number of arguments is: » + a.length);
// используем для каждого цикла отображение содержимого
public static void main(String args[])
// Вызов fun2 () с другим параметром
Важные моменты:
Примеры ошибочных переменных
Пожалуйста, напишите комментарии, если вы обнаружите что-то неправильное, или вы хотите поделиться дополнительной информацией по обсуждаемой теме